moko-platform/cli/package_build.php

#!/usr/bin/env php
<?php

/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * FILE INFORMATION
 * DEFGROUP: moko-platform.CLI
 * INGROUP: moko-platform
 * REPO: https://git.mokoconsulting.tech/MokoConsulting/moko-platform
 * PATH: /cli/package_build.php
 * BRIEF: Build ZIP and tar.gz install packages for Joomla/Dolibarr/generic projects
 *
 * NOTE: Uses PHP exec() with escapeshellarg() for tar — all arguments are escaped.
 */

declare(strict_types=1);

require_once __DIR__ . '/../lib/Enterprise/CliFramework.php';

use MokoEnterprise\CliFramework;

class PackageBuildCli extends CliFramework
{
    protected function configure(): void
    {
        $this->setDescription('Build ZIP and tar.gz install packages for Joomla/Dolibarr/generic projects');
        $this->addArgument('--path', 'Repository root (default: .)', '.');
        $this->addArgument('--version', 'Version string (required)', '');
        $this->addArgument('--output-dir', 'Directory for built packages (default: /tmp)', '/tmp');
        $this->addArgument('--type-prefix', 'Override type prefix (e.g. plg_system_)', '');
        $this->addArgument('--element', 'Override element name', '');
        $this->addArgument('--github-output', 'Export zip_name, tar_name, sha256_zip, sha256_tar to $GITHUB_OUTPUT', false);
    }

    protected function run(): int
    {
        $path = $this->getArgument('--path');
        $version = $this->getArgument('--version');
        $outputDir = $this->getArgument('--output-dir');
        $typePrefixOverride = $this->getArgument('--type-prefix') ?: null;
        $elementOverride = $this->getArgument('--element') ?: null;
        $githubOutput = $this->getArgument('--github-output');

        if ($version === '') {
            $this->log('ERROR', 'Usage: package_build.php --path . --version XX.YY.ZZ [--output-dir /tmp]');
            return 1;
        }

        $root = realpath($path) ?: $path;

        // Ensure output directory exists
        if (!is_dir($outputDir)) {
            mkdir($outputDir, 0755, true);
        }

        // -- Determine source directory -----------------------------------------------
        $sourceDir = null;
        foreach (['src', 'htdocs'] as $candidate) {
            if (is_dir("{$root}/{$candidate}")) {
                $sourceDir = "{$root}/{$candidate}";
                break;
            }
        }

        if ($sourceDir === null) {
            $this->log('ERROR', "No src/ or htdocs/ directory found in {$root}");
            return 1;
        }

        // -- Determine element and type prefix from manifest --------------------------
        $extElement = $elementOverride;
        $typePrefix = $typePrefixOverride ?? '';
        $extType = '';
        $isPackage = false;

        if ($extElement === null || $typePrefixOverride === null) {
            // Find manifest
            $manifest = null;
            foreach (glob("{$sourceDir}/pkg_*.xml") ?: [] as $f) {
                if (strpos(file_get_contents($f), '<extension') !== false) {
                    $manifest = $f;
                    break;
                }
            }
            if ($manifest === null) {
                foreach (glob("{$sourceDir}/*.xml") ?: [] as $f) {
                    if (strpos(file_get_contents($f), '<extension') !== false) {
                        $manifest = $f;
                        break;
                    }
                }
            }

            if ($manifest !== null) {
                $xml = file_get_contents($manifest);

                if ($extElement === null) {
                    if (preg_match('/<element>([^<]+)<\/element>/', $xml, $m)) {
                        $extElement = $m[1];
                    } elseif (preg_match('/plugin="([^"]+)"/', $xml, $m)) {
                        $extElement = $m[1];
                    } elseif (preg_match('/module="([^"]+)"/', $xml, $m)) {
                        $extElement = $m[1];
                    } else {
                        $extElement = strtolower(pathinfo($manifest, PATHINFO_FILENAME));
                    }
                }

                if (preg_match('/<extension[^>]*type="([^"]+)"/', $xml, $m)) {
                    $extType = $m[1];
                }
                $extFolder = '';
                if (preg_match('/<extension[^>]*group="([^"]+)"/', $xml, $m)) {
                    $extFolder = $m[1];
                }

                if ($typePrefixOverride === null) {
                    switch ($extType) {
                        case 'plugin':
                            $typePrefix = "plg_{$extFolder}_";
                            break;
                        case 'module':
                            $typePrefix = 'mod_';
                            break;
                        case 'component':
                            $typePrefix = 'com_';
                            break;
                        case 'template':
                            $typePrefix = 'tpl_';
                            break;
                        case 'library':
                            $typePrefix = 'lib_';
                            break;
                        case 'package':
                            $typePrefix = 'pkg_';
                            break;
                    }
                }

                $isPackage = ($extType === 'package' && is_dir("{$sourceDir}/packages"));
            }
        }

        if ($extElement === null) {
            $extElement = strtolower(basename($root));
        }

        // Prevent double prefix (e.g. pkg_pkg_mokogallery)
        if ($typePrefix !== '' && str_starts_with($extElement, rtrim($typePrefix, '_'))) {
            $extElement = substr($extElement, strlen(rtrim($typePrefix, '_')) + 1);
        }

        $zipName = "{$typePrefix}{$extElement}-{$version}.zip";
        $tarName = "{$typePrefix}{$extElement}-{$version}.tar.gz";
        $zipPath = "{$outputDir}/{$zipName}";
        $tarPath = "{$outputDir}/{$tarName}";

        // -- Exclude patterns ---------------------------------------------------------
        $excludePatterns = [
            '.ftpignore',
            'sftp-config*',
            '*.ppk',
            '*.pem',
            '*.key',
            '.env*',
        ];

        // -- Build packages -----------------------------------------------------------
        if ($isPackage) {
            echo "=== Building Joomla PACKAGE (multi-extension) ===\n";

            $stagingDir = sys_get_temp_dir() . '/moko-pkg-' . uniqid();
            $packagesDir = "{$stagingDir}/packages";
            mkdir($packagesDir, 0755, true);

            // ZIP each sub-extension into packages/
            foreach (glob("{$sourceDir}/packages/*/") ?: [] as $extDir) {
                $subName = basename($extDir);
                echo "  Packaging sub-extension: {$subName}\n";

                $subZip = new \ZipArchive();
                $subZipPath = "{$packagesDir}/{$subName}.zip";
                if ($subZip->open($subZipPath, \ZipArchive::CREATE | \ZipArchive::OVERWRITE) !== true) {
                    $this->log('ERROR', "Failed to create ZIP for {$subName}");
                    continue;
                }

                $this->addDirectoryToZip($subZip, $extDir, '', $excludePatterns);
                $subZip->close();
                echo "    -> packages/{$subName}.zip (" . filesize($subZipPath) . " bytes)\n";
            }

            // Copy package-level files (manifest, script.php, etc.)
            foreach (array_merge(glob("{$sourceDir}/*.xml") ?: [], glob("{$sourceDir}/*.php") ?: []) as $f) {
                copy($f, "{$stagingDir}/" . basename($f));
            }

            // Copy language directory if present
            if (is_dir("{$sourceDir}/language")) {
                $langDest = "{$stagingDir}/language";
                mkdir($langDest, 0755, true);
                $langIterator = new \RecursiveIteratorIterator(
                    new \RecursiveDirectoryIterator("{$sourceDir}/language", \RecursiveDirectoryIterator::SKIP_DOTS),
                    \RecursiveIteratorIterator::SELF_FIRST
                );
                foreach ($langIterator as $item) {
                    $target = $langDest . '/' . substr($item->getPathname(), strlen("{$sourceDir}/language") + 1);
                    if ($item->isDir()) {
                        mkdir($target, 0755, true);
                    } else {
                        copy($item->getPathname(), $target);
                    }
                }
            }

            // Create ZIP from staging
            $zip = new \ZipArchive();
            if ($zip->open($zipPath, \ZipArchive::CREATE | \ZipArchive::OVERWRITE) !== true) {
                $this->log('ERROR', "Failed to create ZIP: {$zipPath}");
                return 1;
            }
            $this->addDirectoryToZip($zip, $stagingDir, '', []);
            $zip->close();

            // Create tar.gz — all arguments are escaped via escapeshellarg()
            $tarCmd = sprintf(
                'tar -czf %s -C %s .',
                escapeshellarg($tarPath),
                escapeshellarg($stagingDir)
            );
            passthru($tarCmd, $tarReturn);

            // Cleanup staging
            $cleanCmd = sprintf('rm -rf %s', escapeshellarg($stagingDir));
            passthru($cleanCmd);
        } else {
            echo "=== Building standard extension package ===\n";

            // ZIP
            $zip = new \ZipArchive();
            if ($zip->open($zipPath, \ZipArchive::CREATE | \ZipArchive::OVERWRITE) !== true) {
                $this->log('ERROR', "Failed to create ZIP: {$zipPath}");
                return 1;
            }
            $this->addDirectoryToZip($zip, $sourceDir, '', $excludePatterns);
            $zip->close();

            // tar.gz — all arguments are escaped via escapeshellarg()
            $excludeArgs = '';
            foreach ($excludePatterns as $pattern) {
                $excludeArgs .= ' --exclude=' . escapeshellarg($pattern);
            }
            $tarCmd = sprintf(
                'tar -czf %s -C %s%s .',
                escapeshellarg($tarPath),
                escapeshellarg($sourceDir),
                $excludeArgs
            );
            passthru($tarCmd, $tarReturn);
        }

        // -- Calculate SHA-256 --------------------------------------------------------
        $sha256Zip = hash_file('sha256', $zipPath);
        $sha256Tar = file_exists($tarPath) ? hash_file('sha256', $tarPath) : '';

        $zipSize = filesize($zipPath);
        $tarSize = file_exists($tarPath) ? filesize($tarPath) : 0;

        echo "\n";
        echo "ZIP: {$zipName} ({$zipSize} bytes)\n";
        echo "  SHA-256: {$sha256Zip}\n";
        if ($tarSize > 0) {
            echo "TAR: {$tarName} ({$tarSize} bytes)\n";
            echo "  SHA-256: {$sha256Tar}\n";
        }

        // -- Export to GITHUB_OUTPUT --------------------------------------------------
        if ($githubOutput) {
            $ghOutput = getenv('GITHUB_OUTPUT');
            $lines = [
                "zip_name={$zipName}",
                "tar_name={$tarName}",
                "zip_path={$zipPath}",
                "tar_path={$tarPath}",
                "sha256_zip={$sha256Zip}",
                "sha256_tar={$sha256Tar}",
                "type_prefix={$typePrefix}",
                "ext_element={$extElement}",
            ];
            if ($ghOutput) {
                file_put_contents($ghOutput, implode("\n", $lines) . "\n", FILE_APPEND);
                $this->log('INFO', "Exported " . count($lines) . " fields to GITHUB_OUTPUT");
            } else {
                foreach ($lines as $line) {
                    echo "{$line}\n";
                }
            }
        }

        return 0;
    }

    /**
     * Recursively add directory contents to a ZipArchive.
     */
    private function addDirectoryToZip(\ZipArchive $zip, string $dir, string $prefix, array $excludes): void
    {
        $iterator = new \RecursiveIteratorIterator(
            new \RecursiveDirectoryIterator($dir, \RecursiveDirectoryIterator::SKIP_DOTS),
            \RecursiveIteratorIterator::SELF_FIRST
        );

        foreach ($iterator as $file) {
            $filePath = $file->getPathname();
            $relativePath = $prefix . substr($filePath, strlen($dir) + 1);

            // Check excludes
            $basename = basename($filePath);
            $skip = false;
            foreach ($excludes as $pattern) {
                if (fnmatch($pattern, $basename)) {
                    $skip = true;
                    break;
                }
            }
            if ($skip) {
                continue;
            }

            // Normalize path separators for ZIP
            $relativePath = str_replace('\\', '/', $relativePath);

            if ($file->isDir()) {
                $zip->addEmptyDir($relativePath);
            } else {
                $zip->addFile($filePath, $relativePath);
            }
        }
    }
}

$app = new PackageBuildCli();
exit($app->execute());