@hyperdrive.bot/cli 1.0.2

package/dist/commands/stage/create.js

@@ -0,0 +1,312 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { execSync } from 'node:child_process';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+// Full AWS regions list
+const AWS_REGIONS = [
+    { name: 'US East (N. Virginia)', value: 'us-east-1' },
+    { name: 'US East (Ohio)', value: 'us-east-2' },
+    { name: 'US West (N. California)', value: 'us-west-1' },
+    { name: 'US West (Oregon)', value: 'us-west-2' },
+    { name: 'Africa (Cape Town)', value: 'af-south-1' },
+    { name: 'Asia Pacific (Hong Kong)', value: 'ap-east-1' },
+    { name: 'Asia Pacific (Hyderabad)', value: 'ap-south-2' },
+    { name: 'Asia Pacific (Jakarta)', value: 'ap-southeast-3' },
+    { name: 'Asia Pacific (Melbourne)', value: 'ap-southeast-4' },
+    { name: 'Asia Pacific (Mumbai)', value: 'ap-south-1' },
+    { name: 'Asia Pacific (Osaka)', value: 'ap-northeast-3' },
+    { name: 'Asia Pacific (Seoul)', value: 'ap-northeast-2' },
+    { name: 'Asia Pacific (Singapore)', value: 'ap-southeast-1' },
+    { name: 'Asia Pacific (Sydney)', value: 'ap-southeast-2' },
+    { name: 'Asia Pacific (Tokyo)', value: 'ap-northeast-1' },
+    { name: 'Canada (Central)', value: 'ca-central-1' },
+    { name: 'Canada West (Calgary)', value: 'ca-west-1' },
+    { name: 'Europe (Frankfurt)', value: 'eu-central-1' },
+    { name: 'Europe (Ireland)', value: 'eu-west-1' },
+    { name: 'Europe (London)', value: 'eu-west-2' },
+    { name: 'Europe (Milan)', value: 'eu-south-1' },
+    { name: 'Europe (Paris)', value: 'eu-west-3' },
+    { name: 'Europe (Spain)', value: 'eu-south-2' },
+    { name: 'Europe (Stockholm)', value: 'eu-north-1' },
+    { name: 'Europe (Zurich)', value: 'eu-central-2' },
+    { name: 'Israel (Tel Aviv)', value: 'il-central-1' },
+    { name: 'Middle East (Bahrain)', value: 'me-south-1' },
+    { name: 'Middle East (UAE)', value: 'me-central-1' },
+    { name: 'South America (São Paulo)', value: 'sa-east-1' },
+];
+import { CloudWatchLogTailer } from '../../services/log-tailer.js';
+export default class StageCreate extends Command {
+    static description = 'Create a new stage';
+    static flags = {
+        accountId: Flags.string({
+            char: 'a',
+            description: 'AWS Account ID for deployments',
+        }),
+        autoLaunch: Flags.boolean({
+            default: false,
+            description: 'Automatically launch deployments for this stage',
+        }),
+        branchName: Flags.string({
+            char: 'b',
+            description: 'Git branch name',
+        }),
+        defaultStage: Flags.boolean({
+            default: false,
+            description: 'Set as default stage for fallback',
+        }),
+        deletionProtection: Flags.boolean({
+            default: false,
+            description: 'Enable deletion protection',
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Name of the stage (e.g., dev, staging, production)',
+        }),
+        production: Flags.boolean({
+            default: false,
+            description: 'Mark as production stage',
+        }),
+        project: Flags.string({
+            char: 'p',
+            description: 'Project slugs to associate with this stage',
+            multiple: true,
+        }),
+        provider: Flags.string({
+            default: 'aws',
+            description: 'Cloud provider',
+        }),
+        region: Flags.string({
+            char: 'r',
+            description: 'AWS region(s) for deployment',
+            multiple: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(StageCreate);
+        this.log(chalk.green('🚀 Let\'s create a new stage!'));
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            const responses = await this.promptUser(flags, service);
+            const combinedData = { ...flags, ...responses };
+            this.log('');
+            this.log(chalk.blue('Creating stage with:'));
+            this.log(chalk.gray(`   Name: ${combinedData.name}`));
+            this.log(chalk.gray(`   Account: ${combinedData.accountId}`));
+            this.log(chalk.gray(`   Region(s): ${combinedData.region.join(', ')}`));
+            this.log(chalk.gray(`   Branch: ${combinedData.branchName}`));
+            this.log(chalk.gray(`   Projects: ${combinedData.project.join(', ')}`));
+            const result = await service.stageCreate({
+                accountId: combinedData.accountId,
+                autoLaunch: combinedData.autoLaunch,
+                branchName: combinedData.branchName,
+                defaultStage: combinedData.defaultStage,
+                deletionProtection: combinedData.deletionProtection,
+                name: combinedData.name,
+                production: combinedData.production,
+                projects: combinedData.project,
+                provider: combinedData.provider,
+                regions: combinedData.region,
+            });
+            // Check if mission was started (autoLaunch + logging config)
+            const loggingConfig = result.logging;
+            const missionId = result.missionId;
+            if (combinedData.autoLaunch && loggingConfig && missionId) {
+                // Start real-time log streaming for mission
+                await this.streamMissionLogs(loggingConfig, missionId);
+            }
+            else {
+                // Standard stage creation (no autoLaunch)
+                this.log(chalk.blue('\n✅ Stage created successfully!'));
+                this.log(JSON.stringify(result, null, 2));
+            }
+        }
+        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;
+            }
+            const axiosError = error;
+            const errorMessage = axiosError.response?.data?.message ?? axiosError.message ?? 'Unknown error';
+            this.log(chalk.red('❌ Error creating stage: ' + 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}`;
+    }
+    getGitBranch() {
+        try {
+            return execSync('git branch --show-current', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async promptUser(flags, service) {
+        const responses = {};
+        // Stage name
+        if (!flags.name) {
+            const { name } = await inquirer.prompt([{
+                    message: chalk.yellow('📛 Enter the stage name (e.g., dev, staging, production):'),
+                    name: 'name',
+                    validate: (input) => Boolean(input.trim()) || 'Stage name is required.',
+                }]);
+            responses.name = name;
+        }
+        // Branch name (auto-detect from git)
+        if (!flags.branchName) {
+            const defaultBranch = this.getGitBranch();
+            const { branchName } = await inquirer.prompt([{
+                    default: defaultBranch,
+                    message: chalk.yellow('🌿 Git branch for this stage:'),
+                    name: 'branchName',
+                    validate: (input) => Boolean(input.trim()) || 'Branch name is required.',
+                }]);
+            responses.branchName = branchName;
+        }
+        // AWS Account (fetch from API)
+        if (!flags.accountId) {
+            this.log(chalk.gray('\n   Fetching AWS accounts...'));
+            const accounts = await service.accountList();
+            if (accounts.length === 0) {
+                this.log(chalk.red('❌ No AWS accounts found. Please add an account first with: hd account add'));
+                this.exit(1);
+            }
+            const accountChoices = accounts.map(acc => ({
+                defaultRegion: acc.defaultRegion,
+                name: acc.name ? `${acc.name} (${acc.accountId}) - ${acc.defaultRegion}` : `${acc.accountId} - ${acc.defaultRegion}`,
+                value: acc.accountId,
+            }));
+            const { accountId } = await inquirer.prompt([{
+                    choices: accountChoices,
+                    message: chalk.yellow('☁️  Select AWS Account:'),
+                    name: 'accountId',
+                    type: 'list',
+                }]);
+            responses.accountId = accountId;
+            // Store default region for pre-selection
+            const selectedAccount = accountChoices.find(a => a.value === accountId);
+            responses._defaultRegion = selectedAccount?.defaultRegion;
+        }
+        // Regions (checkbox with full AWS list)
+        if (!flags.region || flags.region.length === 0) {
+            const defaultRegion = responses._defaultRegion;
+            // Pre-select the account's default region if available
+            const regionChoices = AWS_REGIONS.map(r => ({
+                checked: r.value === defaultRegion,
+                name: `${r.name} (${r.value})`,
+                value: r.value,
+            }));
+            const { region } = await inquirer.prompt([{
+                    choices: regionChoices,
+                    message: chalk.yellow('🌍 Select deployment region(s):'),
+                    name: 'region',
+                    type: 'checkbox',
+                    validate: (input) => input.length > 0 || 'At least one region is required.',
+                }]);
+            responses.region = region;
+        }
+        // Projects (fetch from API, multi-select)
+        if (!flags.project || flags.project.length === 0) {
+            this.log(chalk.gray('\n   Fetching projects...'));
+            const modules = await service.moduleList();
+            if (modules.length === 0) {
+                this.log(chalk.red('❌ No projects found. Please create a project first with: hd module create'));
+                this.exit(1);
+            }
+            const projectChoices = modules.map(m => ({
+                name: m.name ? `${m.name} (${m.slug})` : m.slug,
+                value: m.slug,
+            }));
+            const { project } = await inquirer.prompt([{
+                    choices: projectChoices,
+                    message: chalk.yellow('📦 Select projects to include in this stage:'),
+                    name: 'project',
+                    type: 'checkbox',
+                    validate: (input) => input.length > 0 || 'At least one project is required.',
+                }]);
+            responses.project = project;
+        }
+        // Additional options (only prompt if not already set via flags)
+        this.log('');
+        const additionalPrompts = [];
+        if (flags.production === undefined || flags.production === false) {
+            additionalPrompts.push({
+                default: false,
+                message: chalk.yellow('🏭 Is this a production stage?'),
+                name: 'production',
+                type: 'confirm',
+            });
+        }
+        if (flags.deletionProtection === undefined || flags.deletionProtection === false) {
+            additionalPrompts.push({
+                default: false,
+                message: chalk.yellow('🔒 Enable deletion protection?'),
+                name: 'deletionProtection',
+                type: 'confirm',
+            });
+        }
+        if (flags.defaultStage === undefined || flags.defaultStage === false) {
+            additionalPrompts.push({
+                default: false,
+                message: chalk.yellow('⭐ Set as default stage (fallback)?'),
+                name: 'defaultStage',
+                type: 'confirm',
+            });
+        }
+        if (flags.autoLaunch === undefined || flags.autoLaunch === false) {
+            additionalPrompts.push({
+                default: false,
+                message: chalk.yellow('🚀 Auto-launch deployments after creation?'),
+                name: 'autoLaunch',
+                type: 'confirm',
+            });
+        }
+        if (additionalPrompts.length > 0) {
+            const additionalResponses = await inquirer.prompt(additionalPrompts);
+            Object.assign(responses, additionalResponses);
+        }
+        // Clean up internal properties
+        delete responses._defaultRegion;
+        return responses;
+    }
+    /**
+     * Stream mission logs in real-time
+     */
+    async streamMissionLogs(loggingConfig, missionId) {
+        this.log(chalk.blue(`\n🚀 Mission started: ${missionId}`));
+        this.log(chalk.gray(`   Launching all modules in parallel...`));
+        this.log('');
+        const tailer = new CloudWatchLogTailer(loggingConfig, {
+            pollInterval: 1000,
+            showDebug: false,
+            verbose: true,
+        });
+        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/list.d.ts

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

package/dist/commands/stage/list.js

@@ -0,0 +1,63 @@
+import { Command, Flags, ux } from '@oclif/core';
+import chalk from 'chalk';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class StageList extends Command {
+    static description = 'List all stages';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(StageList);
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            this.log(chalk.blue('🔍 Fetching stages...'));
+            const stages = await service.stageList();
+            if (!stages || stages.length === 0) {
+                this.log(chalk.yellow('⚠️  No stages found'));
+                return;
+            }
+            this.log(chalk.green(`✅ Found ${stages.length} stage(s)\n`));
+            // Display stages in a table
+            ux.table(stages, {
+                branchName: {
+                    header: 'Branch',
+                },
+                createdAt: {
+                    get: (row) => new Date(row.createdAt).toLocaleDateString(),
+                    header: 'Created',
+                },
+                defaultStage: {
+                    get: (row) => row.defaultStage ? chalk.green('✓') : '',
+                    header: 'Default',
+                },
+                name: {
+                    header: 'Name',
+                    minWidth: 15,
+                },
+                production: {
+                    get: (row) => row.production ? chalk.red('PROD') : chalk.blue('DEV'),
+                    header: 'Type',
+                },
+                regions: {
+                    get: (row) => (row.regions || []).join(', '),
+                    header: 'Regions',
+                },
+                slug: {
+                    get: (row) => chalk.cyan(row.slug),
+                    header: 'Slug',
+                    minWidth: 15,
+                },
+            });
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error('An error occurred while listing stages');
+        }
+    }
+}

package/dist/commands/test-api.d.ts

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

package/dist/commands/test-api.js

@@ -0,0 +1,40 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { HyperdriveSigV4Service } from '../services/hyperdrive-sigv4.js';
+export default class TestApi extends Command {
+    static description = 'Test API connection with SigV4 authentication';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(TestApi);
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            this.log(chalk.blue('🧪 Testing Hyperdrive API Connection'));
+            this.log('');
+            this.log(chalk.gray('Attempting to call: GET /'));
+            this.log('');
+            // Try to call the root endpoint
+            const response = await service.makeTestRequest();
+            this.log(chalk.green('✅ API Connection Successful!'));
+            this.log('');
+            this.log(chalk.white('Response:'));
+            this.log(JSON.stringify(response, null, 2));
+        }
+        catch (error) {
+            this.log(chalk.red('❌ API Connection Failed'));
+            this.log('');
+            if (error instanceof Error) {
+                this.log(chalk.yellow('Error:'), error.message);
+            }
+            else {
+                this.log(chalk.yellow('Error:'), String(error));
+            }
+            this.exit(1);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/services/auth-service.d.ts

@@ -0,0 +1,84 @@
+export interface CognitoTokens {
+    access_token: string;
+    expires_in: number;
+    id_token: string;
+    refresh_token: string;
+    token_type: string;
+}
+export interface AWSCredentials {
+    accessKeyId: string;
+    expiration: Date;
+    secretAccessKey: string;
+    sessionToken: string;
+}
+export interface CognitoConfig {
+    clientId: string;
+    domain: string;
+    identityPoolId: string;
+    userPoolId: string;
+}
+export interface StoredCredentials extends CognitoTokens {
+    apiUrl: string;
+    awsCredentials: AWSCredentials;
+    cognitoConfig?: CognitoConfig;
+    obtainedAt: string;
+    region: string;
+    tenantDomain: string;
+    tenantId: string;
+}
+export declare class AuthService {
+    private readonly cognitoConfig;
+    private readonly credDir;
+    private readonly credPath;
+    private readonly domain?;
+    constructor(domain?: string);
+    /**
+     * Clear stored credentials
+     */
+    clearCredentials(): void;
+    /**
+     * Ensure credentials are valid, refresh if needed
+     * Returns valid credentials or throws error
+     */
+    ensureValidCredentials(): Promise<StoredCredentials>;
+    /**
+     * Get AWS credentials from Cognito Identity Pool using ID token
+     */
+    getAWSCredentials(idToken: string, region: string, cognitoConfig: CognitoConfig): Promise<AWSCredentials>;
+    /**
+     * Get all domains with stored credentials
+     */
+    getCredentialDomains(): string[];
+    /**
+     * Check if credentials are expired
+     */
+    isExpired(credentials: StoredCredentials): boolean;
+    /**
+     * Load stored credentials from domain-specific path
+     *
+     * Always uses domain-specific credentials (credentials.<domain>)
+     * Domain is either explicitly specified or uses default domain
+     */
+    loadCredentials(): StoredCredentials | null;
+    /**
+     * Check if credentials need refresh
+     * Returns true if AWS credentials expire in less than 5 minutes
+     */
+    needsRefresh(credentials: StoredCredentials): boolean;
+    /**
+     * Refresh Cognito tokens using refresh token
+     */
+    refreshTokens(refreshToken: string, cognitoConfig: CognitoConfig): Promise<CognitoTokens>;
+    /**
+     * Save credentials to ~/.hyperdrive/credentials
+     */
+    saveCredentials(credentials: StoredCredentials): void;
+    /**
+     * Get the credentials file path (always domain-specific)
+     */
+    private getCredentialsPath;
+    /**
+     * Get default domain from TenantService (avoid circular dependency by reading file directly)
+     */
+    private getDefaultDomain;
+}