@hyperdrive.bot/cli 1.0.2

package/dist/commands/module/create.js

@@ -0,0 +1,498 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import open from 'open';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class ModuleCreate extends Command {
+    static description = 'Create a new project';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --name="New Project" --slug="project-slug"',
+        '<%= config.bin %> <%= command.id %> --name="API Service" --framework="Serverless Framework"',
+    ];
+    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)',
+        }),
+        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',
+        }),
+        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({
+            description: 'Runtime version (e.g., 20, 3.12, 1.21)',
+        }),
+        slug: Flags.string({
+            description: 'Slug of the project',
+        }),
+        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() {
+        this.log(chalk.green('🚀 Let\'s create a new Hyperdrive project!'));
+        const { flags } = await this.parse(ModuleCreate);
+        const responses = await this.promptUser(flags);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        const combinedData = { ...flags, ...responses };
+        try {
+            // Check if source location is a git URL and verify access
+            const sourceLocation = combinedData.sourceLocation;
+            const gitInfo = this.parseGitUrl(sourceLocation);
+            let gitConfig = {};
+            if (gitInfo) {
+                this.log(chalk.blue(`\n🔍 Checking access to ${gitInfo.provider} repository...`));
+                const accessResult = await service.gitCheckRepoAccess({
+                    provider: gitInfo.provider,
+                    repoUrl: sourceLocation,
+                });
+                if (!accessResult.hasAccess) {
+                    this.log(chalk.yellow(`\n⚠️  Hyperdrive doesn't have access to this repository.`));
+                    if (accessResult.needsInstallation) {
+                        const confirmConnect = await inquirer.prompt([{
+                                default: true,
+                                message: `Would you like to connect your ${gitInfo.provider === 'github' ? 'GitHub' : 'GitLab'} account?`,
+                                name: 'connect',
+                                type: 'confirm',
+                            }]);
+                        if (confirmConnect.connect) {
+                            // Initiate the auth flow
+                            const authResponse = await service.gitAuthInitiate(gitInfo.provider);
+                            this.log(chalk.yellow('\nOpening browser for authorization...'));
+                            this.log(chalk.gray(`If the browser doesn't open, visit: ${authResponse.installUrl}`));
+                            // Open the browser
+                            await open(authResponse.installUrl);
+                            this.log(chalk.gray('\nWaiting for authorization...'));
+                            this.log(chalk.gray('Press Enter after you\'ve completed the authorization in your browser.'));
+                            await inquirer.prompt([{
+                                    message: 'Press Enter to continue after authorizing...',
+                                    name: 'continue',
+                                }]);
+                            // Re-check access
+                            const recheckResult = await service.gitCheckRepoAccess({
+                                provider: gitInfo.provider,
+                                repoUrl: sourceLocation,
+                            });
+                            if (!recheckResult.hasAccess) {
+                                this.log(chalk.red('\n❌ Still no access to the repository.'));
+                                this.log(chalk.gray('Make sure you granted access to the repository during authorization.'));
+                                const continueAnyway = await inquirer.prompt([{
+                                        default: false,
+                                        message: 'Continue creating the module without git integration?',
+                                        name: 'continue',
+                                        type: 'confirm',
+                                    }]);
+                                if (!continueAnyway.continue) {
+                                    this.error('Module creation cancelled.');
+                                    return;
+                                }
+                            }
+                            else {
+                                this.log(chalk.green('✅ Repository access confirmed!'));
+                                // Note: gitProvider will be auto-detected from sourceLocation by the API
+                                // Installation will be resolved dynamically at deployment time
+                                gitConfig = {};
+                            }
+                        }
+                    }
+                }
+                else {
+                    this.log(chalk.green('✅ Repository access confirmed!'));
+                    // Note: gitProvider will be auto-detected from sourceLocation by the API
+                    // Installation will be resolved dynamically at deployment time
+                    gitConfig = {};
+                }
+            }
+            // Filter out undefined values and ensure all required fields are strings
+            const cleanedData = Object.fromEntries(Object.entries({ ...combinedData, ...gitConfig }).filter(([_, value]) => value !== undefined));
+            // Convert sourceLocation from SSH to HTTPS format (API requirement)
+            if (cleanedData.sourceLocation) {
+                cleanedData.sourceLocation = this.convertToHttpsUrl(cleanedData.sourceLocation);
+            }
+            // Add gitProvider based on the sourceLocation
+            if (gitInfo) {
+                cleanedData.gitProvider = gitInfo.provider;
+            }
+            const result = await service.moduleCreate(cleanedData);
+            writeFileSync('.hyperdrive.json', JSON.stringify(result, null, 2), 'utf8');
+            this.log(chalk.blue('✨ Project created successfully! Here are the details:'));
+            this.log(JSON.stringify(result, null, 2));
+            // Post-create: Offer Dockerfile generation
+            if (gitInfo && result.slug) {
+                await this.offerDockerfileGeneration(service, result.slug);
+            }
+        }
+        catch (error) {
+            console.log('Error:', error);
+            this.error('An error occurred while creating the project:');
+        }
+    }
+    /**
+     * Convert any git URL (SSH or HTTPS) to HTTPS format for the API
+     */
+    convertToHttpsUrl(url) {
+        if (!url)
+            return url;
+        // Already HTTPS
+        if (url.startsWith('https://')) {
+            return url.replace(/\.git$/, '');
+        }
+        // Convert SSH to HTTPS
+        if (url.startsWith('git@github.com:')) {
+            return url
+                .replace('git@github.com:', 'https://github.com/')
+                .replace(/\.git$/, '');
+        }
+        if (url.startsWith('git@gitlab.com:')) {
+            return url
+                .replace('git@gitlab.com:', 'https://gitlab.com/')
+                .replace(/\.git$/, '');
+        }
+        // Return as-is if unknown format
+        return url;
+    }
+    getDefaultBranch() {
+        try {
+            // Try to get current branch
+            const currentBranch = execSync('git branch --show-current', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+            if (currentBranch) {
+                return currentBranch;
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        try {
+            // Try to get default branch from remote
+            const remoteBranch = execSync('git symbolic-ref refs/remotes/origin/HEAD', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+            if (remoteBranch) {
+                return remoteBranch.replace('refs/remotes/origin/', '');
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        // Default fallback
+        return 'main';
+    }
+    getGitOrigin() {
+        try {
+            return execSync('git remote get-url origin', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Offer AI-powered Dockerfile generation after project creation
+     */
+    async offerDockerfileGeneration(service, slug) {
+        this.log('');
+        this.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        this.log(chalk.cyan('🤖 AI-Powered Dockerfile Generation'));
+        this.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        this.log('');
+        this.log(chalk.gray('Hyperdrive can analyze your repository and generate an'));
+        this.log(chalk.gray('optimized Dockerfile that is validated to actually work.'));
+        this.log('');
+        const confirmAnalyze = await inquirer.prompt([{
+                default: true,
+                message: chalk.yellow('Would you like to generate a Dockerfile for this project?'),
+                name: 'analyze',
+                type: 'confirm',
+            }]);
+        if (!confirmAnalyze.analyze) {
+            this.log(chalk.gray('Skipping Dockerfile generation. You can run it later with:'));
+            this.log(chalk.white(`  hyperdrive module analyze --slug ${slug}`));
+            return;
+        }
+        this.log('');
+        this.log(chalk.blue('🔍 Analyzing repository...'));
+        try {
+            const analyzeResult = await service.moduleAnalyze(slug);
+            this.log(chalk.green(`✅ Analysis queued! Job ID: ${analyzeResult.jobId}`));
+            this.log('');
+            this.log(chalk.gray('The AI is now:'));
+            this.log(chalk.gray('  1. Cloning your repository'));
+            this.log(chalk.gray('  2. Analyzing package.json, CI configs, and existing Dockerfiles'));
+            this.log(chalk.gray('  3. Generating an optimized multi-stage Dockerfile'));
+            this.log(chalk.gray('  4. Building and testing the image to verify it works'));
+            this.log('');
+            // Ask if they want to wait for the result
+            const confirmWait = await inquirer.prompt([{
+                    default: false,
+                    message: chalk.yellow('Would you like to wait for the Dockerfile to be generated? (This may take a few minutes)'),
+                    name: 'wait',
+                    type: 'confirm',
+                }]);
+            if (confirmWait.wait) {
+                await this.pollDockerfileStatus(service, slug);
+            }
+            else {
+                this.log('');
+                this.log(chalk.gray('You can check the status later with:'));
+                this.log(chalk.white(`  hyperdrive module dockerfile --slug ${slug}`));
+            }
+        }
+        catch (error) {
+            this.log(chalk.yellow(`⚠️  Could not start Dockerfile analysis: ${error.message}`));
+            this.log(chalk.gray('You can try again later with:'));
+            this.log(chalk.white(`  hyperdrive module analyze --slug ${slug}`));
+        }
+    }
+    parseGitUrl(url) {
+        if (!url)
+            return null;
+        // Handle SSH URLs (git@github.com:owner/repo.git)
+        if (url.startsWith('git@')) {
+            const githubMatch = url.match(/git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
+            if (githubMatch) {
+                return { owner: githubMatch[1], provider: 'github', repo: githubMatch[2] };
+            }
+            const gitlabMatch = url.match(/git@gitlab\.com:([^/]+)\/(.+?)(?:\.git)?$/);
+            if (gitlabMatch) {
+                return { owner: gitlabMatch[1], provider: 'gitlab', repo: gitlabMatch[2] };
+            }
+            return null;
+        }
+        // Handle HTTPS URLs
+        try {
+            const parsed = new URL(url);
+            if (parsed.hostname === 'github.com' || parsed.hostname === 'www.github.com') {
+                const pathParts = parsed.pathname.replace(/^\//, '').replace(/\.git$/, '').split('/');
+                if (pathParts.length >= 2) {
+                    return { owner: pathParts[0], provider: 'github', repo: pathParts[1] };
+                }
+            }
+            if (parsed.hostname === 'gitlab.com' || parsed.hostname === 'www.gitlab.com') {
+                const pathParts = parsed.pathname.replace(/^\//, '').replace(/\.git$/, '').split('/');
+                if (pathParts.length >= 2) {
+                    return { owner: pathParts[0], provider: 'gitlab', repo: pathParts.slice(1).join('/') };
+                }
+            }
+        }
+        catch {
+            // Not a valid URL
+        }
+        return null;
+    }
+    /**
+     * Poll for Dockerfile generation status
+     */
+    async pollDockerfileStatus(service, slug) {
+        this.log('');
+        this.log(chalk.blue('⏳ Waiting for Dockerfile generation...'));
+        const maxAttempts = 60; // 5 minutes with 5s intervals
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            attempts++;
+            try {
+                const result = await service.moduleGetDockerfile(slug);
+                if (result) {
+                    this.log('');
+                    this.log(chalk.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+                    this.log(chalk.green('✅ Dockerfile Generated Successfully!'));
+                    this.log(chalk.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+                    this.log('');
+                    if (result.validated) {
+                        this.log(chalk.green('🎉 The Dockerfile has been validated:'));
+                        this.log(chalk.gray(`   • Build: ${result.buildSuccess ? '✅ Passed' : '❌ Failed'}`));
+                        this.log(chalk.gray(`   • Run: ${result.runSuccess ? '✅ Passed' : '❌ Failed'}`));
+                        this.log(chalk.gray(`   • Port ${result.analysis?.port || 3000}: ${result.portOpen ? '✅ Open' : '❌ Not responding'}`));
+                    }
+                    else {
+                        this.log(chalk.yellow('⚠️  The Dockerfile was generated but validation is pending.'));
+                    }
+                    this.log('');
+                    this.log(chalk.blue('Analysis:'));
+                    this.log(chalk.gray(`   • Runtime: ${result.analysis?.detectedRuntime || 'unknown'}`));
+                    this.log(chalk.gray(`   • Framework: ${result.analysis?.detectedFramework || 'unknown'}`));
+                    this.log(chalk.gray(`   • Port: ${result.analysis?.port || 'unknown'}`));
+                    if (result.analysis?.recommendations?.length) {
+                        this.log('');
+                        this.log(chalk.blue('Recommendations:'));
+                        for (const rec of result.analysis.recommendations) {
+                            this.log(chalk.gray(`   • ${rec}`));
+                        }
+                    }
+                    this.log('');
+                    this.log(chalk.gray('To view the full Dockerfile, run:'));
+                    this.log(chalk.white(`  hyperdrive module dockerfile --slug ${slug}`));
+                    return;
+                }
+            }
+            catch {
+                // Dockerfile not ready yet, continue polling
+            }
+            // Wait 5 seconds before next attempt
+            await new Promise(resolve => setTimeout(resolve, 5000));
+            process.stdout.write('.');
+        }
+        this.log('');
+        this.log(chalk.yellow('⏱️  Dockerfile generation is taking longer than expected.'));
+        this.log(chalk.gray('You can check the status later with:'));
+        this.log(chalk.white(`  hyperdrive module dockerfile --slug ${slug}`));
+    }
+    async promptUser(flags) {
+        const prompts = [];
+        if (!flags.name) {
+            prompts.push({
+                message: chalk.yellow('📛 Enter the project name:'),
+                name: 'name',
+                validate: (input) => Boolean(input) || 'Project name is required.',
+            });
+        }
+        if (!flags.slug) {
+            prompts.push({
+                default: () => this.suggestSlug(),
+                message: chalk.yellow('🔗 Enter the project slug:'),
+                name: 'slug',
+            });
+        }
+        if (!flags.sourceLocation) {
+            prompts.push({
+                default: () => this.getGitOrigin(),
+                message: chalk.yellow('🗂️ Where is the source code located?'),
+                name: 'sourceLocation',
+            });
+        }
+        if (!flags.defaultBranch) {
+            prompts.push({
+                default: () => this.getDefaultBranch(),
+                message: chalk.yellow('🌿 What is the default branch to create stage branches from?'),
+                name: 'defaultBranch',
+                validate: (input) => Boolean(input) || 'Default branch is required.',
+            });
+        }
+        if (!flags.runtime) {
+            prompts.push({
+                choices: [
+                    { name: 'Node.js', value: 'nodejs' },
+                    { name: 'Python', value: 'python' },
+                    { name: 'Go', value: 'go' },
+                    { name: 'Rust', value: 'rust' },
+                    { name: 'Java', value: 'java' },
+                    { name: '.NET', value: 'dotnet' },
+                    { name: 'Ruby', value: 'ruby' },
+                ],
+                default: 'nodejs',
+                message: chalk.yellow('⚡ What is the runtime?'),
+                name: 'runtime',
+                type: 'list',
+            });
+        }
+        if (!flags.runtimeVersion) {
+            prompts.push({
+                default: '20',
+                message: chalk.yellow('📦 What runtime version? (e.g., 20 for Node, 3.12 for Python)'),
+                name: 'runtimeVersion',
+            });
+        }
+        if (!flags.buildRuntime) {
+            prompts.push({
+                choices: [
+                    { name: 'Node.js', value: 'nodejs' },
+                    { name: 'Python', value: 'python' },
+                    { name: 'Go', value: 'go' },
+                    { name: 'Rust', value: 'rust' },
+                    { name: 'Java', value: 'java' },
+                    { name: '.NET', value: 'dotnet' },
+                    { name: 'Ruby', value: 'ruby' },
+                ],
+                default: 'nodejs',
+                message: chalk.yellow('🐳 What build runtime should be used for the Docker template?'),
+                name: 'buildRuntime',
+                type: 'list',
+            });
+        }
+        if (!flags.framework) {
+            prompts.push({
+                choices: [
+                    { name: 'Express.js', value: 'express' },
+                    { name: 'Fastify', value: 'fastify' },
+                    { name: 'Koa', value: 'koa' },
+                    { name: 'Next.js', value: 'nextjs' },
+                    { name: 'React', value: 'react' },
+                    { name: 'Vue', value: 'vue' },
+                    { name: 'Angular', value: 'angular' },
+                    { name: 'Svelte', value: 'svelte' },
+                    { name: 'Flask', value: 'flask' },
+                    { name: 'Django', value: 'django' },
+                    { name: 'FastAPI', value: 'fastapi' },
+                    { name: 'Gin (Go)', value: 'gin' },
+                    { name: 'Actix (Rust)', value: 'actix' },
+                    { name: 'Spring (Java)', value: 'spring' },
+                    { name: 'ASP.NET', value: 'aspnet' },
+                    { name: 'Rails', value: 'rails' },
+                    { name: 'Other', value: 'other' },
+                ],
+                message: chalk.yellow('🏗️ What is the framework?'),
+                name: 'framework',
+                type: 'list',
+            });
+        }
+        if (!flags.buildCommand) {
+            prompts.push({
+                message: chalk.yellow('🔨 What is the build command?'),
+                name: 'buildCommand',
+            });
+        }
+        if (!flags.runCommand) {
+            prompts.push({
+                message: chalk.yellow('🚀 What is the command to run the application in production/live environments?'),
+                name: 'runCommand',
+            });
+        }
+        return inquirer.prompt(prompts);
+    }
+    suggestSlug() {
+        const packagePath = join(process.cwd(), 'package.json');
+        if (existsSync(packagePath)) {
+            const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
+            return packageJson.name.replaceAll(/[^\dA-Za-z-]/g, '-').toLowerCase();
+        }
+        return basename(process.cwd()).replaceAll(/[^\dA-Za-z-]/g, '-').toLowerCase();
+    }
+}

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

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class ModuleDestroy 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>;
+        force: 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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/module/destroy.js

@@ -0,0 +1,77 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { existsSync, readFileSync } from 'node:fs';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class ModuleDestroy extends Command {
+    static description = 'Destroy/delete a module permanently';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --slug="my-module"',
+        '<%= config.bin %> <%= command.id %> --slug="old-project" --force',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Skip confirmation prompt (DANGEROUS)',
+        }),
+        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 destroy',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ModuleDestroy);
+        if (!flags.force) {
+            this.log(chalk.red('⚠️  WARNING: This will permanently DELETE the module and all its data!'));
+            this.log(chalk.red('⚠️  This action CANNOT be undone!'));
+            const typeConfirmation = await inquirer.prompt([
+                {
+                    message: chalk.red('Type the module slug to confirm deletion:'),
+                    name: 'confirmSlug',
+                    validate: (input) => input === flags.slug || `You must type "${flags.slug}" to confirm`,
+                },
+            ]);
+            if (typeConfirmation.confirmSlug !== flags.slug) {
+                this.log(chalk.yellow('Operation cancelled.'));
+                return;
+            }
+            const confirmation = await inquirer.prompt([
+                {
+                    default: false,
+                    message: chalk.red(`Are you ABSOLUTELY SURE you want to destroy module ${chalk.cyan(flags.slug)}?`),
+                    name: 'confirm',
+                    type: 'confirm',
+                },
+            ]);
+            if (!confirmation.confirm) {
+                this.log(chalk.yellow('Operation cancelled.'));
+                return;
+            }
+        }
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            this.log(chalk.blue('🗑️  Destroying module...'));
+            await service.moduleDestroy({
+                slug: flags.slug,
+            });
+            this.log(chalk.green(`✅ Module ${flags.slug} destroyed successfully!`));
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error('An error occurred while destroying the module');
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class ModuleGet 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>;
+        slug: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/module/get.js

@@ -0,0 +1,43 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'node:fs';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class ModuleGet extends Command {
+    static description = 'Get details of a specific module/project';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --slug="my-module"',
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        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 get details for',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ModuleGet);
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            this.log(chalk.blue(`🔍 Fetching module ${chalk.cyan(flags.slug)}...`));
+            const module = await service.moduleGet({ slug: flags.slug });
+            this.log(chalk.green('✅ Module details:\n'));
+            this.log(JSON.stringify(module, null, 2));
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error(`An error occurred while fetching module ${flags.slug}`);
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class ModuleLink 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>;
+        originSlug: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        parameter: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[], import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        targetSlug: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    confirmDeploymentBehavior(): Promise<any>;
+    prompt(): Promise<void>;
+    promptForEnvironmentVariables(): Promise<string[]>;
+    run(): Promise<void>;
+}