@hyperdrive.bot/cli 1.0.2

package/dist/commands/deployment/create.js

@@ -0,0 +1,188 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import moment from 'moment';
+import { existsSync, readFileSync } from 'node:fs';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+import { CloudWatchLogTailer } from '../../services/log-tailer.js';
+export default class DeploymentCreate extends Command {
+    static description = 'Create a new deployment with real-time log streaming';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --stage="dev" --commit="abc123" --moduleSlug="my-api"',
+        '<%= config.bin %> <%= command.id %> --stage="dev" --commit="abc123" --launch',
+        '<%= config.bin %> <%= command.id %> --stage="dev" --commit="abc123" --verbose',
+    ];
+    static flags = {
+        commit: Flags.string({
+            char: 'c',
+            description: 'Commit hash',
+            required: true,
+        }),
+        debug: Flags.boolean({
+            default: false,
+            description: 'Include debug-level logs (requires --verbose)',
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        launch: Flags.boolean({
+            default: false,
+            description: 'Launch the deployment after creating it',
+        }),
+        moduleSlug: Flags.string({
+            char: 'm',
+            default() {
+                if (existsSync('.hyperdrive.json')) {
+                    const hyperdriveConfig = JSON.parse(readFileSync('.hyperdrive.json', 'utf8'));
+                    return hyperdriveConfig.slug;
+                }
+                return '';
+            },
+            description: 'Module slug',
+            required: true,
+        }),
+        name: Flags.string({
+            char: 'n',
+            default: `Deployment-${moment().format('YYYY-MM-DD-HH-mm-ss')}`,
+            description: 'The name of the deployment',
+            required: false,
+        }),
+        noStream: Flags.boolean({
+            default: false,
+            description: 'Disable log streaming (use polling instead)',
+        }),
+        regions: Flags.string({
+            char: 'r',
+            default: [],
+            description: 'Regions for the deployment',
+            multiple: true,
+        }),
+        stage: Flags.string({
+            char: 's',
+            description: 'Stage for the deployment',
+            required: true,
+        }),
+        verbose: Flags.boolean({
+            char: 'v',
+            default: false,
+            description: 'Show detailed build logs',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DeploymentCreate);
+        this.log(chalk.blue(`\n📦 Creating deployment "${flags.name}"...`));
+        this.log(chalk.gray(`   Module: ${flags.moduleSlug}`));
+        this.log(chalk.gray(`   Stage: ${flags.stage}`));
+        this.log(chalk.gray(`   Commit: ${flags.commit}`));
+        if (flags.regions.length > 0) {
+            this.log(chalk.gray(`   Regions: ${flags.regions.join(', ')}`));
+        }
+        this.log('');
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            const result = await service.deploymentCreate({
+                commit: flags.commit,
+                launch: flags.launch,
+                name: flags.name,
+                projectSlug: flags.moduleSlug, // API still expects projectSlug (backend terminology)
+                regions: flags.regions,
+                stage: flags.stage,
+            });
+            // Check if API returned logging config (for real-time streaming)
+            const loggingConfig = result.logging;
+            if (flags.noStream || !loggingConfig) {
+                // Fallback to polling (existing behavior)
+                if (!flags.noStream && !loggingConfig) {
+                    this.log(chalk.gray('Log streaming not available, using polling...'));
+                }
+                let statusToExpected = 'ready';
+                if (flags.launch) {
+                    statusToExpected = 'launched';
+                }
+                await this.pollDeploymentStatus(service, flags, statusToExpected);
+            }
+            else {
+                // Stream logs using scoped credentials
+                await this.streamDeploymentLogs(loggingConfig, flags, result);
+            }
+        }
+        catch (error) {
+            const err = error;
+            // Ignore EEXIT with code 0 - this is oclif's way of exiting cleanly
+            if (err.message?.includes('EEXIT') && err.oclif?.exit === 0) {
+                return;
+            }
+            if (err.response?.status === 400 && err.response?.data === 'Deployment is not in ready state, so cannot be "recreated"') {
+                this.error(err.response.data);
+            }
+            this.log(chalk.red('❌ Error creating deployment: ' + err.message));
+            this.exit(1);
+        }
+    }
+    /**
+     * Build CloudWatch console URL for log viewing
+     */
+    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}`;
+    }
+    /**
+     * Poll for deployment status (fallback when streaming not available)
+     */
+    async pollDeploymentStatus(service, flags, expectedStatus) {
+        const response = await service.deploymentCheck({
+            name: flags.name,
+            projectSlug: flags.moduleSlug, // API still expects projectSlug
+            stage: flags.stage,
+        });
+        this.log(chalk.blue(`📋 Deployment status: ${response.status}`));
+        if (response.status === expectedStatus) {
+            this.log(chalk.green(`✅ Deployment ${expectedStatus}!`));
+            if (response.url) {
+                this.log(chalk.cyan(`🌐 URL: ${response.url}`));
+            }
+            return;
+        }
+        if (response.status === 'failed') {
+            this.log(chalk.red('❌ Deployment failed'));
+            if (response.error) {
+                this.log(chalk.red(`   Error: ${response.error}`));
+            }
+            this.exit(1);
+        }
+        await new Promise(resolve => {
+            setTimeout(resolve, 10_000);
+        });
+        return this.pollDeploymentStatus(service, flags, expectedStatus);
+    }
+    /**
+     * Stream deployment logs using CloudWatch
+     */
+    async streamDeploymentLogs(loggingConfig, flags, result) {
+        const tailer = new CloudWatchLogTailer(loggingConfig, {
+            pollInterval: 1000,
+            showDebug: flags.debug,
+            verbose: flags.verbose,
+        });
+        const outcome = await tailer.tail();
+        this.log('');
+        if (outcome.success) {
+            this.log(chalk.green(`✅ ${outcome.message}`));
+            if (result.url) {
+                this.log(chalk.cyan(`   URL: ${result.url}`));
+            }
+            // Show CloudWatch console link
+            const consoleUrl = this.buildConsoleUrl(loggingConfig);
+            this.log(chalk.gray(`   Logs: ${consoleUrl}`));
+            this.exit(0);
+        }
+        else {
+            this.log(chalk.red(`❌ ${outcome.message}`));
+            // Show CloudWatch console link for debugging
+            const consoleUrl = this.buildConsoleUrl(loggingConfig);
+            this.log(chalk.gray(`   Full logs: ${consoleUrl}`));
+            this.exit(1);
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class DeploymentGet 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>;
+        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>;
+        stage: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private colorizeStatus;
+}

package/dist/commands/deployment/get.js

@@ -0,0 +1,101 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'node:fs';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class DeploymentGet extends Command {
+    static description = 'Get details of a specific deployment (alias for deployment check)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --name="Deployment-2024-01-01" --stage="dev"',
+        '<%= config.bin %> <%= command.id %> --name="prod-release-v1" --stage="prod"',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        moduleSlug: Flags.string({
+            char: 'm',
+            default() {
+                if (existsSync('.hyperdrive.json')) {
+                    const hyperdriveConfig = JSON.parse(readFileSync('.hyperdrive.json', 'utf8'));
+                    return hyperdriveConfig.slug;
+                }
+                return '';
+            },
+            description: 'Module slug',
+            required: true,
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Deployment name',
+            required: true,
+        }),
+        stage: Flags.string({
+            char: 's',
+            description: 'Stage for the deployment',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DeploymentGet);
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            this.log(chalk.blue(`🔍 Fetching deployment ${chalk.cyan(flags.name)}...`));
+            const deployment = await service.deploymentCheck({
+                name: flags.name,
+                projectSlug: flags.moduleSlug, // API still expects projectSlug
+                stage: flags.stage,
+            });
+            if (!deployment) {
+                this.log(chalk.red(`❌ Deployment ${flags.name} not found`));
+                return;
+            }
+            this.log(chalk.green('✅ Deployment details:\n'));
+            // Display key information
+            this.log(chalk.bold('Name:'), deployment.name || flags.name);
+            this.log(chalk.bold('Status:'), this.colorizeStatus(deployment.status));
+            this.log(chalk.bold('Stage:'), chalk.cyan(flags.stage));
+            this.log(chalk.bold('Project:'), chalk.cyan(flags.moduleSlug));
+            if (deployment.commit) {
+                this.log(chalk.bold('Commit:'), deployment.commit);
+            }
+            if (deployment.url) {
+                this.log(chalk.bold('URL:'), chalk.blue(deployment.url));
+            }
+            if (deployment.createdAt && typeof deployment.createdAt === 'string') {
+                this.log(chalk.bold('Created:'), new Date(deployment.createdAt).toLocaleString());
+            }
+            if (deployment.regions) {
+                this.log(chalk.bold('Regions:'), deployment.regions);
+            }
+            if (deployment.error) {
+                this.log(chalk.bold(chalk.red('Error:')), deployment.error);
+            }
+            // Show full JSON for additional details
+            this.log(chalk.gray('\n📋 Full details:'));
+            this.log(JSON.stringify(deployment, null, 2));
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error(`An error occurred while fetching deployment ${flags.name}`);
+        }
+    }
+    colorizeStatus(status) {
+        if (!status)
+            return chalk.gray('UNKNOWN');
+        switch (status.toLowerCase()) {
+            case 'completed':
+            case 'launched':
+            case 'ready':
+                return chalk.green(status.toUpperCase());
+            case 'failed':
+                return chalk.red(status.toUpperCase());
+            case 'pending':
+            case 'building':
+            case 'deploying':
+                return chalk.yellow(status.toUpperCase());
+            default:
+                return chalk.gray(status.toUpperCase());
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class DeploymentLaunch 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>;
+        force: 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>;
+        region: 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, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private pollDeploymentStatus;
+}

package/dist/commands/deployment/launch.js

@@ -0,0 +1,105 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'node:fs';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class DeploymentLaunch extends Command {
+    static description = 'Launch an existing deployment';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --name="Deployment-2024-01-01" --stage="dev" --region="us-east-1"',
+        '<%= config.bin %> <%= command.id %> --name="prod-release" --stage="prod" --region="us-west-2"',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Force launch even if deployment is not in ready state',
+        }),
+        moduleSlug: Flags.string({
+            char: 'm',
+            default() {
+                if (existsSync('.hyperdrive.json')) {
+                    const hyperdriveConfig = JSON.parse(readFileSync('.hyperdrive.json', 'utf8'));
+                    return hyperdriveConfig.slug;
+                }
+                return '';
+            },
+            description: 'Module slug',
+            required: true,
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'The name of the deployment to launch',
+            required: true,
+        }),
+        region: Flags.string({
+            char: 'r',
+            description: 'Region for the deployment',
+        }),
+        stage: Flags.string({
+            char: 's',
+            description: 'Stage for the deployment',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DeploymentLaunch);
+        this.log(chalk.green(`🚀 Launching deployment "${flags.name}"...`));
+        this.log(chalk.gray(`   Project: ${flags.moduleSlug}`));
+        this.log(chalk.gray(`   Stage: ${flags.stage}`));
+        if (flags.region) {
+            this.log(chalk.gray(`   Region: ${flags.region}`));
+        }
+        if (flags.force) {
+            this.log(chalk.yellow(`   Force: true`));
+        }
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            await service.deploymentLaunch({
+                force: flags.force,
+                name: flags.name,
+                projectSlug: flags.moduleSlug, // API still expects projectSlug
+                region: flags.region,
+                stage: flags.stage,
+            });
+            await this.pollDeploymentStatus(service, flags);
+        }
+        catch (error) {
+            const err = error;
+            if (err.response?.status === 400 && err.response?.data === 'Deployment is not in ready state, so cannot be "launched"') {
+                this.error(err.response.data);
+            }
+            this.log(chalk.red('❌ Error launching deployment: ' + err.message));
+            this.exit(1);
+        }
+    }
+    async pollDeploymentStatus(service, flags) {
+        const response = await service.deploymentCheck({
+            name: flags.name,
+            projectSlug: flags.moduleSlug, // API still expects projectSlug
+            stage: flags.stage,
+        });
+        this.log(chalk.blue(`📋 Deployment status: ${response.status}`));
+        if (response.status === 'completed' || response.status === 'launched') {
+            this.log(chalk.green('✅ Deployment launched successfully!'));
+            if (response.url) {
+                this.log(chalk.cyan(`🌐 URL: ${response.url}`));
+            }
+            return;
+        }
+        if (response.status === 'failed') {
+            this.log(chalk.red('❌ Deployment failed'));
+            if (response.error) {
+                this.log(chalk.red(`   Error: ${response.error}`));
+            }
+            this.exit(1);
+        }
+        await new Promise(resolve => {
+            setTimeout(resolve, 10_000);
+        });
+        return this.pollDeploymentStatus(service, flags);
+    }
+}

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

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class DeploymentList 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>;
+        moduleSlug: 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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/deployment/list.js

@@ -0,0 +1,91 @@
+import { Command, Flags, ux } from '@oclif/core';
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'node:fs';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class DeploymentList extends Command {
+    static description = 'List all deployments for a module and stage';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --stage="dev"',
+        '<%= config.bin %> <%= command.id %> --stage="prod" --moduleSlug="my-api"',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        moduleSlug: Flags.string({
+            char: 'm',
+            default() {
+                if (existsSync('.hyperdrive.json')) {
+                    const hyperdriveConfig = JSON.parse(readFileSync('.hyperdrive.json', 'utf8'));
+                    return hyperdriveConfig.slug;
+                }
+                return '';
+            },
+            description: 'Module slug',
+            required: true,
+        }),
+        stage: Flags.string({
+            char: 's',
+            description: 'Stage to list deployments for',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DeploymentList);
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            this.log(chalk.blue(`🔍 Fetching deployments for ${chalk.cyan(flags.moduleSlug)} in stage ${chalk.cyan(flags.stage)}...`));
+            const deployments = await service.deploymentList({
+                projectSlug: flags.moduleSlug, // API still expects projectSlug
+                stage: flags.stage,
+            });
+            if (!deployments || deployments.length === 0) {
+                this.log(chalk.yellow('⚠️  No deployments found'));
+                return;
+            }
+            this.log(chalk.green(`✅ Found ${deployments.length} deployment(s)\n`));
+            // Display deployments in a table
+            ux.table(deployments, {
+                commit: {
+                    get: (row) => row.commit?.substring(0, 7) || 'N/A',
+                    header: 'Commit',
+                },
+                createdAt: {
+                    get: (row) => new Date(row.createdAt).toLocaleString(),
+                    header: 'Created',
+                },
+                name: {
+                    header: 'Name',
+                    minWidth: 20,
+                },
+                regions: {
+                    get: (row) => (row.regions || []).join(', '),
+                    header: 'Regions',
+                },
+                status: {
+                    get: (row) => {
+                        const status = row.status || 'unknown';
+                        switch (status) {
+                            case 'completed':
+                            case 'launched':
+                                return chalk.green(status.toUpperCase());
+                            case 'failed':
+                                return chalk.red(status.toUpperCase());
+                            case 'pending':
+                            case 'building':
+                                return chalk.yellow(status.toUpperCase());
+                            default:
+                                return chalk.gray(status.toUpperCase());
+                        }
+                    },
+                    header: 'Status',
+                },
+            });
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error('An error occurred while listing deployments');
+        }
+    }
+}

package/dist/commands/domain/current.d.ts

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

package/dist/commands/domain/current.js

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+import chalk from 'chalk';
+import { TenantService } from '../../services/tenant-service.js';
+export default class DomainCurrent extends Command {
+    static description = 'Show the current default domain';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const tenantService = new TenantService();
+        const defaultDomain = tenantService.getDefaultDomain();
+        if (defaultDomain) {
+            this.log(chalk.green(`Current default domain: ${chalk.cyan(defaultDomain)}`));
+        }
+        else {
+            this.log(chalk.yellow('No default domain set.'));
+            this.log(chalk.gray('Run `hd auth login` to set up a domain.'));
+        }
+    }
+}

package/dist/commands/domain/list.d.ts

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

package/dist/commands/domain/list.js

@@ -0,0 +1,42 @@
+import { Command } from '@oclif/core';
+import chalk from 'chalk';
+import { AuthService } from '../../services/auth-service.js';
+import { TenantService } from '../../services/tenant-service.js';
+export default class DomainList extends Command {
+    static description = 'List all configured domains/installations';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const tenantService = new TenantService();
+        const authService = new AuthService();
+        // Get configured domains and authenticated domains
+        const configuredDomains = tenantService.getConfiguredDomains();
+        const credentialDomains = authService.getCredentialDomains();
+        const defaultDomain = tenantService.getDefaultDomain();
+        // Merge both lists
+        const allDomains = new Set([...configuredDomains, ...credentialDomains]);
+        if (allDomains.size === 0) {
+            this.log(chalk.yellow('No domains configured yet.'));
+            this.log(chalk.gray('Run `hd auth login --domain <domain>` to add a domain.'));
+            return;
+        }
+        this.log(chalk.blue('📋 Configured Domains:'));
+        this.log('');
+        for (const domain of Array.from(allDomains).sort()) {
+            const isDefault = domain === defaultDomain;
+            const hasConfig = configuredDomains.includes(domain);
+            const hasCredentials = credentialDomains.includes(domain);
+            let status = '';
+            if (hasCredentials) {
+                status = chalk.green('✓ Authenticated');
+            }
+            else if (hasConfig) {
+                status = chalk.yellow('⚠ Not authenticated');
+            }
+            const defaultBadge = isDefault ? chalk.cyan(' [DEFAULT]') : '';
+            this.log(`  ${chalk.white(domain)}${defaultBadge} ${status}`);
+        }
+        this.log('');
+        this.log(chalk.gray('💡 Use `hd domain switch <domain>` to change the default domain'));
+        this.log(chalk.gray('💡 Use `--domain <domain>` flag to run commands for a specific domain'));
+    }
+}

package/dist/commands/domain/switch.d.ts

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

package/dist/commands/domain/switch.js

@@ -0,0 +1,40 @@
+import { Args, Command } from '@oclif/core';
+import chalk from 'chalk';
+import { AuthService } from '../../services/auth-service.js';
+import { TenantService } from '../../services/tenant-service.js';
+export default class DomainSwitch extends Command {
+    static args = {
+        domain: Args.string({
+            description: 'The domain to set as default',
+            required: true,
+        }),
+    };
+    static description = 'Switch the default domain for CLI commands';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> acme.hyperdrive.bot',
+    ];
+    async run() {
+        const { args } = await this.parse(DomainSwitch);
+        const tenantService = new TenantService();
+        const authService = new AuthService();
+        // Verify domain exists
+        const credentialDomains = authService.getCredentialDomains();
+        const configuredDomains = tenantService.getConfiguredDomains();
+        const allDomains = [...credentialDomains, ...configuredDomains];
+        if (!allDomains.includes(args.domain)) {
+            this.error(chalk.red(`Domain "${args.domain}" not found.\n\n`) +
+                chalk.yellow('Available domains:\n') +
+                (allDomains.length > 0
+                    ? allDomains.map(d => `  - ${d}`).join('\n')
+                    : chalk.gray('  No domains configured yet.')) +
+                '\n\n' +
+                chalk.gray('💡 Run `hd auth login --domain <domain>` to add a new domain.'));
+        }
+        // Set as default
+        tenantService.setDefaultDomain(args.domain);
+        this.log(chalk.green(`✅ Default domain switched to: ${chalk.cyan(args.domain)}`));
+        this.log('');
+        this.log(chalk.gray('All commands will now use this domain by default.'));
+        this.log(chalk.gray('You can still use `--domain <domain>` to override temporarily.'));
+    }
+}