@hyperdrive.bot/cli 1.0.13 → 1.0.17

package/dist/commands/service/get.js

@@ -0,0 +1,97 @@
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+import { printHeader } from '../../utils/table.js';
+export default class ServiceGet extends Command {
+    static description = 'Get details of a registered service';
+    static examples = [
+        '<%= config.bin %> service get rds-postgres-live',
+        '<%= config.bin %> service get rds-postgres-live --json',
+    ];
+    static args = {
+        slug: 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(ServiceGet);
+        const isJson = flags.json;
+        const service = new HyperdriveSigV4Service(flags.domain);
+        const spinner = isJson ? null : ora(`Fetching service "${args.slug}"...`).start();
+        try {
+            const svc = await service.serviceGet(args.slug);
+            spinner?.succeed('Service found');
+            if (isJson) {
+                this.log(JSON.stringify(svc, null, 2));
+                return;
+            }
+            printHeader(`Service: ${svc.slug}`, (msg) => this.log(msg));
+            this.log(`  ${chalk.bold('Name:')}          ${svc.name}`);
+            this.log(`  ${chalk.bold('Type:')}          ${svc.type}`);
+            this.log(`  ${chalk.bold('Access:')}        ${svc.access === 'private' ? chalk.yellow(svc.access) : chalk.green(svc.access)}`);
+            this.log(`  ${chalk.bold('Status:')}        ${svc.status === 'active' ? chalk.green(svc.status) : chalk.yellow(svc.status)}`);
+            this.log(`  ${chalk.bold('Endpoint:')}      ${svc.endpoint}`);
+            if (svc.port)
+                this.log(`  ${chalk.bold('Port:')}          ${svc.port}`);
+            if (svc.protocol)
+                this.log(`  ${chalk.bold('Protocol:')}      ${svc.protocol}`);
+            this.log(`  ${chalk.bold('Account ID:')}    ${svc.accountId}`);
+            this.log(`  ${chalk.bold('Region:')}        ${svc.region}`);
+            if (svc.networkSlug)
+                this.log(`  ${chalk.bold('Network:')}       ${chalk.cyan(svc.networkSlug)}`);
+            // Mask credential ARN — show only last 8 chars
+            if (svc.credentialSecretArn) {
+                const masked = svc.credentialSecretArn.length > 8
+                    ? '***' + svc.credentialSecretArn.slice(-8)
+                    : svc.credentialSecretArn;
+                this.log(`  ${chalk.bold('Credentials:')}   ${masked}`);
+            }
+            if (svc.templateId)
+                this.log(`  ${chalk.bold('Template:')}      ${svc.templateId}`);
+            if (svc.stackName)
+                this.log(`  ${chalk.bold('Stack:')}         ${svc.stackName}`);
+            this.log(`  ${chalk.bold('Created:')}       ${new Date(svc.createdAt).toLocaleString()}`);
+            this.log(`  ${chalk.bold('Updated:')}       ${new Date(svc.updatedAt).toLocaleString()}`);
+            // Exported env vars
+            const envEntries = Object.entries(svc.exportedEnvVars || {});
+            if (envEntries.length > 0) {
+                this.log(`\n  ${chalk.bold('Exported Environment Variables:')}`);
+                for (const [key, value] of envEntries) {
+                    this.log(`    ${chalk.bold(key)}: ${value}`);
+                }
+            }
+            // Metadata
+            const metaEntries = Object.entries(svc.metadata || {});
+            if (metaEntries.length > 0) {
+                this.log(`\n  ${chalk.bold('Metadata:')}`);
+                for (const [key, value] of metaEntries) {
+                    this.log(`    ${chalk.bold(key)}: ${value}`);
+                }
+            }
+        }
+        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.slug}`));
+            }
+            else {
+                this.log(chalk.red(`\n❌ ${axiosError.response?.data?.message ?? axiosError.message}`));
+            }
+            this.exit(1);
+        }
+    }
+}

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

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

package/dist/commands/service/list.js

@@ -0,0 +1,86 @@
+import { 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 ServiceList extends Command {
+    static description = 'List all registered services';
+    static examples = [
+        '<%= config.bin %> service list',
+        '<%= config.bin %> service list --type rds-postgres',
+        '<%= config.bin %> service list --network prod-us-east-1',
+        '<%= config.bin %> service list --json',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        json: Flags.boolean({
+            description: 'Output raw JSON response',
+            default: false,
+        }),
+        network: Flags.string({
+            description: 'Filter by network slug',
+        }),
+        type: Flags.string({
+            description: 'Filter by service type',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ServiceList);
+        const isJson = flags.json;
+        const service = new HyperdriveSigV4Service(flags.domain);
+        const spinner = isJson ? null : ora('Fetching services...').start();
+        try {
+            const services = await service.serviceList({
+                type: flags.type,
+                network: flags.network,
+            });
+            spinner?.stop();
+            if (isJson) {
+                this.log(JSON.stringify(services, null, 2));
+                return;
+            }
+            if (!services || services.length === 0) {
+                this.log(chalk.yellow('\nNo services found.'));
+                this.log(chalk.gray('Use "hd service register" to add a service.'));
+                return;
+            }
+            this.log(chalk.green(`\n${services.length} service(s) found:\n`));
+            printTable(services, {
+                slug: {
+                    header: 'Slug',
+                    minWidth: 25,
+                    get: (row) => chalk.cyan(row.slug),
+                },
+                name: {
+                    header: 'Name',
+                    minWidth: 20,
+                },
+                type: {
+                    header: 'Type',
+                    minWidth: 18,
+                },
+                access: {
+                    header: 'Access',
+                    get: (row) => row.access === 'private' ? chalk.yellow(row.access) : chalk.green(row.access),
+                },
+                status: {
+                    header: 'Status',
+                    get: (row) => row.status === 'active' ? chalk.green(row.status) : chalk.yellow(row.status),
+                },
+                networkSlug: {
+                    header: 'Network',
+                    get: (row) => row.networkSlug || chalk.gray('-'),
+                },
+            }, (msg) => this.log(msg));
+        }
+        catch (error) {
+            spinner?.fail('Failed to fetch services');
+            const axiosError = error;
+            this.log(chalk.red(`\n❌ ${axiosError.response?.data?.message ?? axiosError.message}`));
+            this.exit(1);
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+import { Command } from '@oclif/core';
+export default class ServiceRegister extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        access: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'account-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'credential-secret-arn': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        endpoint: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'exported-env-vars': 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>;
+        'network-slug': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        port: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        protocol: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        region: 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>;
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/service/register.js

@@ -0,0 +1,215 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+const SLUG_REGEX = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+const KNOWN_SERVICE_TYPES = [
+    'rds-postgres',
+    'rds-mysql',
+    'aurora-serverless',
+    'elasticache-redis',
+    's3-bucket',
+    'sqs-queue',
+    'custom',
+];
+export default class ServiceRegister extends Command {
+    static description = 'Register an external service';
+    static examples = [
+        '<%= config.bin %> service register',
+        '<%= config.bin %> service register --slug rds-postgres-live --name "Production PostgreSQL" --type rds-postgres --access private --endpoint prod-db.abc123.rds.amazonaws.com --port 5432 --account-id 084309335408 --region us-east-1 --network-slug prod-us-east-1',
+    ];
+    static flags = {
+        access: Flags.string({ description: 'Access type: private or public', options: ['private', 'public'] }),
+        'account-id': Flags.string({ description: 'AWS Account ID where service lives' }),
+        'credential-secret-arn': Flags.string({ description: 'Secrets Manager ARN for credentials' }),
+        domain: Flags.string({ char: 'd', description: 'Tenant domain (for multi-domain setups)' }),
+        endpoint: Flags.string({ description: 'Service endpoint' }),
+        'exported-env-vars': Flags.string({ description: 'Exported env vars as JSON string' }),
+        name: Flags.string({ description: 'Service display name' }),
+        'network-slug': Flags.string({ description: 'Network slug (required for private services)' }),
+        port: Flags.integer({ description: 'Service port' }),
+        protocol: Flags.string({ description: 'Protocol (e.g. postgres, redis, https)' }),
+        region: Flags.string({ char: 'r', description: 'AWS region' }),
+        slug: Flags.string({ char: 's', description: 'Service slug' }),
+        type: Flags.string({ description: 'Service type' }),
+    };
+    async run() {
+        const { flags } = await this.parse(ServiceRegister);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        let slug = flags.slug;
+        let name = flags.name;
+        let type = flags.type;
+        let access = flags.access;
+        let endpoint = flags.endpoint;
+        let port = flags.port;
+        let protocol = flags.protocol;
+        let credentialSecretArn = flags['credential-secret-arn'];
+        let networkSlug = flags['network-slug'];
+        let accountId = flags['account-id'];
+        let region = flags.region;
+        let exportedEnvVars;
+        if (flags['exported-env-vars']) {
+            try {
+                exportedEnvVars = JSON.parse(flags['exported-env-vars']);
+            }
+            catch {
+                this.log(chalk.red('❌ Invalid JSON for --exported-env-vars'));
+                this.exit(1);
+                return;
+            }
+        }
+        // Interactive mode if missing required fields
+        if (!slug || !name || !type || !access || !endpoint || !accountId || !region) {
+            const inquirer = (await import('inquirer')).default;
+            if (!slug) {
+                const { inputSlug } = await inquirer.prompt([{
+                        message: chalk.yellow('Service slug:'),
+                        name: 'inputSlug',
+                        validate: (input) => SLUG_REGEX.test(input) || 'Must be lowercase alphanumeric with hyphens',
+                    }]);
+                slug = inputSlug;
+            }
+            if (!name) {
+                const { inputName } = await inquirer.prompt([{
+                        message: chalk.yellow('Service display name:'),
+                        name: 'inputName',
+                        validate: (input) => input.length > 0 || 'Name is required',
+                    }]);
+                name = inputName;
+            }
+            if (!type) {
+                const { inputType } = await inquirer.prompt([{
+                        choices: KNOWN_SERVICE_TYPES,
+                        message: chalk.yellow('Service type:'),
+                        name: 'inputType',
+                        type: 'list',
+                    }]);
+                type = inputType;
+            }
+            if (!access) {
+                const { inputAccess } = await inquirer.prompt([{
+                        choices: [
+                            { name: 'Private (requires VPC/network)', value: 'private' },
+                            { name: 'Public (no VPC constraint)', value: 'public' },
+                        ],
+                        message: chalk.yellow('Access type:'),
+                        name: 'inputAccess',
+                        type: 'list',
+                    }]);
+                access = inputAccess;
+            }
+            if (!endpoint) {
+                const { inputEndpoint } = await inquirer.prompt([{
+                        message: chalk.yellow('Service endpoint (hostname or URL):'),
+                        name: 'inputEndpoint',
+                        validate: (input) => input.length > 0 || 'Endpoint is required',
+                    }]);
+                endpoint = inputEndpoint;
+            }
+            if (port === undefined) {
+                const { inputPort } = await inquirer.prompt([{
+                        message: chalk.yellow('Port (or leave empty):'),
+                        name: 'inputPort',
+                    }]);
+                if (inputPort)
+                    port = parseInt(inputPort, 10);
+            }
+            if (!protocol) {
+                const { inputProtocol } = await inquirer.prompt([{
+                        message: chalk.yellow('Protocol (e.g. postgres, redis, https — or leave empty):'),
+                        name: 'inputProtocol',
+                    }]);
+                if (inputProtocol)
+                    protocol = inputProtocol;
+            }
+            if (!credentialSecretArn) {
+                const { inputCredArn } = await inquirer.prompt([{
+                        message: chalk.yellow('Credential Secret ARN (or leave empty):'),
+                        name: 'inputCredArn',
+                    }]);
+                if (inputCredArn)
+                    credentialSecretArn = inputCredArn;
+            }
+            if (access === 'private' && !networkSlug) {
+                const { inputNetworkSlug } = await inquirer.prompt([{
+                        message: chalk.yellow('Network slug (required for private services):'),
+                        name: 'inputNetworkSlug',
+                        validate: (input) => input.length > 0 || 'Network slug is required for private services',
+                    }]);
+                networkSlug = inputNetworkSlug;
+            }
+            if (!accountId) {
+                const { inputAccountId } = await inquirer.prompt([{
+                        message: chalk.yellow('AWS Account ID:'),
+                        name: 'inputAccountId',
+                        validate: (input) => /^\d{12}$/.test(input) || 'Must be exactly 12 digits',
+                    }]);
+                accountId = inputAccountId;
+            }
+            if (!region) {
+                const { inputRegion } = await inquirer.prompt([{
+                        choices: [
+                            'us-east-1', 'us-east-2', 'us-west-1', 'us-west-2',
+                            'sa-east-1', 'eu-west-1', 'eu-west-2', 'eu-central-1',
+                            'ap-southeast-1', 'ap-southeast-2', 'ap-northeast-1',
+                        ],
+                        default: 'us-east-1',
+                        message: chalk.yellow('AWS Region:'),
+                        name: 'inputRegion',
+                        type: 'list',
+                    }]);
+                region = inputRegion;
+            }
+            if (!exportedEnvVars) {
+                const { inputEnvVars } = await inquirer.prompt([{
+                        message: chalk.yellow('Exported env vars JSON (e.g. {"DATABASE_URL":"postgres://..."}, or leave empty):'),
+                        name: 'inputEnvVars',
+                    }]);
+                if (inputEnvVars) {
+                    try {
+                        exportedEnvVars = JSON.parse(inputEnvVars);
+                    }
+                    catch {
+                        this.log(chalk.yellow('Invalid JSON — skipping exported env vars.'));
+                    }
+                }
+            }
+        }
+        // Validate: private services require networkSlug
+        if (access === 'private' && !networkSlug) {
+            this.log(chalk.red('❌ Private services require --network-slug'));
+            this.exit(1);
+            return;
+        }
+        // Validate slug
+        if (!SLUG_REGEX.test(slug)) {
+            this.log(chalk.red(`❌ Invalid slug format: "${slug}"`));
+            this.exit(1);
+            return;
+        }
+        const spinner = ora(`Registering service "${slug}"...`).start();
+        try {
+            await service.serviceRegister({
+                slug: slug,
+                name: name,
+                type: type,
+                access: access,
+                endpoint: endpoint,
+                port,
+                protocol,
+                credentialSecretArn,
+                networkSlug,
+                accountId: accountId,
+                region: region,
+                exportedEnvVars,
+            });
+            spinner.succeed(chalk.green(`Service registered: ${slug}`));
+        }
+        catch (error) {
+            spinner.fail('Registration failed');
+            const axiosError = error;
+            this.log(chalk.red(`\n❌ ${axiosError.response?.data?.message ?? axiosError.message}`));
+            this.exit(1);
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+export default class ServiceRestore 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>;
+        from: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        target: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        network: 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/restore.js

@@ -0,0 +1,158 @@
+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 ServiceRestore extends Command {
+    static description = 'Restore a service from a previously created backup';
+    static examples = [
+        '<%= config.bin %> service restore rds-postgres-live --from 018d4e7f-af32-7000-8000-000000000001',
+        '<%= config.bin %> service restore rds-postgres-live --from 018d4e7f --target rds-postgres-staging',
+        '<%= config.bin %> service restore rds-postgres-live --from 018d4e7f --target rds-new --network prod-us-east-1 --instance-class db.t3.medium',
+        '<%= config.bin %> service restore rds-postgres-live --from 018d4e7f --no-wait --json',
+        '<%= config.bin %> service restore rds-postgres-live --from 018d4e7f --force',
+    ];
+    static args = {
+        slug: Args.string({
+            description: 'Service slug to restore',
+            required: true,
+        }),
+    };
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        from: Flags.string({
+            description: 'Backup ID to restore from',
+            required: true,
+        }),
+        target: Flags.string({
+            description: 'Target service slug for a new instance (omit for in-place restore)',
+        }),
+        network: Flags.string({
+            description: 'Network slug for the restored instance (for new-target restores)',
+        }),
+        '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 restore to complete',
+            default: false,
+        }),
+        force: Flags.boolean({
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ServiceRestore);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        const isJson = flags.json;
+        // Confirmation prompt (unless --force or --json)
+        if (!flags.force && !isJson) {
+            const action = flags.target
+                ? `create new service "${flags.target}" from`
+                : `replace existing service "${args.slug}" from`;
+            this.log(chalk.yellow(`\nRestore service: ${action} backup ${flags.from}`));
+            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 restore request...').start();
+        try {
+            const backup = await service.serviceRestore(args.slug, {
+                backupId: flags.from,
+                targetSlug: flags.target,
+                networkSlug: flags.network,
+                instanceClass: flags['instance-class'],
+            });
+            if (isJson && flags['no-wait']) {
+                this.log(JSON.stringify(backup, null, 2));
+                return;
+            }
+            spinner?.succeed(chalk.green(`Restore initiated: ${backup.id}`));
+            if (!isJson) {
+                this.log(`  Service:    ${chalk.cyan(args.slug)}`);
+                this.log(`  Backup:     ${chalk.cyan(flags.from)}`);
+                this.log(`  Restore ID: ${chalk.cyan(backup.id)}`);
+                if (flags.target)
+                    this.log(`  Target:     ${chalk.cyan(flags.target)}`);
+                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.slug}`));
+                }
+                return;
+            }
+            // Poll for restore completion
+            const result = await pollLifecycle({
+                pollFn: () => service.serviceGetBackup(args.slug, backup.id),
+                getStatus: (b) => b.status,
+                terminalStates: new Set(['completed', 'failed']),
+                successStates: new Set(['completed']),
+                getErrorMessage: (b) => b.errorMessage,
+                operationLabel: 'Restoring',
+            }, isJson);
+            if (isJson) {
+                this.log(JSON.stringify(result.entity, null, 2));
+            }
+            if (result.timedOut) {
+                if (!isJson) {
+                    this.log(chalk.yellow('The restore job may still be running.'));
+                    this.log(chalk.gray(`Check status: hd service get ${args.slug}`));
+                }
+                this.exit(1);
+            }
+            if (!result.success) {
+                this.exit(1);
+            }
+            // Success summary
+            if (!isJson) {
+                this.log('');
+                if (flags.target) {
+                    this.log(chalk.yellow('Next step:'));
+                    this.log(chalk.gray(`  hd service get ${flags.target}`));
+                    this.log(chalk.gray(`  hd service bind ${flags.target} <module> --stage <stage>`));
+                }
+                else {
+                    this.log(chalk.yellow('Service endpoint updated. Check:'));
+                    this.log(chalk.gray(`  hd service get ${args.slug}`));
+                }
+            }
+        }
+        catch (error) {
+            spinner?.fail('Restore 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/seed.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+export default class ServiceSeed 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>;
+        from: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        inline: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'allow-production': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'no-wait': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}