@hyperdrive.bot/cli 1.0.2

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

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Status extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/auth/status.js

@@ -0,0 +1,63 @@
+import { Command } from '@oclif/core';
+import chalk from 'chalk';
+import { decode } from 'jsonwebtoken';
+import { AuthService } from '../../services/auth-service.js';
+export default class Status extends Command {
+    static description = 'Show current authentication status';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const authService = new AuthService();
+        const credentials = authService.loadCredentials();
+        if (!credentials) {
+            this.log(chalk.yellow('❌ Not authenticated'));
+            this.log('');
+            this.log(chalk.gray('Run `hd auth login` to authenticate'));
+            return;
+        }
+        try {
+            // Decode ID token to get user info (without verification - just for display)
+            const idTokenPayload = decode(credentials.id_token);
+            this.log(chalk.blue('🔐 Authentication Status'));
+            this.log('');
+            this.log(chalk.white('Status:'), chalk.green('✓ Authenticated'));
+            if (idTokenPayload) {
+                this.log(chalk.white('User:'), chalk.cyan(idTokenPayload.email || idTokenPayload.sub));
+                if (idTokenPayload.name) {
+                    this.log(chalk.white('Name:'), chalk.cyan(idTokenPayload.name));
+                }
+            }
+            this.log('');
+            this.log(chalk.white('AWS Credentials:'));
+            const awsExpiration = new Date(credentials.awsCredentials.expiration);
+            const now = new Date();
+            const expiresInMs = awsExpiration.getTime() - now.getTime();
+            const expiresInMin = Math.floor(expiresInMs / 1000 / 60);
+            const isExpired = expiresInMs <= 0;
+            const isExpiringSoon = expiresInMs > 0 && expiresInMs < 5 * 60 * 1000; // Less than 5 minutes
+            if (isExpired) {
+                this.log(chalk.white('  Status:'), chalk.red('✗ Expired'));
+                this.log(chalk.white('  Expired:'), chalk.red(awsExpiration.toLocaleString()));
+                this.log('');
+                this.log(chalk.yellow('⚠️  Run `hd auth refresh` to renew your session'));
+            }
+            else if (isExpiringSoon) {
+                this.log(chalk.white('  Status:'), chalk.yellow('⚠ Expiring soon'));
+                this.log(chalk.white('  Expires:'), chalk.yellow(`in ${expiresInMin} minutes`));
+                this.log(chalk.white('  Expires at:'), chalk.gray(awsExpiration.toLocaleString()));
+                this.log('');
+                this.log(chalk.yellow('💡 Tip: Run `hd auth refresh` to extend your session'));
+            }
+            else {
+                this.log(chalk.white('  Status:'), chalk.green('✓ Valid'));
+                this.log(chalk.white('  Expires:'), chalk.green(`in ${expiresInMin} minutes`));
+                this.log(chalk.white('  Expires at:'), chalk.gray(awsExpiration.toLocaleString()));
+            }
+            this.log('');
+            this.log(chalk.gray('Access Key:'), chalk.gray(credentials.awsCredentials.accessKeyId));
+            this.log(chalk.gray('Session Token:'), chalk.gray(`${credentials.awsCredentials.sessionToken.substring(0, 20)}...`));
+        }
+        catch (error) {
+            this.error(chalk.red(`Failed to check status: ${error instanceof Error ? error.message : String(error)}`));
+        }
+    }
+}

package/dist/commands/ci/account/create.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class CIAccountCreate extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        domain: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        project: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        scope: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        stage: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private promptForName;
+    private promptForScopes;
+}

package/dist/commands/ci/account/create.js

@@ -0,0 +1,158 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { HyperdriveSigV4Service } from '../../../services/hyperdrive-sigv4.js';
+const VALID_SCOPES = [
+    'deploy',
+    'deploy:create',
+    'deploy:launch',
+    'module:read',
+    'module:write',
+    'parameter:read',
+    'parameter:write',
+    'stage:read',
+    'stage:write',
+];
+export default class CIAccountCreate extends Command {
+    static description = 'Create a CI token for non-interactive authentication in CI/CD pipelines';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --name="github-prod" --scope=deploy --scope=module:read',
+        '<%= config.bin %> <%= command.id %> --name="gitlab-staging" --scope=deploy --scope=parameter:read',
+    ];
+    static flags = {
+        description: Flags.string({
+            description: 'Optional description for the CI account',
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain',
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Name for the CI account (e.g., github-prod, gitlab-staging)',
+        }),
+        project: Flags.string({
+            description: 'Restrict to specific project slugs (can be specified multiple times)',
+            multiple: true,
+        }),
+        scope: Flags.string({
+            char: 's',
+            description: 'Scopes to grant (can be specified multiple times)',
+            multiple: true,
+            options: [...VALID_SCOPES],
+        }),
+        stage: Flags.string({
+            description: 'Restrict to specific stages (can be specified multiple times)',
+            multiple: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(CIAccountCreate);
+        this.log(chalk.cyan('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        this.log(chalk.cyan('🔑 Create CI Service Account'));
+        this.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        this.log('');
+        // Prompt for missing values
+        const name = flags.name || await this.promptForName();
+        const scopes = flags.scope && flags.scope.length > 0 ? flags.scope : await this.promptForScopes();
+        if (scopes.length === 0) {
+            this.error('At least one scope is required');
+        }
+        // Validate scopes
+        for (const scope of scopes) {
+            if (!VALID_SCOPES.includes(scope)) {
+                this.error(`Invalid scope: ${scope}. Valid scopes: ${VALID_SCOPES.join(', ')}`);
+            }
+        }
+        const service = new HyperdriveSigV4Service(flags.domain);
+        this.log(chalk.blue(`\n🔄 Creating CI account "${name}"...`));
+        try {
+            const result = await service.ciAccountCreate({
+                description: flags.description,
+                name,
+                projectSlugs: flags.project,
+                scopes,
+                stages: flags.stage,
+            });
+            this.log('');
+            this.log(chalk.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+            this.log(chalk.green('✅ CI Token Created Successfully!'));
+            this.log(chalk.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+            this.log('');
+            this.log(chalk.white('Account Details:'));
+            this.log(chalk.gray(`  • ID: ${result.account.accountId}`));
+            this.log(chalk.gray(`  • Name: ${result.account.name}`));
+            this.log(chalk.gray(`  • Scopes: ${result.account.scopes.join(', ')}`));
+            this.log('');
+            this.log(chalk.yellow('⚠️  IMPORTANT: Save this token securely!'));
+            this.log(chalk.yellow('    It will NOT be shown again.'));
+            this.log('');
+            this.log(chalk.white('Token:'));
+            this.log('');
+            this.log(chalk.cyan(`  ${result.token}`));
+            this.log('');
+            this.log(chalk.white('Add to your CI environment:'));
+            this.log('');
+            this.log(chalk.gray('  GitHub Actions:'));
+            this.log(chalk.gray('    Settings → Secrets and variables → Actions → New repository secret'));
+            this.log(chalk.gray('    Name: HD_TOKEN'));
+            this.log('');
+            this.log(chalk.gray('  GitLab CI:'));
+            this.log(chalk.gray('    Settings → CI/CD → Variables → Add variable'));
+            this.log(chalk.gray('    Key: HD_TOKEN (masked)'));
+            this.log('');
+            this.log(chalk.white('Usage in CI pipeline:'));
+            this.log('');
+            this.log(chalk.gray('  export HD_TOKEN=<your-token>'));
+            this.log(chalk.gray('  hd auth login --ci --domain <your-domain>'));
+            this.log(chalk.gray('  hd deployment create --project <slug> --stage <stage>'));
+            this.log('');
+        }
+        catch (error) {
+            const err = error;
+            const message = err.response?.data?.message || err.message;
+            this.error(`Failed to create CI account: ${message}`);
+        }
+    }
+    async promptForName() {
+        const { name } = await inquirer.prompt([{
+                message: chalk.yellow('Enter a name for this CI account (e.g., github-prod):'),
+                name: 'name',
+                validate: (input) => {
+                    if (!input || input.trim().length === 0) {
+                        return 'Name is required';
+                    }
+                    if (input.length > 50) {
+                        return 'Name must be 50 characters or less';
+                    }
+                    return true;
+                },
+            }]);
+        return name;
+    }
+    async promptForScopes() {
+        const { scopes } = await inquirer.prompt([{
+                choices: [
+                    { checked: true, name: 'deploy - Create and launch deployments', value: 'deploy' },
+                    { name: 'deploy:create - Create deployments only', value: 'deploy:create' },
+                    { name: 'deploy:launch - Launch deployments only', value: 'deploy:launch' },
+                    { checked: true, name: 'module:read - Read module information', value: 'module:read' },
+                    { name: 'module:write - Create/update modules', value: 'module:write' },
+                    { name: 'parameter:read - Read parameters', value: 'parameter:read' },
+                    { name: 'parameter:write - Create/update parameters', value: 'parameter:write' },
+                    { name: 'stage:read - Read stage information', value: 'stage:read' },
+                    { name: 'stage:write - Create stages', value: 'stage:write' },
+                ],
+                message: chalk.yellow('Select scopes for this CI account:'),
+                name: 'scopes',
+                type: 'checkbox',
+                validate: (input) => {
+                    if (input.length === 0) {
+                        return 'At least one scope is required';
+                    }
+                    return true;
+                },
+            }]);
+        return scopes;
+    }
+}

package/dist/commands/ci/account/delete.d.ts

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

package/dist/commands/ci/account/delete.js

@@ -0,0 +1,88 @@
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { HyperdriveSigV4Service } from '../../../services/hyperdrive-sigv4.js';
+export default class CIAccountDelete extends Command {
+    static args = {
+        accountId: Args.string({
+            description: 'CI token ID to delete',
+            required: false,
+        }),
+    };
+    static description = 'Delete (revoke) a CI token';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> <account-id>',
+        '<%= config.bin %> <%= command.id %> <account-id> --force',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Skip confirmation prompt',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(CIAccountDelete);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        // If no account ID provided, list accounts and let user select
+        let accountId = args.accountId;
+        if (!accountId) {
+            accountId = await this.selectAccount(service);
+        }
+        if (!accountId) {
+            this.error('Account ID is required');
+        }
+        // Confirm deletion unless --force is used
+        if (!flags.force) {
+            const { confirm } = await inquirer.prompt([{
+                    default: false,
+                    message: chalk.yellow(`Are you sure you want to revoke CI token ${accountId}?`),
+                    name: 'confirm',
+                    type: 'confirm',
+                }]);
+            if (!confirm) {
+                this.log(chalk.gray('Revocation cancelled.'));
+                return;
+            }
+        }
+        this.log(chalk.blue(`\n🗑️  Revoking CI token...`));
+        try {
+            await service.ciAccountDelete(accountId);
+            this.log(chalk.green('\n✅ CI token revoked successfully.'));
+            this.log(chalk.gray('Any CI pipelines using this token will no longer be able to authenticate.'));
+        }
+        catch (error) {
+            const err = error;
+            const message = err.response?.data?.message || err.message;
+            this.error(`Failed to delete CI account: ${message}`);
+        }
+    }
+    async selectAccount(service) {
+        try {
+            const accounts = await service.ciAccountList();
+            if (accounts.length === 0) {
+                this.log(chalk.yellow('\nNo CI tokens found.'));
+                return undefined;
+            }
+            const { accountId } = await inquirer.prompt([{
+                    choices: accounts.map(account => ({
+                        name: `${account.name} (${account.cognitoUsername}) - ${account.status}`,
+                        value: account.accountId,
+                    })),
+                    message: chalk.yellow('Select a CI token to revoke:'),
+                    name: 'accountId',
+                    type: 'list',
+                }]);
+            return accountId;
+        }
+        catch (error) {
+            const err = error;
+            const message = err.response?.data?.message || err.message;
+            this.error(`Failed to list CI accounts: ${message}`);
+        }
+    }
+}

package/dist/commands/ci/account/list.d.ts

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

package/dist/commands/ci/account/list.js

@@ -0,0 +1,65 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { HyperdriveSigV4Service } from '../../../services/hyperdrive-sigv4.js';
+export default class CIAccountList extends Command {
+    static description = 'List all CI tokens';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain',
+        }),
+        json: Flags.boolean({
+            description: 'Output as JSON',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(CIAccountList);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        try {
+            const accounts = await service.ciAccountList();
+            if (flags.json) {
+                this.log(JSON.stringify(accounts, null, 2));
+                return;
+            }
+            if (accounts.length === 0) {
+                this.log(chalk.yellow('\nNo CI tokens found.'));
+                this.log(chalk.gray('Create one with: hd ci account create'));
+                return;
+            }
+            this.log(chalk.cyan('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+            this.log(chalk.cyan('🔑 CI Tokens'));
+            this.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+            this.log('');
+            for (const account of accounts) {
+                const statusColor = account.status === 'active' ? chalk.green : chalk.red;
+                const statusIcon = account.status === 'active' ? '●' : '○';
+                this.log(chalk.white(`${statusColor(statusIcon)} ${account.name}`));
+                this.log(chalk.gray(`    ID: ${account.accountId}`));
+                this.log(chalk.gray(`    Username: ${account.cognitoUsername}`));
+                this.log(chalk.gray(`    Scopes: ${account.scopes.join(', ')}`));
+                this.log(chalk.gray(`    Status: ${account.status}`));
+                this.log(chalk.gray(`    Created: ${new Date(account.createdAt).toLocaleString()}`));
+                if (account.lastUsedAt) {
+                    this.log(chalk.gray(`    Last Used: ${new Date(account.lastUsedAt).toLocaleString()}`));
+                }
+                if (account.projectSlugs && account.projectSlugs.length > 0) {
+                    this.log(chalk.gray(`    Projects: ${account.projectSlugs.join(', ')}`));
+                }
+                if (account.stages && account.stages.length > 0) {
+                    this.log(chalk.gray(`    Stages: ${account.stages.join(', ')}`));
+                }
+                this.log('');
+            }
+            this.log(chalk.gray(`Total: ${accounts.length} token(s)`));
+        }
+        catch (error) {
+            const err = error;
+            const message = err.response?.data?.message || err.message;
+            this.error(`Failed to list CI accounts: ${message}`);
+        }
+    }
+}

package/dist/commands/config/get.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class ConfigGet extends Command {
+    static args: {
+        key: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/config/get.js

@@ -0,0 +1,37 @@
+import { Args, Command } from '@oclif/core';
+import chalk from 'chalk';
+import { TenantService } from '../../services/tenant-service.js';
+export default class ConfigGet extends Command {
+    static args = {
+        key: Args.string({
+            description: 'Configuration key',
+            options: ['tenant-domain', 'bootstrap-url', 'api-url', 'region'],
+            required: true,
+        }),
+    };
+    static description = 'Get CLI configuration value';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> tenant-domain',
+        '<%= config.bin %> <%= command.id %> bootstrap-url',
+    ];
+    async run() {
+        const { args } = await this.parse(ConfigGet);
+        const tenantService = new TenantService();
+        // Convert kebab-case to camelCase
+        const configKey = args.key.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+        try {
+            const config = tenantService.loadConfigFile();
+            if (!config || !config[configKey]) {
+                this.log(chalk.yellow(`⚠️  ${args.key} is not set`));
+                this.log('');
+                this.log(chalk.gray(`Set it with: hd config set ${args.key} <value>`));
+                return;
+            }
+            this.log('');
+            this.log(chalk.white(`${args.key}:`), chalk.cyan(config[configKey]));
+        }
+        catch (error) {
+            this.error(chalk.red(`Failed to get configuration: ${error instanceof Error ? error.message : String(error)}`));
+        }
+    }
+}

package/dist/commands/config/set.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class ConfigSet extends Command {
+    static args: {
+        key: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/config/set.js

@@ -0,0 +1,48 @@
+import { Args, Command } from '@oclif/core';
+import chalk from 'chalk';
+import { TenantService } from '../../services/tenant-service.js';
+export default class ConfigSet extends Command {
+    static args = {
+        key: Args.string({
+            description: 'Configuration key',
+            options: ['tenant-domain', 'bootstrap-url', 'api-url', 'region'],
+            required: true,
+        }),
+        value: Args.string({
+            description: 'Configuration value',
+            required: true,
+        }),
+    };
+    static description = 'Set CLI configuration values';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> tenant-domain acme.hyperdrive.bot',
+        '<%= config.bin %> <%= command.id %> bootstrap-url https://custom-api.example.com/tenant/bootstrap',
+        '<%= config.bin %> <%= command.id %> api-url https://api.us-east-1.hyperdrive.bot',
+        '<%= config.bin %> <%= command.id %> region us-west-2',
+    ];
+    async run() {
+        const { args } = await this.parse(ConfigSet);
+        const tenantService = new TenantService();
+        // Convert kebab-case to camelCase for config keys
+        const configKey = args.key.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+        try {
+            // Load existing config
+            const existingConfig = tenantService.loadConfigFile() || {};
+            // Update config
+            const newConfig = {
+                ...existingConfig,
+                [configKey]: args.value,
+            };
+            tenantService.saveConfig(newConfig);
+            this.log('');
+            this.log(chalk.green(`✅ Configuration updated successfully!`));
+            this.log('');
+            this.log(chalk.white(`${args.key}:`), chalk.cyan(args.value));
+            this.log('');
+            this.log(chalk.gray('💡 Tip: Environment variables take precedence over config file settings'));
+        }
+        catch (error) {
+            this.error(chalk.red(`Failed to set configuration: ${error instanceof Error ? error.message : String(error)}`));
+        }
+    }
+}

package/dist/commands/config/show.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class ConfigShow extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/config/show.js

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+import { TenantService } from '../../services/tenant-service.js';
+export default class ConfigShow extends Command {
+    static description = 'Show all CLI configuration settings';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const tenantService = new TenantService();
+        tenantService.showConfig();
+    }
+}

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

@@ -0,0 +1,30 @@
+import { Command } from '@oclif/core';
+export default class DeploymentCreate extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        commit: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        debug: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        domain: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        launch: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        moduleSlug: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        noStream: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        regions: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[], import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        stage: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /**
+     * Build CloudWatch console URL for log viewing
+     */
+    private buildConsoleUrl;
+    /**
+     * Poll for deployment status (fallback when streaming not available)
+     */
+    private pollDeploymentStatus;
+    /**
+     * Stream deployment logs using CloudWatch
+     */
+    private streamDeploymentLogs;
+}