@hyperdrive.bot/cli 1.0.13 → 1.0.17

package/dist/commands/seed.js

@@ -0,0 +1,324 @@
+import { existsSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import { isAbsolute, join, resolve } from 'node:path';
+import { 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';
+const PHASES = ['runMigrations', 'copyData', 'resetSequences', 'seedFixtures'];
+const PHASE_LABEL = {
+    runMigrations: 'Schema migration',
+    copyData: 'Data copy',
+    resetSequences: 'Sequence reset',
+    seedFixtures: 'Fixtures',
+};
+export default class Seed extends Command {
+    static description = 'Per-stage Postgres schema migration + data copy + sequence reset, orchestrating per-app seed scripts';
+    static examples = [
+        '<%= config.bin %> seed --stage feat-e2e-expansion --apps core,alunos,professores --from-schema public --to-schema feat_e2e_expansion --cf-domain alunos-feat-e2e-expansion.tutory.com.br',
+        '<%= config.bin %> seed --stage feat-e2e-expansion --apps core --from-schema public --cf-domain alunos.example.com --dry-run',
+        '<%= config.bin %> seed --stage ss-99 --apps core,alunos --from-schema public --cf-domain alunos.example.com --service rds-postgres-tutory-dev',
+    ];
+    static flags = {
+        stage: Flags.string({
+            description: 'Target stage slug (e.g. ss-11, feat-e2e-expansion). Becomes the destination schema name when --to-schema is omitted.',
+            required: true,
+        }),
+        apps: Flags.string({
+            description: 'Comma-separated list of apps that own seed scripts (e.g. core,alunos,professores). Order is significant — apps run sequentially.',
+            required: true,
+        }),
+        'from-schema': Flags.string({
+            description: 'Postgres schema to copy reference rows from (typically `public`).',
+            required: true,
+        }),
+        'to-schema': Flags.string({
+            description: 'Destination Postgres schema. Defaults to the stage name.',
+        }),
+        'cf-domain': Flags.string({
+            description: 'Per-stage CloudFront hostname passed to seed scripts as ctx.cfDomain (templated into professores.domain etc.).',
+            required: true,
+        }),
+        service: Flags.string({
+            description: 'DB service slug to run SQL against (resolved from the stage if omitted).',
+        }),
+        'apps-dir': Flags.string({
+            description: 'Root directory containing `apps/<app>/scripts/seed.ts` files. Defaults to ./apps under the current working directory.',
+            default: 'apps',
+        }),
+        'dry-run': Flags.boolean({
+            description: 'Compute and print SQL + phase summary without executing any seed run.',
+            default: false,
+        }),
+        'allow-production': Flags.boolean({
+            description: 'Allow seeding against a production-bound service (forwarded to `hd service seed`).',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output a structured JSON summary of the orchestration.',
+            default: false,
+        }),
+        'no-wait': Flags.boolean({
+            description: 'Submit each phase without polling for completion.',
+            default: false,
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups).',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Seed);
+        const isJson = flags.json;
+        const stage = flags.stage;
+        const fromSchema = flags['from-schema'];
+        const toSchema = flags['to-schema'] ?? stage.replaceAll('-', '_');
+        const cfDomain = flags['cf-domain'];
+        const apps = flags.apps
+            .split(',')
+            .map((s) => s.trim())
+            .filter((s) => s.length > 0);
+        if (apps.length === 0) {
+            this.log(chalk.red('Error: --apps must list at least one app'));
+            this.exit(1);
+            return;
+        }
+        const appsRoot = isAbsolute(flags['apps-dir'])
+            ? flags['apps-dir']
+            : resolve(process.cwd(), flags['apps-dir']);
+        // 1. Load per-app seed scripts
+        const scripts = new Map();
+        for (const app of apps) {
+            const candidates = [
+                join(appsRoot, app, 'scripts', 'seed.ts'),
+                join(appsRoot, app, 'scripts', 'seed.js'),
+                join(appsRoot, app, 'scripts', 'seed.mjs'),
+            ];
+            const found = candidates.find((p) => existsSync(p));
+            if (!found) {
+                this.log(chalk.red(`Error: missing seed script for app "${app}" — looked for: ${candidates.join(', ')}`));
+                this.log(chalk.gray(`  Each app must export a default AppSeedScript from apps/${app}/scripts/seed.{ts,js,mjs}.`));
+                this.log(chalk.gray(`  See: hd seed --help for the contract.`));
+                this.exit(1);
+                return;
+            }
+            try {
+                const mod = (await import(pathToFileURL(found).href));
+                const script = mod.default ?? mod;
+                if (!script || typeof script !== 'object') {
+                    throw new Error(`module did not export an object as default`);
+                }
+                scripts.set(app, script);
+            }
+            catch (error) {
+                this.log(chalk.red(`Error loading seed script for "${app}" at ${found}: ${error.message}`));
+                this.exit(1);
+                return;
+            }
+        }
+        // 2. Build the plan: for each app, for each phase, call the function and collect SQL
+        const ctxBase = { stage, fromSchema, toSchema, cfDomain };
+        const plan = [];
+        const planSpinner = isJson ? null : ora('Planning seed phases...').start();
+        try {
+            for (const app of apps) {
+                const script = scripts.get(app);
+                for (const phase of PHASES) {
+                    const fn = script[phase];
+                    if (typeof fn !== 'function')
+                        continue;
+                    const result = await fn({ ...ctxBase, app });
+                    const sql = (result?.sql ?? '').trim();
+                    if (sql.length === 0)
+                        continue;
+                    plan.push({ app, phase, sql, description: result?.description });
+                }
+            }
+            planSpinner?.succeed(chalk.green(`Planned ${plan.length} phase(s) across ${apps.length} app(s)`));
+        }
+        catch (error) {
+            planSpinner?.fail('Planning failed');
+            this.log(chalk.red(`Error: ${error.message}`));
+            this.exit(1);
+            return;
+        }
+        if (plan.length === 0) {
+            this.log(chalk.yellow('No SQL produced by any phase. Nothing to do.'));
+            if (isJson)
+                this.log(JSON.stringify({ stage, apps, phases: [] }, null, 2));
+            return;
+        }
+        // 3. --dry-run: print the plan and exit (no service call, no DB writes)
+        if (flags['dry-run']) {
+            this.printDryRun(plan, { stage, fromSchema, toSchema, cfDomain, apps }, isJson);
+            return;
+        }
+        // 4. Resolve the target DB service
+        const service = new HyperdriveSigV4Service(flags.domain);
+        const targetSlug = await this.resolveServiceSlug(service, flags.service, stage, isJson);
+        if (!targetSlug) {
+            this.exit(1);
+            return;
+        }
+        // 5. Execute each planned phase via `service.serviceSeed`
+        const runs = [];
+        let allOk = true;
+        for (const item of plan) {
+            const label = `[${item.app}/${PHASE_LABEL[item.phase]}]`;
+            const spinner = isJson ? null : ora(`${label} submitting...`).start();
+            try {
+                const seedRun = await service.serviceSeed(targetSlug, {
+                    scriptSource: item.sql,
+                    scriptPath: `${item.app}.${item.phase}.sql`,
+                    allowProduction: flags['allow-production'] || undefined,
+                });
+                spinner?.succeed(chalk.green(`${label} submitted: ${seedRun.id}`));
+                if (flags['no-wait']) {
+                    runs.push({ app: item.app, phase: item.phase, seedRun, ok: true });
+                    continue;
+                }
+                const result = await pollLifecycle({
+                    pollFn: () => service.serviceGetSeedRun(targetSlug, seedRun.id),
+                    getStatus: (sr) => sr.status,
+                    terminalStates: new Set(['completed', 'failed']),
+                    successStates: new Set(['completed']),
+                    getErrorMessage: (sr) => sr.errorMessage,
+                    operationLabel: `${label} seeding`,
+                }, isJson);
+                const ok = result.success && !result.timedOut;
+                runs.push({ app: item.app, phase: item.phase, seedRun: result.entity ?? seedRun, ok });
+                if (!ok) {
+                    allOk = false;
+                    // Halt — don't keep submitting phases on a broken DB
+                    break;
+                }
+            }
+            catch (error) {
+                spinner?.fail(`${label} failed`);
+                const axiosError = error;
+                const status = axiosError.response?.status;
+                const errorMessage = axiosError.response?.data?.message ?? axiosError.message;
+                if (status === 403) {
+                    this.log(chalk.red(`Production safety: ${errorMessage}`));
+                    this.log(chalk.yellow('Use --allow-production to override.'));
+                }
+                else if (status === 404) {
+                    this.log(chalk.red(`Not found: ${errorMessage}`));
+                }
+                else {
+                    this.log(chalk.red(`Error: ${errorMessage}`));
+                }
+                allOk = false;
+                break;
+            }
+        }
+        // 6. Final summary
+        if (isJson) {
+            this.log(JSON.stringify({
+                stage,
+                fromSchema,
+                toSchema,
+                cfDomain,
+                apps,
+                service: targetSlug,
+                phases: runs.map((r) => ({
+                    app: r.app,
+                    phase: r.phase,
+                    seedRunId: r.seedRun.id,
+                    status: r.seedRun.status,
+                    ok: r.ok,
+                })),
+                ok: allOk,
+            }, null, 2));
+        }
+        else {
+            this.log('');
+            this.log(chalk.bold('Summary'));
+            for (const r of runs) {
+                const mark = r.ok ? chalk.green('OK') : chalk.red('FAIL');
+                this.log(`  ${mark}  ${r.app}/${PHASE_LABEL[r.phase]}  ${chalk.gray(r.seedRun.id)}  ${r.seedRun.status}`);
+            }
+            this.log('');
+            if (!allOk)
+                this.log(chalk.red('One or more phases failed. See log group for details.'));
+        }
+        if (!allOk)
+            this.exit(1);
+    }
+    /**
+     * Resolve the DB service slug to seed against.
+     *
+     * If `--service` was passed, trust it. Otherwise list services and pick the
+     * single rds-postgres service registered for this stage. Fail loudly when
+     * resolution is ambiguous — never guess silently.
+     */
+    async resolveServiceSlug(service, explicit, stage, isJson) {
+        if (explicit)
+            return explicit;
+        const spinner = isJson ? null : ora(`Resolving DB service for stage ${stage}...`).start();
+        try {
+            const services = await service.serviceList({ type: 'rds-postgres' });
+            const matches = services.filter((s) => {
+                const stageTag = (s.metadata && s.metadata.stage) ?? '';
+                return stageTag === stage;
+            });
+            if (matches.length === 1) {
+                spinner?.succeed(chalk.gray(`Service: ${matches[0].slug}`));
+                return matches[0].slug;
+            }
+            if (matches.length > 1) {
+                spinner?.fail(`Multiple rds-postgres services tagged stage=${stage}: ${matches.map((m) => m.slug).join(', ')}`);
+                this.log(chalk.yellow('Pass --service <slug> to disambiguate.'));
+                return null;
+            }
+            // Fallback: if there's exactly one rds-postgres service in the tenant, use it.
+            if (services.length === 1) {
+                spinner?.succeed(chalk.gray(`Service: ${services[0].slug} (only rds-postgres in tenant)`));
+                return services[0].slug;
+            }
+            spinner?.fail(`Could not resolve a DB service for stage ${stage} (found ${services.length} rds-postgres service(s) in tenant).`);
+            this.log(chalk.yellow('Pass --service <slug> to choose explicitly.'));
+            return null;
+        }
+        catch (error) {
+            spinner?.fail('Service resolution failed');
+            this.log(chalk.red(`Error: ${error.message}`));
+            this.log(chalk.yellow('Pass --service <slug> to skip auto-resolution.'));
+            return null;
+        }
+    }
+    printDryRun(plan, summary, isJson) {
+        if (isJson) {
+            this.log(JSON.stringify({
+                ...summary,
+                dryRun: true,
+                phases: plan.map((p) => ({
+                    app: p.app,
+                    phase: p.phase,
+                    description: p.description,
+                    sqlLength: p.sql.length,
+                    sqlPreview: p.sql.slice(0, 200),
+                })),
+            }, null, 2));
+            return;
+        }
+        this.log(chalk.bold('Dry run — no SQL will be executed'));
+        this.log(`  Stage:        ${chalk.cyan(summary.stage)}`);
+        this.log(`  Schema:       ${chalk.cyan(summary.fromSchema)} -> ${chalk.cyan(summary.toSchema)}`);
+        this.log(`  CF domain:    ${chalk.cyan(summary.cfDomain)}`);
+        this.log(`  Apps:         ${chalk.cyan(summary.apps.join(', '))}`);
+        this.log('');
+        for (const item of plan) {
+            this.log(chalk.bold(`[${item.app}] ${PHASE_LABEL[item.phase]} ${chalk.gray(`(${item.sql.length} chars)`)}`));
+            if (item.description)
+                this.log(chalk.gray(`  ${item.description}`));
+            const preview = item.sql.length > 800 ? `${item.sql.slice(0, 800)}\n... [+${item.sql.length - 800} chars]` : item.sql;
+            for (const line of preview.split('\n')) {
+                this.log(chalk.gray(`    ${line}`));
+            }
+            this.log('');
+        }
+        this.log(chalk.gray(`Total: ${plan.length} phase(s). Re-run without --dry-run to execute.`));
+    }
+}

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

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+export default class ServiceBackup 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>;
+        'no-wait': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        metadata: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        schedule: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private handleSchedule;
+}

package/dist/commands/service/backup.js

@@ -0,0 +1,156 @@
+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 ServiceBackup extends Command {
+    static description = 'Create a backup (snapshot) of a service, or configure a backup schedule';
+    static examples = [
+        '<%= config.bin %> service backup rds-postgres-live',
+        '<%= config.bin %> service backup rds-postgres-live --no-wait',
+        '<%= config.bin %> service backup rds-postgres-live --json',
+        '<%= config.bin %> service backup rds-postgres-live --metadata env=staging --metadata reason=migration',
+        '<%= config.bin %> service backup rds-postgres-live --schedule daily',
+    ];
+    static args = {
+        slug: Args.string({
+            description: 'Service slug to back up',
+            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,
+        }),
+        'no-wait': Flags.boolean({
+            description: 'Do not wait for backup to complete; print backup ID and exit',
+            default: false,
+        }),
+        metadata: Flags.string({
+            description: 'Metadata key=value pairs to attach to the backup',
+            multiple: true,
+        }),
+        schedule: Flags.string({
+            description: 'Configure automatic backup schedule instead of a one-time backup',
+            options: ['daily', 'weekly'],
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ServiceBackup);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        const isJson = flags.json;
+        // Handle --schedule: configure schedule, not a one-time backup
+        if (flags.schedule) {
+            await this.handleSchedule(service, args.slug, flags.schedule, isJson);
+            return;
+        }
+        // Parse metadata key=value pairs
+        const metadata = flags.metadata
+            ? Object.fromEntries(flags.metadata.map(kv => {
+                const eqIdx = kv.indexOf('=');
+                if (eqIdx === -1)
+                    return [kv, 'true'];
+                return [kv.slice(0, eqIdx), kv.slice(eqIdx + 1)];
+            }))
+            : undefined;
+        const spinner = isJson ? null : ora(`Creating backup for "${args.slug}"...`).start();
+        try {
+            const backup = await service.serviceCreateBackup(args.slug, metadata);
+            if (isJson && flags['no-wait']) {
+                this.log(JSON.stringify(backup, null, 2));
+                return;
+            }
+            spinner?.succeed(chalk.green(`Backup initiated: ${backup.id}`));
+            if (!isJson) {
+                this.log(`  Service:    ${chalk.cyan(args.slug)}`);
+                this.log(`  Backup ID:  ${chalk.cyan(backup.id)}`);
+                this.log(`  Type:       ${backup.type}`);
+                this.log(`  Status:     ${chalk.yellow(backup.status)}`);
+                this.log('');
+            }
+            if (flags['no-wait']) {
+                if (!isJson) {
+                    this.log(chalk.gray(`Check status: hd service backups ${args.slug}`));
+                }
+                return;
+            }
+            // Poll for completion using shared poller
+            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: 'Backing up',
+            }, isJson);
+            if (isJson) {
+                this.log(JSON.stringify(result.entity, null, 2));
+            }
+            if (result.timedOut) {
+                if (!isJson) {
+                    this.log(chalk.yellow('The backup may still be running.'));
+                    this.log(chalk.gray(`Check status: hd service backups ${args.slug}`));
+                }
+                this.exit(1);
+            }
+            if (!result.success) {
+                this.exit(1);
+            }
+            // Success — print summary
+            if (!isJson && result.entity) {
+                const b = result.entity;
+                if (b.snapshotArn)
+                    this.log(`  Snapshot ARN: ${chalk.gray(b.snapshotArn)}`);
+                if (b.completedAt)
+                    this.log(`  Completed:    ${new Date(b.completedAt).toLocaleString()}`);
+            }
+        }
+        catch (error) {
+            spinner?.fail('Backup request failed');
+            const axiosError = error;
+            const status = axiosError.response?.status;
+            const errorMessage = axiosError.response?.data?.message ?? axiosError.message;
+            if (status === 404) {
+                this.log(chalk.red(`Service not found: ${args.slug}`));
+            }
+            else if (status === 400) {
+                this.log(chalk.red(`Validation error: ${errorMessage}`));
+            }
+            else if (status === 409) {
+                this.log(chalk.red(`Conflict: ${errorMessage}`));
+            }
+            else {
+                this.log(chalk.red(`Error: ${errorMessage}`));
+            }
+            this.exit(1);
+        }
+    }
+    async handleSchedule(service, slug, schedule, isJson) {
+        const spinner = isJson ? null : ora(`Configuring ${schedule} backup schedule for "${slug}"...`).start();
+        try {
+            await service.serviceBackupSchedule(slug, schedule);
+            spinner?.succeed(chalk.green(`Backup schedule configured: ${schedule}`));
+            if (isJson) {
+                this.log(JSON.stringify({ slug, backupSchedule: schedule, message: 'Schedule configured' }, null, 2));
+            }
+            else {
+                this.log(`  Service:   ${chalk.cyan(slug)}`);
+                this.log(`  Schedule:  ${chalk.cyan(schedule)}`);
+                this.log('');
+                this.log(chalk.gray('Automatic backups will run on this schedule.'));
+            }
+        }
+        catch (error) {
+            spinner?.fail('Failed to configure backup schedule');
+            const axiosError = error;
+            const errorMessage = axiosError.response?.data?.message ?? axiosError.message;
+            this.log(chalk.red(`Error: ${errorMessage}`));
+            this.exit(1);
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class ServiceBackups 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>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/service/backups.js

@@ -0,0 +1,110 @@
+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 ServiceBackups extends Command {
+    static description = 'List all backups for a service';
+    static examples = [
+        '<%= config.bin %> service backups rds-postgres-live',
+        '<%= config.bin %> service backups rds-postgres-live --limit 5',
+        '<%= config.bin %> service backups 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,
+        }),
+        limit: Flags.integer({
+            description: 'Maximum number of backups to return',
+            default: 20,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ServiceBackups);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        const isJson = flags.json;
+        const spinner = isJson ? null : ora(`Fetching backups for "${args.slug}"...`).start();
+        try {
+            const result = await service.serviceListBackups(args.slug, {
+                limit: String(flags.limit),
+            });
+            spinner?.stop();
+            const backups = result.backups ?? [];
+            if (isJson) {
+                this.log(JSON.stringify(backups, null, 2));
+                return;
+            }
+            if (backups.length === 0) {
+                this.log(chalk.yellow(`\nNo backups found for service "${args.slug}".`));
+                this.log(chalk.gray(`Create one: hd service backup ${args.slug}`));
+                return;
+            }
+            this.log(chalk.green(`\n${backups.length} backup(s) found:\n`));
+            printTable(backups, {
+                id: {
+                    header: 'ID',
+                    minWidth: 20,
+                    get: (row) => {
+                        const id = row.id;
+                        return chalk.cyan(id.length > 18 ? id.slice(0, 18) + '...' : id);
+                    },
+                },
+                status: {
+                    header: 'Status',
+                    get: (row) => {
+                        const status = row.status;
+                        if (status === 'completed')
+                            return chalk.green(status);
+                        if (status === 'failed')
+                            return chalk.red(status);
+                        return chalk.yellow(status);
+                    },
+                },
+                type: {
+                    header: 'Type',
+                },
+                serviceType: {
+                    header: 'Service Type',
+                },
+                createdAt: {
+                    header: 'Created At',
+                    get: (row) => new Date(row.createdAt).toLocaleString(),
+                },
+                snapshotArn: {
+                    header: 'Snapshot ARN',
+                    get: (row) => {
+                        const arn = row.snapshotArn;
+                        if (!arn)
+                            return chalk.gray('-');
+                        return arn.length > 30
+                            ? '...' + arn.slice(-27)
+                            : arn;
+                    },
+                },
+            }, (msg) => this.log(msg));
+        }
+        catch (error) {
+            spinner?.fail('Failed to fetch backups');
+            const axiosError = error;
+            const status = axiosError.response?.status;
+            if (status === 404) {
+                this.log(chalk.red(`Service not found: ${args.slug}`));
+            }
+            else {
+                this.log(chalk.red(`Error: ${axiosError.response?.data?.message ?? axiosError.message}`));
+            }
+            this.exit(1);
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class ServiceBind extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        service: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        module: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'env-var-mapping': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        stage: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'template-vars': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}