@growthub/cli 0.6.5 → 0.6.7

package/dist/kits/service.js

@@ -1,630 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { expandHomePrefix, resolvePaperclipHomeDir } from "../config/home.js";
-import { BUNDLED_KIT_CATALOG } from "./catalog.js";
-import { SUPPORTED_SCHEMA_VERSIONS, KIT_CAPABILITY_TYPES, KIT_ACTIVATION_MODES, normalizeManifest, normalizeBundleManifest, } from "./contract.js";
-const LATEST_SCHEMA_VERSION = 2;
-const ZIP_TIMESTAMP = new Date("2026-04-09T00:00:00.000Z");
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-function resolveBundledKitAssetsRoot() {
-    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
-    const candidates = [
-        path.resolve(moduleDir, "../../assets/worker-kits"),
-        path.resolve(moduleDir, "../assets/worker-kits"),
-    ];
-    for (const candidate of candidates) {
-        if (fs.existsSync(candidate))
-            return candidate;
-    }
-    throw new Error("Could not locate bundled worker kit assets.");
-}
-function resolveRequestedOutputRoot(outDir) {
-    if (outDir?.trim()) {
-        return path.resolve(expandHomePrefix(outDir.trim()));
-    }
-    return path.resolve(resolvePaperclipHomeDir(), "kits", "exports");
-}
-function readJsonFile(filePath) {
-    return JSON.parse(fs.readFileSync(filePath, "utf8"));
-}
-function assertRelativePathExists(assetRoot, relativePath, label) {
-    const fullPath = path.resolve(assetRoot, relativePath);
-    if (!fs.existsSync(fullPath)) {
-        throw new Error(`${label} is missing required path: ${relativePath}`);
-    }
-}
-function listRelativeFiles(rootDir) {
-    const files = [];
-    const walk = (currentDir) => {
-        for (const entry of fs.readdirSync(currentDir, { withFileTypes: true })) {
-            const fullPath = path.join(currentDir, entry.name);
-            if (entry.isDirectory()) {
-                walk(fullPath);
-                continue;
-            }
-            files.push(path.relative(rootDir, fullPath).split(path.sep).join("/"));
-        }
-    };
-    walk(rootDir);
-    return files.sort();
-}
-// ---------------------------------------------------------------------------
-// Manifest parsing — supports v1 and v2, normalizes to v2
-// ---------------------------------------------------------------------------
-function parseManifest(assetRoot) {
-    const raw = readJsonFile(path.resolve(assetRoot, "kit.json"));
-    if (!SUPPORTED_SCHEMA_VERSIONS.includes(raw.schemaVersion)) {
-        throw new Error(`Unsupported kit schema version for ${assetRoot}: ${raw.schemaVersion}`);
-    }
-    return normalizeManifest(raw);
-}
-function parseBundleManifest(assetRoot, manifest, bundleId) {
-    const bundleRef = manifest.bundles.find((item) => item.id === bundleId);
-    if (!bundleRef) {
-        throw new Error(`Kit ${manifest.kit.id} does not declare bundle ${bundleId}.`);
-    }
-    const raw = readJsonFile(path.resolve(assetRoot, bundleRef.path));
-    if (!SUPPORTED_SCHEMA_VERSIONS.includes(raw.schemaVersion)) {
-        throw new Error(`Unsupported bundle schema version for ${bundleRef.path}: ${raw.schemaVersion}`);
-    }
-    return normalizeBundleManifest(raw);
-}
-// ---------------------------------------------------------------------------
-// Validation
-// ---------------------------------------------------------------------------
-function validateBundledKit(resolved) {
-    const { assetRoot, manifest, bundleManifest } = resolved;
-    if (manifest.kit.id !== resolved.catalogEntry.id) {
-        throw new Error(`Bundled catalog mismatch: expected ${resolved.catalogEntry.id}, got ${manifest.kit.id}.`);
-    }
-    if (bundleManifest.bundle.kitId !== manifest.kit.id) {
-        throw new Error(`Bundle ${bundleManifest.bundle.id} points at ${bundleManifest.bundle.kitId}, expected ${manifest.kit.id}.`);
-    }
-    if (bundleManifest.bundle.workerId !== manifest.entrypoint.workerId) {
-        throw new Error(`Bundle ${bundleManifest.bundle.id} worker mismatch: ${bundleManifest.bundle.workerId} vs ${manifest.entrypoint.workerId}.`);
-    }
-    assertRelativePathExists(assetRoot, manifest.entrypoint.path, "Kit manifest");
-    assertRelativePathExists(assetRoot, manifest.agentContractPath, "Kit manifest");
-    assertRelativePathExists(assetRoot, manifest.brandTemplatePath, "Kit manifest");
-    for (const bundle of manifest.bundles) {
-        assertRelativePathExists(assetRoot, bundle.path, "Kit manifest bundle");
-    }
-    for (const relativePath of manifest.frozenAssetPaths) {
-        assertRelativePathExists(assetRoot, relativePath, "Kit manifest");
-    }
-    for (const requiredPath of manifest.outputStandard.requiredPaths) {
-        assertRelativePathExists(assetRoot, requiredPath, "Output standard");
-    }
-    for (const relativePath of bundleManifest.requiredFrozenAssets) {
-        assertRelativePathExists(assetRoot, relativePath, "Bundle manifest");
-    }
-    const kitPublicBrands = new Set(manifest.publicExampleBrandPaths ?? []);
-    const bundlePublicBrands = new Set(bundleManifest.publicExampleBrandPaths ?? []);
-    for (const brandPath of kitPublicBrands) {
-        if (!bundlePublicBrands.has(brandPath)) {
-            throw new Error(`Bundle ${bundleManifest.bundle.id} is missing declared public brand ${brandPath}.`);
-        }
-    }
-    const bundledFiles = listRelativeFiles(assetRoot);
-    const brandKitFiles = bundledFiles.filter((filePath) => filePath.startsWith("brands/") && filePath.endsWith("/brand-kit.md"));
-    const allowedBrandPaths = new Set([
-        manifest.brandTemplatePath,
-        ...(manifest.publicExampleBrandPaths ?? []),
-    ]);
-    const disallowedBrandFiles = brandKitFiles.filter((filePath) => !allowedBrandPaths.has(filePath));
-    if (disallowedBrandFiles.length > 0) {
-        throw new Error(`Bundled kit ${manifest.kit.id} includes non-public brand kits: ${disallowedBrandFiles.join(", ")}`);
-    }
-}
-// ---------------------------------------------------------------------------
-// Generic kit directory validation (for `kit validate <path>`)
-// ---------------------------------------------------------------------------
-export function validateKitDirectory(kitPath) {
-    const errors = [];
-    const warnings = [];
-    let schemaVersion = 0;
-    let kitId = "<unknown>";
-    const kitJsonPath = path.resolve(kitPath, "kit.json");
-    if (!fs.existsSync(kitJsonPath)) {
-        errors.push({ field: "kit.json", message: "kit.json not found in kit directory" });
-        return { valid: false, schemaVersion, kitId, errors, warnings };
-    }
-    let raw;
-    try {
-        raw = JSON.parse(fs.readFileSync(kitJsonPath, "utf8"));
-    }
-    catch {
-        errors.push({ field: "kit.json", message: "kit.json is not valid JSON" });
-        return { valid: false, schemaVersion, kitId, errors, warnings };
-    }
-    schemaVersion = typeof raw.schemaVersion === "number" ? raw.schemaVersion : 0;
-    if (!SUPPORTED_SCHEMA_VERSIONS.includes(schemaVersion)) {
-        errors.push({
-            field: "schemaVersion",
-            message: `Unsupported schema version ${schemaVersion}. Supported: ${SUPPORTED_SCHEMA_VERSIONS.join(", ")}`,
-        });
-        return { valid: false, schemaVersion, kitId, errors, warnings };
-    }
-    const kitBlock = raw.kit;
-    if (!kitBlock || typeof kitBlock !== "object") {
-        errors.push({ field: "kit", message: "Missing required 'kit' block" });
-        return { valid: false, schemaVersion, kitId, errors, warnings };
-    }
-    kitId = typeof kitBlock.id === "string" ? kitBlock.id : "<unknown>";
-    // Required string fields in kit block
-    for (const field of ["id", "version", "name", "description"]) {
-        if (typeof kitBlock[field] !== "string" || kitBlock[field].trim() === "") {
-            errors.push({ field: `kit.${field}`, message: `Missing or empty required field 'kit.${field}'` });
-        }
-    }
-    // Schema v2 specific fields
-    if (schemaVersion === 2) {
-        const kitType = kitBlock.type;
-        if (!kitType || !KIT_CAPABILITY_TYPES.includes(kitType)) {
-            errors.push({
-                field: "kit.type",
-                message: `Invalid or missing kit.type. Expected one of: ${KIT_CAPABILITY_TYPES.join(", ")}`,
-            });
-        }
-        const execMode = raw.executionMode;
-        if (!execMode) {
-            errors.push({ field: "executionMode", message: "Missing required field 'executionMode'" });
-        }
-        else if (!KIT_ACTIVATION_MODES.includes(execMode)) {
-            errors.push({
-                field: "executionMode",
-                message: `Invalid executionMode '${execMode}'. Expected one of: ${KIT_ACTIVATION_MODES.join(", ")}`,
-            });
-        }
-        const activationModes = raw.activationModes;
-        if (!Array.isArray(activationModes) || activationModes.length === 0) {
-            errors.push({ field: "activationModes", message: "Missing or empty 'activationModes' array" });
-        }
-        else {
-            for (const mode of activationModes) {
-                if (!KIT_ACTIVATION_MODES.includes(mode)) {
-                    errors.push({
-                        field: "activationModes",
-                        message: `Invalid activation mode '${mode}'. Expected one of: ${KIT_ACTIVATION_MODES.join(", ")}`,
-                    });
-                }
-            }
-        }
-    }
-    else {
-        // v1 — warn about missing v2 fields
-        warnings.push({ field: "schemaVersion", message: "Kit uses schema v1. Consider upgrading to v2 for capability metadata." });
-    }
-    // Entrypoint
-    const entrypoint = raw.entrypoint;
-    if (!entrypoint || typeof entrypoint !== "object") {
-        errors.push({ field: "entrypoint", message: "Missing required 'entrypoint' block" });
-    }
-    else {
-        if (typeof entrypoint.workerId !== "string") {
-            errors.push({ field: "entrypoint.workerId", message: "Missing required field 'entrypoint.workerId'" });
-        }
-        if (typeof entrypoint.path !== "string") {
-            errors.push({ field: "entrypoint.path", message: "Missing required field 'entrypoint.path'" });
-        }
-        else {
-            const fullPath = path.resolve(kitPath, entrypoint.path);
-            if (!fs.existsSync(fullPath)) {
-                errors.push({ field: "entrypoint.path", message: `Entrypoint file not found: ${entrypoint.path}` });
-            }
-        }
-    }
-    // Agent contract
-    if (typeof raw.agentContractPath !== "string") {
-        errors.push({ field: "agentContractPath", message: "Missing required field 'agentContractPath'" });
-    }
-    else {
-        const fullPath = path.resolve(kitPath, raw.agentContractPath);
-        if (!fs.existsSync(fullPath)) {
-            errors.push({ field: "agentContractPath", message: `Agent contract not found: ${raw.agentContractPath}` });
-        }
-    }
-    // Brand template
-    if (typeof raw.brandTemplatePath !== "string") {
-        errors.push({ field: "brandTemplatePath", message: "Missing required field 'brandTemplatePath'" });
-    }
-    else {
-        const fullPath = path.resolve(kitPath, raw.brandTemplatePath);
-        if (!fs.existsSync(fullPath)) {
-            errors.push({ field: "brandTemplatePath", message: `Brand template not found: ${raw.brandTemplatePath}` });
-        }
-    }
-    // Frozen assets
-    const frozenAssets = raw.frozenAssetPaths;
-    if (!Array.isArray(frozenAssets)) {
-        errors.push({ field: "frozenAssetPaths", message: "Missing required 'frozenAssetPaths' array" });
-    }
-    else {
-        for (const assetPath of frozenAssets) {
-            if (typeof assetPath !== "string")
-                continue;
-            const fullPath = path.resolve(kitPath, assetPath);
-            if (!fs.existsSync(fullPath)) {
-                errors.push({ field: "frozenAssetPaths", message: `Frozen asset not found: ${assetPath}` });
-            }
-        }
-    }
-    // Output standard
-    const outputStandard = raw.outputStandard;
-    if (!outputStandard || typeof outputStandard !== "object") {
-        errors.push({ field: "outputStandard", message: "Missing required 'outputStandard' block" });
-    }
-    else {
-        if (typeof outputStandard.type !== "string") {
-            errors.push({ field: "outputStandard.type", message: "Missing required field 'outputStandard.type'" });
-        }
-        const requiredPaths = outputStandard.requiredPaths;
-        if (!Array.isArray(requiredPaths)) {
-            errors.push({ field: "outputStandard.requiredPaths", message: "Missing required 'outputStandard.requiredPaths' array" });
-        }
-        else {
-            for (const reqPath of requiredPaths) {
-                if (typeof reqPath !== "string")
-                    continue;
-                const fullPath = path.resolve(kitPath, reqPath);
-                if (!fs.existsSync(fullPath)) {
-                    errors.push({ field: "outputStandard.requiredPaths", message: `Required output path not found: ${reqPath}` });
-                }
-            }
-        }
-    }
-    // Bundles
-    const bundles = raw.bundles;
-    if (!Array.isArray(bundles) || bundles.length === 0) {
-        errors.push({ field: "bundles", message: "Missing or empty 'bundles' array" });
-    }
-    else {
-        for (const bundleRef of bundles) {
-            const ref = bundleRef;
-            if (typeof ref.path !== "string") {
-                errors.push({ field: "bundles[].path", message: "Bundle ref missing 'path' field" });
-                continue;
-            }
-            const bundlePath = path.resolve(kitPath, ref.path);
-            if (!fs.existsSync(bundlePath)) {
-                errors.push({ field: "bundles[].path", message: `Bundle manifest not found: ${ref.path}` });
-                continue;
-            }
-            // Validate bundle manifest
-            try {
-                const bundleRaw = JSON.parse(fs.readFileSync(bundlePath, "utf8"));
-                const bundleBlock = bundleRaw.bundle;
-                if (!bundleBlock || typeof bundleBlock !== "object") {
-                    errors.push({ field: `bundle(${ref.id})`, message: "Bundle manifest missing 'bundle' block" });
-                }
-                else {
-                    if (bundleBlock.kitId !== kitId) {
-                        errors.push({
-                            field: `bundle(${ref.id}).kitId`,
-                            message: `Bundle kitId '${bundleBlock.kitId}' does not match kit id '${kitId}'`,
-                        });
-                    }
-                }
-                if (!bundleRaw.export || typeof bundleRaw.export !== "object") {
-                    errors.push({ field: `bundle(${ref.id}).export`, message: "Bundle manifest missing 'export' block" });
-                }
-            }
-            catch {
-                errors.push({ field: `bundle(${ref.id})`, message: `Bundle manifest at ${ref.path} is not valid JSON` });
-            }
-        }
-    }
-    return {
-        valid: errors.length === 0,
-        schemaVersion,
-        kitId,
-        errors,
-        warnings,
-    };
-}
-// ---------------------------------------------------------------------------
-// Resolution
-// ---------------------------------------------------------------------------
-function loadResolvedBundledKit(assetRoot, catalogEntry) {
-    const manifest = parseManifest(assetRoot);
-    const bundleManifest = parseBundleManifest(assetRoot, manifest, catalogEntry.defaultBundleId);
-    const resolved = { catalogEntry, assetRoot, manifest, bundleManifest };
-    validateBundledKit(resolved);
-    return resolved;
-}
-export function validateBundledKitAssetRoot(assetRoot, input) {
-    const catalogEntry = {
-        id: input.kitId,
-        packageDirName: path.basename(assetRoot),
-        defaultBundleId: input.bundleId ?? input.kitId,
-        type: "worker",
-        executionMode: "export",
-        activationModes: ["export"],
-        family: "studio",
-    };
-    loadResolvedBundledKit(assetRoot, catalogEntry);
-}
-// ---------------------------------------------------------------------------
-// Fuzzy slug resolver — tries exact → suffix → contains → "did you mean"
-// ---------------------------------------------------------------------------
-export function fuzzyResolveKitId(input) {
-    const needle = input.toLowerCase().trim();
-    // 1. Exact match
-    const exact = BUNDLED_KIT_CATALOG.find((e) => e.id === needle);
-    if (exact)
-        return exact.id;
-    // 2. Suffix match (e.g. "higgsfield-studio-v1" matches "growthub-open-higgsfield-studio-v1")
-    const suffix = BUNDLED_KIT_CATALOG.find((e) => e.id.endsWith(needle));
-    if (suffix)
-        return suffix.id;
-    // 3. Contains match
-    const contains = BUNDLED_KIT_CATALOG.find((e) => e.id.includes(needle));
-    if (contains)
-        return contains.id;
-    // 4. Word-token match (any word in input appears in kit id)
-    const tokens = needle.split(/[-\s]+/).filter((t) => t.length > 2);
-    for (const token of tokens) {
-        const tokenMatch = BUNDLED_KIT_CATALOG.find((e) => e.id.includes(token));
-        if (tokenMatch)
-            return tokenMatch.id;
-    }
-    return null;
-}
-function resolveBundledKit(kitId) {
-    // Try exact first, then fuzzy
-    const resolvedId = fuzzyResolveKitId(kitId);
-    if (!resolvedId) {
-        const available = BUNDLED_KIT_CATALOG.map((e) => e.id).join(", ");
-        throw new Error(`Unknown kit '${kitId}'. Run 'growthub kit list' to browse available kits.\nAvailable: ${available}`);
-    }
-    const catalogEntry = BUNDLED_KIT_CATALOG.find((e) => e.id === resolvedId);
-    const assetRoot = path.resolve(resolveBundledKitAssetsRoot(), catalogEntry.packageDirName);
-    return loadResolvedBundledKit(assetRoot, catalogEntry);
-}
-// ---------------------------------------------------------------------------
-// List / Inspect / Path / Download
-// ---------------------------------------------------------------------------
-function toListItem(resolved) {
-    return {
-        id: resolved.manifest.kit.id,
-        version: resolved.manifest.kit.version,
-        name: resolved.manifest.kit.name,
-        description: resolved.manifest.kit.description,
-        type: resolved.manifest.kit.type,
-        family: resolved.catalogEntry.family,
-        executionMode: resolved.manifest.executionMode,
-        activationModes: resolved.manifest.activationModes,
-        bundleId: resolved.bundleManifest.bundle.id,
-        bundleVersion: resolved.bundleManifest.bundle.version,
-        briefType: resolved.bundleManifest.briefType,
-    };
-}
-function resolveOutputPaths(resolved, outDir) {
-    const outputRoot = resolveRequestedOutputRoot(outDir);
-    const folderPath = path.resolve(outputRoot, resolved.bundleManifest.export.folderName);
-    const zipPath = path.resolve(outputRoot, resolved.bundleManifest.export.zipFileName);
-    return { outputRoot, folderPath, zipPath };
-}
-export function listBundledKits() {
-    return BUNDLED_KIT_CATALOG.map((entry) => toListItem(resolveBundledKit(entry.id)));
-}
-export function inspectBundledKit(kitId, outDir) {
-    const resolved = resolveBundledKit(kitId);
-    const outputPaths = resolveOutputPaths(resolved, outDir);
-    return {
-        ...toListItem(resolved),
-        entrypointPath: resolved.manifest.entrypoint.path,
-        agentContractPath: resolved.manifest.agentContractPath,
-        brandTemplatePath: resolved.manifest.brandTemplatePath,
-        publicExampleBrandPaths: resolved.manifest.publicExampleBrandPaths ?? [],
-        frozenAssetCount: resolved.manifest.frozenAssetPaths.length,
-        requiredFrozenAssetCount: resolved.bundleManifest.requiredFrozenAssets.length,
-        outputRoot: outputPaths.outputRoot,
-        exportFolderName: resolved.bundleManifest.export.folderName,
-        exportFolderPath: outputPaths.folderPath,
-        exportZipName: resolved.bundleManifest.export.zipFileName,
-        exportZipPath: outputPaths.zipPath,
-        requiredPaths: resolved.manifest.outputStandard.requiredPaths,
-        compatibility: resolved.manifest.compatibility,
-        schemaVersion: resolved.manifest.schemaVersion,
-    };
-}
-export function resolveKitPath(kitId, outDir) {
-    const resolved = resolveBundledKit(kitId);
-    return resolveOutputPaths(resolved, outDir).folderPath;
-}
-export function getBundledKitSourceInfo(kitId) {
-    const resolved = resolveBundledKit(kitId);
-    return {
-        id: resolved.manifest.kit.id,
-        version: resolved.manifest.kit.version,
-        family: resolved.catalogEntry.family,
-        assetRoot: resolved.assetRoot,
-    };
-}
-export function copyBundledKitSource(kitId, destinationPath) {
-    const info = getBundledKitSourceInfo(kitId);
-    fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
-    fs.rmSync(destinationPath, { recursive: true, force: true });
-    fs.cpSync(info.assetRoot, destinationPath, { recursive: true });
-    return info;
-}
-// ---------------------------------------------------------------------------
-// ZIP builder
-// ---------------------------------------------------------------------------
-function crc32(buffer) {
-    let crc = 0xffffffff;
-    for (const byte of buffer) {
-        crc ^= byte;
-        for (let bit = 0; bit < 8; bit += 1) {
-            crc = (crc >>> 1) ^ (0xedb88320 & -(crc & 1));
-        }
-    }
-    return (crc ^ 0xffffffff) >>> 0;
-}
-function toDosTimeParts(date) {
-    const year = Math.max(date.getUTCFullYear(), 1980);
-    const month = date.getUTCMonth() + 1;
-    const day = date.getUTCDate();
-    const hours = date.getUTCHours();
-    const minutes = date.getUTCMinutes();
-    const seconds = Math.floor(date.getUTCSeconds() / 2);
-    return {
-        dosTime: (hours << 11) | (minutes << 5) | seconds,
-        dosDate: ((year - 1980) << 9) | (month << 5) | day,
-    };
-}
-function buildStoredZip(entries) {
-    const parts = [];
-    const centralDirectoryParts = [];
-    let offset = 0;
-    const { dosTime, dosDate } = toDosTimeParts(ZIP_TIMESTAMP);
-    for (const entry of entries) {
-        const nameBuffer = Buffer.from(entry.name, "utf8");
-        const data = entry.data;
-        const checksum = crc32(data);
-        const localHeader = Buffer.alloc(30 + nameBuffer.length);
-        localHeader.writeUInt32LE(0x04034b50, 0);
-        localHeader.writeUInt16LE(20, 4);
-        localHeader.writeUInt16LE(0, 6);
-        localHeader.writeUInt16LE(0, 8);
-        localHeader.writeUInt16LE(dosTime, 10);
-        localHeader.writeUInt16LE(dosDate, 12);
-        localHeader.writeUInt32LE(checksum, 14);
-        localHeader.writeUInt32LE(data.length, 18);
-        localHeader.writeUInt32LE(data.length, 22);
-        localHeader.writeUInt16LE(nameBuffer.length, 26);
-        localHeader.writeUInt16LE(0, 28);
-        nameBuffer.copy(localHeader, 30);
-        parts.push(localHeader, data);
-        const centralHeader = Buffer.alloc(46 + nameBuffer.length);
-        centralHeader.writeUInt32LE(0x02014b50, 0);
-        centralHeader.writeUInt16LE(20, 4);
-        centralHeader.writeUInt16LE(20, 6);
-        centralHeader.writeUInt16LE(0, 8);
-        centralHeader.writeUInt16LE(0, 10);
-        centralHeader.writeUInt16LE(dosTime, 12);
-        centralHeader.writeUInt16LE(dosDate, 14);
-        centralHeader.writeUInt32LE(checksum, 16);
-        centralHeader.writeUInt32LE(data.length, 20);
-        centralHeader.writeUInt32LE(data.length, 24);
-        centralHeader.writeUInt16LE(nameBuffer.length, 28);
-        centralHeader.writeUInt16LE(0, 30);
-        centralHeader.writeUInt16LE(0, 32);
-        centralHeader.writeUInt16LE(0, 34);
-        centralHeader.writeUInt16LE(0, 36);
-        centralHeader.writeUInt32LE(0, 38);
-        centralHeader.writeUInt32LE(offset, 42);
-        nameBuffer.copy(centralHeader, 46);
-        centralDirectoryParts.push(centralHeader);
-        offset += localHeader.length + data.length;
-    }
-    const centralDirectory = Buffer.concat(centralDirectoryParts);
-    const endRecord = Buffer.alloc(22);
-    endRecord.writeUInt32LE(0x06054b50, 0);
-    endRecord.writeUInt16LE(0, 4);
-    endRecord.writeUInt16LE(0, 6);
-    endRecord.writeUInt16LE(entries.length, 8);
-    endRecord.writeUInt16LE(entries.length, 10);
-    endRecord.writeUInt32LE(centralDirectory.length, 12);
-    endRecord.writeUInt32LE(offset, 16);
-    endRecord.writeUInt16LE(0, 20);
-    return Buffer.concat([...parts, centralDirectory, endRecord]);
-}
-function buildZipEntries(sourceRoot, exportFolderName) {
-    return listRelativeFiles(sourceRoot).map((relativePath) => ({
-        name: path.posix.join(exportFolderName, relativePath),
-        data: fs.readFileSync(path.resolve(sourceRoot, relativePath)),
-    }));
-}
-function reportProgress(onProgress, progress) {
-    onProgress?.(progress);
-}
-function copyDirectoryWithProgress(sourceRoot, targetRoot, onProgress) {
-    const files = listRelativeFiles(sourceRoot);
-    const total = Math.max(files.length, 1);
-    fs.mkdirSync(targetRoot, { recursive: true });
-    reportProgress(onProgress, {
-        phase: "copying",
-        completed: 0,
-        total,
-        percent: 10,
-        detail: "Preparing files",
-    });
-    files.forEach((relativePath, index) => {
-        const sourcePath = path.resolve(sourceRoot, relativePath);
-        const targetPath = path.resolve(targetRoot, relativePath);
-        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-        fs.copyFileSync(sourcePath, targetPath);
-        const completed = index + 1;
-        const percent = 10 + Math.round((completed / total) * 55);
-        reportProgress(onProgress, {
-            phase: "copying",
-            completed,
-            total,
-            percent,
-            detail: relativePath,
-        });
-    });
-}
-function buildZipEntriesWithProgress(sourceRoot, exportFolderName, onProgress) {
-    const files = listRelativeFiles(sourceRoot);
-    const total = Math.max(files.length, 1);
-    return files.map((relativePath, index) => {
-        const completed = index + 1;
-        const percent = 65 + Math.round((completed / total) * 30);
-        reportProgress(onProgress, {
-            phase: "zipping",
-            completed,
-            total,
-            percent,
-            detail: relativePath,
-        });
-        return {
-            name: path.posix.join(exportFolderName, relativePath),
-            data: fs.readFileSync(path.resolve(sourceRoot, relativePath)),
-        };
-    });
-}
-// ---------------------------------------------------------------------------
-// Download
-// ---------------------------------------------------------------------------
-export function downloadBundledKit(kitId, outDir, options = {}) {
-    const resolved = resolveBundledKit(kitId);
-    const outputPaths = resolveOutputPaths(resolved, outDir);
-    const onProgress = options.onProgress;
-    reportProgress(onProgress, {
-        phase: "preparing",
-        completed: 0,
-        total: 1,
-        percent: 0,
-        detail: "Resolving export target",
-    });
-    fs.mkdirSync(outputPaths.outputRoot, { recursive: true });
-    fs.rmSync(outputPaths.folderPath, { recursive: true, force: true });
-    copyDirectoryWithProgress(resolved.assetRoot, outputPaths.folderPath, onProgress);
-    const zipBuffer = buildStoredZip(buildZipEntriesWithProgress(outputPaths.folderPath, resolved.bundleManifest.export.folderName, onProgress));
-    reportProgress(onProgress, {
-        phase: "writing_zip",
-        completed: 1,
-        total: 1,
-        percent: 98,
-        detail: path.basename(outputPaths.zipPath),
-    });
-    fs.writeFileSync(outputPaths.zipPath, zipBuffer);
-    reportProgress(onProgress, {
-        phase: "done",
-        completed: 1,
-        total: 1,
-        percent: 100,
-        detail: "Export complete",
-    });
-    return {
-        folderPath: outputPaths.folderPath,
-        zipPath: outputPaths.zipPath,
-    };
-}
-//# sourceMappingURL=service.js.map