@hyperdrive.bot/cli 1.0.12 → 1.0.16

package/dist/commands/service/seed.js

@@ -0,0 +1,173 @@
+import { readFileSync } from 'node:fs';
+import { basename } from 'node:path';
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+import { pollLifecycle } from '../../utils/lifecycle-poller.js';
+export default class ServiceSeed extends Command {
+    static description = 'Execute a SQL script against a service database';
+    static examples = [
+        '<%= config.bin %> service seed rds-postgres-live --from ./seed.sql',
+        '<%= config.bin %> service seed rds-postgres-live --inline "INSERT INTO users VALUES (1, \'admin\')"',
+        '<%= config.bin %> service seed rds-postgres-live --from ./seed.sql --allow-production',
+        '<%= config.bin %> service seed rds-postgres-live --from ./seed.sql --no-wait --json',
+    ];
+    static args = {
+        slug: Args.string({
+            description: 'Service slug to seed',
+            required: true,
+        }),
+    };
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        from: Flags.string({
+            description: 'Path to local SQL script file to upload and execute',
+            exclusive: ['inline'],
+        }),
+        inline: Flags.string({
+            description: 'Inline SQL string to execute directly',
+            exclusive: ['from'],
+        }),
+        'allow-production': Flags.boolean({
+            description: 'Allow seeding production-bound services',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output raw JSON response',
+            default: false,
+        }),
+        'no-wait': Flags.boolean({
+            description: 'Do not wait for seed to complete',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ServiceSeed);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        const isJson = flags.json;
+        // Validate exactly one of --from or --inline is provided
+        if (!flags.from && !flags.inline) {
+            this.log(chalk.red('Error: Provide either --from <file> or --inline <sql>'));
+            this.exit(1);
+            return;
+        }
+        let scriptSource;
+        let scriptPath;
+        if (flags.from) {
+            try {
+                scriptSource = readFileSync(flags.from, 'utf-8');
+                scriptPath = basename(flags.from);
+            }
+            catch (error) {
+                this.log(chalk.red(`Error reading file: ${error.message}`));
+                this.exit(1);
+                return;
+            }
+        }
+        else {
+            scriptSource = flags.inline;
+        }
+        // Production safety confirmation
+        if (flags['allow-production'] && !isJson) {
+            this.log(chalk.red.bold('\n⚠️  WARNING: You are about to seed a production-bound service.'));
+            this.log(chalk.red(`  Service: ${args.slug}\n`));
+            const response = await new Promise((resolve) => {
+                process.stdout.write(chalk.yellow('Are you sure you want to proceed? (y/N): '));
+                process.stdin.setEncoding('utf-8');
+                process.stdin.once('data', (data) => {
+                    resolve(data.toString().trim().toLowerCase());
+                });
+            });
+            if (response !== 'y' && response !== 'yes') {
+                this.log(chalk.gray('Aborted.'));
+                return;
+            }
+        }
+        const spinner = isJson ? null : ora('Submitting seed request...').start();
+        try {
+            const seedRun = await service.serviceSeed(args.slug, {
+                scriptSource,
+                scriptPath,
+                allowProduction: flags['allow-production'] || undefined,
+            });
+            if (isJson && flags['no-wait']) {
+                this.log(JSON.stringify(seedRun, null, 2));
+                return;
+            }
+            spinner?.succeed(chalk.green(`Seed job submitted: ${seedRun.id}`));
+            if (!isJson) {
+                this.log(`  Service:     ${chalk.cyan(args.slug)}`);
+                this.log(`  Seed Run ID: ${chalk.cyan(seedRun.id)}`);
+                this.log(`  Status:      ${chalk.yellow(seedRun.status)}`);
+                if (seedRun.logGroupName) {
+                    this.log(`  Log Group:   ${chalk.gray(seedRun.logGroupName)}`);
+                }
+                this.log('');
+            }
+            if (flags['no-wait']) {
+                if (!isJson) {
+                    this.log(chalk.gray(`Check status: hd service backups ${args.slug}`));
+                }
+                return;
+            }
+            // Poll for seed completion
+            const result = await pollLifecycle({
+                pollFn: () => service.serviceGetSeedRun(args.slug, seedRun.id),
+                getStatus: (sr) => sr.status,
+                terminalStates: new Set(['completed', 'failed']),
+                successStates: new Set(['completed']),
+                getErrorMessage: (sr) => sr.errorMessage,
+                operationLabel: 'Seeding',
+            }, isJson);
+            if (isJson) {
+                this.log(JSON.stringify(result.entity, null, 2));
+            }
+            if (result.timedOut) {
+                if (!isJson) {
+                    this.log(chalk.yellow('The seed job may still be running.'));
+                    this.log(chalk.gray(`Check status: hd service backups ${args.slug}`));
+                }
+                this.exit(1);
+            }
+            if (!result.success) {
+                this.exit(1);
+            }
+            // Success summary
+            if (!isJson && result.entity) {
+                if (result.entity.logGroupName) {
+                    this.log(chalk.gray(`  Log group: ${result.entity.logGroupName}`));
+                }
+                if (result.entity.completedAt) {
+                    this.log(`  Completed: ${new Date(result.entity.completedAt).toLocaleString()}`);
+                }
+            }
+        }
+        catch (error) {
+            spinner?.fail('Seed request failed');
+            const axiosError = error;
+            const status = axiosError.response?.status;
+            const errorMessage = axiosError.response?.data?.message ?? axiosError.message;
+            if (status === 400) {
+                this.log(chalk.red(`Validation error: ${errorMessage}`));
+            }
+            else if (status === 403) {
+                this.log(chalk.red(`Production safety: ${errorMessage}`));
+                this.log(chalk.yellow('Use --allow-production flag to override.'));
+            }
+            else if (status === 404) {
+                this.log(chalk.red(`Not found: ${errorMessage}`));
+            }
+            else if (status === 409) {
+                this.log(chalk.red(`Conflict: ${errorMessage}`));
+            }
+            else {
+                this.log(chalk.red(`Error: ${errorMessage}`));
+            }
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/service/templates.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class ServiceTemplates extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/service/templates.js

@@ -0,0 +1,66 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+import { printTable } from '../../utils/table.js';
+export default class ServiceTemplates extends Command {
+    static description = 'List available service provisioning templates';
+    static examples = [
+        '<%= config.bin %> service templates',
+        '<%= config.bin %> service templates --json',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        json: Flags.boolean({
+            description: 'Output raw JSON response',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ServiceTemplates);
+        const isJson = flags.json;
+        const service = new HyperdriveSigV4Service(flags.domain);
+        const spinner = isJson ? null : ora('Fetching service templates...').start();
+        try {
+            const templates = await service.serviceTemplates();
+            spinner?.stop();
+            if (isJson) {
+                this.log(JSON.stringify(templates, null, 2));
+                return;
+            }
+            if (!templates || templates.length === 0) {
+                this.log(chalk.yellow('\nNo service templates available.'));
+                return;
+            }
+            this.log(chalk.green(`\n${templates.length} template(s) available:\n`));
+            printTable(templates, {
+                id: {
+                    header: 'ID',
+                    minWidth: 25,
+                    get: (row) => chalk.cyan(row.id),
+                },
+                name: {
+                    header: 'Name',
+                    minWidth: 25,
+                },
+                type: {
+                    header: 'Type',
+                    minWidth: 18,
+                },
+                description: {
+                    header: 'Description',
+                    minWidth: 30,
+                },
+            }, (msg) => this.log(msg));
+        }
+        catch (error) {
+            spinner?.fail('Failed to fetch templates');
+            const axiosError = error;
+            this.log(chalk.red(`\n❌ ${axiosError.response?.data?.message ?? axiosError.message}`));
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/service/unbind.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class ServiceUnbind extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        service: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        module: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        stage: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/service/unbind.js

@@ -0,0 +1,74 @@
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class ServiceUnbind extends Command {
+    static description = 'Unbind a service from a module+stage';
+    static examples = [
+        '<%= config.bin %> service unbind rds-postgres-live my-api --stage live',
+        '<%= config.bin %> service unbind rds-postgres-live my-api --stage live --yes',
+    ];
+    static args = {
+        service: Args.string({
+            description: 'Service slug',
+            required: true,
+        }),
+        module: Args.string({
+            description: 'Module slug',
+            required: true,
+        }),
+    };
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        stage: Flags.string({
+            description: 'Deployment stage',
+            required: true,
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ServiceUnbind);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        // Confirmation prompt unless --yes
+        if (!flags.yes) {
+            const inquirer = (await import('inquirer')).default;
+            const { confirmed } = await inquirer.prompt([{
+                    default: false,
+                    message: chalk.yellow(`Unbind "${args.service}" from "${args.module}" (stage: ${flags.stage})?`),
+                    name: 'confirmed',
+                    type: 'confirm',
+                }]);
+            if (!confirmed) {
+                this.log(chalk.gray('Cancelled.'));
+                return;
+            }
+        }
+        const spinner = ora(`Unbinding "${args.service}" from "${args.module}" (stage: ${flags.stage})...`).start();
+        try {
+            await service.serviceUnbind(args.service, {
+                moduleSlug: args.module,
+                stage: flags.stage,
+            });
+            spinner.succeed(chalk.green(`Service unbound: ${args.service} ✕ ${args.module} (${flags.stage})`));
+        }
+        catch (error) {
+            spinner.fail('Unbind failed');
+            const axiosError = error;
+            const status = axiosError.response?.status;
+            if (status === 404) {
+                this.log(chalk.red(`\n❌ Binding not found: ${args.service} → ${args.module} (${flags.stage})`));
+            }
+            else {
+                this.log(chalk.red(`\n❌ ${axiosError.response?.data?.message ?? axiosError.message}`));
+            }
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/stage/create.d.ts

@@ -3,7 +3,9 @@ export default class StageCreate extends Command {
     static description: string;
     static flags: {
         accountId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        autoCreateBranches: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         autoLaunch: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        autoWarm: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         branchName: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         defaultStage: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         deletionProtection: import("@oclif/core/interfaces").BooleanFlag<boolean>;
@@ -13,16 +15,37 @@ export default class StageCreate extends Command {
         project: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         provider: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         region: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        warmConcurrency: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
     /**
      * Build CloudWatch console URL
      */
     private buildConsoleUrl;
+    /**
+     * Ensure the stage branch exists on every linked project remote BEFORE
+     * `service.stageCreate` is invoked. Implements the contract described in
+     * Story 1.2 ACs 3–5 + 9:
+     *
+     *   - all projects succeed          → proceed silently to stageCreate
+     *   - some projects fail (partial)  → log yellow warning + proceed
+     *   - every project fails           → log red error + exit(1) + NEVER
+     *                                     call stageCreate
+     *
+     * The shared `ensureBranches()` lib never throws — all errors are collected
+     * into `result.failed`, so we translate the result into the three branches
+     * above here.
+     */
+    private runEnsureBranches;
     private getGitBranch;
     private promptUser;
     /**
      * Stream mission logs in real-time
      */
     private streamMissionLogs;
+    /**
+     * Discover and invoke each module Lambda once to mitigate cold-start.
+     * Best-effort — any failure is logged but never blocks `stage create` success.
+     */
+    private runAutoWarm;
 }

package/dist/commands/stage/create.js

@@ -2,6 +2,8 @@ import { Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { execSync } from 'node:child_process';
+import { ensureBranches } from '../../lib/ensure-branches.js';
+import { DEFAULT_WARMUP_CONCURRENCY, warmStage } from '../../lib/lambda-warmer.js';
 import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
 // Full AWS regions list
 const AWS_REGIONS = [
@@ -43,10 +45,18 @@ export default class StageCreate extends Command {
             char: 'a',
             description: 'AWS Account ID for deployments',
         }),
+        autoCreateBranches: Flags.boolean({
+            default: false,
+            description: "Ensure the stage branch exists on all linked project remotes before launching the mission (creates missing branches from each remote's default branch)",
+        }),
         autoLaunch: Flags.boolean({
             default: false,
             description: 'Automatically launch deployments for this stage',
         }),
+        autoWarm: Flags.boolean({
+            default: false,
+            description: 'After deployment completes, invoke each module Lambda once to mitigate cold-start. Best-effort — never blocks stage creation. Requires --autoLaunch.',
+        }),
         branchName: Flags.string({
             char: 'b',
             description: 'Git branch name',
@@ -85,6 +95,10 @@ export default class StageCreate extends Command {
             description: 'AWS region(s) for deployment',
             multiple: true,
         }),
+        warmConcurrency: Flags.integer({
+            default: DEFAULT_WARMUP_CONCURRENCY,
+            description: `Max in-flight Lambda warmup invocations (default ${DEFAULT_WARMUP_CONCURRENCY}). Only used with --autoWarm.`,
+        }),
     };
     async run() {
         const { flags } = await this.parse(StageCreate);
@@ -100,6 +114,9 @@ export default class StageCreate extends Command {
             this.log(chalk.gray(`   Region(s): ${combinedData.region.join(', ')}`));
             this.log(chalk.gray(`   Branch: ${combinedData.branchName}`));
             this.log(chalk.gray(`   Projects: ${combinedData.project.join(', ')}`));
+            if (combinedData.autoCreateBranches) {
+                await this.runEnsureBranches(combinedData, service);
+            }
             const result = await service.stageCreate({
                 accountId: combinedData.accountId,
                 autoLaunch: combinedData.autoLaunch,
@@ -117,12 +134,30 @@ export default class StageCreate extends Command {
             const missionId = result.missionId;
             if (combinedData.autoLaunch && loggingConfig && missionId) {
                 // Start real-time log streaming for mission
-                await this.streamMissionLogs(loggingConfig, missionId);
+                await this.streamMissionLogs(loggingConfig, missionId, {
+                    autoWarm: Boolean(combinedData.autoWarm),
+                    regions: combinedData.region,
+                    stageName: combinedData.name,
+                    warmConcurrency: combinedData.warmConcurrency,
+                });
             }
             else {
                 // Standard stage creation (no autoLaunch)
                 this.log(chalk.blue('\n✅ Stage created successfully!'));
+                if (result.customDomain) {
+                    this.log(chalk.cyan(`🌐 Domain: ${result.customDomain}`));
+                    this.log(`   Status: ${result.domainStatus || 'unknown'}`);
+                }
                 this.log(JSON.stringify(result, null, 2));
+                if (combinedData.autoWarm) {
+                    // AC1: --auto-warm only meaningful when modules have actually deployed.
+                    // Without --autoLaunch, the stage exists as a record but no Lambdas
+                    // have been launched yet — surface that to the user instead of silently
+                    // skipping.
+                    this.log(chalk.yellow('\n⚠️  --auto-warm was requested but --autoLaunch was not set. ' +
+                        'Lambdas will not be warmed (none have been deployed yet). ' +
+                        'Run `hd stage deploy` and re-run with --auto-warm next time, or pair --auto-warm with --autoLaunch.'));
+                }
             }
         }
         catch (error) {
@@ -131,6 +166,12 @@ export default class StageCreate extends Command {
             if (err.message?.includes('EEXIT') && err.oclif?.exit === 0) {
                 return;
             }
+            // Preserve explicit non-zero oclif exits (e.g. from runEnsureBranches)
+            // without wrapping them in "Error creating stage" — the inner caller
+            // has already printed its own specific error message.
+            if (err.oclif?.exit !== undefined && err.oclif.exit !== 0) {
+                throw err;
+            }
             const axiosError = error;
             const errorMessage = axiosError.response?.data?.message ?? axiosError.message ?? 'Unknown error';
             this.log(chalk.red('❌ Error creating stage: ' + errorMessage));
@@ -145,6 +186,57 @@ export default class StageCreate extends Command {
         const encodedStream = encodeURIComponent(encodeURIComponent(config.logStream));
         return `https://${config.region}.console.aws.amazon.com/cloudwatch/home?region=${config.region}#logsV2:log-groups/log-group/${encodedGroup}/log-events/${encodedStream}`;
     }
+    /**
+     * Ensure the stage branch exists on every linked project remote BEFORE
+     * `service.stageCreate` is invoked. Implements the contract described in
+     * Story 1.2 ACs 3–5 + 9:
+     *
+     *   - all projects succeed          → proceed silently to stageCreate
+     *   - some projects fail (partial)  → log yellow warning + proceed
+     *   - every project fails           → log red error + exit(1) + NEVER
+     *                                     call stageCreate
+     *
+     * The shared `ensureBranches()` lib never throws — all errors are collected
+     * into `result.failed`, so we translate the result into the three branches
+     * above here.
+     */
+    async runEnsureBranches(combinedData, service) {
+        this.log('');
+        this.log(chalk.blue('🌿 Ensuring stage branches on linked project remotes...'));
+        const projectSlugs = combinedData.project ?? [];
+        const branchName = combinedData.branchName;
+        const stageName = combinedData.name;
+        if (projectSlugs.length === 0) {
+            this.log(chalk.gray('ℹ️  No linked projects — nothing to ensure'));
+            return;
+        }
+        const allModules = await service.moduleList();
+        const linkedProjects = allModules
+            .filter((m) => m.slug && projectSlugs.includes(m.slug))
+            .map((m) => ({
+            gitFullRepoPath: m.gitFullRepoPath,
+            gitProvider: m.gitProvider,
+            slug: m.slug,
+        }));
+        const verbose = process.env.DEBUG === '1';
+        const result = await ensureBranches({
+            branchName,
+            linkedProjects,
+            logger: (msg) => this.log(msg),
+            stageName,
+            verbose,
+        });
+        // Hard failure: every project failed. stageCreate MUST NOT run.
+        if (result.total > 0 && result.failed === result.total) {
+            this.log(chalk.red(`❌ Branch auto-create failed: ${result.failed}/${result.total} remotes failed — aborting stage creation`));
+            this.exit(1);
+        }
+        if (result.failed > 0) {
+            this.log(chalk.yellow('⚠️ Branch auto-create completed with warnings — proceeding with stage creation'));
+            return;
+        }
+        this.log(chalk.green(`✅ ${result.created + result.alreadyExisted}/${result.total} branches ensured (${result.created} created, ${result.alreadyExisted} already existed)`));
+    }
     getGitBranch() {
         try {
             return execSync('git branch --show-current', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
@@ -241,7 +333,7 @@ export default class StageCreate extends Command {
         // Additional options (only prompt if not already set via flags)
         this.log('');
         const additionalPrompts = [];
-        if (flags.production === undefined || flags.production === false) {
+        if (flags.production === undefined) {
             additionalPrompts.push({
                 default: false,
                 message: chalk.yellow('🏭 Is this a production stage?'),
@@ -249,7 +341,7 @@ export default class StageCreate extends Command {
                 type: 'confirm',
             });
         }
-        if (flags.deletionProtection === undefined || flags.deletionProtection === false) {
+        if (flags.deletionProtection === undefined) {
             additionalPrompts.push({
                 default: false,
                 message: chalk.yellow('🔒 Enable deletion protection?'),
@@ -257,7 +349,7 @@ export default class StageCreate extends Command {
                 type: 'confirm',
             });
         }
-        if (flags.defaultStage === undefined || flags.defaultStage === false) {
+        if (flags.defaultStage === undefined) {
             additionalPrompts.push({
                 default: false,
                 message: chalk.yellow('⭐ Set as default stage (fallback)?'),
@@ -265,7 +357,7 @@ export default class StageCreate extends Command {
                 type: 'confirm',
             });
         }
-        if (flags.autoLaunch === undefined || flags.autoLaunch === false) {
+        if (flags.autoLaunch === undefined) {
             additionalPrompts.push({
                 default: false,
                 message: chalk.yellow('🚀 Auto-launch deployments after creation?'),
@@ -284,7 +376,7 @@ export default class StageCreate extends Command {
     /**
      * Stream mission logs in real-time
      */
-    async streamMissionLogs(loggingConfig, missionId) {
+    async streamMissionLogs(loggingConfig, missionId, warmOptions) {
         this.log(chalk.blue(`\n🚀 Mission started: ${missionId}`));
         this.log(chalk.gray(`   Launching all modules in parallel...`));
         this.log('');
@@ -300,13 +392,60 @@ export default class StageCreate extends Command {
             this.log(chalk.cyan(`   Mission: ${missionId}`));
             const consoleUrl = this.buildConsoleUrl(loggingConfig);
             this.log(chalk.gray(`   Logs: ${consoleUrl}`));
+            // AC2/AC4/AC5: opt-in post-deploy Lambda warmup. Best-effort.
+            if (warmOptions?.autoWarm) {
+                await this.runAutoWarm(warmOptions.stageName, warmOptions.regions, warmOptions.warmConcurrency);
+            }
             this.exit(0);
         }
         else {
             this.log(chalk.red(`❌ ${outcome.message}`));
             const consoleUrl = this.buildConsoleUrl(loggingConfig);
             this.log(chalk.gray(`   Full logs: ${consoleUrl}`));
+            // AC5: never warm a failed deploy.
             this.exit(1);
         }
     }
+    /**
+     * Discover and invoke each module Lambda once to mitigate cold-start.
+     * Best-effort — any failure is logged but never blocks `stage create` success.
+     */
+    async runAutoWarm(stageName, regions, concurrency) {
+        this.log('');
+        this.log(chalk.blue('🔥 Auto-warm: pre-warming Lambdas to mitigate cold-start...'));
+        let summary;
+        try {
+            summary = await warmStage({
+                concurrency,
+                logger: (msg) => this.log(chalk.gray(`   ${msg}`)),
+                regions,
+                stageName,
+            });
+        }
+        catch (error) {
+            // Defensive: warmStage itself does not throw, but if it ever does we
+            // must NOT block stage-create success (AC5).
+            this.log(chalk.yellow(`⚠️  Auto-warm failed unexpectedly: ${error.message ?? String(error)} (ignored)`));
+            return;
+        }
+        if (summary.total === 0) {
+            this.log(chalk.gray(`   No Lambdas matched stage '${stageName}' in ${regions.join(', ')} ` +
+                '— nothing to warm.'));
+            return;
+        }
+        const ok = summary.succeeded;
+        const ko = summary.failed;
+        const sk = summary.skipped;
+        if (ko === 0 && sk === 0) {
+            this.log(chalk.green(`   ✅ Warmed ${ok}/${summary.total} Lambdas`));
+        }
+        else {
+            this.log(chalk.yellow(`   ⚠️  Warmed ${ok}/${summary.total} Lambdas (${ko} failed, ${sk} region(s) skipped) — non-fatal`));
+            // Surface the first few failures for quick triage. AC5: never throws.
+            const failures = summary.results.filter((r) => !r.success).slice(0, 5);
+            for (const f of failures) {
+                this.log(chalk.gray(`      - ${f.functionName} (${f.region}): ${f.error ?? 'unknown error'}`));
+            }
+        }
+    }
 }

package/dist/commands/stage/delete.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class StageDelete extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}