@agenthippo-ai/agenthippo 0.1.0

package/out/cli/commands/chat.js

@@ -0,0 +1,354 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatCommand = chatCommand;
+/**
+ * Chat Command - Interactive REPL
+ */
+const readline = __importStar(require("readline"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const headless_1 = require("../../headless");
+const pack_loader_1 = require("../pack-loader");
+const utils_1 = require("../utils");
+const branding_1 = require("../../branding");
+const runtime_1 = require("../runtime");
+const customRegistry_1 = require("../../engines/customRegistry");
+const BANNER_LINE = '-'.repeat(62);
+async function chatCommand(options) {
+    const apiConfig = (0, pack_loader_1.getApiConfig)();
+    // Load pack if specified
+    let pack;
+    let packId = 'default';
+    let engine;
+    let model;
+    let claudeCheapModel;
+    const syncLogger = options.verbose ? new headless_1.ConsoleLogger('[Sync]') : new headless_1.NoOpLogger();
+    if (options.agent) {
+        try {
+            pack = await (0, pack_loader_1.loadAgentPack)(options.agent, options.workspace);
+            packId = pack.manifest.metadata.name;
+            const resolvedEngine = options.engine || pack.manifest.spec.engine;
+            engine = resolvedEngine;
+            const customEngineDefaultModel = !['claude', 'codex'].includes(engine)
+                ? (0, customRegistry_1.tryResolveCustomEngineManifest)(options.workspace, engine)?.model?.defaultModel
+                : undefined;
+            // Custom engine manifest defaultModel beats the global AGENTHIPPO_DEFAULT_MODEL
+            // so --engine gemini without --model uses gemini's manifest default, not the
+            // user's global Claude/Codex fallback.
+            const rawModel = options.model || pack.manifest.spec.model || customEngineDefaultModel || (0, pack_loader_1.getEnvDefaultModel)() || (0, pack_loader_1.getDefaultConfig)().model;
+            model = (0, headless_1.resolveModelAlias)(rawModel);
+            const rawCheapModel = pack.manifest.spec.cheapModel?.trim();
+            claudeCheapModel = rawCheapModel ? (0, headless_1.resolveModelAlias)(rawCheapModel) : undefined;
+            // Sync pack content to workspace (now includes packId)
+            await (0, headless_1.syncPackToWorkspace)(options.workspace, pack.packPath, packId, engine, syncLogger, (0, utils_1.findBundledBasePromptsDir)());
+            console.log(`${utils_1.COLORS.green}OK:${utils_1.COLORS.reset} Loaded agent: ${pack.manifest.metadata.name} v${pack.manifest.metadata.version}`);
+            if (rawModel !== model) {
+                console.log(`${utils_1.COLORS.dim}   Model: ${rawModel} -> ${model}${utils_1.COLORS.reset}`);
+            }
+            if (rawCheapModel && rawCheapModel !== claudeCheapModel) {
+                console.log(`${utils_1.COLORS.dim}   Cheap model: ${rawCheapModel} -> ${claudeCheapModel}${utils_1.COLORS.reset}`);
+            }
+        }
+        catch (err) {
+            console.error(`${utils_1.COLORS.red}Error: ${err instanceof Error ? err.message : err}${utils_1.COLORS.reset}`);
+            process.exit(1);
+        }
+    }
+    else {
+        const defaults = (0, pack_loader_1.getDefaultConfig)();
+        engine = options.engine || defaults.engine;
+        const customEngineDefaultModel = !['claude', 'codex'].includes(engine)
+            ? (0, customRegistry_1.tryResolveCustomEngineManifest)(options.workspace, engine)?.model?.defaultModel
+            : undefined;
+        const rawModel = options.model || customEngineDefaultModel || (0, pack_loader_1.getEnvDefaultModel)() || defaults.model;
+        model = (0, headless_1.resolveModelAlias)(rawModel);
+        if (rawModel !== model) {
+            console.log(`${utils_1.COLORS.dim}Model: ${rawModel} -> ${model}${utils_1.COLORS.reset}`);
+        }
+    }
+    if (!apiConfig.apiKey && (engine === 'claude' || engine === 'codex')) {
+        const quickstartLines = (0, utils_1.getLiteLLMQuickstartHintLines)();
+        console.log([
+            'To start a chat, set an API key and re-run the command. Example:',
+            `  ${quickstartLines[1]}`,
+            '',
+            'Other options:',
+            '  AGENTHIPPO_LITELLM_API_KEY=your_key AGENTHIPPO_LITELLM_BASE_URL=https://... dist/agenthippo chat',
+            '  LITELLM_API_KEY=your_key LITELLM_BASE_URL=https://... dist/agenthippo chat',
+            '  ANTHROPIC_API_KEY=your_key dist/agenthippo chat',
+            '  OPENAI_API_KEY=your_key dist/agenthippo chat',
+        ].join('\n'));
+        process.exit(1);
+    }
+    // Create runner
+    const storagePath = path.join(os.tmpdir(), `${branding_1.AGENTIDE_CLI_NAME}-cli`);
+    const logger = options.verbose ? new headless_1.ConsoleLogger('[Agent]') : new headless_1.NoOpLogger();
+    // Find SDK CLI paths and bundled prompts
+    const claudeCodePath = (0, utils_1.findClaudeCodePath)();
+    const codexPath = (0, utils_1.findCodexPath)();
+    const bundledPromptsDir = (0, utils_1.findBundledBasePromptsDir)();
+    // Validate required CLI is available
+    if (engine === 'claude' && !claudeCodePath) {
+        console.error(`${utils_1.COLORS.red}Error: Claude Code CLI not found.${utils_1.COLORS.reset}`);
+        console.error('   Install it: npm install -g @anthropic-ai/claude-code');
+        console.error('   Or set CLAUDE_CODE_PATH environment variable');
+        console.error('   Or use --engine codex instead');
+        process.exit(1);
+    }
+    if (engine === 'codex' && !codexPath) {
+        console.error(`${utils_1.COLORS.red}Error: Codex CLI not found.${utils_1.COLORS.reset}`);
+        console.error('   Install it: npm install -g @openai/codex');
+        console.error('   Or set CODEX_PATH environment variable');
+        console.error('   Or use --engine claude instead');
+        process.exit(1);
+    }
+    // V1 permissions are non-interactive in CLI mode.
+    const permissionHandler = new headless_1.AutoApprovePermissionHandler();
+    const permissions = {
+        fileAccess: (0, pack_loader_1.getFileAccess)(pack),
+    };
+    const sessionId = `cli-${Date.now()}`;
+    const createRunner = () => (0, headless_1.createHeadlessRunner)({
+        storagePath,
+        packId,
+        packVersion: pack?.manifest.metadata.version,
+        bundledPromptsDir,
+        apiKey: apiConfig.apiKey,
+        baseUrl: apiConfig.baseUrl,
+        useLiteLLM: apiConfig.useLiteLLM,
+        logger,
+        freshState: false, // Persist session within REPL
+        claudeCodeExecutablePath: claudeCodePath,
+        codexExecutablePath: codexPath,
+        permissionHandler,
+        cliEnvPatch: (0, runtime_1.buildCliEnvPatch)({
+            cliPath: process.execPath,
+            workspaceRoot: options.workspace,
+            agentId: packId,
+            chatSessionId: sessionId,
+            baseEnv: process.env,
+        }),
+        ...(claudeCheapModel ? { engineSettings: { claudeCheapModel } } : {}),
+    });
+    const state = {
+        runner: createRunner(),
+        sessionId,
+        engine,
+        model,
+    };
+    // Streaming emitter
+    const createStreamingEmitter = () => ({
+        async thinking(delta) {
+            process.stdout.write(`${utils_1.COLORS.gray}${delta}${utils_1.COLORS.reset}`);
+        },
+        async text(delta) {
+            process.stdout.write(delta);
+        },
+        async toolStart(name, input) {
+            console.log(`\n${utils_1.COLORS.blue}Tool: ${name}${utils_1.COLORS.reset}`);
+            if (input && input.length < 200 && options.verbose) {
+                console.log(`   ${utils_1.COLORS.gray}${input}${utils_1.COLORS.reset}`);
+            }
+        },
+        async toolEnd(_name, _toolCallId, result, isError) {
+            if (isError) {
+                console.log(`   ${utils_1.COLORS.red}Error: ${result?.slice(0, 100)}${utils_1.COLORS.reset}`);
+            }
+            else {
+                console.log(`   ${utils_1.COLORS.green}OK${utils_1.COLORS.reset}`);
+            }
+        },
+        async progress(msg) {
+            if (options.verbose) {
+                console.log(`${utils_1.COLORS.yellow}Progress: ${msg}${utils_1.COLORS.reset}`);
+            }
+        },
+        async error(msg) {
+            console.error(`${utils_1.COLORS.red}Error: ${msg}${utils_1.COLORS.reset}`);
+        },
+        async question(_payload) {
+            // CLI has no UI for questions; decline so engine can proceed with defaults or fail
+            return { selected: [], freeText: null, declined: true };
+        },
+        async done() {
+            console.log('\n');
+        },
+    });
+    // Print banner
+    console.log('');
+    console.log(BANNER_LINE);
+    console.log(`${branding_1.AGENTIDE_BRAND_NAME} Chat`);
+    console.log(BANNER_LINE);
+    console.log(`Engine:    ${state.engine}`);
+    console.log(`Model:     ${state.model}`);
+    if (claudeCheapModel) {
+        console.log(`Cheap:     ${claudeCheapModel}`);
+    }
+    console.log(`Workspace: ${options.workspace}`);
+    if (pack) {
+        console.log(`Agent:     ${pack.manifest.metadata.name}`);
+    }
+    console.log(BANNER_LINE);
+    console.log('Type a message to chat. Commands: /help');
+    console.log('');
+    // Create readline interface
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const prompt = () => {
+        rl.question(`${utils_1.COLORS.cyan}> ${utils_1.COLORS.reset}`, async (input) => {
+            const trimmed = input.trim();
+            if (!trimmed) {
+                prompt();
+                return;
+            }
+            // Handle commands
+            if (trimmed.startsWith('/')) {
+                const handled = await handleCommand(trimmed, state, rl, {
+                    createRunner,
+                    claudeCodePath,
+                    codexPath,
+                });
+                if (!handled) {
+                    return; // Exit
+                }
+                prompt();
+                return;
+            }
+            // Send message
+            try {
+                const result = await state.runner.run({
+                    engineId: state.engine,
+                    modelId: state.model,
+                    message: trimmed,
+                    workspaceRoot: options.workspace,
+                    sessionId: state.sessionId,
+                    emitter: createStreamingEmitter(),
+                    permissions,
+                });
+                // Check for errors in result (may not have been streamed)
+                if (!result.success && result.error) {
+                    console.error(`\n${utils_1.COLORS.red}Error: ${result.error}${utils_1.COLORS.reset}\n`);
+                }
+            }
+            catch (err) {
+                console.error(`\n${utils_1.COLORS.red}Error: ${err instanceof Error ? err.message : err}${utils_1.COLORS.reset}\n`);
+            }
+            prompt();
+        });
+    };
+    prompt();
+}
+async function handleCommand(input, state, rl, handlers) {
+    const [cmd, ...args] = input.split(/\s+/);
+    switch (cmd) {
+        case '/exit':
+        case '/quit':
+            console.log('Goodbye!');
+            state.runner.dispose();
+            rl.close();
+            return false;
+        case '/clear':
+        case '/reset':
+        case '/new':
+            state.runner.dispose();
+            state.runner = handlers.createRunner();
+            state.sessionId = `cli-${Date.now()}`;
+            console.log('Session cleared. Fresh state.');
+            return true;
+        case '/engine': {
+            const nextEngine = args[0]?.trim();
+            if (!nextEngine) {
+                console.log('Usage: /engine <id>');
+                return true;
+            }
+            if (nextEngine === 'claude' && !handlers.claudeCodePath) {
+                console.log('Cannot switch to claude: Claude Code CLI not found.');
+                return true;
+            }
+            if (nextEngine === 'codex' && !handlers.codexPath) {
+                console.log('Cannot switch to codex: Codex CLI not found.');
+                return true;
+            }
+            state.engine = nextEngine;
+            console.log(`Switched engine to ${state.engine}`);
+            return true;
+        }
+        case '/model': {
+            const nextModel = args[0];
+            if (!nextModel) {
+                console.log('Usage: /model <model-id>');
+                return true;
+            }
+            const resolvedModel = (0, headless_1.resolveModelAlias)(nextModel);
+            state.model = resolvedModel;
+            if (resolvedModel === nextModel) {
+                console.log(`Switched model to ${state.model}`);
+            }
+            else {
+                console.log(`Switched model to ${nextModel} -> ${state.model}`);
+            }
+            return true;
+        }
+        case '/status':
+            console.log([
+                'Current session:',
+                `  Engine: ${state.engine}`,
+                `  Model: ${state.model}`,
+                `  Session: ${state.sessionId}`,
+            ].join('\n'));
+            return true;
+        case '/help':
+            console.log([
+                'Commands:',
+                '  /exit, /quit    Exit the chat',
+                '  /clear          Clear session history',
+                '  /reset, /new    Alias for /clear',
+                '  /engine <id>    Switch engine (claude|codex or custom engine id)',
+                '  /model <id>     Switch model for this session',
+                '  /status         Show current engine/model/session',
+                '  /help           Show this help',
+            ].join('\n'));
+            return true;
+        default:
+            console.log(`Unknown command: ${cmd}. Type /help for available commands.`);
+            return true;
+    }
+}

package/out/cli/commands/deploy.js

@@ -0,0 +1,223 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyPackToStaging = copyPackToStaging;
+exports.deployCommand = deployCommand;
+/**
+ * Deploy Command — `agenthippo deploy init <pack> --target <t>`
+ *
+ * Generates platform-native deploy artifacts into <pack>/deploy/<target>/.
+ * Generates only; never builds images or calls a cloud (serve-v3 §A4).
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const deploy_init_1 = require("../deploy-init");
+const utils_1 = require("../utils");
+const DEFAULT_PORT = 8080;
+/** Read pack id + engine + model from agent.yaml without the full loader (no workspace/sync needed). */
+function readManifest(packDir) {
+    const manifestPath = path.join(packDir, 'agent.yaml');
+    if (!fs.existsSync(manifestPath)) {
+        throw new Error(`No agent.yaml in ${packDir} — point deploy init at a pack directory.`);
+    }
+    const parsed = yaml.load(fs.readFileSync(manifestPath, 'utf8'));
+    const name = parsed?.metadata?.name?.trim();
+    if (!name) {
+        throw new Error(`agent.yaml is missing metadata.name in ${packDir}`);
+    }
+    const model = parsed?.spec?.model?.trim();
+    return {
+        name,
+        engine: parsed?.spec?.engine?.trim() || 'claude',
+        ...(model ? { model } : {}),
+    };
+}
+/** Basenames never copied into staging (mirrors the generated `.dockerignore`): VCS, dev
+ * caches, build output, IDE cruft. Keeping this in sync with `renderDockerignore()` means
+ * the staging dir on disk is a faithful preview of what the image will contain. */
+const PACK_IGNORE_BASENAMES = new Set([
+    '.git', 'node_modules', '__pycache__', '.pytest_cache', '.mypy_cache', '.ruff_cache',
+    '.venv', 'venv', '.next', '.turbo', '.cache', 'dist', 'build', '.DS_Store', '.idea', '.vscode',
+]);
+/** Copy the pack into the staging root, filtered to drop VCS/dev caches + secrets. The
+ * source pack's own `deploy/` and any nested `deploy-out/` are skipped (the generator
+ * owns `staging/deploy/`, and a staging tree under the pack would otherwise recurse).
+ *
+ * `dereference: true` resolves symlinks to their real content so the staging dir (and thus
+ * the Docker build context) is self-contained: an absolute symlink into a shared registry
+ * becomes a real file, and `COPY . /app/pack/` can never chase a link outside the context.
+ * Broken symlinks (e.g. a pack hydrated with self-referential dead links) are skipped and
+ * returned so the caller can warn — silently staging dead links would ship an image with
+ * empty skills. */
+function copyPackToStaging(packDir, stagingDir) {
+    const broken = [];
+    const stagingResolved = path.resolve(stagingDir);
+    fs.cpSync(packDir, stagingDir, {
+        recursive: true,
+        force: true,
+        dereference: true,
+        preserveTimestamps: true,
+        filter: (src) => {
+            const rel = path.relative(packDir, src);
+            if (!rel)
+                return true; // the pack root itself
+            if (src === stagingResolved || src.startsWith(stagingResolved + path.sep))
+                return false;
+            const base = path.basename(src);
+            if (rel === 'deploy' || rel.startsWith('deploy' + path.sep))
+                return false;
+            if (rel === 'deploy-out' || rel.startsWith('deploy-out' + path.sep))
+                return false;
+            if (PACK_IGNORE_BASENAMES.has(base))
+                return false;
+            if (base.startsWith('.nfs'))
+                return false; // stale NFS handles on macOS
+            // Broken symlink → skip + record (don't stage a dead link that would empty the image).
+            try {
+                const st = fs.lstatSync(src);
+                if (st.isSymbolicLink() && !fs.existsSync(src)) {
+                    broken.push(rel);
+                    return false;
+                }
+            }
+            catch {
+                return false; // unreadable entry
+            }
+            if (base === '.env' || base === '.env.local' || base === '.env.production')
+                return false;
+            if (base.endsWith('.log'))
+                return false;
+            if (/credentials/i.test(base) && base.endsWith('.json'))
+                return false;
+            return true;
+        },
+    });
+    return broken;
+}
+async function deployCommand(action, packArg, options) {
+    if (action !== 'init') {
+        console.error(`Unknown deploy action "${action}". Supported: init`);
+        process.exit(1);
+    }
+    const packDir = path.resolve(options.packdir || packArg || process.cwd());
+    const targetsRequested = options.target === 'all' ? [...deploy_init_1.DEPLOY_TARGETS] : [options.target];
+    for (const t of targetsRequested) {
+        if (!(0, deploy_init_1.isDeployTarget)(t)) {
+            console.error(`Unknown --target "${t}". Supported: ${deploy_init_1.DEPLOY_TARGETS.join(', ')}, all`);
+            process.exit(1);
+        }
+    }
+    let manifest;
+    try {
+        manifest = readManifest(packDir);
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+        return;
+    }
+    const envVars = (0, deploy_init_1.scanEnvRefs)(packDir);
+    // Agent Anywhere adds its own secrets to the documented surface.
+    const gateway = options.gateway?.trim();
+    if (gateway) {
+        for (const v of ['OPENCLAW_GATEWAY_TOKEN', 'SLACK_BOT_TOKEN', 'SLACK_APP_TOKEN']) {
+            if (!envVars.includes(v)) {
+                envVars.push(v);
+            }
+        }
+    }
+    const ctx = {
+        packName: manifest.name,
+        image: options.image || (0, deploy_init_1.defaultRuntimeImage)(manifest.engine),
+        port: options.port || DEFAULT_PORT,
+        engine: manifest.engine,
+        model: manifest.model,
+        envVars,
+        gatewayChannels: gateway,
+        publicHostname: (0, deploy_init_1.resolveDeployPublicHostname)(options.hostname),
+        ingress: options.ingress,
+        idpUrl: options.idpUrl,
+        cookieDomain: options.cookieDomain,
+    };
+    for (const target of targetsRequested) {
+        // Staging dir = a self-contained pack (pack content + generated deploy/). Default
+        // ./deploy-out/<pack>-<target> (cwd-relative); --out overrides (per-target subdir if
+        // multiple targets). Build context = staging root, so COPY . /app/pack/ is correct
+        // regardless of where the script is invoked from.
+        const outDir = options.out
+            ? (targetsRequested.length > 1 ? path.join(path.resolve(options.out), target) : path.resolve(options.out))
+            : path.join(process.cwd(), 'deploy-out', `${manifest.name}-${target}`);
+        fs.mkdirSync(outDir, { recursive: true });
+        // Copy the pack into the staging root (filtered: no VCS/caches/secrets, no source deploy/).
+        const brokenLinks = copyPackToStaging(packDir, outDir);
+        if (brokenLinks.length > 0) {
+            const sample = brokenLinks.slice(0, 3).join(', ');
+            console.log(`    ${utils_1.COLORS.yellow}⚠ ${brokenLinks.length} broken symlink(s) skipped (not staged — the image would have no content for these). Sample: ${sample}${brokenLinks.length > 3 ? ', …' : ''}${utils_1.COLORS.reset}`);
+        }
+        // Generated artifacts → <staging>/deploy/; .dockerignore → <staging>/ (build-context root,
+        // the only location Docker reads it from).
+        fs.mkdirSync(path.join(outDir, 'deploy'), { recursive: true });
+        const files = (0, deploy_init_1.renderTarget)(target, ctx);
+        const written = [];
+        const skipped = [];
+        for (const [rel, content] of Object.entries(files)) {
+            const dest = rel === '.dockerignore'
+                ? path.join(outDir, '.dockerignore')
+                : path.join(outDir, 'deploy', rel);
+            if (fs.existsSync(dest) && !options.force) {
+                skipped.push(rel);
+                continue;
+            }
+            fs.mkdirSync(path.dirname(dest), { recursive: true });
+            fs.writeFileSync(dest, content);
+            written.push(rel);
+        }
+        console.log(`${utils_1.COLORS.green}✓${utils_1.COLORS.reset} ${target} → ${path.relative(process.cwd(), outDir) || '.'}`);
+        for (const f of written) {
+            console.log(`    ${utils_1.COLORS.dim}+ ${f}${utils_1.COLORS.reset}`);
+        }
+        for (const f of skipped) {
+            console.log(`    ${utils_1.COLORS.yellow}• ${f} (exists; --force to overwrite)${utils_1.COLORS.reset}`);
+        }
+    }
+    if (envVars.length > 0) {
+        console.log(`\n${utils_1.COLORS.dim}Scanned pack secrets into .env.example: ${envVars.join(', ')}${utils_1.COLORS.reset}`);
+    }
+    console.log(`\nNext: cd into the staging dir above, \`cp deploy/.env.example deploy/.env\`, then run the command in deploy/README.md (scripts anchor themselves to the staging root).`);
+}