@hyperdrive.bot/cli 1.0.2

package/dist/commands/module/link.js

@@ -0,0 +1,175 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class ModuleLink extends Command {
+    static description = 'Links two modules using specified environment variables as connectors';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --originSlug="vixting-integration" --targetSlug="vixting-api" --parameter="VLOW_API_ENDPOINT_PREFIX"',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        originSlug: Flags.string({
+            description: 'Slug of the origin module (the one that depends on another)',
+            required: true,
+        }),
+        parameter: Flags.string({
+            description: 'Environment variable to link (e.g., API_URL)',
+            multiple: true,
+            required: true,
+        }),
+        targetSlug: Flags.string({
+            description: 'Slug of the target module (the dependency)',
+            required: true,
+        }),
+    };
+    async confirmDeploymentBehavior() {
+        const confirmation = await inquirer.prompt([
+            {
+                default: true,
+                message: chalk.blue('In every deployment, we will attempt to find a backend instance in the same stage as your application is being deployed to. If no such backend instance is found, we will connect your frontend to the backend instance deployed in the default stage. Do you want to proceed?'),
+                name: 'confirmDeployment',
+                type: 'confirm',
+            },
+        ]);
+        return confirmation.confirmDeployment;
+    }
+    async prompt() {
+        await inquirer.prompt([
+            {
+                message: chalk.green('Enter the origin module slug:'),
+                name: 'originSlug',
+                validate: input => Boolean(input) || 'Origin module slug is required.',
+            },
+        ]);
+        await inquirer.prompt([
+            {
+                choices: ['front-end', 'back-end'],
+                message: chalk.green('What is the type of the module?'),
+                name: 'projectType',
+                type: 'list',
+            },
+        ]);
+        await this.promptForEnvironmentVariables();
+        await inquirer.prompt([
+            {
+                message: chalk.green('Enter the destination module slug:'),
+                name: 'targetSlug',
+                validate: input => Boolean(input) || 'Destination module slug is required.',
+            },
+        ]);
+        const proceed = await this.confirmDeploymentBehavior();
+        if (!proceed) {
+            this.log(chalk.red('Deployment cancelled by user.'));
+        }
+    }
+    async promptForEnvironmentVariables() {
+        const envVariables = [];
+        const collectVariable = async () => {
+            const response = await inquirer.prompt([
+                {
+                    message: chalk.yellow('Enter the environment variable used to connect your front-end to your back-end:'),
+                    name: 'envVariable',
+                    validate: input => Boolean(input) || 'Environment variable is required.',
+                },
+                {
+                    default: false,
+                    message: chalk.yellow('Do you want to add another environment variable?'),
+                    name: 'addAnother',
+                    type: 'confirm',
+                },
+            ]);
+            envVariables.push(response.envVariable);
+            if (response.addAnother) {
+                return collectVariable();
+            }
+        };
+        await collectVariable();
+        return envVariables;
+    }
+    async run() {
+        const { flags } = await this.parse(ModuleLink);
+        // Validation: Ensure origin and target are different
+        if (flags.originSlug === flags.targetSlug) {
+            this.log(chalk.red('❌ Error: Cannot link a module to itself'));
+            this.log(chalk.gray('   originSlug and targetSlug must be different'));
+            this.exit(1);
+        }
+        // Validation: Ensure at least one parameter
+        if (!flags.parameter || flags.parameter.length === 0) {
+            this.log(chalk.red('❌ Error: At least one parameter is required'));
+            this.log(chalk.gray('   Use --parameter=PARAM_NAME to specify parameters'));
+            this.exit(1);
+        }
+        // Validation: Check for duplicate parameters
+        const uniqueParams = new Set(flags.parameter);
+        if (uniqueParams.size !== flags.parameter.length) {
+            this.log(chalk.yellow('⚠️  Warning: Duplicate parameters detected, removing duplicates'));
+        }
+        this.log(chalk.green(`🔗 Linking ${flags.originSlug} → ${flags.targetSlug}...`));
+        this.log(chalk.gray(`   Parameters: ${[...uniqueParams].join(', ')}`));
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            // Convert array of parameter names to object format
+            // Each parameter will receive the target module's deployment URL at deploy time
+            const parametersObject = {};
+            for (const param of uniqueParams) {
+                parametersObject[param] = true;
+            }
+            const result = await service.moduleLink({
+                originSlug: flags.originSlug,
+                parameters: parametersObject,
+                targetSlug: flags.targetSlug,
+            });
+            this.log('');
+            this.log(chalk.blue('✅ Module link successful!'));
+            this.log('');
+            this.log(chalk.bold('What happens during deployment:'));
+            this.log(chalk.gray(`  1. When you deploy ${chalk.cyan(flags.originSlug)}, Hyperdrive will:`));
+            this.log(chalk.gray(`     - Look for ${chalk.cyan(flags.targetSlug)} in the same stage`));
+            this.log(chalk.gray(`     - If not found, fall back to default stage`));
+            this.log(chalk.gray(`     - Inject the deployment URL into these parameters:`));
+            for (const param of uniqueParams) {
+                this.log(chalk.gray(`       • ${chalk.yellow(param)}`));
+            }
+            this.log('');
+            this.log(chalk.gray('Example: If you deploy to "prod" stage:'));
+            this.log(chalk.gray(`  - First deploy ${chalk.cyan(flags.targetSlug)} to prod → gets URL https://api.example.com`));
+            this.log(chalk.gray(`  - Then deploy ${chalk.cyan(flags.originSlug)} to prod → receives ${chalk.yellow(flags.parameter[0])}=https://api.example.com`));
+            this.log('');
+            this.log(chalk.gray('Link details:'));
+            this.log(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            this.log('');
+            this.log(chalk.red('❌ Error linking modules'));
+            this.log('');
+            // Parse error response for better messages
+            if (error.response?.data?.message) {
+                this.log(chalk.red('Error: ' + error.response.data.message));
+            }
+            else if (error.message) {
+                this.log(chalk.red('Error: ' + error.message));
+            }
+            else {
+                this.log(chalk.red('Error: ' + error.toString()));
+            }
+            // Provide helpful hints based on common errors
+            if (error.response?.status === 404) {
+                this.log('');
+                this.log(chalk.yellow('💡 Tip: Make sure both modules exist'));
+                this.log(chalk.gray(`   Run: hd module list`));
+            }
+            else if (error.response?.status === 400) {
+                this.log('');
+                this.log(chalk.yellow('💡 Tip: Check your command syntax'));
+                this.log(chalk.gray(`   Example: hd module link --originSlug=my-app --targetSlug=my-api --parameter=API_URL`));
+            }
+            this.log('');
+            this.exit(1);
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class ModuleList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        domain: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/module/list.js

@@ -0,0 +1,51 @@
+import { Command, Flags, ux } from '@oclif/core';
+import chalk from 'chalk';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class ModuleList extends Command {
+    static description = 'List all modules/projects';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ModuleList);
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            this.log(chalk.blue('🔍 Fetching modules...'));
+            const modules = await service.moduleList();
+            if (!modules || modules.length === 0) {
+                this.log(chalk.yellow('⚠️  No modules found'));
+                return;
+            }
+            this.log(chalk.green(`✅ Found ${modules.length} module(s)\n`));
+            // Display modules in a table
+            ux.table(modules, {
+                createdAt: {
+                    get: (row) => new Date(row.createdAt).toLocaleDateString(),
+                    header: 'Created',
+                },
+                framework: {
+                    header: 'Framework',
+                },
+                name: {
+                    header: 'Name',
+                    minWidth: 20,
+                },
+                slug: {
+                    get: (row) => chalk.cyan(row.slug),
+                    header: 'Slug',
+                    minWidth: 15,
+                },
+            });
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error('An error occurred while listing modules');
+        }
+    }
+}

package/dist/commands/module/reanalyze.d.ts

@@ -0,0 +1,30 @@
+import { Command } from '@oclif/core';
+export default class DockerfileReanalyze extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        domain: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        prompt: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        save: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        slug: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        wait: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /**
+     * Build CloudWatch console URL for log viewing
+     */
+    private buildConsoleUrl;
+    /**
+     * Display analysis results
+     */
+    private displayResults;
+    /**
+     * Poll for Dockerfile (fallback when streaming not available)
+     */
+    private pollForDockerfile;
+    /**
+     * Stream analysis logs using CloudWatch
+     */
+    private streamAnalysisLogs;
+}

package/dist/commands/module/reanalyze.js

@@ -0,0 +1,206 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+import { CloudWatchLogTailer } from '../../services/log-tailer.js';
+export default class DockerfileReanalyze extends Command {
+    static description = 'Reanalyze a module\'s Dockerfile with custom instructions';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --slug="my-module" --prompt="Use Node.js 18 instead of 20"',
+        '<%= config.bin %> <%= command.id %> --prompt="Fix the build - missing Python dependency"',
+        '<%= config.bin %> <%= command.id %> -s my-module -p "Exclude source maps from S3 upload" --verbose',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        prompt: Flags.string({
+            char: 'p',
+            description: 'Custom instructions for Dockerfile regeneration',
+            required: true,
+        }),
+        save: Flags.boolean({
+            default: false,
+            description: 'Save generated Dockerfile to current directory',
+        }),
+        slug: Flags.string({
+            char: 's',
+            default() {
+                if (existsSync('.hyperdrive.json')) {
+                    const hyperdriveConfig = JSON.parse(readFileSync('.hyperdrive.json', 'utf8'));
+                    return hyperdriveConfig.slug;
+                }
+                return '';
+            },
+            description: 'Module slug to reanalyze',
+            required: true,
+        }),
+        verbose: Flags.boolean({
+            char: 'v',
+            default: false,
+            description: 'Show detailed analysis progress and real-time logs',
+        }),
+        wait: Flags.boolean({
+            char: 'w',
+            default: true,
+            description: 'Wait for reanalysis to complete and show results',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DockerfileReanalyze);
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            this.log(chalk.blue(`🔄 Reanalyzing module ${chalk.cyan(flags.slug)}...`));
+            this.log(chalk.gray(`Custom instructions: ${chalk.italic(flags.prompt)}\n`));
+            if (flags.verbose) {
+                this.log(chalk.gray('📝 Verbose mode enabled - streaming real-time logs\n'));
+            }
+            const result = await service.moduleReanalyze(flags.slug, flags.prompt);
+            this.log(chalk.green(`✅ Reanalysis queued successfully!`));
+            this.log(chalk.gray(`   Job ID: ${result.jobId}`));
+            this.log(chalk.gray(`   Status: ${result.status}`));
+            if (flags.verbose && result.logging) {
+                this.log(chalk.gray(`   Project ID: ${result.projectId}`));
+            }
+            if (!flags.wait) {
+                this.log(chalk.yellow('\nUse --wait to poll for results, or check later with:'));
+                this.log(chalk.cyan(`   hyperdrive module dockerfile --slug ${flags.slug}`));
+                return;
+            }
+            // If verbose and API returned logging config, stream logs
+            if (flags.verbose && result.logging) {
+                await this.streamAnalysisLogs(result.logging, flags, service);
+            }
+            else {
+                // Fallback to polling
+                if (flags.verbose && !result.logging) {
+                    this.log(chalk.yellow('⚠️  Log streaming not available (API limitation), falling back to polling'));
+                }
+                this.log(chalk.blue('\n⏳ Waiting for reanalysis to complete...'));
+                this.log(chalk.gray('   This typically takes 2-5 minutes.\n'));
+                const dockerfile = await this.pollForDockerfile(service, flags.slug);
+                if (!dockerfile) {
+                    this.log(chalk.yellow('\n⚠️  Reanalysis is still in progress.'));
+                    this.log(chalk.gray('   Check back later with:'));
+                    this.log(chalk.cyan(`   hyperdrive module dockerfile --slug ${flags.slug}`));
+                    return;
+                }
+                await this.displayResults(dockerfile, flags);
+            }
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error(`Failed to reanalyze module ${flags.slug}`);
+        }
+    }
+    /**
+     * Build CloudWatch console URL for log viewing
+     */
+    buildConsoleUrl(config) {
+        const encodedGroup = encodeURIComponent(encodeURIComponent(config.logGroup));
+        const encodedStream = encodeURIComponent(encodeURIComponent(config.logStream));
+        return `https://${config.region}.console.aws.amazon.com/cloudwatch/home?region=${config.region}#logsV2:log-groups/log-group/${encodedGroup}/log-events/${encodedStream}`;
+    }
+    /**
+     * Display analysis results
+     */
+    async displayResults(dockerfile, flags) {
+        if (!dockerfile) {
+            this.log(chalk.yellow('\n⚠️  No Dockerfile found'));
+            return;
+        }
+        // Show results
+        this.log(chalk.green('\n✅ Dockerfile regenerated successfully!\n'));
+        if (dockerfile.analysis) {
+            this.log(chalk.blue('📊 Analysis Results:'));
+            this.log(chalk.gray(`   Runtime: ${dockerfile.analysis.detectedRuntime || 'unknown'}`));
+            this.log(chalk.gray(`   Framework: ${dockerfile.analysis.detectedFramework || 'unknown'}`));
+            if (dockerfile.analysis.port) {
+                this.log(chalk.gray(`   Port: ${dockerfile.analysis.port}`));
+            }
+            if (dockerfile.analysis.healthEndpoint) {
+                this.log(chalk.gray(`   Health: ${dockerfile.analysis.healthEndpoint}`));
+            }
+        }
+        this.log(chalk.blue('\n🐳 Validation Results:'));
+        this.log(chalk.gray(`   Build: ${dockerfile.buildSuccess ? chalk.green('✓ Success') : chalk.red('✗ Failed')}`));
+        this.log(chalk.gray(`   Run: ${dockerfile.runSuccess ? chalk.green('✓ Success') : chalk.red('✗ Failed')}`));
+        this.log(chalk.gray(`   Port: ${dockerfile.portOpen ? chalk.green('✓ Open') : chalk.red('✗ Closed')}`));
+        if (dockerfile.analysis?.recommendations?.length) {
+            this.log(chalk.blue('\n💡 Recommendations:'));
+            for (const rec of dockerfile.analysis.recommendations) {
+                this.log(chalk.gray(`   • ${rec}`));
+            }
+        }
+        this.log(chalk.blue('\n📄 Regenerated Dockerfile:'));
+        this.log(chalk.gray('─'.repeat(60)));
+        this.log(dockerfile.dockerfile);
+        this.log(chalk.gray('─'.repeat(60)));
+        if (flags.save) {
+            writeFileSync('Dockerfile', dockerfile.dockerfile);
+            this.log(chalk.green('\n✅ Dockerfile saved to ./Dockerfile'));
+            if (dockerfile.dockerignore) {
+                writeFileSync('.dockerignore', dockerfile.dockerignore);
+                this.log(chalk.green('✅ .dockerignore saved to ./.dockerignore'));
+            }
+        }
+        else {
+            this.log(chalk.gray('\nTip: Use --save to write files to current directory'));
+        }
+    }
+    /**
+     * Poll for Dockerfile (fallback when streaming not available)
+     */
+    async pollForDockerfile(service, slug, maxAttempts = 60, intervalMs = 5000) {
+        for (let i = 0; i < maxAttempts; i++) {
+            try {
+                const result = await service.moduleGetDockerfile(slug);
+                if (result) {
+                    return result;
+                }
+            }
+            catch {
+                // Not ready yet
+            }
+            // Show progress
+            process.stdout.write(chalk.gray('.'));
+            await new Promise(resolve => setTimeout(resolve, intervalMs));
+        }
+        return null;
+    }
+    /**
+     * Stream analysis logs using CloudWatch
+     */
+    async streamAnalysisLogs(loggingConfig, flags, service) {
+        const tailer = new CloudWatchLogTailer(loggingConfig, {
+            pollInterval: 1000,
+            showDebug: false,
+            verbose: true,
+        });
+        this.log('');
+        const outcome = await tailer.tail();
+        this.log('');
+        if (outcome.success) {
+            this.log(chalk.green(`✅ ${outcome.message}`));
+            // Show CloudWatch console link
+            const consoleUrl = this.buildConsoleUrl(loggingConfig);
+            this.log(chalk.gray(`   Logs: ${consoleUrl}`));
+            // Fetch generated Dockerfile
+            const dockerfile = await service.moduleGetDockerfile(flags.slug);
+            if (dockerfile) {
+                await this.displayResults(dockerfile, flags);
+            }
+            else {
+                this.log(chalk.yellow('\n⚠️  Dockerfile not found yet, may still be processing'));
+            }
+        }
+        else {
+            this.log(chalk.red(`❌ ${outcome.message}`));
+            // Show CloudWatch console link for debugging
+            const consoleUrl = this.buildConsoleUrl(loggingConfig);
+            this.log(chalk.gray(`   Full logs: ${consoleUrl}`));
+            this.exit(1);
+        }
+    }
+}

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

@@ -0,0 +1,27 @@
+import { Command } from '@oclif/core';
+export default class ModuleUpdate extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        buildCommand: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        buildDirectory: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        buildFolder: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        buildRuntime: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        buildRuntimeVersion: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        ciService: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        defaultBranch: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        deploymentStrategy: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        domain: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        framework: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        installCommand: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        routeDiscovery: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        runCommand: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        runtime: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        runtimeVersion: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        slug: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        sourceDirectory: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        sourceLocation: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/module/update.js

@@ -0,0 +1,102 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class ModuleUpdate extends Command {
+    static description = 'Update a module/project configuration';
+    static examples = [
+        '<%= 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"',
+    ];
+    static flags = {
+        buildCommand: Flags.string({
+            description: 'Build command',
+        }),
+        buildDirectory: Flags.string({
+            description: 'Build output directory (e.g., dist, build, .next) - where compiled artifacts are output',
+        }),
+        buildFolder: Flags.string({
+            description: 'Build folder',
+        }),
+        buildRuntime: Flags.string({
+            description: 'Build runtime for Dockerfile template selection',
+            options: ['nodejs', 'python', 'go', 'rust', 'java', 'dotnet', 'ruby'],
+        }),
+        buildRuntimeVersion: Flags.string({
+            description: 'Build runtime version (e.g., 20 for Node, 3.12 for Python)',
+        }),
+        ciService: Flags.string({
+            description: 'CI service used',
+            options: ['github-actions', 'gitlab-ci', 'circle-ci', 'jenkins'],
+        }),
+        defaultBranch: Flags.string({
+            description: 'Default git branch to branch from (e.g., main, master)',
+        }),
+        deploymentStrategy: Flags.string({
+            description: 'Deployment strategy: "serverless" for Serverless Framework deployment to Lambda',
+            options: ['serverless'],
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        framework: Flags.string({
+            description: 'Framework used',
+            options: ['express', 'fastify', 'koa', 'nextjs', 'react', 'vue', 'angular', 'svelte', 'flask', 'django', 'fastapi', 'gin', 'actix', 'spring', 'aspnet', 'rails', 'other'],
+        }),
+        installCommand: Flags.string({
+            description: 'Install command',
+        }),
+        name: Flags.string({
+            description: 'Name of the project',
+        }),
+        routeDiscovery: Flags.boolean({
+            allowNo: true,
+            description: 'Enable AI-powered route discovery for per-route Lambda functions',
+        }),
+        runCommand: Flags.string({
+            description: 'Run command',
+        }),
+        runtime: Flags.string({
+            char: 'r',
+            description: 'Runtime environment',
+            options: ['nodejs', 'python', 'go', 'rust', 'java', 'dotnet', 'ruby'],
+        }),
+        runtimeVersion: Flags.string({
+            char: 'v',
+            description: 'Runtime version (e.g., 20, 3.12, 1.21)',
+        }),
+        slug: Flags.string({
+            char: 's',
+            description: 'Module slug to update (required)',
+            required: true,
+        }),
+        sourceDirectory: Flags.string({
+            description: 'Source code directory (e.g., src, lib, . for root) - default: src for Lambda, . for static',
+        }),
+        sourceLocation: Flags.string({
+            description: 'Source location of the project',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ModuleUpdate);
+        const { slug, ...updateFields } = flags;
+        // Filter out undefined values
+        const updateData = Object.fromEntries(Object.entries(updateFields).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;
+        }
+        this.log(chalk.blue(`🔄 Updating module "${slug}"...`));
+        const service = new HyperdriveSigV4Service(flags.domain);
+        try {
+            const result = await service.moduleUpdate({ slug, ...updateData });
+            this.log(chalk.green('✅ Module updated successfully!'));
+            this.log(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error('An error occurred while updating the module');
+        }
+    }
+}

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

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