@hyperdrive.bot/cli 1.0.12 → 1.0.16

package/dist/commands/service/bind.js

@@ -0,0 +1,106 @@
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class ServiceBind extends Command {
+    static description = 'Bind a service to a module+stage';
+    static examples = [
+        '<%= config.bin %> service bind rds-postgres-live my-api --stage live',
+        '<%= config.bin %> service bind rds-postgres-live my-api --stage live --template-vars \'{"dbName":"mydb"}\'',
+    ];
+    static args = {
+        service: Args.string({
+            description: 'Service slug',
+            required: true,
+        }),
+        module: Args.string({
+            description: 'Module slug',
+            required: true,
+        }),
+    };
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        'env-var-mapping': Flags.string({
+            description: 'Environment variable mapping overrides as JSON',
+        }),
+        stage: Flags.string({
+            description: 'Deployment stage',
+            required: true,
+        }),
+        'template-vars': Flags.string({
+            description: 'Template variables as JSON',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ServiceBind);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        let envVarMapping;
+        let templateVars;
+        if (flags['env-var-mapping']) {
+            try {
+                envVarMapping = JSON.parse(flags['env-var-mapping']);
+            }
+            catch {
+                this.log(chalk.red('❌ Invalid JSON for --env-var-mapping'));
+                this.exit(1);
+                return;
+            }
+        }
+        if (flags['template-vars']) {
+            try {
+                templateVars = JSON.parse(flags['template-vars']);
+            }
+            catch {
+                this.log(chalk.red('❌ Invalid JSON for --template-vars'));
+                this.exit(1);
+                return;
+            }
+        }
+        const spinner = ora(`Binding "${args.service}" to "${args.module}" (stage: ${flags.stage})...`).start();
+        try {
+            const binding = await service.serviceBind(args.service, {
+                moduleSlug: args.module,
+                stage: flags.stage,
+                envVarMapping,
+                templateVars,
+            });
+            spinner.succeed(chalk.green(`Service bound: ${args.service} → ${args.module} (${flags.stage})`));
+            // Show VPC anchor info if the service details are returned
+            try {
+                const svc = await service.serviceGet(args.service);
+                if (svc.access === 'private' && svc.networkSlug) {
+                    this.log(chalk.blue(`\n  Module bound via network: ${chalk.cyan(svc.networkSlug)}`));
+                    this.log(chalk.gray('  All other private services for this module+stage must share this network.'));
+                }
+            }
+            catch {
+                // Non-critical — skip VPC info display
+            }
+        }
+        catch (error) {
+            spinner.fail('Binding failed');
+            const axiosError = error;
+            const status = axiosError.response?.status;
+            const errorMessage = axiosError.response?.data?.message ?? axiosError.message;
+            if (status === 409) {
+                // VPC conflict — display actionable error
+                this.log(chalk.red(`\n❌ ${errorMessage}`));
+                this.log('');
+                this.log(chalk.yellow('   Options:'));
+                this.log(chalk.yellow('     1. Register the service in the correct network'));
+                this.log(chalk.yellow('     2. Unbind existing private services first'));
+                this.log(chalk.yellow('     3. Set up VPC peering between the two networks'));
+            }
+            else if (status === 404) {
+                this.log(chalk.red(`\n❌ Not found: ${errorMessage}`));
+            }
+            else {
+                this.log(chalk.red(`\n❌ ${errorMessage}`));
+            }
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/service/bindings.d.ts

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

package/dist/commands/service/bindings.js

@@ -0,0 +1,78 @@
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+import { printTable } from '../../utils/table.js';
+export default class ServiceBindings extends Command {
+    static description = 'List all bindings for a service';
+    static examples = [
+        '<%= config.bin %> service bindings rds-postgres-live',
+        '<%= config.bin %> service bindings rds-postgres-live --json',
+    ];
+    static args = {
+        service: Args.string({
+            description: 'Service slug',
+            required: true,
+        }),
+    };
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        json: Flags.boolean({
+            description: 'Output raw JSON response',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ServiceBindings);
+        const isJson = flags.json;
+        const service = new HyperdriveSigV4Service(flags.domain);
+        const spinner = isJson ? null : ora(`Fetching bindings for "${args.service}"...`).start();
+        try {
+            const bindings = await service.serviceBindings(args.service);
+            spinner?.stop();
+            if (isJson) {
+                this.log(JSON.stringify(bindings, null, 2));
+                return;
+            }
+            if (!bindings || bindings.length === 0) {
+                this.log(chalk.yellow(`\nNo bindings found for service "${args.service}".`));
+                return;
+            }
+            this.log(chalk.green(`\n${bindings.length} binding(s) for "${args.service}":\n`));
+            printTable(bindings, {
+                stage: {
+                    header: 'Stage',
+                    minWidth: 15,
+                    get: (row) => chalk.cyan(row.stage),
+                },
+                moduleSlug: {
+                    header: 'Module',
+                    minWidth: 20,
+                },
+                envVars: {
+                    header: 'Env Vars',
+                    get: (row) => String(Object.keys(row.envVarMapping || {}).length),
+                },
+                createdAt: {
+                    header: 'Created',
+                    get: (row) => new Date(row.createdAt).toLocaleDateString(),
+                },
+            }, (msg) => this.log(msg));
+        }
+        catch (error) {
+            spinner?.fail('Failed');
+            const axiosError = error;
+            const status = axiosError.response?.status;
+            if (status === 404) {
+                this.log(chalk.red(`\n❌ Service not found: ${args.service}`));
+            }
+            else {
+                this.log(chalk.red(`\n❌ ${axiosError.response?.data?.message ?? axiosError.message}`));
+            }
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/service/clone.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+export default class ServiceClone extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        source: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        network: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        account: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'instance-class': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'no-wait': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/service/clone.js

@@ -0,0 +1,153 @@
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+import { pollLifecycle } from '../../utils/lifecycle-poller.js';
+export default class ServiceClone extends Command {
+    static description = 'Clone a service (snapshot source, restore as new instance in target network)';
+    static examples = [
+        '<%= config.bin %> service clone rds-postgres-live --name rds-postgres-staging --network staging-us-east-1',
+        '<%= config.bin %> service clone rds-postgres-live --name rds-postgres-dr --network dr-us-west-2 --account 123456789012',
+        '<%= config.bin %> service clone rds-postgres-live --name rds-staging --network staging-vpc --instance-class db.t3.medium',
+        '<%= config.bin %> service clone rds-postgres-live --name rds-staging --network staging-vpc --no-wait --json',
+        '<%= config.bin %> service clone rds-postgres-live --name rds-staging --network staging-vpc --force',
+    ];
+    static args = {
+        source: Args.string({
+            description: 'Source service slug to clone',
+            required: true,
+        }),
+    };
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        name: Flags.string({
+            description: 'Target service slug for the cloned instance',
+            required: true,
+        }),
+        network: Flags.string({
+            description: 'Target network slug to place the cloned instance in',
+            required: true,
+        }),
+        account: Flags.string({
+            description: 'Target AWS account ID (for cross-account clones)',
+        }),
+        'instance-class': Flags.string({
+            description: 'RDS instance class override (e.g., db.t3.medium)',
+        }),
+        json: Flags.boolean({
+            description: 'Output raw JSON response',
+            default: false,
+        }),
+        'no-wait': Flags.boolean({
+            description: 'Do not wait for clone to complete',
+            default: false,
+        }),
+        force: Flags.boolean({
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ServiceClone);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        const isJson = flags.json;
+        // Confirmation prompt (unless --force or --json)
+        if (!flags.force && !isJson) {
+            this.log(chalk.yellow(`\nClone service "${args.source}" to "${flags.name}" in network "${flags.network}"`));
+            this.log(chalk.gray('This creates a new service with a fresh database copy.\n'));
+            const response = await new Promise((resolve) => {
+                process.stdout.write(chalk.yellow('Are you sure you want to proceed? (y/N): '));
+                process.stdin.setEncoding('utf-8');
+                process.stdin.once('data', (data) => {
+                    resolve(data.toString().trim().toLowerCase());
+                });
+            });
+            if (response !== 'y' && response !== 'yes') {
+                this.log(chalk.gray('Aborted.'));
+                return;
+            }
+        }
+        const spinner = isJson ? null : ora('Submitting clone request...').start();
+        try {
+            const backup = await service.serviceClone(args.source, {
+                targetSlug: flags.name,
+                targetNetworkSlug: flags.network,
+                targetAccountId: flags.account,
+                instanceClass: flags['instance-class'],
+            });
+            if (isJson && flags['no-wait']) {
+                this.log(JSON.stringify(backup, null, 2));
+                return;
+            }
+            spinner?.succeed(chalk.green(`Clone initiated: ${backup.id}`));
+            if (!isJson) {
+                this.log(`  Source:     ${chalk.cyan(args.source)}`);
+                this.log(`  Target:     ${chalk.cyan(flags.name)}`);
+                this.log(`  Network:    ${chalk.cyan(flags.network)}`);
+                if (flags.account)
+                    this.log(`  Account:    ${chalk.cyan(flags.account)}`);
+                this.log(`  Clone ID:   ${chalk.cyan(backup.id)}`);
+                this.log(`  Status:     ${chalk.yellow(backup.status)}`);
+                this.log('');
+            }
+            if (flags['no-wait']) {
+                if (!isJson) {
+                    this.log(chalk.gray(`Check status: hd service get ${args.source}`));
+                }
+                return;
+            }
+            // Poll for clone completion with phase-aware display
+            const result = await pollLifecycle({
+                pollFn: () => service.serviceGetBackup(args.source, backup.id),
+                getStatus: (b) => b.status,
+                terminalStates: new Set(['completed', 'failed']),
+                successStates: new Set(['completed']),
+                getPhase: (b) => b.metadata?.phase,
+                getErrorMessage: (b) => b.errorMessage,
+                operationLabel: 'Cloning',
+            }, isJson);
+            if (isJson) {
+                this.log(JSON.stringify(result.entity, null, 2));
+            }
+            if (result.timedOut) {
+                if (!isJson) {
+                    this.log(chalk.yellow('The clone job may still be running.'));
+                    this.log(chalk.gray(`Check status: hd service get ${args.source}`));
+                }
+                this.exit(1);
+            }
+            if (!result.success) {
+                this.exit(1);
+            }
+            // Success summary
+            if (!isJson) {
+                this.log('');
+                this.log(chalk.yellow('Next steps:'));
+                this.log(chalk.gray(`  hd service get ${flags.name}`));
+                this.log(chalk.gray(`  hd service bind ${flags.name} <module> --stage <stage>`));
+            }
+        }
+        catch (error) {
+            spinner?.fail('Clone request failed');
+            const axiosError = error;
+            const status = axiosError.response?.status;
+            const errorMessage = axiosError.response?.data?.message ?? axiosError.message;
+            if (status === 400) {
+                this.log(chalk.red(`Validation error: ${errorMessage}`));
+            }
+            else if (status === 404) {
+                this.log(chalk.red(`Not found: ${errorMessage}`));
+            }
+            else if (status === 409) {
+                this.log(chalk.red(`Conflict: ${errorMessage}`));
+            }
+            else {
+                this.log(chalk.red(`Error: ${errorMessage}`));
+            }
+            this.exit(1);
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class ServiceCreate extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        template: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        network: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        slug: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        stage: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        parameter: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'no-interactive': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/service/create.js

@@ -0,0 +1,212 @@
+import { Command, Flags, ux } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+const POLL_INTERVAL_MS = 10_000;
+const PROVISION_TIMEOUT_MS = 30 * 60 * 1000;
+export default class ServiceCreate extends Command {
+    static description = 'Provision a new service from the template catalog';
+    static examples = [
+        '<%= config.bin %> service create --template rds-postgres-v1 --network prod-us-east-1 --stage live',
+        '<%= config.bin %> service create --template s3-bucket-v1 --stage dev --slug my-bucket --no-interactive',
+        '<%= config.bin %> service create --template rds-postgres-v1 --stage dev -p dbName=myapp -p instanceClass=db.t3.small --no-interactive',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        template: Flags.string({
+            char: 't',
+            description: 'Template ID (e.g., rds-postgres-v1)',
+            required: true,
+        }),
+        network: Flags.string({
+            char: 'n',
+            description: 'Network slug (required for private services)',
+        }),
+        name: Flags.string({
+            description: 'Service display name',
+        }),
+        slug: Flags.string({
+            description: 'Service slug (auto-generated if not provided)',
+        }),
+        stage: Flags.string({
+            char: 's',
+            description: 'Deployment stage',
+            required: true,
+        }),
+        parameter: Flags.string({
+            char: 'p',
+            description: 'Template parameter as key=value (repeatable, for CI/CD)',
+            multiple: true,
+        }),
+        'no-interactive': Flags.boolean({
+            description: 'Skip interactive prompts, use defaults',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ServiceCreate);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        // 1. Fetch template details
+        let template;
+        try {
+            template = await service.serviceTemplateGet(flags.template);
+        }
+        catch (error) {
+            const axiosError = error;
+            if (axiosError.response?.status === 404) {
+                this.log(chalk.red(`Template not found: ${flags.template}`));
+                this.log('Run `hd service templates` to see available templates.');
+                this.exit(1);
+                return;
+            }
+            throw error;
+        }
+        this.log(chalk.blue(`Template: ${chalk.cyan(template.name)} (${template.id})`));
+        this.log(chalk.gray(template.description));
+        this.log('');
+        // 2. Collect parameters
+        const parameters = {};
+        // Parse --parameter key=value flags first
+        const flagParams = {};
+        if (flags.parameter) {
+            for (const kv of flags.parameter) {
+                const eqIdx = kv.indexOf('=');
+                if (eqIdx === -1) {
+                    this.log(chalk.red(`Invalid parameter format: "${kv}". Expected key=value.`));
+                    this.exit(1);
+                    return;
+                }
+                flagParams[kv.substring(0, eqIdx)] = kv.substring(eqIdx + 1);
+            }
+        }
+        for (const param of template.parameters) {
+            // Use --parameter flag value if provided
+            if (flagParams[param.name] !== undefined) {
+                parameters[param.name] = flagParams[param.name];
+                continue;
+            }
+            if (flags['no-interactive']) {
+                if (param.default !== undefined) {
+                    parameters[param.name] = param.default;
+                }
+                else if (param.required) {
+                    this.log(chalk.red(`Required parameter "${param.name}" must be provided via --parameter ${param.name}=<value> in non-interactive mode.`));
+                    this.exit(1);
+                    return;
+                }
+                continue;
+            }
+            let promptMessage = `  ${param.name}`;
+            if (param.description)
+                promptMessage += ` (${param.description})`;
+            if (param.allowed)
+                promptMessage += ` [${param.allowed.join(', ')}]`;
+            if (param.default !== undefined)
+                promptMessage += ` (default: ${param.default})`;
+            if (param.required)
+                promptMessage += chalk.red(' *');
+            const response = await ux.prompt(promptMessage, {
+                required: param.required,
+                default: param.default,
+            });
+            if (response) {
+                parameters[param.name] = response;
+            }
+        }
+        // 3. Generate slug if not provided
+        const serviceSlug = flags.slug || `${template.type}-${flags.stage}-${Date.now().toString(36)}`;
+        const serviceName = flags.name || `${template.name} (${flags.stage})`;
+        this.log('');
+        this.log(chalk.blue('Provisioning:'));
+        this.log(`  Slug:     ${chalk.cyan(serviceSlug)}`);
+        this.log(`  Template: ${chalk.cyan(template.id)}`);
+        this.log(`  Stage:    ${chalk.cyan(flags.stage)}`);
+        if (flags.network)
+            this.log(`  Network:  ${chalk.cyan(flags.network)}`);
+        this.log('');
+        // 4. Call provisioning API
+        const spinner = ora('Submitting provisioning request...').start();
+        try {
+            const result = await service.serviceProvision({
+                templateId: flags.template,
+                serviceSlug,
+                serviceName,
+                stage: flags.stage,
+                parameters,
+                networkSlug: flags.network,
+            });
+            spinner.succeed(chalk.green(`Provisioning started: ${result.serviceSlug}`));
+            this.log(chalk.gray(`  Status: ${result.status}`));
+            this.log(chalk.gray(`  Log group: ${result.logGroupName}`));
+            this.log('');
+            // 5. Poll for status
+            this.log(chalk.blue('Waiting for provisioning to complete...'));
+            const startTime = Date.now();
+            while (Date.now() - startTime < PROVISION_TIMEOUT_MS) {
+                await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS));
+                try {
+                    const svc = await service.serviceGet(serviceSlug);
+                    if (svc.status === 'active') {
+                        this.log('');
+                        this.log(chalk.green('Service provisioned successfully!'));
+                        this.log('');
+                        this.log(`  Slug:     ${chalk.cyan(svc.slug)}`);
+                        this.log(`  Endpoint: ${chalk.cyan(svc.endpoint || 'N/A')}`);
+                        if (svc.port)
+                            this.log(`  Port:     ${chalk.cyan(String(svc.port))}`);
+                        if (svc.credentialSecretArn)
+                            this.log(`  Creds:    ${chalk.cyan(svc.credentialSecretArn)}`);
+                        this.log('');
+                        this.log(chalk.yellow('Next step:'));
+                        this.log(chalk.gray(`  hd service bind ${serviceSlug} <module> --stage ${flags.stage}`));
+                        return;
+                    }
+                    if (svc.status === 'failed') {
+                        this.log('');
+                        this.log(chalk.red('Provisioning failed!'));
+                        const metadata = svc.metadata || {};
+                        if (metadata.failureReason) {
+                            this.log(chalk.red(`  Reason: ${metadata.failureReason}`));
+                        }
+                        this.exit(1);
+                        return;
+                    }
+                    // Still provisioning
+                    process.stdout.write(chalk.gray('.'));
+                }
+                catch {
+                    // Transient error — keep polling
+                    process.stdout.write(chalk.yellow('?'));
+                }
+            }
+            // Timeout
+            this.log('');
+            this.log(chalk.yellow(`Provisioning timeout (${PROVISION_TIMEOUT_MS / 60000} minutes).`));
+            this.log(chalk.yellow('The provisioning job may still be running.'));
+            this.log(chalk.gray(`Check status: hd service get ${serviceSlug}`));
+            this.exit(1);
+        }
+        catch (error) {
+            spinner.fail('Provisioning request failed');
+            const axiosError = error;
+            const status = axiosError.response?.status;
+            const errorMessage = axiosError.response?.data?.message ?? axiosError.message;
+            if (status === 400) {
+                this.log(chalk.red(`Validation error: ${errorMessage}`));
+            }
+            else if (status === 404) {
+                this.log(chalk.red(`Not found: ${errorMessage}`));
+            }
+            else if (status === 409) {
+                this.log(chalk.red(`Conflict: ${errorMessage}`));
+            }
+            else {
+                this.log(chalk.red(`Error: ${errorMessage}`));
+            }
+            this.exit(1);
+        }
+    }
+}

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

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