@cicore/cli 1.0.0

package/dist/commands/build/index.js

@@ -0,0 +1,726 @@
+/**
+ * CiCore CLI — Build commands (host-aware)
+ *
+ * Three subcommands, one for each core image plus addons:
+ *
+ *   - `vu build nuxt --host <h> [--deploy]`  build Nuxt → push → upload UI → deploy
+ *   - `vu build php  --host <h> [--deploy]`  build PHP  → push → deploy
+ *   - `vu build addon <name> --host <h>`     vite build → upload → install backend → deploy
+ *
+ * Everything host-specific (registry namespace, CDN endpoint, server paths,
+ * container names, ssh target, CF zone) comes from {@link getHostConfig};
+ * there is no global CONFIG sabit any more, no hardcoded URL, no hardcoded
+ * `/home/cores/...`. Add a host to STATIC_TOPOLOGY and the same commands
+ * deploy to it.
+ *
+ * Heavy lifting (image build/push/pull/retag, compose ops, CDN clean/upload,
+ * nginx reload, CF purge) is delegated to the `ops/` primitives written in
+ * step 2. This file is mostly orchestration + CLI plumbing + the things
+ * still local to the Mac build host (Tailwind safelist, Vite build, manifest
+ * generation, Asset hashing).
+ */
+import { createWriteStream } from 'node:fs';
+import { join as joinPath } from 'node:path';
+import archiver from 'archiver';
+import fs from 'fs-extra';
+import { log, spinner } from '../../lib/logger.js';
+import { paths } from '../../lib/config.js';
+import { confirm } from '../../lib/prompts.js';
+import { getHostConfig, } from '../../lib/hosts.js';
+import { buildImage, composeImageRef, pushImage, pullImage, retagForCompose, } from '../../lib/ops/image.js';
+import { composeForceRecreate } from '../../lib/ops/compose.js';
+import { cdnCleanCoreUi, cdnCleanAddon, cdnUploadZip } from '../../lib/ops/cdn.js';
+import { cfPurgeZone } from '../../lib/ops/cf.js';
+import { addonClearRouteCache } from '../../lib/ops/addon.js';
+import { runLocal, runRemote, uploadFile } from '../../lib/ops/ssh.js';
+export function registerBuildCommands(program) {
+    const build = program.command('build').description('Build and deploy Docker images');
+    build
+        .command('nuxt')
+        .description('Build Nuxt image, push to registry, upload CoreUI to CDN, optionally deploy')
+        .option('--skip-cdn', 'Skip CDN upload')
+        .option('--skip-push', 'Skip Docker Hub push')
+        .option('--skip-build', 'Skip Docker build and push (use existing image)')
+        .option('--skip-server', 'Skip server pull/restart')
+        .option('--skip-safelist', 'Skip addon CSS safelist generation')
+        .option('-h, --host <host>', 'Host alias (vucore | cicore)')
+        .option('-c, --core <core>', 'Core name for cache clearing (e.g. cicore, vucore)')
+        .option('--deploy', 'Full deployment: pull, cache clear, recreate container')
+        .option('--dry-run', 'Show what would be done without executing')
+        .action(async (options) => {
+        await buildNuxt(options);
+    });
+    build
+        .command('php')
+        .description('Build PHP image and push to registry, optionally deploy')
+        .option('--skip-push', 'Skip Docker Hub push')
+        .option('--skip-server', 'Skip server pull/restart')
+        .option('-h, --host <host>', 'Host alias (vucore | cicore)')
+        .option('-c, --core <core>', 'Core name for cache clearing (e.g. cicore, vucore)')
+        .option('--deploy', 'Full deployment: pull, cache clear, recreate container')
+        .option('--dry-run', 'Show what would be done without executing')
+        .action(async (options) => {
+        await buildPHP(options);
+    });
+    build
+        .command('addon <name>')
+        .description('Build addon UI to CDN and deploy backend to server')
+        .option('-c, --core <name>', 'Core name', 'core1')
+        .option('--skip-cdn', 'Skip CDN upload')
+        .option('--skip-server', 'Skip server deploy')
+        .option('-h, --host <host>', 'Host alias (vucore | cicore)')
+        .option('--dry-run', 'Show what would be done without executing')
+        .action(async (addonName, options) => {
+        await buildAddon(addonName, options);
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────
+// vu build nuxt
+// ─────────────────────────────────────────────────────────────────────────
+export async function buildNuxt(options) {
+    const startTime = Date.now();
+    log.title('🔨 Build Nuxt Image + CDN Upload');
+    // Resolve host eagerly so a missing/typo'd --host fails before any work.
+    const cfg = options.host !== undefined ? getHostConfig(options.host) : undefined;
+    if (cfg !== undefined)
+        log.info(`Target: ${cfg.brandName}`);
+    log.info(`Skip build: ${options.skipBuild === true}`);
+    log.info(`Skip CDN:   ${options.skipCdn === true}`);
+    log.info(`Skip push:  ${options.skipPush === true}`);
+    log.info(`Dry run:    ${options.dryRun === true}`);
+    log.blank();
+    if (!(await confirm('Start Nuxt build?', true))) {
+        log.warn('Cancelled');
+        return;
+    }
+    if (options.skipSafelist !== true) {
+        await runSafelistPipeline(options.dryRun === true);
+    }
+    if (options.skipBuild !== true) {
+        if (cfg === undefined) {
+            log.error('--host is required for build (image namespace comes from host config)');
+            process.exit(1);
+        }
+        await runImageBuild(cfg, 'nuxt');
+        if (options.skipPush !== true) {
+            await runImagePush(cfg, 'nuxt');
+        }
+        else {
+            log.warn('[skip] Docker Hub push');
+        }
+    }
+    else {
+        log.warn('[skip] Docker build (using existing image)');
+    }
+    if (options.skipCdn !== true) {
+        if (cfg === undefined) {
+            log.error('--host is required for CDN upload (cdn endpoint comes from host config)');
+            process.exit(1);
+        }
+        await uploadCoreUiBundle(cfg, options.dryRun === true);
+    }
+    else {
+        log.warn('[skip] CDN upload');
+    }
+    if (options.skipServer !== true && cfg !== undefined && options.deploy === true) {
+        await deployNuxtToHost(cfg, options.core ?? 'core1', options.dryRun === true);
+    }
+    log.blank();
+    log.success(`✨ Nuxt build complete in ${elapsed(startTime)}`);
+}
+async function runImageBuild(cfg, service) {
+    const sp = spinner(`Building ${service} image (linux/amd64) ...`).start();
+    const result = await buildImage(cfg, service, 'latest', { silent: true });
+    if (!result.success) {
+        sp.fail('Docker build failed');
+        log.error(result.stderr || result.stdout);
+        process.exit(1);
+    }
+    sp.succeed('Docker image built');
+}
+async function runImagePush(cfg, service) {
+    const sp = spinner('Pushing to Docker Hub ...').start();
+    const result = await pushImage(cfg, service, 'latest', { silent: true });
+    if (!result.success) {
+        sp.fail('Docker push failed');
+        log.error(result.stderr || result.stdout);
+        process.exit(1);
+    }
+    sp.succeed('Image pushed');
+}
+/**
+ * Extract `/app/.output/public/` from the freshly-built Nuxt image, zip it,
+ * and hand off to {@link cdnUploadZip}. The Worker unpacks the zip into
+ * `CoreUI/latest/**` in R2 server-side.
+ *
+ * No-op on hosts with cdnBypassForNuxt — `ops/cdn` honors that flag.
+ */
+async function uploadCoreUiBundle(cfg, dryRun) {
+    if (cfg.cdnBypassForNuxt) {
+        log.info(`[cdn] ${cfg.brandName} bypasses CoreUI CDN — nothing to upload`);
+        return;
+    }
+    const imageRef = composeImageRef(cfg, 'nuxt');
+    const tempDir = joinPath(paths.dev.root, '.tmp-core-ui-latest');
+    const zipPath = joinPath(paths.dev.root, '.tmp-core-ui-latest.zip');
+    if (dryRun) {
+        log.warn(`[dry-run] extract ${imageRef}:/app/.output/public → ${tempDir}`);
+        log.warn(`[dry-run] zip ${tempDir} → ${zipPath}`);
+        log.warn(`[dry-run] cdnUploadZip ${zipPath}`);
+        return;
+    }
+    try {
+        await fs.remove(tempDir);
+        await fs.ensureDir(tempDir);
+        const createResult = await runLocal('docker', ['create', imageRef], { silent: true });
+        if (!createResult.success) {
+            log.error('Failed to create temp container for UI extract');
+            process.exit(1);
+        }
+        const containerId = createResult.stdout.trim();
+        try {
+            log.info(`Extracting CoreUI from ${containerId.substring(0, 12)} ...`);
+            const copyResult = await runLocal('docker', ['cp', `${containerId}:/app/.output/public/.`, tempDir], { silent: true });
+            if (!copyResult.success) {
+                log.error('Failed to extract UI files');
+                process.exit(1);
+            }
+        }
+        finally {
+            await runLocal('docker', ['rm', containerId], { silent: true });
+        }
+        await pruneNonCdnFiles(tempDir);
+        await zipDirectory(tempDir, zipPath);
+        await cdnCleanCoreUi(cfg);
+        const upload = await cdnUploadZip(cfg, zipPath, { version: 'latest' });
+        if (!upload.success) {
+            log.error(`CDN upload failed: ${upload.errorMessage}`);
+            process.exit(1);
+        }
+        log.success('CoreUI uploaded to CDN');
+    }
+    finally {
+        await fs.remove(tempDir).catch(() => undefined);
+        await fs.remove(zipPath).catch(() => undefined);
+    }
+}
+/**
+ * Full deployment sequence for Nuxt: server-side pull → retag for compose →
+ * cache clear → force-recreate container → CF zone purge.
+ */
+async function deployNuxtToHost(cfg, core, dryRun) {
+    log.blank();
+    log.title('🚀 Deploy Nuxt');
+    log.info(`Target: ${cfg.brandName} (core: ${core})`);
+    if (dryRun) {
+        log.warn(`[dry-run] full Nuxt deploy to ${cfg.alias} for ${core}`);
+        return;
+    }
+    log.info('[1/4] pull image on server');
+    const pull = await pullImage(cfg, 'nuxt', 'latest', { silent: true });
+    if (!pull.success)
+        log.warn(`pull had issues (continuing): ${pull.stderr}`);
+    log.info('[2/4] retag for compose');
+    await retagForCompose(cfg, 'nuxt', 'latest', { silent: true });
+    log.info('[3/4] clear addon route cache + opcache');
+    await addonClearRouteCache(cfg, core);
+    log.info('[4/4] force-recreate Nuxt container');
+    const recreate = await composeForceRecreate(cfg, 'nuxt', { silent: true });
+    if (!recreate.success)
+        log.warn(`recreate had issues: ${recreate.stderr}`);
+    log.info('[+] purge Cloudflare zone cache');
+    await cfPurgeZone(cfg);
+    log.success('✅ Nuxt deploy complete');
+}
+// ─────────────────────────────────────────────────────────────────────────
+// vu build php
+// ─────────────────────────────────────────────────────────────────────────
+export async function buildPHP(options) {
+    const startTime = Date.now();
+    log.title('🔨 Build PHP Image');
+    const cfg = options.host !== undefined ? getHostConfig(options.host) : undefined;
+    if (cfg !== undefined)
+        log.info(`Target: ${cfg.brandName}`);
+    log.info(`Skip push: ${options.skipPush === true}`);
+    log.info(`Dry run:   ${options.dryRun === true}`);
+    log.blank();
+    if (!(await confirm('Start PHP build?', true))) {
+        log.warn('Cancelled');
+        return;
+    }
+    if (cfg === undefined) {
+        log.error('--host is required for build (image namespace comes from host config)');
+        process.exit(1);
+    }
+    await runImageBuild(cfg, 'php');
+    if (options.skipPush !== true) {
+        await runImagePush(cfg, 'php');
+    }
+    else {
+        log.warn('[skip] Docker Hub push');
+    }
+    if (options.skipServer !== true && options.deploy === true) {
+        await deployPhpToHost(cfg, options.core ?? 'core1', options.dryRun === true);
+    }
+    log.blank();
+    log.success(`✨ PHP build complete in ${elapsed(startTime)}`);
+}
+async function deployPhpToHost(cfg, core, dryRun) {
+    log.blank();
+    log.title('🚀 Deploy PHP');
+    log.info(`Target: ${cfg.brandName} (core: ${core})`);
+    if (dryRun) {
+        log.warn(`[dry-run] full PHP deploy to ${cfg.alias} for ${core}`);
+        return;
+    }
+    log.info('[1/5] pull image on server');
+    const pull = await pullImage(cfg, 'php', 'latest', { silent: true });
+    if (!pull.success)
+        log.warn(`pull had issues (continuing): ${pull.stderr}`);
+    log.info('[2/5] retag for compose');
+    await retagForCompose(cfg, 'php', 'latest', { silent: true });
+    log.info('[3/5] force-recreate PHP container');
+    const recreate = await composeForceRecreate(cfg, 'php', { silent: true });
+    if (!recreate.success)
+        log.warn(`recreate had issues: ${recreate.stderr}`);
+    log.info('[4/5] fix storage perms + clear caches');
+    await fixStoragePerms(cfg);
+    await addonClearRouteCache(cfg, core);
+    log.info('[5/5] purge Cloudflare zone cache');
+    await cfPurgeZone(cfg);
+    log.success('✅ PHP deploy complete');
+}
+/**
+ * Ensure `/var/www/storage` is owned by www-data (uid 82) and writable.
+ * Done after every PHP container recreate because the freshly-started
+ * container resets ownership of any volume-mounted dirs without owner pin.
+ */
+async function fixStoragePerms(cfg) {
+    const phpContainer = cfg.containerNames.php;
+    const script = `docker exec -u root ${phpContainer} mkdir -p /var/www/storage/cache || true; ` +
+        `docker exec -u root ${phpContainer} chown -R www-data:www-data /var/www/storage || true; ` +
+        `docker exec -u root ${phpContainer} chmod -R 777 /var/www/storage || true`;
+    await runRemote(cfg, script, { silent: true });
+}
+// ─────────────────────────────────────────────────────────────────────────
+// vu build addon
+// ─────────────────────────────────────────────────────────────────────────
+export async function buildAddon(addonName, options) {
+    const startTime = Date.now();
+    const core = options.core ?? 'core1';
+    log.title(`🔨 Build Addon: ${addonName}`);
+    const cfg = options.host !== undefined ? getHostConfig(options.host) : undefined;
+    if (cfg !== undefined)
+        log.info(`Target: ${cfg.brandName}`);
+    log.info(`Core: ${core}`);
+    log.info(`Skip CDN:    ${options.skipCdn === true}`);
+    log.info(`Skip server: ${options.skipServer === true}`);
+    log.info(`Dry run:     ${options.dryRun === true}`);
+    log.blank();
+    const addonPath = joinPath(paths.dev.root, 'addons', addonName);
+    const addonJsonPath = joinPath(addonPath, 'addon.json');
+    if (!(await fs.pathExists(addonJsonPath))) {
+        log.error(`addon.json not found: ${addonJsonPath}`);
+        process.exit(1);
+    }
+    const addonConfig = (await fs.readJson(addonJsonPath));
+    log.info(`Addon: ${addonConfig.name} v${addonConfig.version}`);
+    if (!(await confirm('Start addon build?', true))) {
+        log.warn('Cancelled');
+        return;
+    }
+    const tempCdnDir = joinPath(paths.dev.root, `.tmp-addon-${addonName}-latest`);
+    await runAddonViteBuild(addonName, addonPath, tempCdnDir, options.dryRun === true);
+    await copyAddonAssetsWithHash(addonPath, tempCdnDir);
+    if (cfg !== undefined) {
+        await writeAddonUiManifest(cfg, addonName, addonPath, tempCdnDir);
+    }
+    if (options.skipCdn !== true) {
+        if (cfg === undefined) {
+            log.error('--host is required for CDN upload (cdn endpoint comes from host config)');
+            process.exit(1);
+        }
+        await uploadAddonBundleToCdn(cfg, addonName, tempCdnDir, options.dryRun === true);
+    }
+    else {
+        log.warn('[skip] CDN upload');
+    }
+    const stagedBackendPath = joinPath(paths.dev.root, 'product', 'cores', core, 'addons', addonName);
+    if (options.dryRun === true) {
+        log.warn(`[dry-run] stage backend → ${stagedBackendPath}`);
+    }
+    else {
+        await stageAddonBackend(addonPath, addonJsonPath, tempCdnDir, stagedBackendPath);
+    }
+    if (options.skipServer !== true && cfg !== undefined) {
+        await deployAddonBackend(cfg, addonName, core, stagedBackendPath, options.dryRun === true);
+    }
+    else {
+        log.warn('[skip] Server deploy');
+    }
+    if (cfg !== undefined && options.dryRun !== true) {
+        await cfPurgeZone(cfg);
+    }
+    log.blank();
+    log.success(`✨ Addon build complete in ${elapsed(startTime)}`);
+}
+async function runAddonViteBuild(addonName, addonPath, tempCdnDir, dryRun) {
+    if (dryRun) {
+        log.warn(`[dry-run] vite build for ${addonName}`);
+        return;
+    }
+    await fs.remove(tempCdnDir);
+    await fs.ensureDir(tempCdnDir);
+    const ownConfig = joinPath(addonPath, 'vite.config.js');
+    const viteBin = joinPath(paths.dev.root, 'node_modules', '.bin', 'vite');
+    if (await fs.pathExists(ownConfig)) {
+        log.info(`Using addon's own vite.config.js`);
+        const build = await runLocal(viteBin, ['build'], { cwd: addonPath });
+        if (!build.success) {
+            log.error('Vite build failed');
+            log.error(build.stderr);
+            process.exit(1);
+        }
+        const distDir = joinPath(addonPath, 'dist');
+        if (await fs.pathExists(distDir)) {
+            await fs.copy(distDir, tempCdnDir);
+        }
+        const inputCss = joinPath(addonPath, 'ui', 'input.css');
+        if (await fs.pathExists(inputCss)) {
+            const tailwindConfig = joinPath(addonPath, 'ui', 'tailwind.config.js');
+            const args = ['tailwindcss'];
+            if (await fs.pathExists(tailwindConfig)) {
+                args.push('-c', tailwindConfig);
+            }
+            args.push('-i', inputCss, '-o', joinPath(tempCdnDir, 'style.css'), '--minify');
+            await runLocal('npx', args, { cwd: paths.dev.root });
+        }
+    }
+    else {
+        log.info('No vite.config.js — using legacy temp-build approach');
+        const tempBuildDir = joinPath(paths.dev.root, `.temp-addon-esm-${addonName}`);
+        try {
+            await fs.remove(tempBuildDir);
+            await fs.ensureDir(tempBuildDir);
+            for (const sub of ['ui', 'pages', 'locales', 'components']) {
+                const src = joinPath(addonPath, sub);
+                if (await fs.pathExists(src)) {
+                    const dest = sub === 'ui' ? tempBuildDir : joinPath(tempBuildDir, sub);
+                    await fs.copy(src, dest);
+                }
+            }
+            await fs.writeFile(joinPath(tempBuildDir, 'vite.config.js'), legacyViteConfig(addonName));
+            await fs.writeJson(joinPath(tempBuildDir, 'package.json'), {
+                name: `${addonName.toLowerCase()}-addon`,
+                version: '1.0.0',
+                type: 'module',
+                scripts: { build: 'vite build' },
+            });
+            const build = await runLocal(viteBin, ['build', '--config', 'vite.config.js'], {
+                cwd: tempBuildDir,
+            });
+            if (!build.success) {
+                log.error('Vite build failed');
+                log.error(build.stderr);
+                process.exit(1);
+            }
+            const distDir = joinPath(tempBuildDir, 'dist');
+            if (await fs.pathExists(distDir))
+                await fs.copy(distDir, tempCdnDir);
+        }
+        finally {
+            await fs.remove(tempBuildDir).catch(() => undefined);
+        }
+    }
+    log.success('Addon UI built');
+}
+async function copyAddonAssetsWithHash(addonPath, tempCdnDir) {
+    const assetsSrc = joinPath(addonPath, 'Assets');
+    if (!(await fs.pathExists(assetsSrc)))
+        return;
+    const assetsDst = joinPath(tempCdnDir, 'assets');
+    await fs.ensureDir(assetsDst);
+    await walkAndHashCopy(assetsSrc, assetsDst);
+}
+async function walkAndHashCopy(src, dst) {
+    const { createHash } = await import('node:crypto');
+    const items = await fs.readdir(src, { withFileTypes: true });
+    for (const item of items) {
+        const srcPath = joinPath(src, item.name);
+        if (item.isDirectory()) {
+            const dstSub = joinPath(dst, item.name);
+            await fs.ensureDir(dstSub);
+            await walkAndHashCopy(srcPath, dstSub);
+        }
+        else {
+            const content = await fs.readFile(srcPath);
+            const hash = createHash('md5').update(content).digest('hex').substring(0, 8);
+            const dotIdx = item.name.lastIndexOf('.');
+            const base = dotIdx === -1 ? item.name : item.name.slice(0, dotIdx);
+            const ext = dotIdx === -1 ? '' : item.name.slice(dotIdx);
+            const hashed = `${base}-${hash}${ext}`;
+            // Ship both: hashed for cache-busting (Vue components resolve through
+            // manifest), un-hashed for stable references (og:image, share cards).
+            await fs.copy(srcPath, joinPath(dst, hashed));
+            await fs.copy(srcPath, joinPath(dst, item.name));
+        }
+    }
+}
+async function writeAddonUiManifest(cfg, addonName, addonPath, tempCdnDir) {
+    const cdnBase = `${cfg.cdnBaseUrl}/addons/${addonName}/latest`;
+    const cssFiles = [];
+    const builtAssetsDir = joinPath(tempCdnDir, 'assets');
+    if (await fs.pathExists(builtAssetsDir)) {
+        for (const file of await fs.readdir(builtAssetsDir)) {
+            if (file.endsWith('.css'))
+                cssFiles.push(`${cdnBase}/assets/${file}`);
+        }
+    }
+    const chunkFiles = [];
+    const chunksDir = joinPath(tempCdnDir, 'chunks');
+    if (await fs.pathExists(chunksDir)) {
+        for (const file of await fs.readdir(chunksDir)) {
+            if (file.endsWith('.js'))
+                chunkFiles.push(`${cdnBase}/chunks/${file}`);
+        }
+    }
+    const imageAssets = {};
+    if (await fs.pathExists(builtAssetsDir)) {
+        await scanForImageAssets(builtAssetsDir, '', imageAssets, cdnBase);
+    }
+    let thumbnailUrl = '';
+    try {
+        const decl = (await fs.readJson(joinPath(addonPath, 'addon.json')));
+        const declared = typeof decl.thumbnail === 'string' ? decl.thumbnail : null;
+        if (declared !== null) {
+            const lookupKey = declared.replace(/^Assets\//i, '').replace(/^\//, '');
+            if (imageAssets[lookupKey] !== undefined)
+                thumbnailUrl = imageAssets[lookupKey];
+        }
+    }
+    catch {
+        // missing or unparseable addon.json — fall through to conventions
+    }
+    if (thumbnailUrl === '') {
+        for (const k of [
+            'img/thumbnail.webp', 'thumbnail.webp',
+            'img/thumbnail.png', 'thumbnail.png',
+            'img/thumbnail.jpg', 'thumbnail.jpg',
+            'img/thumbnail.jpeg', 'thumbnail.jpeg',
+        ]) {
+            if (imageAssets[k] !== undefined) {
+                thumbnailUrl = imageAssets[k];
+                break;
+            }
+        }
+    }
+    const manifest = {
+        addon: addonName,
+        version: 'latest',
+        cdn_base: cdnBase,
+        entry: `${cdnBase}/entry.js`,
+        css: cssFiles,
+        chunks: chunkFiles,
+        assets: imageAssets,
+        thumbnail: thumbnailUrl,
+        built_at: new Date().toISOString(),
+    };
+    await fs.writeJson(joinPath(tempCdnDir, 'ui-manifest.json'), manifest, { spaces: 2 });
+    log.info(`Manifest written with ${Object.keys(imageAssets).length} asset mappings`);
+}
+async function scanForImageAssets(dir, prefix, out, cdnBase) {
+    const items = await fs.readdir(dir, { withFileTypes: true });
+    for (const item of items) {
+        const rel = prefix === '' ? item.name : `${prefix}/${item.name}`;
+        if (item.isDirectory()) {
+            await scanForImageAssets(joinPath(dir, item.name), rel, out, cdnBase);
+        }
+        else if (/\.(png|jpe?g|jfif|gif|svg|webp|ico)$/i.test(item.name)) {
+            const match = item.name.match(/^(.+)-[a-f0-9]{8}(\.[^.]+)$/);
+            if (match !== null) {
+                const originalName = `${match[1]}${match[2]}`;
+                const originalPath = prefix === '' ? originalName : `${prefix}/${originalName}`;
+                out[originalPath] = `${cdnBase}/assets/${rel}`;
+            }
+        }
+    }
+}
+async function uploadAddonBundleToCdn(cfg, addonName, tempCdnDir, dryRun) {
+    const zipPath = joinPath(paths.dev.root, `.tmp-addon-${addonName}-latest.zip`);
+    if (dryRun) {
+        log.warn(`[dry-run] zip ${tempCdnDir} → ${zipPath}`);
+        log.warn(`[dry-run] cdnUploadZip addon=${addonName}`);
+        return;
+    }
+    try {
+        await zipDirectory(tempCdnDir, zipPath);
+        await cdnCleanAddon(cfg, addonName);
+        const upload = await cdnUploadZip(cfg, zipPath, { addon: addonName, version: 'latest' });
+        if (!upload.success) {
+            log.error(`Addon CDN upload failed: ${upload.errorMessage}`);
+            process.exit(1);
+        }
+        log.success('Addon UI uploaded to CDN');
+    }
+    finally {
+        await fs.remove(zipPath).catch(() => undefined);
+    }
+}
+async function stageAddonBackend(addonPath, addonJsonPath, tempCdnDir, destPath) {
+    await fs.ensureDir(destPath);
+    for (const entry of ['Backend', 'locales', 'Assets']) {
+        const src = joinPath(addonPath, entry);
+        if (await fs.pathExists(src))
+            await fs.copy(src, joinPath(destPath, entry));
+    }
+    await fs.copy(addonJsonPath, joinPath(destPath, 'addon.json'));
+    const manifestSrc = joinPath(tempCdnDir, 'ui-manifest.json');
+    if (await fs.pathExists(manifestSrc)) {
+        await fs.copy(manifestSrc, joinPath(destPath, 'ui-manifest.json'));
+    }
+    log.success(`Backend staged at ${destPath}`);
+}
+async function deployAddonBackend(cfg, addonName, core, stagedBackendPath, dryRun) {
+    const serverPath = `${cfg.coresHostPath}/${core}/addons/${addonName}`;
+    if (dryRun) {
+        log.warn(`[dry-run] upload ${stagedBackendPath}/. → ${cfg.sshUser}@${cfg.sshHostname}:${serverPath}/`);
+        return;
+    }
+    log.info('Cleaning existing addon directory on server ...');
+    await runRemote(cfg, `rm -rf ${shellQuote(serverPath)} && mkdir -p ${shellQuote(serverPath)}`, { silent: true });
+    log.info('Uploading addon files ...');
+    const upload = await uploadFile(cfg, `${stagedBackendPath}/.`, `${serverPath}/`, {
+        recursive: true,
+    });
+    if (!upload.success) {
+        log.error(`scp failed: ${upload.stderr}`);
+        process.exit(1);
+    }
+    log.info('Fixing permissions ...');
+    const containerAddonPath = `/var/www/cores/${core}/addons/${addonName}`;
+    const permScript = `chmod -R 777 ${shellQuote(serverPath)} || true; ` +
+        `docker exec -u root ${cfg.containerNames.php} chown -R www-data:www-data ${shellQuote(containerAddonPath)} || true; ` +
+        `docker exec -u root ${cfg.containerNames.php} chmod -R 777 ${shellQuote(containerAddonPath)} || true`;
+    await runRemote(cfg, permScript, { silent: true });
+    log.info('Restarting PHP + clearing caches ...');
+    await runRemote(cfg, `docker restart ${cfg.containerNames.php}`, { silent: true });
+    await addonClearRouteCache(cfg, core);
+    await runRemote(cfg, `docker exec ${cfg.containerNames.nginx} nginx -s reload`, { silent: true }).catch(() => undefined);
+    log.success(`Backend deployed: ${serverPath}`);
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Shared helpers
+// ─────────────────────────────────────────────────────────────────────────
+async function runSafelistPipeline(dryRun) {
+    if (dryRun) {
+        log.warn('[dry-run] vu addon extract-classes && vu addon generate-safelist');
+        return;
+    }
+    log.info('📦 Extracting addon Tailwind classes ...');
+    const extract = await runLocal('npx', ['vu', 'addon', 'extract-classes'], {
+        cwd: paths.dev.root,
+    });
+    if (!extract.success) {
+        log.warn('Class extraction failed (continuing with base safelist)');
+        return;
+    }
+    log.info('🧬 Generating Tailwind safelist regex patterns ...');
+    const gen = await runLocal('npx', ['vu', 'addon', 'generate-safelist'], {
+        cwd: paths.dev.root,
+    });
+    if (!gen.success) {
+        log.warn('Safelist generation failed (continuing with base safelist)');
+    }
+}
+async function pruneNonCdnFiles(dir) {
+    const entries = await fs.readdir(dir, { recursive: true });
+    for (const entry of entries) {
+        const p = joinPath(dir, entry);
+        const stat = await fs.stat(p);
+        if (!stat.isFile())
+            continue;
+        if (p.endsWith('.php') || p.endsWith('.br') || p.endsWith('.gz')) {
+            await fs.remove(p);
+        }
+    }
+}
+async function zipDirectory(srcDir, destZip) {
+    await new Promise((resolve, reject) => {
+        const output = createWriteStream(destZip);
+        const archive = archiver('zip', { zlib: { level: 9 } });
+        output.on('close', () => resolve());
+        output.on('error', reject);
+        archive.on('error', reject);
+        archive.pipe(output);
+        archive.directory(srcDir, false);
+        archive.finalize().catch(reject);
+    });
+}
+function shellQuote(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function elapsed(startMs) {
+    const seconds = (Date.now() - startMs) / 1000;
+    if (seconds < 60)
+        return `${seconds.toFixed(1)}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remSec = seconds - minutes * 60;
+    return `${minutes}m${remSec.toFixed(0)}s`;
+}
+function legacyViteConfig(addonName) {
+    return `import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import { resolve } from 'path'
+
+// Nuxt bare-specifier shims (bundled inline — not externalized)
+const SHIMS_DIR = resolve(__dirname, '../../addons/_shims')
+
+export default defineConfig({
+  plugins: [vue()],
+  css: { postcss: {} },
+  // Nuxt compile-time macros → no-op (standalone Vite has no Nuxt macro plugin)
+  define: {
+    definePageMeta: '(() => {})',
+  },
+  resolve: {
+    alias: {
+      'vue': '@cicore/shared',
+      '#imports': resolve(SHIMS_DIR, 'nuxt-imports.js'),
+      '#app':     resolve(SHIMS_DIR, 'nuxt-app.js'),
+      '#build':   resolve(SHIMS_DIR, 'nuxt-build.js'),
+    },
+  },
+  build: {
+    lib: {
+      entry: resolve(__dirname, 'entry.js'),
+      name: '${addonName}',
+      fileName: () => 'entry.js',
+      formats: ['es']
+    },
+    rollupOptions: {
+      external(id) {
+        if (id.startsWith('#')) return false
+        if (id.startsWith('@/')) return false  // @/-alias = addon-local, bundle
+        if (id === 'vue' || id.startsWith('vue/') || id.startsWith('@vue/')) return true
+        if (id === '@cicore/shared' || id.startsWith('@cicore/')) return true
+        if (['vue-router', 'pinia', '@vueuse/core', '@nuxt/ui'].includes(id)) return true
+        if (/^@iconify\\//.test(id)) return true
+        return false
+      },
+      output: {
+        format: 'es',
+        entryFileNames: 'entry.js',
+        chunkFileNames: 'chunks/[name]-[hash].js',
+        assetFileNames: 'assets/[name]-[hash][extname]',
+        paths: { 'vue': '@cicore/shared' },
+        exports: 'named'
+      }
+    },
+    outDir: 'dist',
+    sourcemap: false,
+    minify: 'esbuild',
+    emptyOutDir: true
+  }
+})`;
+}
+//# sourceMappingURL=index.js.map