@hyperdrive.bot/cli 1.0.2

package/dist/commands/parameter/remove.js

@@ -0,0 +1,90 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { existsSync, readFileSync } from 'node:fs';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class ParameterRemove extends Command {
+    static description = 'Remove a parameter from SSM Parameter Store';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --key="API_URL" --stage="dev"',
+        '<%= config.bin %> <%= command.id %> --key="DB_HOST" --specific --stage="prod"',
+        '<%= config.bin %> <%= command.id %> --key="PORT" --force',
+    ];
+    static flags = {
+        accountId: Flags.string({
+            description: 'AWS Account ID',
+            env: 'AWS_ACCOUNT_ID',
+            required: true,
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Skip confirmation prompt',
+        }),
+        key: Flags.string({
+            char: 'k',
+            description: 'Parameter key/name to remove',
+            required: true,
+        }),
+        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,
+        }),
+        specific: Flags.boolean({
+            default: false,
+            description: 'Remove from project-specific parameters (default: global)',
+        }),
+        stage: Flags.string({
+            char: 's',
+            default: 'all',
+            description: 'Stage for the parameter (default: all stages)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ParameterRemove);
+        if (!flags.force) {
+            const confirmation = await inquirer.prompt([
+                {
+                    default: false,
+                    message: chalk.red(`Are you sure you want to remove parameter ${chalk.cyan(flags.key)} from ${flags.specific ? 'project-specific' : 'global'} parameters for stage ${chalk.cyan(flags.stage)}?`),
+                    name: 'confirm',
+                    type: 'confirm',
+                },
+            ]);
+            if (!confirmation.confirm) {
+                this.log(chalk.yellow('Operation cancelled.'));
+                return;
+            }
+        }
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            await service.parameterRemove({
+                accountId: flags.accountId,
+                key: flags.key,
+                projectSlug: flags.moduleSlug, // API still expects projectSlug
+                specific: flags.specific,
+                stage: flags.stage,
+            });
+            this.log(chalk.green('✅ Parameter removed successfully!'));
+            this.log(chalk.gray(`   Key: ${flags.key}`));
+            this.log(chalk.gray(`   Scope: ${flags.specific ? 'Project-specific' : 'Global'}`));
+            this.log(chalk.gray(`   Stage: ${flags.stage}`));
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error('An error occurred while removing the parameter');
+        }
+    }
+}

package/dist/commands/parameter/sync.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class ParameterSync extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        accountId: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, 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>;
+        file: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, 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>;
+        specific: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        stage: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/parameter/sync.js

@@ -0,0 +1,153 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+const POLL_INTERVAL_MS = 2000;
+const MAX_POLL_TIME_MS = 15 * 60 * 1000; // 15 minutes
+export default class ParameterSync extends Command {
+    static description = 'Synchronize environment variables from a .env file to Hyperdrive';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --stage="dev"',
+        '<%= config.bin %> <%= command.id %> --file=".env.production" --stage="prod"',
+        '<%= config.bin %> <%= command.id %> --no-specific --stage="all"',
+    ];
+    static flags = {
+        accountId: Flags.string({
+            description: 'AWS Account ID',
+            env: 'AWS_ACCOUNT_ID',
+            required: true,
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        file: Flags.string({
+            char: 'f',
+            default: '.env',
+            description: 'Path to the .env file',
+        }),
+        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,
+        }),
+        specific: Flags.boolean({
+            allowNo: true,
+            char: 's',
+            default: true,
+            description: 'Whether the env vars are project-specific (default: true)',
+        }),
+        stage: Flags.string({
+            char: 't',
+            default: 'all',
+            description: 'Stage for the env vars (default: all stages)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ParameterSync);
+        const { accountId, domain, file, moduleSlug, specific, stage } = flags;
+        const envPath = path.resolve(process.cwd(), file);
+        if (!existsSync(envPath)) {
+            this.error(`The file "${file}" does not exist.`);
+            return;
+        }
+        const content = readFileSync(envPath, 'utf8');
+        // Check file size
+        const byteLength = Buffer.byteLength(content, 'utf8');
+        if (byteLength > 3750) {
+            this.warn(chalk.yellow(`⚠️  The .env file size is approaching the 4KB limit (${byteLength} bytes). Consider optimizing your environment variables.`));
+        }
+        // Convert content to base64
+        const encodedContent = Buffer.from(content).toString('base64');
+        // Regex to find potential secrets
+        const secretPattern = /secret|private_key|password|token|api_key/gi;
+        const secretsFound = content.match(secretPattern);
+        if (secretsFound) {
+            this.warn(chalk.yellow('⚠️  Potentially sensitive keys found. Please ensure you are handling secrets securely.'));
+            this.warn(chalk.gray(`   Keys: ${[...new Set(secretsFound)].join(', ')}`));
+        }
+        try {
+            const service = new HyperdriveSigV4Service(domain);
+            this.log(chalk.blue('🔄 Initiating parameter sync...'));
+            this.log(chalk.gray(`   File: ${file}`));
+            this.log(chalk.gray(`   Module: ${moduleSlug}`));
+            this.log(chalk.gray(`   Stage: ${stage}`));
+            this.log(chalk.gray(`   Scope: ${specific ? 'Project-specific' : 'Global'}`));
+            // Initiate async sync
+            const initResult = await service.parameterSync({
+                accountId,
+                encodedContent,
+                projectSlug: moduleSlug,
+                specific,
+                stage,
+            });
+            const { taskId, totalParameters } = initResult;
+            this.log(chalk.gray(`   Task ID: ${taskId}`));
+            this.log(chalk.gray(`   Parameters: ${totalParameters}`));
+            // Poll for completion
+            const ora = (await import('ora')).default;
+            const spinner = ora('Synchronizing parameters...').start();
+            let lastProgress = 0;
+            const startTime = Date.now();
+            while (true) {
+                // Check for timeout
+                if (Date.now() - startTime > MAX_POLL_TIME_MS) {
+                    spinner.fail('Parameter sync timed out');
+                    this.error('Parameter sync took too long. Check the task status manually.');
+                    return;
+                }
+                const status = await service.parameterSyncStatus({ taskId });
+                // Update spinner with progress
+                if (status.progress && status.progress.percentage !== lastProgress) {
+                    spinner.text = `Synchronizing parameters... ${status.progress.percentage}% (${status.progress.processed}/${status.progress.total})`;
+                    lastProgress = status.progress.percentage;
+                }
+                if (status.status === 'completed') {
+                    spinner.succeed('Parameters synchronized successfully!');
+                    if (status.errors && status.errors.length > 0) {
+                        // Filter out non-fatal errors (commented/empty keys)
+                        const fatalErrors = status.errors.filter(e => !e.error.includes('was ignored'));
+                        const warnings = status.errors.filter(e => e.error.includes('was ignored'));
+                        if (warnings.length > 0) {
+                            this.log(chalk.yellow(`\n⚠️  ${warnings.length} parameters were skipped:`));
+                            for (const warning of warnings) {
+                                this.log(chalk.gray(`   - ${warning.key}: ${warning.error}`));
+                            }
+                        }
+                        if (fatalErrors.length > 0) {
+                            this.log(chalk.red(`\n❌ ${fatalErrors.length} parameters failed:`));
+                            for (const error of fatalErrors) {
+                                this.log(chalk.red(`   - ${error.key}: ${error.error}`));
+                            }
+                        }
+                    }
+                    break;
+                }
+                if (status.status === 'failed') {
+                    spinner.fail('Parameter sync failed');
+                    if (status.errors && status.errors.length > 0) {
+                        this.log(chalk.red('\n❌ Errors:'));
+                        for (const error of status.errors) {
+                            this.log(chalk.red(`   - ${error.key}: ${error.error}`));
+                        }
+                    }
+                    this.exit(1);
+                }
+                // Wait before next poll
+                await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS));
+            }
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error('An error occurred while synchronizing parameters');
+        }
+    }
+}

package/dist/commands/parameter/update.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class ParameterUpdate extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        accountId: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, 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>;
+        key: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, 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>;
+        specific: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        stage: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        value: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/parameter/update.js

@@ -0,0 +1,100 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { existsSync, readFileSync } from 'node:fs';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class ParameterUpdate extends Command {
+    static description = 'Update an existing parameter in SSM Parameter Store';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --key="API_URL" --value="https://new-api.example.com" --stage="dev"',
+        '<%= config.bin %> <%= command.id %> --key="DB_HOST" --value="new-host" --specific',
+    ];
+    static flags = {
+        accountId: Flags.string({
+            description: 'AWS Account ID',
+            env: 'AWS_ACCOUNT_ID',
+            required: true,
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        key: Flags.string({
+            char: 'k',
+            description: 'Parameter key/name to update',
+            required: true,
+        }),
+        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,
+        }),
+        specific: Flags.boolean({
+            default: false,
+            description: 'Update project-specific parameter (default: global)',
+        }),
+        stage: Flags.string({
+            char: 's',
+            default: 'all',
+            description: 'Stage for the parameter (default: all stages)',
+        }),
+        value: Flags.string({
+            char: 'v',
+            description: 'New parameter value',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ParameterUpdate);
+        const confirmation = await inquirer.prompt([
+            {
+                default: true,
+                message: chalk.yellow(`Update parameter ${chalk.cyan(flags.key)} to ${chalk.green(flags.value)} in ${flags.specific ? 'project-specific' : 'global'} parameters for stage ${chalk.cyan(flags.stage)}?`),
+                name: 'confirm',
+                type: 'confirm',
+            },
+        ]);
+        if (!confirmation.confirm) {
+            this.log(chalk.red('Operation cancelled.'));
+            return;
+        }
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            // Encode single parameter in key=value format (update uses same sync mechanism)
+            const paramContent = `${flags.key}=${flags.value}`;
+            const encodedContent = Buffer.from(paramContent).toString('base64');
+            const result = await service.parameterUpdate({
+                accountId: flags.accountId,
+                encodedContent,
+                key: flags.key,
+                projectSlug: flags.moduleSlug, // API still expects projectSlug
+                specific: flags.specific,
+                stage: flags.stage,
+            });
+            if (result.errors && Array.isArray(result.errors) && result.errors.length > 0) {
+                this.log(chalk.red('❌ Failed to update parameter:'));
+                for (const error of result.errors) {
+                    this.log(chalk.red(`  - ${error.key}: ${error.error}`));
+                }
+            }
+            else {
+                this.log(chalk.green('✅ Parameter updated successfully!'));
+                this.log(chalk.gray(`   Key: ${flags.key}`));
+                this.log(chalk.gray(`   New Value: ${flags.value.substring(0, 50)}${flags.value.length > 50 ? '...' : ''}`));
+                this.log(chalk.gray(`   Scope: ${flags.specific ? 'Project-specific' : 'Global'}`));
+                this.log(chalk.gray(`   Stage: ${flags.stage}`));
+            }
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error('An error occurred while updating the parameter');
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+import { Command } from '@oclif/core';
+export default class StageCreate extends Command {
+    static description: string;
+    static flags: {
+        accountId: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        autoLaunch: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        branchName: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        defaultStage: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        deletionProtection: 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>;
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        production: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        project: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        provider: 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>;
+    };
+    run(): Promise<void>;
+    /**
+     * Build CloudWatch console URL
+     */
+    private buildConsoleUrl;
+    private getGitBranch;
+    private promptUser;
+    /**
+     * Stream mission logs in real-time
+     */
+    private streamMissionLogs;
+}