@hyperdrive.bot/cli 1.0.12 → 1.0.16

package/dist/commands/stage/delete.js

@@ -0,0 +1,85 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class StageDelete extends Command {
+    static description = 'Delete a stage (cleanup runs asynchronously via SQS)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --name stress-test-19 -d ds.hyperdrivebot.dev',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Ignored (kept for backward compatibility — cleanup is always async now)',
+            default: false,
+            hidden: true,
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Stage name to delete',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(StageDelete);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        this.log(chalk.red(`\u{1F5D1}\u{FE0F}  Deleting stage "${flags.name}"...`));
+        this.log(chalk.yellow('   This will destroy all CloudFormation stacks for this stage.'));
+        if (flags.force) {
+            this.log(chalk.yellow('   --force: Skipping domain teardown.'));
+        }
+        try {
+            const result = await service.stageDelete(flags.name, flags.force);
+            this.log(chalk.green('\n\u2705 Stage deleted from DynamoDB'));
+            if ('cleanup' in result && result.cleanup === 'queued') {
+                // New async path — cleanup runs via SQS worker
+                this.log(chalk.blue('\nCleanup queued \u2014 resources will be cleaned up asynchronously.'));
+                this.log(chalk.dim('   CF stacks, log groups, domain resources, and access tuples will be removed by the cleanup worker.'));
+            }
+            else {
+                // Old sync path (backward compat during rollout)
+                const syncResult = result;
+                if (syncResult.domainTeardown === 'skipped') {
+                    this.log(chalk.yellow('\n\u26A0\uFE0F  Domain teardown was skipped (--force). CloudFront/Route53 resources may remain.'));
+                }
+                if (syncResult.stacks.stacksDeleted.length > 0) {
+                    this.log(chalk.blue(`\n\u{1F4E6} ${syncResult.stacks.stacksDeleted.length} stacks queued for deletion:`));
+                    for (const stack of syncResult.stacks.stacksDeleted) {
+                        this.log(chalk.dim(`   - ${stack}`));
+                    }
+                    this.log(chalk.yellow('\n\u23F3 Stack deletion is async \u2014 may take several minutes to complete.'));
+                }
+                else {
+                    this.log(chalk.dim('\n   No matching CloudFormation stacks found.'));
+                }
+                if (syncResult.stacks.errors.length > 0) {
+                    this.log(chalk.red(`\n\u26A0\uFE0F  ${syncResult.stacks.errors.length} stack error(s):`));
+                    for (const err of syncResult.stacks.errors) {
+                        this.log(chalk.red(`   - ${err}`));
+                    }
+                }
+                // Log group cleanup results
+                if (syncResult.logGroups) {
+                    if (syncResult.logGroups.deleted > 0) {
+                        this.log(chalk.blue(`\n\u{1F9F9} ${syncResult.logGroups.deleted} CloudWatch log groups deleted`));
+                    }
+                    else {
+                        this.log(chalk.dim('\n   No CloudWatch log groups found to clean up.'));
+                    }
+                    if (syncResult.logGroups.errors.length > 0) {
+                        this.log(chalk.red(`\n\u26A0\uFE0F  ${syncResult.logGroups.errors.length} log group error(s):`));
+                        for (const err of syncResult.logGroups.errors) {
+                            this.log(chalk.red(`   - ${err}`));
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.error(`Failed to delete stage: ${error.message}`);
+        }
+    }
+}

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

@@ -0,0 +1,34 @@
+import { Command } from '@oclif/core';
+export default class StageDeploy extends Command {
+    static args: {
+        stageName: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        module: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        retry: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /**
+     * Single-module surgical deploy
+     */
+    private runSingleModuleDeploy;
+    /**
+     * Retry all failed/pending modules
+     */
+    private runRetryDeploy;
+    /**
+     * Handle API error responses
+     */
+    private handleApiError;
+    /**
+     * Build CloudWatch console URL
+     */
+    private buildConsoleUrl;
+    /**
+     * Stream mission logs in real-time (shared by --retry and --module)
+     */
+    private streamMissionLogs;
+}

package/dist/commands/stage/deploy.js

@@ -0,0 +1,294 @@
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+import { CloudWatchLogTailer } from '../../services/log-tailer.js';
+export default class StageDeploy extends Command {
+    static args = {
+        stageName: Args.string({ description: 'Stage slug (e.g., ss-11)', required: true }),
+    };
+    static description = 'Retry or surgically redeploy modules on a per-branch stage';
+    static flags = {
+        module: Flags.string({
+            char: 'm',
+            description: 'Surgically redeploy a single module after validating prior-wave dependencies',
+            exclusive: ['retry'],
+        }),
+        retry: Flags.boolean({
+            char: 'r',
+            default: false,
+            description: 'Retry failed and pending modules from the last mission',
+            exclusive: ['module'],
+        }),
+        verbose: Flags.boolean({
+            char: 'v',
+            default: false,
+            description: 'Show verbose log output',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            default: false,
+            description: 'Skip confirmation prompt',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(StageDeploy);
+        // Mutual exclusion belt-and-suspenders (oclif handles it, but exit cleanly)
+        if (flags.retry && flags.module) {
+            this.error('--retry and --module are mutually exclusive', { exit: 2 });
+            return;
+        }
+        if (!flags.retry && !flags.module) {
+            this.log(chalk.yellow('Please specify a deploy mode: --retry or --module <slug>'));
+            this.log(chalk.gray('  Examples:'));
+            this.log(chalk.gray('    hd stage deploy ss-11 --retry'));
+            this.log(chalk.gray('    hd stage deploy ss-11 --module sign'));
+            this.exit(1);
+            return;
+        }
+        try {
+            const service = new HyperdriveSigV4Service();
+            if (flags.module) {
+                await this.runSingleModuleDeploy(service, args.stageName, flags.module, flags.verbose, flags.yes);
+            }
+            else {
+                await this.runRetryDeploy(service, args.stageName, flags.verbose, flags.yes);
+            }
+        }
+        catch (error) {
+            const err = error;
+            // Ignore EEXIT with code 0
+            if (err.message?.includes('EEXIT') && err.oclif?.exit === 0) {
+                return;
+            }
+            // Preserve explicit non-zero oclif exits
+            if (err.oclif?.exit !== undefined && err.oclif.exit !== 0) {
+                throw err;
+            }
+            this.handleApiError(error, args.stageName);
+        }
+    }
+    /**
+     * Single-module surgical deploy
+     */
+    async runSingleModuleDeploy(service, stageName, moduleSlug, verbose, skipPrompt) {
+        // 1. Fetch manifest for confirmation
+        this.log(chalk.gray('Fetching deploy manifest...'));
+        const manifestResponse = await service.stageGetDeployManifest(stageName);
+        if (!manifestResponse.manifest) {
+            this.log(chalk.yellow(`No deploy manifest found for stage '${stageName}'. Run \`hd stage create\` first.`));
+            this.exit(0);
+            return;
+        }
+        const manifest = manifestResponse.manifest;
+        // 2. Find the module and its wave
+        let targetWave = -1;
+        let found = false;
+        for (const wave of manifest.waves) {
+            for (const mod of wave.modules) {
+                if (mod.moduleSlug === moduleSlug) {
+                    targetWave = wave.waveIndex;
+                    found = true;
+                    break;
+                }
+            }
+            if (found)
+                break;
+        }
+        if (!found) {
+            this.log(chalk.red(`Module '${moduleSlug}' not found in manifest for stage ${stageName}`));
+            this.exit(2);
+            return;
+        }
+        // 3. Count deployed modules in prior waves
+        const priorDeployedCount = manifest.waves
+            .filter(w => w.waveIndex < targetWave)
+            .reduce((sum, w) => sum + w.modules.length, 0);
+        // 4. Confirmation prompt
+        if (!skipPrompt) {
+            this.log('');
+            this.log(chalk.blue(`Deploying 1 module: ${moduleSlug} (W${targetWave}). Prior-wave deps OK (${priorDeployedCount} modules deployed).`));
+            this.log('');
+            const { confirm } = await inquirer.prompt([{
+                    default: true,
+                    message: 'Continue? [Y/n]',
+                    name: 'confirm',
+                    type: 'confirm',
+                }]);
+            if (!confirm) {
+                this.log('Deploy cancelled.');
+                this.exit(0);
+                return;
+            }
+        }
+        // 5. Call the deploy API
+        this.log(chalk.gray(`Starting single-module deploy for ${moduleSlug}...`));
+        const response = await service.stageDeploy({
+            mode: 'module',
+            moduleSlug,
+            stageName,
+        });
+        // 6. Stream mission logs (reuse same helper as --retry and create --autoLaunch)
+        await this.streamMissionLogs(response.logging, response.missionId, verbose, 'module', moduleSlug);
+    }
+    /**
+     * Retry all failed/pending modules
+     */
+    async runRetryDeploy(service, stageName, verbose, skipPrompt) {
+        // 1. Fetch manifest to show confirmation prompt
+        this.log(chalk.gray('Fetching deploy manifest...'));
+        const manifestResponse = await service.stageGetDeployManifest(stageName);
+        if (!manifestResponse.manifest) {
+            this.log(chalk.yellow(`No deploy manifest found for stage '${stageName}'. Run \`hd stage create\` first.`));
+            this.exit(0);
+            return;
+        }
+        const manifest = manifestResponse.manifest;
+        // 2. Compute non-deployed modules
+        const retryableModules = [];
+        for (const wave of manifest.waves) {
+            for (const mod of wave.modules) {
+                if (mod.status !== 'deployed') {
+                    retryableModules.push({
+                        moduleSlug: mod.moduleSlug,
+                        status: mod.status,
+                        waveIndex: wave.waveIndex,
+                    });
+                }
+            }
+        }
+        if (retryableModules.length === 0) {
+            this.log(chalk.green('All modules are already deployed. Nothing to retry.'));
+            this.exit(0);
+            return;
+        }
+        // 3. Print retry summary and confirm
+        this.log('');
+        this.log(chalk.blue(`Retrying ${retryableModules.length} modules:`));
+        for (const mod of retryableModules) {
+            this.log(chalk.gray(`  - ${mod.moduleSlug} (W${mod.waveIndex}, ${mod.status})`));
+        }
+        if (!skipPrompt) {
+            this.log('');
+            const { confirm } = await inquirer.prompt([{
+                    default: true,
+                    message: 'Continue?',
+                    name: 'confirm',
+                    type: 'confirm',
+                }]);
+            if (!confirm) {
+                this.log('Retry cancelled.');
+                this.exit(0);
+                return;
+            }
+        }
+        // 4. Call the deploy API
+        this.log(chalk.gray('Starting retry...'));
+        const response = await service.stageDeploy({
+            mode: 'retry',
+            stageName,
+        });
+        // 5. Stream mission logs
+        await this.streamMissionLogs(response.logging, response.missionId, verbose, 'retry');
+    }
+    /**
+     * Handle API error responses
+     */
+    handleApiError(error, stageName) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        // The API returns structured errors as JSON-stringified message
+        let errorCode;
+        let errorMessage;
+        let parsedBody;
+        if (responseData?.message) {
+            try {
+                parsedBody = JSON.parse(responseData.message);
+                errorCode = parsedBody?.code;
+                errorMessage = parsedBody?.error ?? responseData.message;
+            }
+            catch {
+                errorMessage = responseData.message;
+            }
+        }
+        else {
+            errorMessage = responseData?.error ?? axiosError.message ?? 'Unknown error';
+            errorCode = responseData?.code;
+            parsedBody = responseData;
+        }
+        // NOTHING_TO_RETRY is not an error — clean exit
+        if (errorCode === 'NOTHING_TO_RETRY') {
+            this.log(chalk.green(errorMessage));
+            this.exit(0);
+            return;
+        }
+        // WAVE_DEPS_NOT_MET — format blocking modules
+        if (errorCode === 'WAVE_DEPS_NOT_MET' || (parsedBody?.error === 'WAVE_DEPS_NOT_MET')) {
+            const targetModule = parsedBody?.targetModule || 'unknown';
+            const targetWave = parsedBody?.targetWave ?? '?';
+            const blockers = parsedBody?.blockingModules || [];
+            const blockerList = blockers.map(b => `${b.slug} (W${b.wave}, ${b.status})`).join(', ');
+            this.log(chalk.red(`Cannot deploy ${targetModule} (W${targetWave}) — blocking modules: ${blockerList}. Run 'hd stage deploy ${stageName} --retry' first.`));
+            this.exit(2);
+            return;
+        }
+        // PREVIOUS_MISSION_NOT_TERMINAL
+        if (errorCode === 'PREVIOUS_MISSION_NOT_TERMINAL' || errorCode === 'MISSION_IN_FLIGHT') {
+            const missionId = parsedBody?.missionId || 'unknown';
+            const state = parsedBody?.state || 'RUNNING';
+            this.log(chalk.red(`Previous mission ${missionId} is still ${state}. Wait for it to complete before retrying.`));
+            this.exit(2);
+            return;
+        }
+        // MODULE_NOT_FOUND
+        if (errorCode === 'MODULE_NOT_FOUND') {
+            this.log(chalk.red(errorMessage));
+            this.exit(2);
+            return;
+        }
+        this.log(chalk.red(`❌ ${errorMessage}`));
+        this.exit(1);
+    }
+    /**
+     * Build CloudWatch console URL
+     */
+    buildConsoleUrl(config) {
+        const encodedGroup = encodeURIComponent(encodeURIComponent(config.logGroup));
+        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}`;
+    }
+    /**
+     * Stream mission logs in real-time (shared by --retry and --module)
+     */
+    async streamMissionLogs(loggingConfig, missionId, verbose, mode, moduleSlug) {
+        if (mode === 'module') {
+            this.log(chalk.blue(`\n🎯 Single-module deploy started: ${missionId}`));
+            this.log(chalk.gray(`   Deploying: ${moduleSlug}`));
+        }
+        else {
+            this.log(chalk.blue(`\n🚀 Retry mission started: ${missionId}`));
+            this.log(chalk.gray('   Resuming deployment of failed/pending modules...'));
+        }
+        this.log('');
+        const tailer = new CloudWatchLogTailer(loggingConfig, {
+            pollInterval: 1000,
+            showDebug: false,
+            verbose,
+        });
+        const outcome = await tailer.tail();
+        this.log('');
+        if (outcome.success) {
+            this.log(chalk.green(`✅ ${outcome.message}`));
+            this.log(chalk.cyan(`   Mission: ${missionId}`));
+            const consoleUrl = this.buildConsoleUrl(loggingConfig);
+            this.log(chalk.gray(`   Logs: ${consoleUrl}`));
+            this.exit(0);
+        }
+        else {
+            this.log(chalk.red(`❌ ${outcome.message}`));
+            const consoleUrl = this.buildConsoleUrl(loggingConfig);
+            this.log(chalk.gray(`   Full logs: ${consoleUrl}`));
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/stage/ensure-branches.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `hd stage ensure-branches <stageName>` — ensure the stage branch exists on
+ * all linked project remotes, creating it when missing.
+ *
+ * This is a CLI-side command: by the time `hd stage create --autoLaunch`
+ * kicks off the builder pods, branches must already exist on linked frontend
+ * remotes. Running this command beforehand is the primary fix for the
+ * "sign + tenant-seed blocked because the SS-N branch doesn't exist on the
+ * Sign remote" class of mission failures.
+ */
+import { Command } from '@oclif/core';
+export default class StageEnsureBranches extends Command {
+    static description: string;
+    static args: {
+        stageName: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        dryRun: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/stage/ensure-branches.js

@@ -0,0 +1,101 @@
+/**
+ * `hd stage ensure-branches <stageName>` — ensure the stage branch exists on
+ * all linked project remotes, creating it when missing.
+ *
+ * This is a CLI-side command: by the time `hd stage create --autoLaunch`
+ * kicks off the builder pods, branches must already exist on linked frontend
+ * remotes. Running this command beforehand is the primary fix for the
+ * "sign + tenant-seed blocked because the SS-N branch doesn't exist on the
+ * Sign remote" class of mission failures.
+ */
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { ensureBranches } from '../../lib/ensure-branches.js';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class StageEnsureBranches extends Command {
+    static description = 'Ensure the stage branch exists on all linked project remotes (creates if missing)';
+    static args = {
+        stageName: Args.string({ description: 'Name of the stage', required: true }),
+    };
+    static flags = {
+        verbose: Flags.boolean({
+            char: 'v',
+            default: false,
+            description: 'Print per-project status',
+        }),
+        dryRun: Flags.boolean({
+            default: false,
+            description: 'Detect missing branches without creating them',
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(StageEnsureBranches);
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            this.log(chalk.blue(`🌿 Ensuring branches for stage: ${args.stageName}`));
+            const stage = await service.stageGet({ name: args.stageName });
+            if (!stage.branchName) {
+                this.error('Stage has no branchName — cannot ensure branches');
+            }
+            // Prefer `projectSlugs` (creation-time intent list) — fall back to the
+            // keys of `projects` (runtime tracking map) if the backend only
+            // exposes the deployment state.
+            const projectSlugs = (stage.projectSlugs && stage.projectSlugs.length > 0
+                ? stage.projectSlugs
+                : stage.projects
+                    ? Object.keys(stage.projects)
+                    : []);
+            if (projectSlugs.length === 0) {
+                this.log(chalk.gray(`ℹ️  No linked projects for stage ${args.stageName} — nothing to do`));
+                this.exit(0);
+            }
+            const allModules = await service.moduleList();
+            const linkedProjects = allModules
+                .filter((m) => m.slug && projectSlugs.includes(m.slug))
+                .map((m) => ({
+                slug: m.slug,
+                gitProvider: m.gitProvider,
+                gitFullRepoPath: m.gitFullRepoPath,
+            }));
+            if (flags.dryRun) {
+                this.log(chalk.yellow('[dry-run] detection only — no branches will be created'));
+            }
+            const result = await ensureBranches({
+                stageName: args.stageName,
+                branchName: stage.branchName,
+                linkedProjects,
+                verbose: flags.verbose,
+                dryRun: flags.dryRun,
+                logger: (msg) => this.log(msg),
+            });
+            // Always print a one-line summary (even in --verbose mode).
+            const summary = `${result.created + result.alreadyExisted}/${result.total} branches ensured (${result.created} created, ${result.alreadyExisted} already existed, ${result.failed} failed)`;
+            if (result.failed > 0) {
+                this.log(chalk.red(`❌ ${summary}`));
+                this.exit(1);
+            }
+            else {
+                this.log(chalk.green(`✅ ${summary}`));
+            }
+        }
+        catch (error) {
+            const err = error;
+            // Ignore EEXIT with code 0 — oclif's clean-exit pattern.
+            if (err.message?.includes('EEXIT') && err.oclif?.exit === 0) {
+                return;
+            }
+            // Re-throw oclif exits with non-zero code so the process bubbles up.
+            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 ensuring branches: ${errorMessage}`));
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/stage/list.js

@@ -46,6 +46,10 @@ export default class StageList extends Command {
                     header: 'Regions',
                     get: (row) => (row.regions || []).join(', '),
                 },
+                customDomain: {
+                    header: 'Domain',
+                    get: (row) => row.customDomain || '',
+                },
                 defaultStage: {
                     header: 'Default',
                     get: (row) => row.defaultStage ? chalk.green('✓') : '',

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

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

package/dist/commands/stage/status.js

@@ -0,0 +1,100 @@
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+const STATUS_ICONS = {
+    deployed: '✅',
+    failed: '❌',
+    skipped: '⏸️',
+    pending: '⏳',
+    timeout: '⏱️',
+};
+const colorizeStatus = (status) => {
+    switch (status) {
+        case 'success':
+            return chalk.green(status);
+        case 'running':
+        case 'partial-failure':
+            return chalk.yellow(status);
+        case 'failed':
+            return chalk.red(status);
+        default:
+            return status;
+    }
+};
+export default class StageStatus extends Command {
+    static args = {
+        slug: Args.string({ description: 'Stage slug (e.g. ss-11)', required: true }),
+    };
+    static description = 'Show deployment status for a stage';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> ss-11',
+        '<%= config.bin %> <%= command.id %> ss-11 --verbose',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        verbose: Flags.boolean({
+            char: 'v',
+            description: 'Show deploymentId and errorType per module',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(StageStatus);
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            const response = await service.stageGetDeployManifest(args.slug);
+            if (!response.manifest) {
+                this.log(chalk.yellow(`⚠️  No deployment data for stage ${args.slug}`));
+                this.log(chalk.gray(`The stage exists but has no deploy manifest. Run hd stage create ${args.slug} --autoLaunch to deploy it.`));
+                return;
+            }
+            this.renderManifest(response.manifest, args.slug, flags.verbose ?? false);
+        }
+        catch (error) {
+            const statusCode = error?.response?.status ?? error?.statusCode;
+            if (statusCode === 404) {
+                this.error(chalk.red(`❌ Stage ${args.slug} not found`));
+            }
+            throw error;
+        }
+    }
+    renderManifest(manifest, slug, verbose) {
+        // Compute totals
+        const allModules = manifest.waves.flatMap(w => w.modules);
+        const total = allModules.length;
+        const counts = { deployed: 0, failed: 0, pending: 0, skipped: 0, timeout: 0 };
+        for (const m of allModules) {
+            counts[m.status] = (counts[m.status] || 0) + 1;
+        }
+        // Header
+        this.log(`Stage: ${chalk.cyan(slug)} | Mission: ${chalk.cyan(manifest.missionId)} | Status: ${colorizeStatus(manifest.status)}`);
+        this.log(`Started: ${manifest.startedAt}  Updated: ${manifest.updatedAt}  ` +
+            `Modules: ${counts.deployed}/${total} ✅  ${counts.failed} ❌  ${counts.skipped} ⏸️  ${counts.pending} ⏳  ${counts.timeout} ⏱️`);
+        this.log('');
+        // Waves
+        for (const wave of manifest.waves) {
+            const waveDeployed = wave.modules.filter(m => m.status === 'deployed').length;
+            if (verbose) {
+                this.log(`W${wave.waveIndex}: (${waveDeployed}/${wave.modules.length})`);
+                for (const m of wave.modules) {
+                    const icon = STATUS_ICONS[m.status] || '?';
+                    let line = `  ${m.moduleSlug} ${icon} ${m.status}`;
+                    if (m.deploymentId)
+                        line += `  deploymentId=${m.deploymentId}`;
+                    if (m.errorType)
+                        line += `  errorType=${m.errorType}`;
+                    this.log(line);
+                }
+            }
+            else {
+                const moduleSegments = wave.modules.map(m => {
+                    const icon = STATUS_ICONS[m.status] || '?';
+                    return `[${m.moduleSlug} ${icon}]`;
+                });
+                this.log(`W${wave.waveIndex}: ${moduleSegments.join(' ')} (${waveDeployed}/${wave.modules.length})`);
+            }
+        }
+    }
+}