@hyperdrive.bot/cli 1.0.12 → 1.0.16

package/dist/commands/module/update.js

@@ -7,6 +7,9 @@ export default class ModuleUpdate extends Command {
         '<%= config.bin %> <%= command.id %> --slug="my-module" --runtimeVersion="12"',
         '<%= config.bin %> <%= command.id %> --slug="my-module" --buildCommand="npm run build:prod"',
         '<%= config.bin %> <%= command.id %> --slug="my-module" --name="New Name" --framework="React.js"',
+        '<%= config.bin %> <%= command.id %> --slug="my-module" --postDeployCommand="npm run migrate" --postDeployFailureMode="warn"',
+        '<%= config.bin %> <%= command.id %> --slug="my-module" --runtime-config=\'{"timeout":60,"memory":4096}\'',
+        '<%= config.bin %> <%= command.id %> --slug="my-module" --show',
     ];
     static flags = {
         buildCommand: Flags.string({
@@ -32,9 +35,18 @@ export default class ModuleUpdate extends Command {
         defaultBranch: Flags.string({
             description: 'Default git branch to branch from (e.g., main, master)',
         }),
+        dependsOn: Flags.string({
+            description: 'JSON array of artifact dependencies: [{"artifactKey":"name","downloadTo":"path/"}]',
+        }),
         deploymentStrategy: Flags.string({
-            description: 'Deployment strategy: "serverless" for Serverless Framework deployment to Lambda',
-            options: ['serverless'],
+            description: 'Deployment strategy: "serverless" for SLS deploy, "docker-build" for Docker-based artifact builds',
+            options: ['serverless', 'docker-build'],
+        }),
+        dockerBuild: Flags.string({
+            description: 'Docker-build config JSON: {"image","buildCommand","artifactPaths","artifactKey","workdir","cache"}',
+        }),
+        'deploy-command': Flags.string({
+            description: 'Custom LAUNCH phase deploy command (default: sls deploy --package .serverless --stage <stage> --region <region>). E.g., "npm run deploy:devsquad". BUILD phase uses buildCommand.',
         }),
         domain: Flags.string({
             char: 'd',
@@ -47,6 +59,17 @@ export default class ModuleUpdate extends Command {
         installCommand: Flags.string({
             description: 'Install command',
         }),
+        postDeployCommand: Flags.string({
+            description: 'Command to run after successful deploy',
+        }),
+        postDeployFailureMode: Flags.string({
+            description: 'Post-deploy command failure behavior: fail (default) or warn',
+            options: ['fail', 'warn'],
+        }),
+        'module-type': Flags.string({
+            description: 'Module deployment type (determines API Gateway vs CloudFront vs CDK)',
+            options: ['backend', 'frontend', 'cdk'],
+        }),
         name: Flags.string({
             description: 'Name of the project',
         }),
@@ -54,18 +77,28 @@ export default class ModuleUpdate extends Command {
             allowNo: true,
             description: 'Enable AI-powered route discovery for per-route Lambda functions',
         }),
+        'runtime-mode': Flags.string({
+            description: 'Runtime mode: "handler" for native Lambda handlers, "server" for HTTP server wrapping',
+            options: ['handler', 'server'],
+        }),
         runCommand: Flags.string({
             description: 'Run command',
         }),
         runtime: Flags.string({
             char: 'r',
             description: 'Runtime environment',
-            options: ['nodejs', 'python', 'go', 'rust', 'java', 'dotnet', 'ruby'],
+            options: ['nodejs', 'python', 'go', 'rust', 'java', 'dotnet', 'ruby', 'static'],
+        }),
+        'runtime-config': Flags.string({
+            description: 'Lambda runtime config JSON: {"timeout":60,"memory":4096}. timeout=1-900s, memory=128-10240MB.',
         }),
         runtimeVersion: Flags.string({
             char: 'v',
             description: 'Runtime version (e.g., 20, 3.12, 1.21)',
         }),
+        show: Flags.boolean({
+            description: 'Print current module config (including runtimeConfig) without updating',
+        }),
         slug: Flags.string({
             char: 's',
             description: 'Module slug to update (required)',
@@ -77,12 +110,142 @@ export default class ModuleUpdate extends Command {
         sourceLocation: Flags.string({
             description: 'Source location of the project',
         }),
+        subdomain: Flags.string({
+            description: 'Subdomain prefix for custom domain URLs (e.g., "api", "app", "www", "" for apex)',
+        }),
     };
     async run() {
         const { flags } = await this.parse(ModuleUpdate);
-        const { slug, ...updateFields } = flags;
+        const { show, slug, ...updateFields } = flags;
+        // --show short-circuit: fetch and print the current module record without updating
+        if (show) {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            try {
+                const module = await service.moduleGet({ slug });
+                const runtimeConfig = module.runtimeConfig;
+                this.log(chalk.green(`✅ Module "${slug}" runtimeConfig:`));
+                this.log(JSON.stringify(runtimeConfig ?? null, null, 2));
+                return;
+            }
+            catch (error) {
+                console.error('Error:', error);
+                this.error(`An error occurred while fetching module ${slug}`);
+            }
+        }
+        // Map kebab-case flags to camelCase API fields
+        const mappedFields = { ...updateFields };
+        if (mappedFields['module-type'] !== undefined) {
+            mappedFields.moduleType = mappedFields['module-type'];
+            delete mappedFields['module-type'];
+        }
+        if (mappedFields['deploy-command'] !== undefined) {
+            mappedFields.deployCommand = mappedFields['deploy-command'];
+            delete mappedFields['deploy-command'];
+        }
+        if (mappedFields['runtime-mode'] !== undefined) {
+            mappedFields.runtimeMode = mappedFields['runtime-mode'];
+            delete mappedFields['runtime-mode'];
+        }
+        if (mappedFields['post-deploy-command'] !== undefined) {
+            mappedFields.postDeployCommand = mappedFields['post-deploy-command'];
+            delete mappedFields['post-deploy-command'];
+        }
+        if (mappedFields['post-deploy-failure-mode'] !== undefined) {
+            mappedFields.postDeployFailureMode = mappedFields['post-deploy-failure-mode'];
+            delete mappedFields['post-deploy-failure-mode'];
+        }
+        // Parse and validate runtimeConfig JSON (Lambda timeout + memory)
+        if (mappedFields['runtime-config'] !== undefined) {
+            let parsed;
+            try {
+                parsed = JSON.parse(mappedFields['runtime-config']);
+            }
+            catch (error) {
+                if (error instanceof SyntaxError) {
+                    this.error('--runtime-config must be valid JSON: ' + error.message);
+                }
+                throw error;
+            }
+            if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+                this.error('--runtime-config must be a JSON object');
+            }
+            const cfg = parsed;
+            const allowedKeys = new Set(['memory', 'timeout']);
+            for (const key of Object.keys(cfg)) {
+                if (!allowedKeys.has(key)) {
+                    this.error(`--runtime-config has unknown field "${key}" (allowed: timeout, memory)`);
+                }
+            }
+            if (cfg.timeout === undefined && cfg.memory === undefined) {
+                this.error('--runtime-config must include at least one of "timeout" or "memory"');
+            }
+            const out = {};
+            if (cfg.timeout !== undefined) {
+                if (typeof cfg.timeout !== 'number' || !Number.isInteger(cfg.timeout)) {
+                    this.error('--runtime-config "timeout" must be an integer (seconds)');
+                }
+                if (cfg.timeout < 1 || cfg.timeout > 900) {
+                    this.error('--runtime-config "timeout" must be between 1 and 900 seconds (Lambda hard limit)');
+                }
+                out.timeout = cfg.timeout;
+            }
+            if (cfg.memory !== undefined) {
+                if (typeof cfg.memory !== 'number' || !Number.isInteger(cfg.memory)) {
+                    this.error('--runtime-config "memory" must be an integer (MB)');
+                }
+                if (cfg.memory < 128 || cfg.memory > 10_240) {
+                    this.error('--runtime-config "memory" must be between 128 and 10240 MB (Lambda hard limit)');
+                }
+                out.memory = cfg.memory;
+            }
+            mappedFields.runtimeConfig = out;
+            delete mappedFields['runtime-config'];
+        }
+        // Parse and validate dockerBuild JSON
+        if (mappedFields.dockerBuild !== undefined) {
+            try {
+                const parsed = JSON.parse(mappedFields.dockerBuild);
+                if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+                    this.error('--dockerBuild must be a JSON object');
+                }
+                if (!parsed.image || !parsed.buildCommand || !parsed.artifactPaths || !parsed.artifactKey) {
+                    this.error('--dockerBuild must include: image, buildCommand, artifactPaths, artifactKey');
+                }
+                mappedFields.dockerBuild = parsed;
+            }
+            catch (error) {
+                if (error instanceof SyntaxError) {
+                    this.error('--dockerBuild must be valid JSON: ' + error.message);
+                }
+                throw error;
+            }
+        }
+        // Parse and validate dependsOn JSON
+        if (mappedFields.dependsOn !== undefined) {
+            try {
+                const parsed = JSON.parse(mappedFields.dependsOn);
+                if (!Array.isArray(parsed)) {
+                    this.error('--dependsOn must be a JSON array');
+                }
+                for (const entry of parsed) {
+                    if (typeof entry.artifactKey !== 'string' || !entry.artifactKey) {
+                        this.error('Each dependsOn entry must have a non-empty "artifactKey" string');
+                    }
+                    if (typeof entry.downloadTo !== 'string' || !entry.downloadTo) {
+                        this.error('Each dependsOn entry must have a non-empty "downloadTo" string');
+                    }
+                }
+                mappedFields.dependsOn = parsed;
+            }
+            catch (error) {
+                if (error instanceof SyntaxError) {
+                    this.error('--dependsOn must be valid JSON: ' + error.message);
+                }
+                throw error;
+            }
+        }
         // Filter out undefined values
-        const updateData = Object.fromEntries(Object.entries(updateFields).filter(([_, value]) => value !== undefined));
+        const updateData = Object.fromEntries(Object.entries(mappedFields).filter(([_, value]) => value !== undefined));
         if (Object.keys(updateData).length === 0) {
             this.log(chalk.yellow('No fields to update. Please provide at least one field to update.'));
             return;

package/dist/commands/network/discover.d.ts

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

package/dist/commands/network/discover.js

@@ -0,0 +1,210 @@
+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 NetworkDiscover extends Command {
+    static description = 'Discover VPCs in a connected AWS account';
+    static examples = [
+        '<%= config.bin %> network discover --account 084309335408 --region us-east-1',
+        '<%= config.bin %> network discover --account 084309335408 --region us-east-1 --json',
+    ];
+    static flags = {
+        account: Flags.string({
+            char: 'a',
+            description: 'AWS Account ID to discover VPCs in',
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        json: Flags.boolean({
+            description: 'Output raw JSON response (non-interactive)',
+            default: false,
+        }),
+        region: Flags.string({
+            char: 'r',
+            description: 'AWS region to discover VPCs in',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(NetworkDiscover);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        // Prompt for missing flags
+        let accountId = flags.account;
+        let region = flags.region;
+        if (!accountId || !region) {
+            const inquirer = (await import('inquirer')).default;
+            if (!accountId) {
+                // Try to fetch registered accounts for selection
+                try {
+                    const accounts = await service.accountList();
+                    if (accounts.length > 0) {
+                        const { selectedAccount } = await inquirer.prompt([{
+                                choices: accounts.map(a => ({
+                                    name: `${a.name || 'Unnamed'} (${a.accountId}) - ${a.defaultRegion}`,
+                                    value: a.accountId,
+                                })),
+                                message: chalk.yellow('Select an AWS account:'),
+                                name: 'selectedAccount',
+                                type: 'list',
+                            }]);
+                        accountId = selectedAccount;
+                        // Default region from selected account
+                        if (!region) {
+                            const selectedAccountObj = accounts.find(a => a.accountId === selectedAccount);
+                            region = selectedAccountObj?.defaultRegion;
+                        }
+                    }
+                }
+                catch {
+                    // Fall through to manual input
+                }
+                if (!accountId) {
+                    const { inputAccount } = await inquirer.prompt([{
+                            message: chalk.yellow('Enter the AWS Account ID (12 digits):'),
+                            name: 'inputAccount',
+                            validate: (input) => /^\d{12}$/.test(input) || 'AWS Account ID must be exactly 12 digits',
+                        }]);
+                    accountId = inputAccount;
+                }
+            }
+            if (!region) {
+                const inquirerModule = (await import('inquirer')).default;
+                const { inputRegion } = await inquirerModule.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('Select the AWS region:'),
+                        name: 'inputRegion',
+                        type: 'list',
+                    }]);
+                region = inputRegion;
+            }
+        }
+        const spinner = ora(`Discovering VPCs in ${accountId}/${region}...`).start();
+        try {
+            const result = await service.networkDiscover({
+                accountId: accountId,
+                region: region,
+            });
+            spinner.stop();
+            // JSON mode — output raw response and exit
+            if (flags.json) {
+                this.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            if (result.vpcs.length === 0) {
+                this.log(chalk.yellow(`\nNo VPCs found in ${accountId}/${region}.`));
+                return;
+            }
+            this.log(chalk.blue(`\nDiscovered ${result.vpcs.length} VPC(s) in ${accountId}/${region}:\n`));
+            printTable(result.vpcs, {
+                vpcId: {
+                    header: 'VPC ID',
+                    minWidth: 25,
+                    get: (row) => chalk.cyan(row.vpcId),
+                },
+                name: {
+                    header: 'Name',
+                    minWidth: 20,
+                    get: (row) => row.name || chalk.gray('(unnamed)'),
+                },
+                cidrBlock: {
+                    header: 'CIDR',
+                    minWidth: 18,
+                },
+                subnets: {
+                    header: 'Subnets (Priv/Pub)',
+                    minWidth: 20,
+                    get: (row) => `${row.privateSubnetIds.length} / ${row.publicSubnetIds.length}`,
+                },
+                sgs: {
+                    header: 'Security Groups',
+                    minWidth: 16,
+                    get: (row) => String(row.securityGroups.length),
+                },
+                registered: {
+                    header: 'Registered?',
+                    get: (row) => row.alreadyRegistered
+                        ? chalk.green(`Yes (${row.existingNetworkSlug})`)
+                        : chalk.gray('No'),
+                },
+            }, (msg) => this.log(msg));
+            // Interactive mode — select VPCs to register
+            const unregisteredVpcs = result.vpcs.filter(v => !v.alreadyRegistered);
+            if (unregisteredVpcs.length === 0) {
+                this.log(chalk.green('\nAll discovered VPCs are already registered.'));
+                return;
+            }
+            const inquirer = (await import('inquirer')).default;
+            const { selectedVpcs } = await inquirer.prompt([{
+                    choices: unregisteredVpcs.map(v => ({
+                        name: `${v.vpcId} - ${v.name || '(unnamed)'} (${v.cidrBlock})`,
+                        value: v.vpcId,
+                    })),
+                    message: chalk.yellow('\nSelect VPCs to register as networks:'),
+                    name: 'selectedVpcs',
+                    type: 'checkbox',
+                }]);
+            if (selectedVpcs.length === 0) {
+                this.log(chalk.gray('\nNo VPCs selected. Done.'));
+                return;
+            }
+            // Register each selected VPC
+            for (const vpcId of selectedVpcs) {
+                const vpc = unregisteredVpcs.find(v => v.vpcId === vpcId);
+                // Auto-generate slug from name tag or VPC ID suffix
+                const slugBase = vpc.name
+                    ? vpc.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
+                    : `vpc-${vpcId.slice(-8)}`;
+                const slug = `${slugBase}-${region}`;
+                const { confirmedSlug } = await inquirer.prompt([{
+                        default: slug,
+                        message: chalk.yellow(`Slug for ${vpcId}:`),
+                        name: 'confirmedSlug',
+                        validate: (input) => /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(input) || 'slug must be lowercase alphanumeric with hyphens',
+                    }]);
+                const registerSpinner = ora(`Registering ${confirmedSlug}...`).start();
+                try {
+                    await service.networkRegister({
+                        slug: confirmedSlug,
+                        accountId: accountId,
+                        region: region,
+                        vpcId,
+                        privateSubnetIds: vpc.privateSubnetIds,
+                        publicSubnetIds: vpc.publicSubnetIds,
+                        source: 'discovered',
+                    });
+                    registerSpinner.succeed(chalk.green(`Registered: ${confirmedSlug}`));
+                }
+                catch (error) {
+                    const axiosErr = error;
+                    const errMsg = axiosErr.response?.data?.message ?? axiosErr.message ?? 'Unknown error';
+                    registerSpinner.fail(chalk.red(`Failed to register ${confirmedSlug}: ${errMsg}`));
+                }
+            }
+            this.log(chalk.green('\nDone.'));
+        }
+        catch (error) {
+            spinner.stop();
+            const axiosError = error;
+            const statusCode = axiosError.response?.status;
+            const errorMessage = axiosError.response?.data?.message ?? axiosError.message ?? 'Unknown error';
+            if (statusCode === 403) {
+                this.log(chalk.red(`\n❌ Access denied: ${errorMessage}`));
+                this.log(chalk.gray('Ensure HyperdriveDiscoveryRole exists in the target account and allows this account to assume it.'));
+            }
+            else if (statusCode === 502) {
+                this.log(chalk.red(`\n❌ Discovery failed: ${errorMessage}`));
+            }
+            else {
+                this.log(chalk.red(`\n❌ Error: ${errorMessage}`));
+            }
+            this.exit(1);
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class NetworkGet 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>;
+}

package/dist/commands/network/get.js

@@ -0,0 +1,90 @@
+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 NetworkGet extends Command {
+    static description = 'Get details of a registered network';
+    static examples = [
+        '<%= config.bin %> network get prod-us-east-1',
+        '<%= config.bin %> network get prod-us-east-1 --json',
+    ];
+    static args = {
+        slug: Args.string({
+            description: 'Network 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(NetworkGet);
+        const isJson = flags.json;
+        const service = new HyperdriveSigV4Service(flags.domain);
+        const spinner = isJson ? null : ora(`Fetching network "${args.slug}"...`).start();
+        try {
+            const network = await service.networkGet(args.slug);
+            spinner?.succeed('Network found');
+            if (isJson) {
+                this.log(JSON.stringify(network, null, 2));
+                return;
+            }
+            printHeader(`Network: ${network.slug}`, (msg) => this.log(msg));
+            this.log(`  ${chalk.bold('Account ID:')}    ${network.accountId}`);
+            this.log(`  ${chalk.bold('Region:')}        ${network.region}`);
+            this.log(`  ${chalk.bold('VPC ID:')}        ${chalk.cyan(network.vpcId)}`);
+            this.log(`  ${chalk.bold('Status:')}        ${network.status === 'active' ? chalk.green(network.status) : chalk.yellow(network.status)}`);
+            this.log(`  ${chalk.bold('Source:')}        ${network.source}`);
+            this.log(`  ${chalk.bold('Created:')}       ${new Date(network.createdAt).toLocaleString()}`);
+            this.log(`  ${chalk.bold('Updated:')}       ${new Date(network.updatedAt).toLocaleString()}`);
+            this.log(`\n  ${chalk.bold('Private Subnets:')}`);
+            if (network.privateSubnetIds.length > 0) {
+                for (const subnet of network.privateSubnetIds) {
+                    this.log(`    - ${subnet}`);
+                }
+            }
+            else {
+                this.log(chalk.gray('    (none)'));
+            }
+            this.log(`\n  ${chalk.bold('Public Subnets:')}`);
+            if (network.publicSubnetIds.length > 0) {
+                for (const subnet of network.publicSubnetIds) {
+                    this.log(`    - ${subnet}`);
+                }
+            }
+            else {
+                this.log(chalk.gray('    (none)'));
+            }
+            this.log(`\n  ${chalk.bold('Security Groups:')}`);
+            const sgEntries = Object.entries(network.securityGroups || {});
+            if (sgEntries.length > 0) {
+                for (const [purpose, groupId] of sgEntries) {
+                    this.log(`    ${chalk.bold(purpose)}: ${groupId}`);
+                }
+            }
+            else {
+                this.log(chalk.gray('    (none)'));
+            }
+        }
+        catch (error) {
+            spinner?.fail('Failed');
+            const axiosError = error;
+            const status = axiosError.response?.status;
+            if (status === 404) {
+                this.log(chalk.red(`\n❌ Network not found: ${args.slug}`));
+            }
+            else {
+                this.log(chalk.red(`\n❌ ${axiosError.response?.data?.message ?? axiosError.message}`));
+            }
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/{auth/logout.d.ts → network/list.d.ts}

@@ -1,17 +1,10 @@
 import { Command } from '@oclif/core';
-export default class Logout extends Command {
+export default class NetworkList 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>;
     };
     run(): Promise<void>;
-    /**
-     * Remove credentials for a specific domain
-     */
-    private logoutDomain;
-    /**
-     * Remove default domain credentials and all stored config
-     */
-    private logoutAll;
 }

package/dist/commands/network/list.js

@@ -0,0 +1,71 @@
+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 NetworkList extends Command {
+    static description = 'List all registered networks';
+    static examples = [
+        '<%= config.bin %> network list',
+        '<%= config.bin %> network 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,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(NetworkList);
+        const isJson = flags.json;
+        const service = new HyperdriveSigV4Service(flags.domain);
+        const spinner = isJson ? null : ora('Fetching networks...').start();
+        try {
+            const networks = await service.networkList();
+            spinner?.stop();
+            if (isJson) {
+                this.log(JSON.stringify(networks, null, 2));
+                return;
+            }
+            if (!networks || networks.length === 0) {
+                this.log(chalk.yellow('\nNo networks found.'));
+                this.log(chalk.gray('Use "hd network discover" or "hd network register" to add networks.'));
+                return;
+            }
+            this.log(chalk.green(`\n${networks.length} network(s) found:\n`));
+            printTable(networks, {
+                slug: {
+                    header: 'Slug',
+                    minWidth: 25,
+                    get: (row) => chalk.cyan(row.slug),
+                },
+                accountId: {
+                    header: 'Account ID',
+                    minWidth: 15,
+                },
+                region: {
+                    header: 'Region',
+                    minWidth: 15,
+                },
+                vpcId: {
+                    header: 'VPC ID',
+                    minWidth: 25,
+                },
+                status: {
+                    header: 'Status',
+                    get: (row) => row.status === 'active' ? chalk.green(row.status) : chalk.yellow(row.status),
+                },
+            }, (msg) => this.log(msg));
+        }
+        catch (error) {
+            spinner?.fail('Failed to fetch networks');
+            const axiosError = error;
+            this.log(chalk.red(`\n❌ ${axiosError.response?.data?.message ?? axiosError.message}`));
+            this.exit(1);
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class NetworkRegister extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'account-id': 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>;
+        'private-subnets': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'public-subnets': 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>;
+        'security-groups': 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>;
+        'vpc-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}