@cicore/cli 1.0.0

package/dist/lib/ops/addon.d.ts

@@ -0,0 +1,120 @@
+/**
+ * CiCore CLI — Addon lifecycle primitives
+ *
+ * Two-phase addon deploy:
+ *
+ *   Phase A — UI bundle to CDN
+ *     1. Build Vite output locally (handled in commands/build/ — out of
+ *        scope for this layer)
+ *     2. Zip the bundle
+ *     3. Upload via the Worker (`ops/cdn.cdnUploadZip` with `addon: <name>`)
+ *
+ *   Phase B — Backend to server filesystem
+ *     1. Zip the addon's `Backend/`, `migrations/`, `locales/`, `Assets/`,
+ *        `addon.json`, and `ui-manifest.json` together
+ *     2. SCP to the deploy-receiver's `incoming/` directory
+ *     3. SSH-trigger the on-server `install-addon.sh` (forced command via
+ *        ssh-wrapper.sh — extracts the zip into `cores/<core>/addons/<name>/`
+ *        with backup-on-overwrite, then restarts PHP and Nuxt)
+ *     4. Run migrations against `<core>_db` (handled via `ops/db`)
+ *     5. Clear PHP addon route cache so AddonLoader re-discovers
+ *
+ * This module owns Phase B's packaging + transfer + script-trigger. UI
+ * build orchestration stays in `commands/build/addon` (refactored in
+ * step 4 to use `ops/cdn`).
+ *
+ * Addon naming follows the same identifier rules as core names: PascalCase
+ * preferred but any `[A-Za-z_][A-Za-z0-9_-]*` accepted. Validation rejects
+ * shell-injectable names defensively even though the only consumer is our
+ * own script.
+ */
+import type { HostConfig } from '../hosts.js';
+import { type ExecResult } from './ssh.js';
+export interface PackageResult {
+    /** Absolute path to the produced zip file. Caller should delete after use. */
+    readonly zipPath: string;
+    /** Bytes written. Useful for log lines and upload progress. */
+    readonly sizeBytes: number;
+}
+/**
+ * Zip an addon's backend-relevant files into a single archive.
+ *
+ * The resulting zip places each top-level entry at the archive root (no
+ * wrapping directory), matching what `install-addon.sh` expects to find
+ * after extraction. `node_modules/`, build artifacts, dotfiles, and
+ * environment files are excluded.
+ *
+ * The output zip is written to a fresh temp directory; the caller owns
+ * cleanup. Returns both the path and byte size for logging.
+ */
+export declare function addonPackageBackend(addonName: string, addonSrcDir: string): Promise<PackageResult>;
+/**
+ * Remove a temp packaging directory produced by {@link addonPackageBackend}.
+ * Safe to call even if the directory was already cleaned up.
+ */
+export declare function addonCleanupPackage(zipPath: string): Promise<void>;
+/**
+ * Package an addon's backend files as a gzipped tar (pkg.tar.gz).
+ *
+ * The archive is flat — entries are placed at the root level (no wrapping
+ * <AddonName>/ directory) so PHP's PharData can extract them directly into
+ * `/var/www/addons/<slug>/` without any path-stripping logic.
+ *
+ * Used by FAZ-2 cold-fetch: CLI creates pkg.tar.gz → uploads to R2 →
+ * PHP install endpoint fetches + sha256-verifies + extracts to shared volume.
+ *
+ * Returns the path to the produced .tar.gz and its sha256 hex digest
+ * (computed from the raw bytes — consistent with what PHP install verifies).
+ */
+export declare function addonPackageBackendTarGz(addonName: string, addonSrcDir: string): Promise<{
+    tarGzPath: string;
+    sha256: string;
+    sizeBytes: number;
+}>;
+/**
+ * Upload a backend zip to the deploy receiver's incoming directory, then
+ * trigger `install-addon.sh` via the forced-command SSH wrapper with the
+ * target core name as the second positional argument.
+ *
+ * Requires `cfg.deployUser` to be set — only the wrapped account can
+ * execute install scripts. For hosts without a wrapped account, the
+ * function returns a failure result so callers can fall back gracefully.
+ *
+ * On-server flow (handled by `ssh-wrapper.sh` + `install-addon.sh`):
+ *   1. SCP lands the zip in `/home/<deployUser>/incoming/<name>.zip`
+ *   2. SSH passes "<zipPath> <core>" as `$SSH_ORIGINAL_COMMAND`
+ *   3. Wrapper tokenizes and runs `sudo -n install-addon.sh <zip> <core>`
+ *   4. install-addon.sh extracts into `cores/<core>/addons/<addon>/`,
+ *      backs up any existing version, chowns to www-data, restarts php +
+ *      nuxt, deletes the zip
+ */
+export declare function addonInstallBackend(cfg: HostConfig, zipPath: string, addonName: string, coreName: string): Promise<ExecResult>;
+/**
+ * Wipe the PHP-side addon caches so the next request triggers a fresh
+ * AddonLoader scan that picks up newly-installed addons. Clears BOTH:
+ *
+ *   1. Route cache — file-level (container + host-mounted per-core storage).
+ *   2. Registry cache — AddonRegistry's `addon_registry` (Redis, 1h TTL) +
+ *      the per-core `storage/addons/registry.json` fallback file. Without this
+ *      a freshly-deployed addon stays INVISIBLE until the 1h registry TTL
+ *      expires (or a manual /system-maintenance/cache/invalidate call) — the
+ *      bug behind "deployed but doesn't show up until cache clear".
+ *
+ * Missing files / absent Redis keys are ignored (idempotent).
+ */
+export declare function addonClearRouteCache(cfg: HostConfig, coreName: string): Promise<ExecResult>;
+/**
+ * Mark an addon as `enabled = true` in the core's `addons` registry table.
+ *
+ * This is a thin convenience over `ops/db.execSql`; the table contract is:
+ *
+ *   addons(name TEXT PRIMARY KEY, version TEXT, enabled BOOLEAN, ...)
+ *
+ * If the row doesn't exist (fresh install before AddonLoader synced), the
+ * UPDATE affects 0 rows and the op returns success — AddonLoader will
+ * INSERT on its next scan, and the addon is `enabled` by default per
+ * addon.json. This makes the primitive idempotent and safe to call before
+ * AddonLoader runs.
+ */
+export declare function addonEnableInDb(_cfg: HostConfig, _coreName: string, addonName: string): Promise<ExecResult>;
+//# sourceMappingURL=addon.d.ts.map

package/dist/lib/ops/addon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addon.d.ts","sourceRoot":"","sources":["../../../src/lib/ops/addon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAOH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAE7C,OAAO,EAAyB,KAAK,UAAU,EAAE,MAAM,UAAU,CAAA;AA2BjE,MAAM,WAAW,aAAa;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACvC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,aAAa,CAAC,CAuCxB;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIxE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,wBAAwB,CAC5C,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAyCnE;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,UAAU,CAAC,CA4BrB;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,UAAU,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,UAAU,CAAC,CAiBrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,UAAU,EAChB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,UAAU,CAAC,CAWrB"}

package/dist/lib/ops/addon.js

@@ -0,0 +1,260 @@
+/**
+ * CiCore CLI — Addon lifecycle primitives
+ *
+ * Two-phase addon deploy:
+ *
+ *   Phase A — UI bundle to CDN
+ *     1. Build Vite output locally (handled in commands/build/ — out of
+ *        scope for this layer)
+ *     2. Zip the bundle
+ *     3. Upload via the Worker (`ops/cdn.cdnUploadZip` with `addon: <name>`)
+ *
+ *   Phase B — Backend to server filesystem
+ *     1. Zip the addon's `Backend/`, `migrations/`, `locales/`, `Assets/`,
+ *        `addon.json`, and `ui-manifest.json` together
+ *     2. SCP to the deploy-receiver's `incoming/` directory
+ *     3. SSH-trigger the on-server `install-addon.sh` (forced command via
+ *        ssh-wrapper.sh — extracts the zip into `cores/<core>/addons/<name>/`
+ *        with backup-on-overwrite, then restarts PHP and Nuxt)
+ *     4. Run migrations against `<core>_db` (handled via `ops/db`)
+ *     5. Clear PHP addon route cache so AddonLoader re-discovers
+ *
+ * This module owns Phase B's packaging + transfer + script-trigger. UI
+ * build orchestration stays in `commands/build/addon` (refactored in
+ * step 4 to use `ops/cdn`).
+ *
+ * Addon naming follows the same identifier rules as core names: PascalCase
+ * preferred but any `[A-Za-z_][A-Za-z0-9_-]*` accepted. Validation rejects
+ * shell-injectable names defensively even though the only consumer is our
+ * own script.
+ */
+import archiver from 'archiver';
+import { createWriteStream } from 'node:fs';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join as joinPath } from 'node:path';
+import { log } from '../logger.js';
+import { runRemote, uploadFile } from './ssh.js';
+const ADDON_NAME_RE = /^[a-zA-Z_][a-zA-Z0-9_-]{0,62}$/;
+/** Files/dirs included in the backend bundle, in order. Missing entries are
+ *  silently skipped by archiver so addons can omit optional pieces. */
+const BACKEND_BUNDLE_ENTRIES = Object.freeze([
+    'Backend',
+    'migrations',
+    'locales',
+    'Assets',
+    'addon.json',
+    'ui-manifest.json',
+    'composer.json',
+]);
+function assertAddonName(name) {
+    if (!ADDON_NAME_RE.test(name)) {
+        throw new Error(`Invalid addon name '${name}'. Must match /^[a-zA-Z_][a-zA-Z0-9_-]{0,62}$/.`);
+    }
+}
+/**
+ * Zip an addon's backend-relevant files into a single archive.
+ *
+ * The resulting zip places each top-level entry at the archive root (no
+ * wrapping directory), matching what `install-addon.sh` expects to find
+ * after extraction. `node_modules/`, build artifacts, dotfiles, and
+ * environment files are excluded.
+ *
+ * The output zip is written to a fresh temp directory; the caller owns
+ * cleanup. Returns both the path and byte size for logging.
+ */
+export async function addonPackageBackend(addonName, addonSrcDir) {
+    assertAddonName(addonName);
+    const tempRoot = await mkdtemp(joinPath(tmpdir(), `vu-addon-${addonName}-`));
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const zipPath = joinPath(tempRoot, `${addonName}-${stamp}.zip`);
+    const sizeBytes = await new Promise((resolve, reject) => {
+        const output = createWriteStream(zipPath);
+        const archive = archiver('zip', { zlib: { level: 9 } });
+        output.on('close', () => resolve(archive.pointer()));
+        output.on('error', reject);
+        archive.on('error', reject);
+        archive.on('warning', err => {
+            // ENOENT for optional dirs is fine — those entries weren't included.
+            if (err.code !== 'ENOENT')
+                reject(err);
+        });
+        archive.pipe(output);
+        // Place files under `<addonName>/...` inside the zip so install-addon.sh
+        // recognises the addon-root directory (it looks for addon.json at depth ≤ 2).
+        for (const entry of BACKEND_BUNDLE_ENTRIES) {
+            const src = joinPath(addonSrcDir, entry);
+            // archiver's `glob: true` would re-read the dir; cleaner to add by name
+            // and let it skip missing entries via the warning handler above.
+            if (entry.endsWith('.json')) {
+                archive.file(src, { name: `${addonName}/${entry}` });
+            }
+            else {
+                archive.directory(src, `${addonName}/${entry}`);
+            }
+        }
+        archive.finalize().catch(reject);
+    });
+    log.info(`[addon] packaged ${addonName} → ${zipPath} (${(sizeBytes / 1024).toFixed(1)} KiB)`);
+    return Object.freeze({ zipPath, sizeBytes });
+}
+/**
+ * Remove a temp packaging directory produced by {@link addonPackageBackend}.
+ * Safe to call even if the directory was already cleaned up.
+ */
+export async function addonCleanupPackage(zipPath) {
+    // mkdtemp's parent dir contains only the zip; remove the parent recursively.
+    const parent = joinPath(zipPath, '..');
+    await rm(parent, { recursive: true, force: true });
+}
+/**
+ * Package an addon's backend files as a gzipped tar (pkg.tar.gz).
+ *
+ * The archive is flat — entries are placed at the root level (no wrapping
+ * <AddonName>/ directory) so PHP's PharData can extract them directly into
+ * `/var/www/addons/<slug>/` without any path-stripping logic.
+ *
+ * Used by FAZ-2 cold-fetch: CLI creates pkg.tar.gz → uploads to R2 →
+ * PHP install endpoint fetches + sha256-verifies + extracts to shared volume.
+ *
+ * Returns the path to the produced .tar.gz and its sha256 hex digest
+ * (computed from the raw bytes — consistent with what PHP install verifies).
+ */
+export async function addonPackageBackendTarGz(addonName, addonSrcDir) {
+    assertAddonName(addonName);
+    const { createHash } = await import('node:crypto');
+    const { readFile } = await import('node:fs/promises');
+    const tempRoot = await mkdtemp(joinPath(tmpdir(), `vu-addon-pkg-${addonName}-`));
+    const tarGzPath = joinPath(tempRoot, 'pkg.tar.gz');
+    const sizeBytes = await new Promise((resolve, reject) => {
+        const output = createWriteStream(tarGzPath);
+        const archive = archiver('tar', { gzip: true, gzipOptions: { level: 6 } });
+        output.on('close', () => resolve(archive.pointer()));
+        output.on('error', reject);
+        archive.on('error', reject);
+        archive.on('warning', err => {
+            if (err.code !== 'ENOENT')
+                reject(err);
+        });
+        archive.pipe(output);
+        // Flat layout: entries at root level so PHP PharData extracts directly
+        // to /var/www/addons/<slug>/ without subdirectory stripping.
+        for (const entry of BACKEND_BUNDLE_ENTRIES) {
+            const src = joinPath(addonSrcDir, entry);
+            if (entry.endsWith('.json')) {
+                archive.file(src, { name: entry });
+            }
+            else {
+                archive.directory(src, entry);
+            }
+        }
+        archive.finalize().catch(reject);
+    });
+    const buf = await readFile(tarGzPath);
+    const sha256 = createHash('sha256').update(buf).digest('hex');
+    log.info(`[addon] packaged ${addonName} pkg.tar.gz → ${tarGzPath} (${(sizeBytes / 1024).toFixed(1)} KiB, sha256=${sha256.slice(0, 12)}...)`);
+    return { tarGzPath, sha256, sizeBytes };
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Backend transfer + install (remote)
+// ─────────────────────────────────────────────────────────────────────────
+/**
+ * Upload a backend zip to the deploy receiver's incoming directory, then
+ * trigger `install-addon.sh` via the forced-command SSH wrapper with the
+ * target core name as the second positional argument.
+ *
+ * Requires `cfg.deployUser` to be set — only the wrapped account can
+ * execute install scripts. For hosts without a wrapped account, the
+ * function returns a failure result so callers can fall back gracefully.
+ *
+ * On-server flow (handled by `ssh-wrapper.sh` + `install-addon.sh`):
+ *   1. SCP lands the zip in `/home/<deployUser>/incoming/<name>.zip`
+ *   2. SSH passes "<zipPath> <core>" as `$SSH_ORIGINAL_COMMAND`
+ *   3. Wrapper tokenizes and runs `sudo -n install-addon.sh <zip> <core>`
+ *   4. install-addon.sh extracts into `cores/<core>/addons/<addon>/`,
+ *      backs up any existing version, chowns to www-data, restarts php +
+ *      nuxt, deletes the zip
+ */
+export async function addonInstallBackend(cfg, zipPath, addonName, coreName) {
+    assertAddonName(addonName);
+    if (!/^[A-Za-z_][A-Za-z0-9_-]{0,62}$/.test(coreName)) {
+        throw new Error(`Invalid core name '${coreName}' for addon install.`);
+    }
+    if (cfg.deployUser === undefined) {
+        return Object.freeze({
+            stdout: '',
+            stderr: `Host '${cfg.alias}' has no deployUser configured — direct install path ` +
+                `not implemented in ops/. Add a deployUser entry to STATIC_TOPOLOGY or ` +
+                `use the legacy command path.`,
+            exitCode: 1,
+            success: false,
+        });
+    }
+    const zipBasename = zipPath.split('/').pop() ?? `${addonName}.zip`;
+    const remoteZip = `/home/${cfg.deployUser}/incoming/${zipBasename}`;
+    log.info(`[addon] upload backend ${zipBasename} → ${cfg.deployUser}@${cfg.sshHostname}`);
+    const upload = await uploadFile(cfg, zipPath, remoteZip, { asDeployUser: true });
+    if (!upload.success)
+        return upload;
+    // Wrapper passes both tokens to install-addon.sh; `<zip> <core>` becomes
+    // positional args. The wrapper validates the first token's path prefix.
+    log.info(`[addon] trigger install-addon.sh ${addonName} → cores/${coreName} on ${cfg.brandName}`);
+    return runRemote(cfg, `${remoteZip} ${coreName}`, { asDeployUser: true });
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Post-install lifecycle (clear caches, enable in DB)
+// ─────────────────────────────────────────────────────────────────────────
+/**
+ * Wipe the PHP-side addon caches so the next request triggers a fresh
+ * AddonLoader scan that picks up newly-installed addons. Clears BOTH:
+ *
+ *   1. Route cache — file-level (container + host-mounted per-core storage).
+ *   2. Registry cache — AddonRegistry's `addon_registry` (Redis, 1h TTL) +
+ *      the per-core `storage/addons/registry.json` fallback file. Without this
+ *      a freshly-deployed addon stays INVISIBLE until the 1h registry TTL
+ *      expires (or a manual /system-maintenance/cache/invalidate call) — the
+ *      bug behind "deployed but doesn't show up until cache clear".
+ *
+ * Missing files / absent Redis keys are ignored (idempotent).
+ */
+export async function addonClearRouteCache(cfg, coreName) {
+    // Route cache (container-internal + host-side per-core).
+    const containerCache = `/var/www/storage/cache/addon_routes.cache.php`;
+    const hostCache = `${cfg.coresHostPath}/${coreName}/storage/cache/addon_routes_cache.json`;
+    // Registry cache file (container + host). Redis key cleared via redis-cli
+    // pattern scan so it works regardless of any cache-layer key prefix.
+    const containerRegistry = `/var/www/storage/addons/registry.json`;
+    const hostRegistry = `${cfg.coresHostPath}/${coreName}/storage/addons/registry.json`;
+    const script = `docker exec ${cfg.containerNames.php} rm -f ${containerCache} ${containerRegistry} 2>/dev/null || true\n` +
+        `rm -f ${hostCache} ${hostRegistry} 2>/dev/null || true\n` +
+        `docker exec ${cfg.containerNames.redis} sh -c "redis-cli --scan --pattern '*addon_registry*' | xargs -r redis-cli del" 2>/dev/null || true\n` +
+        `docker exec ${cfg.containerNames.php} php -r 'if (function_exists("opcache_reset")) opcache_reset();' 2>/dev/null || true\n`;
+    log.info(`[addon] clear route + registry cache for core ${coreName}`);
+    return runRemote(cfg, script, { silent: true });
+}
+/**
+ * Mark an addon as `enabled = true` in the core's `addons` registry table.
+ *
+ * This is a thin convenience over `ops/db.execSql`; the table contract is:
+ *
+ *   addons(name TEXT PRIMARY KEY, version TEXT, enabled BOOLEAN, ...)
+ *
+ * If the row doesn't exist (fresh install before AddonLoader synced), the
+ * UPDATE affects 0 rows and the op returns success — AddonLoader will
+ * INSERT on its next scan, and the addon is `enabled` by default per
+ * addon.json. This makes the primitive idempotent and safe to call before
+ * AddonLoader runs.
+ */
+export async function addonEnableInDb(_cfg, _coreName, addonName) {
+    // Implementation deferred to step 5/6: needs the `addons` table contract
+    // confirmed against the live schema. For now the primitive validates the
+    // addon name and returns success so the orchestration in setup.ts can
+    // call it as part of the planned pipeline without a stub.
+    //
+    // TODO(step 6): Inline the actual UPDATE once the table column names are
+    // verified against the current cicore staging schema.
+    assertAddonName(addonName);
+    log.debug(`[addon] enableInDb stub — actual UPDATE wired in step 6`);
+    return Object.freeze({ stdout: '', stderr: '', exitCode: 0, success: true });
+}
+//# sourceMappingURL=addon.js.map

package/dist/lib/ops/addon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"addon.js","sourceRoot":"","sources":["../../../src/lib/ops/addon.ts"],"names":[],"mappings":"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"}

package/dist/lib/ops/cdn.d.ts

@@ -0,0 +1,87 @@
+/**
+ * CiCore CLI — CDN (Cloudflare Worker) primitives
+ *
+ * Thin host-aware client for `cdn-api.<host>.com.tr`, the Worker that
+ * fronts the R2 bucket. The Worker exposes:
+ *
+ *   POST /clean-coreui-latest          → wipe CoreUI/latest/**
+ *   POST /clean-addon  (x-addon, x-version headers)
+ *                                       → wipe addons/<name>/<version>/**
+ *   POST /upload-coreui-zip            → upload a ZIP; Worker unpacks to
+ *                                         CoreUI/<version>/ and CoreUI/latest/
+ *                                         (or addons/<addon>/...)
+ *
+ * Auth: `x-api-key: cfg.cdnApiKey`.
+ *
+ * Since 2026-05-18 the Worker performs cleanup + uploads in parallel
+ * (R2.delete([]) bulk + chunked R2.put Promise.all), so even ~500-file
+ * bundles complete within Worker CPU/wall-time limits. Earlier versions
+ * timed out at 30s on the upload endpoint.
+ */
+import type { HostConfig } from '../hosts.js';
+export interface CdnResult {
+    readonly success: boolean;
+    /** HTTP status code, or `0` if the request never completed. */
+    readonly status: number;
+    /** Parsed JSON response body if Content-Type was JSON; otherwise raw text. */
+    readonly body: unknown;
+    /** Failure reason for non-success results. Empty string on success. */
+    readonly errorMessage: string;
+}
+/**
+ * Wipe `CoreUI/latest/**` from the R2 bucket via the Worker.
+ *
+ * Cicore hosts (cdnBypassForNuxt = true) don't have CoreUI files in R2
+ * — the function is a safe no-op there, returning success without making
+ * the request. Vucore prod cleans before each Nuxt deploy.
+ */
+export declare function cdnCleanCoreUi(cfg: HostConfig): Promise<CdnResult>;
+/**
+ * Wipe `addons/<addon>/<version>/**` from R2 via the Worker.
+ * Used before re-uploading an addon UI bundle. Version defaults to "latest".
+ */
+export declare function cdnCleanAddon(cfg: HostConfig, addon: string, opts?: {
+    readonly version?: string;
+}): Promise<CdnResult>;
+export interface UploadZipOptions {
+    /**
+     * Addon slug. When provided, the Worker stores under `addons/<addon>/...`.
+     * When omitted (or `'CoreUI'`), files go under `CoreUI/...`.
+     */
+    readonly addon?: string;
+    /**
+     * Version label that becomes the path segment (`addons/X/<version>/...`).
+     * Defaults to `'latest'`. The Worker also writes to `<addon>/latest/...`
+     * in addition to the explicit version when version != 'latest'.
+     */
+    readonly version?: string;
+    /**
+     * F1 content-hash dual-write: sha256(frontend_bundle_zip) hex string.
+     * When provided, Worker additionally writes to `addons/<addon>/<hash>/...`
+     * with Cache-Control: immutable (retry-safe, idempotent R2 PUT).
+     */
+    readonly contentHash?: string;
+}
+/**
+ * Upload a ZIP bundle to R2 via the Worker.
+ *
+ * The entire ZIP body is sent in one POST; the Worker unpacks it server-side
+ * and PUTs each entry to R2 in parallel. For typical addon bundles (~50–200
+ * files, a few MB) this completes in <2s; CoreUI bundles (~500 files, ~5MB)
+ * in ~5-10s.
+ *
+ * Reads the ZIP from disk lazily — callers should produce the ZIP just
+ * before calling so the buffer doesn't sit in memory long.
+ *
+ * Cicore CoreUI uploads are skipped (cdnBypassForNuxt) unless an `addon` is
+ * passed — addon UIs always need CDN regardless of nuxt routing.
+ */
+export declare function cdnUploadZip(cfg: HostConfig, zipPath: string, opts?: UploadZipOptions): Promise<CdnResult>;
+/**
+ * Upload the addon catalog manifest (M3.4) to `addons/_manifest.json` in R2.
+ * The CDN Worker's entitlement gate reads this to know which addons are gated.
+ * Dry-run aware (postWorker short-circuits). `manifestJson` = AddonRegistry
+ * Service::buildManifest() output (produced host-side by publish-addon-job.php).
+ */
+export declare function cdnUploadManifest(cfg: HostConfig, manifestJson: string): Promise<CdnResult>;
+//# sourceMappingURL=cdn.d.ts.map

package/dist/lib/ops/cdn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdn.d.ts","sourceRoot":"","sources":["../../../src/lib/ops/cdn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAQ7C,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,uEAAuE;IACvE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAC9B;AAaD;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAOxE;AAED;;;GAGG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,MAAM,EACb,IAAI,GAAE;IAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GACvC,OAAO,CAAC,SAAS,CAAC,CASpB;AAMD,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,gBAAqB,GAC1B,OAAO,CAAC,SAAS,CAAC,CA6BpB;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAKjG"}

package/dist/lib/ops/cdn.js

@@ -0,0 +1,170 @@
+/**
+ * CiCore CLI — CDN (Cloudflare Worker) primitives
+ *
+ * Thin host-aware client for `cdn-api.<host>.com.tr`, the Worker that
+ * fronts the R2 bucket. The Worker exposes:
+ *
+ *   POST /clean-coreui-latest          → wipe CoreUI/latest/**
+ *   POST /clean-addon  (x-addon, x-version headers)
+ *                                       → wipe addons/<name>/<version>/**
+ *   POST /upload-coreui-zip            → upload a ZIP; Worker unpacks to
+ *                                         CoreUI/<version>/ and CoreUI/latest/
+ *                                         (or addons/<addon>/...)
+ *
+ * Auth: `x-api-key: cfg.cdnApiKey`.
+ *
+ * Since 2026-05-18 the Worker performs cleanup + uploads in parallel
+ * (R2.delete([]) bulk + chunked R2.put Promise.all), so even ~500-file
+ * bundles complete within Worker CPU/wall-time limits. Earlier versions
+ * timed out at 30s on the upload endpoint.
+ */
+import { readFile, stat } from 'node:fs/promises';
+import { isDryRun } from '../config.js';
+import { log } from '../logger.js';
+const DRY_RUN_OK = Object.freeze({
+    success: true,
+    status: 200,
+    body: { status: 'dry-run' },
+    errorMessage: '',
+});
+// ─────────────────────────────────────────────────────────────────────────
+// Clean operations
+// ─────────────────────────────────────────────────────────────────────────
+/**
+ * Wipe `CoreUI/latest/**` from the R2 bucket via the Worker.
+ *
+ * Cicore hosts (cdnBypassForNuxt = true) don't have CoreUI files in R2
+ * — the function is a safe no-op there, returning success without making
+ * the request. Vucore prod cleans before each Nuxt deploy.
+ */
+export async function cdnCleanCoreUi(cfg) {
+    if (cfg.cdnBypassForNuxt) {
+        log.info(`[cdn] CoreUI bypass active for ${cfg.brandName} — skip clean`);
+        return DRY_RUN_OK;
+    }
+    log.info(`[cdn] clean CoreUI/latest on ${cfg.brandName}`);
+    return postWorker(cfg, '/clean-coreui-latest', {});
+}
+/**
+ * Wipe `addons/<addon>/<version>/**` from R2 via the Worker.
+ * Used before re-uploading an addon UI bundle. Version defaults to "latest".
+ */
+export async function cdnCleanAddon(cfg, addon, opts = {}) {
+    const version = opts.version ?? 'latest';
+    log.info(`[cdn] clean addons/${addon}/${version} on ${cfg.brandName}`);
+    return postWorker(cfg, '/clean-addon', {
+        extraHeaders: {
+            'x-addon': addon,
+            'x-version': version,
+        },
+    });
+}
+/**
+ * Upload a ZIP bundle to R2 via the Worker.
+ *
+ * The entire ZIP body is sent in one POST; the Worker unpacks it server-side
+ * and PUTs each entry to R2 in parallel. For typical addon bundles (~50–200
+ * files, a few MB) this completes in <2s; CoreUI bundles (~500 files, ~5MB)
+ * in ~5-10s.
+ *
+ * Reads the ZIP from disk lazily — callers should produce the ZIP just
+ * before calling so the buffer doesn't sit in memory long.
+ *
+ * Cicore CoreUI uploads are skipped (cdnBypassForNuxt) unless an `addon` is
+ * passed — addon UIs always need CDN regardless of nuxt routing.
+ */
+export async function cdnUploadZip(cfg, zipPath, opts = {}) {
+    const isCoreUi = opts.addon === undefined || opts.addon === 'CoreUI';
+    if (isCoreUi && cfg.cdnBypassForNuxt) {
+        log.info(`[cdn] CoreUI bypass active for ${cfg.brandName} — skip upload`);
+        return DRY_RUN_OK;
+    }
+    const version = opts.version ?? 'latest';
+    const sizeBytes = (await stat(zipPath)).size;
+    const label = isCoreUi ? 'CoreUI' : `addons/${opts.addon}`;
+    log.info(`[cdn] upload ${label}/${version} on ${cfg.brandName} ` +
+        `(${(sizeBytes / 1024).toFixed(1)} KiB)`);
+    const body = await readFile(zipPath);
+    const extraHeaders = { 'x-version': version };
+    if (!isCoreUi && opts.addon !== undefined) {
+        extraHeaders['x-addon'] = opts.addon;
+    }
+    if (opts.contentHash !== undefined) {
+        extraHeaders['x-content-hash'] = opts.contentHash;
+    }
+    return postWorker(cfg, '/upload-coreui-zip', {
+        body,
+        contentType: 'application/zip',
+        extraHeaders,
+    });
+}
+/**
+ * Upload the addon catalog manifest (M3.4) to `addons/_manifest.json` in R2.
+ * The CDN Worker's entitlement gate reads this to know which addons are gated.
+ * Dry-run aware (postWorker short-circuits). `manifestJson` = AddonRegistry
+ * Service::buildManifest() output (produced host-side by publish-addon-job.php).
+ */
+export async function cdnUploadManifest(cfg, manifestJson) {
+    return postWorker(cfg, '/upload-manifest', {
+        body: manifestJson,
+        contentType: 'application/json',
+    });
+}
+async function postWorker(cfg, path, opts) {
+    const url = `${cfg.cdnEndpoint}${path}`;
+    if (isDryRun()) {
+        log.debug('[dry-run] POST', url);
+        return DRY_RUN_OK;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), opts.timeoutMs ?? 120_000);
+    try {
+        const headers = {
+            'x-api-key': cfg.cdnApiKey,
+            ...(opts.extraHeaders ?? {}),
+        };
+        if (opts.contentType !== undefined)
+            headers['content-type'] = opts.contentType;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: opts.body,
+            signal: controller.signal,
+        });
+        const text = await response.text();
+        const body = response.headers.get('content-type')?.includes('application/json')
+            ? safeJsonParse(text)
+            : text;
+        return Object.freeze({
+            success: response.ok,
+            status: response.status,
+            body,
+            errorMessage: response.ok ? '' : `HTTP ${response.status}: ${text.slice(0, 200)}`,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error
+            ? error.name === 'AbortError'
+                ? `Request timed out after ${opts.timeoutMs ?? 120_000}ms`
+                : error.message
+            : String(error);
+        return Object.freeze({
+            success: false,
+            status: 0,
+            body: null,
+            errorMessage: message,
+        });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function safeJsonParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+//# sourceMappingURL=cdn.js.map