@hyperdrive.bot/cli 1.0.13 → 1.0.16

package/dist/commands/deploy.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class Deploy extends Command {
+    static args: {
+        directory: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        commit: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        moduleSlug: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        spa: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        stage: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/deploy.js

@@ -0,0 +1,239 @@
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import moment from 'moment';
+import { lookup } from 'mime-types';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../services/hyperdrive-sigv4.js';
+import { retryWithBackoff } from '../utils/retry.js';
+// Validation limits — must match server-side constants in static-deployments.ts
+const MAX_FILE_COUNT = 10_000;
+const MAX_TOTAL_SIZE_BYTES = 500 * 1024 * 1024; // 500 MB
+const MAX_SINGLE_FILE_BYTES = 50 * 1024 * 1024; // 50 MB
+/**
+ * Recursively walk a directory and return all file paths.
+ * Skips hidden files/directories (starting with .)
+ * Rejects paths containing '..' (path traversal)
+ */
+function walkDir(dir, baseDir) {
+    const results = [];
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        // Skip hidden files and directories
+        if (entry.name.startsWith('.'))
+            continue;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...walkDir(fullPath, baseDir));
+        }
+        else if (entry.isFile()) {
+            const relativePath = relative(baseDir, fullPath);
+            // Reject path traversal
+            if (relativePath.includes('..'))
+                continue;
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(0)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+export default class Deploy extends Command {
+    static args = {
+        directory: Args.string({
+            description: 'Path to the directory to deploy',
+            required: true,
+        }),
+    };
+    static description = 'Deploy a static site to Hyperdrive (S3 + CloudFront)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> ./my-site --type static --stage dev --moduleSlug my-demo',
+        '<%= config.bin %> <%= command.id %> ./dist --type static --stage dev -m my-app --name "Release v1.0"',
+    ];
+    static flags = {
+        commit: Flags.string({
+            char: 'c',
+            default: 'static',
+            description: 'Commit reference (default: "static")',
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        moduleSlug: Flags.string({
+            char: 'm',
+            default() {
+                if (existsSync('.hyperdrive.json')) {
+                    const hyperdriveConfig = JSON.parse(readFileSync('.hyperdrive.json', 'utf8'));
+                    return hyperdriveConfig.slug;
+                }
+                return '';
+            },
+            description: 'Module slug',
+            required: true,
+        }),
+        name: Flags.string({
+            char: 'n',
+            default: `Deployment-${moment().format('YYYY-MM-DD-HH-mm-ss')}`,
+            description: 'Deployment name (auto-generated if omitted)',
+        }),
+        spa: Flags.boolean({
+            default: false,
+            description: 'Enable SPA routing mode — returns index.html for 404 paths',
+        }),
+        stage: Flags.string({
+            char: 's',
+            description: 'Target stage',
+            required: true,
+        }),
+        type: Flags.string({
+            char: 't',
+            default: 'static',
+            description: 'Deployment type',
+            options: ['static'],
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Deploy);
+        const dir = args.directory;
+        // 1. Validate directory exists
+        if (!existsSync(dir)) {
+            this.error(`Directory not found: ${dir}`);
+        }
+        // 2. Validate index.html exists at root
+        if (!existsSync(join(dir, 'index.html'))) {
+            this.error(`No index.html found in ${dir}`);
+        }
+        // 3. Walk directory and build file manifest
+        const filePaths = walkDir(dir, dir);
+        const files = filePaths.map((f) => {
+            const relativePath = relative(dir, f);
+            const size = statSync(f).size;
+            const contentType = lookup(relativePath) || 'application/octet-stream';
+            return { contentType, localPath: f, path: relativePath, size };
+        });
+        const totalSize = files.reduce((sum, f) => sum + f.size, 0);
+        this.log(chalk.blue(`\n📦 Static deployment: ${flags.moduleSlug} → ${flags.stage}`));
+        this.log(chalk.gray(`   Found ${files.length} files (${formatBytes(totalSize)})`));
+        this.log('');
+        // Pre-flight validation — catch limit violations before making the API call
+        if (files.length > MAX_FILE_COUNT) {
+            this.error(`File count ${files.length} exceeds maximum of ${MAX_FILE_COUNT}`);
+        }
+        if (totalSize > MAX_TOTAL_SIZE_BYTES) {
+            this.error(`Total size ${formatBytes(totalSize)} exceeds maximum of ${formatBytes(MAX_TOTAL_SIZE_BYTES)}`);
+        }
+        const oversizedFiles = files.filter(f => f.size > MAX_SINGLE_FILE_BYTES);
+        if (oversizedFiles.length > 0) {
+            const offenders = oversizedFiles.map(f => `${f.path} (${formatBytes(f.size)})`).join(', ');
+            this.error(`File(s) exceed maximum size of ${formatBytes(MAX_SINGLE_FILE_BYTES)}: ${offenders}`);
+        }
+        const traversalPaths = files.filter(f => f.path.includes('..'));
+        if (traversalPaths.length > 0) {
+            const offenders = traversalPaths.map(f => f.path).join(', ');
+            this.error(`Path traversal detected in file path(s): ${offenders}`);
+        }
+        const absolutePaths = files.filter(f => f.path.startsWith('/'));
+        if (absolutePaths.length > 0) {
+            const offenders = absolutePaths.map(f => f.path).join(', ');
+            this.error(`Absolute path(s) not allowed: ${offenders}`);
+        }
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            // 4. Create static deployment (get presigned URLs)
+            const createSpinner = ora('Creating deployment and generating upload URLs...').start();
+            const { deploymentId, uploadUrls } = await service.deploymentCreateStatic({
+                commit: flags.commit,
+                deploymentName: flags.name,
+                files: files.map((f) => ({ contentType: f.contentType, path: f.path, size: f.size })),
+                projectSlug: flags.moduleSlug,
+                stage: flags.stage,
+            });
+            createSpinner.succeed('Deployment created');
+            // 5. Upload files in parallel via presigned URLs with retry
+            const uploadSpinner = ora(`Uploading files... 0/${files.length}`).start();
+            const urlMap = new Map(uploadUrls.map((u) => [u.path, u.url]));
+            let uploaded = 0;
+            let retriedCount = 0;
+            /**
+             * Upload a single file to its presigned URL.
+             * Throws on HTTP errors to let retryWithBackoff classify them.
+             */
+            const uploadFile = async (localPath, url, contentType) => {
+                const body = readFileSync(localPath);
+                const response = await fetch(url, {
+                    body,
+                    headers: { 'Content-Type': contentType },
+                    method: 'PUT',
+                });
+                if (!response.ok) {
+                    const err = new Error(`Upload failed: HTTP ${response.status}`);
+                    err.status = response.status;
+                    throw err;
+                }
+            };
+            const results = await Promise.all(files.map(async (entry) => {
+                const url = urlMap.get(entry.path);
+                if (!url) {
+                    return { attempts: 0, error: 'No presigned URL received', path: entry.path, success: false };
+                }
+                try {
+                    const { attempts } = await retryWithBackoff(() => uploadFile(entry.localPath, url, entry.contentType), { backoffMultiplier: 2, baseDelayMs: 1000, maxRetries: 3 });
+                    uploaded++;
+                    if (attempts > 1)
+                        retriedCount++;
+                    uploadSpinner.text = `Uploading files... ${uploaded}/${files.length}`;
+                    return { attempts, path: entry.path, success: true };
+                }
+                catch (error) {
+                    const errMsg = error instanceof Error ? error.message : String(error);
+                    return { attempts: 4, error: errMsg, path: entry.path, success: false };
+                }
+            }));
+            const failedResults = results.filter((r) => !r.success);
+            if (failedResults.length > 0) {
+                uploadSpinner.fail(`Upload failed for ${failedResults.length} file(s) after retries`);
+                for (const item of failedResults) {
+                    this.log(chalk.red(`   ${item.path}: ${item.error}`));
+                }
+                this.exit(1);
+            }
+            const successMsg = retriedCount > 0
+                ? `Uploaded ${uploaded}/${files.length} files (${retriedCount} required retries)`
+                : `Uploaded ${uploaded}/${files.length} files`;
+            uploadSpinner.succeed(successMsg);
+            // 6. Finalize deployment
+            const finalizeSpinner = ora('Finalizing deployment...').start();
+            const { url } = await service.deploymentFinalizeStatic(deploymentId, { spa: flags.spa });
+            finalizeSpinner.succeed('CloudFront invalidation created');
+            this.log('');
+            this.log(chalk.green(`✅ Deployed to ${chalk.cyan(url)}`));
+            this.log(chalk.gray(`   Deployment: ${flags.name}`));
+        }
+        catch (error) {
+            const err = error;
+            // Ignore EEXIT with code 0 - oclif clean exit
+            if (err.message?.includes('EEXIT') && err.oclif?.exit === 0) {
+                return;
+            }
+            if (err.response?.status === 400) {
+                this.log(chalk.red(`❌ ${err.response.data || err.message}`));
+                this.log(chalk.gray('   Hint: ensure the module is configured for static deployment'));
+                this.log(chalk.gray('   Run: hd module update <slug> --deploymentStrategy static'));
+            }
+            else if (err.response?.status === 404) {
+                this.log(chalk.red(`❌ Project or stage not found: ${err.response.data || err.message}`));
+            }
+            else {
+                this.log(chalk.red(`❌ Error: ${err.message}`));
+            }
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/deployment/create.js

@@ -80,14 +80,22 @@ export default class DeploymentCreate extends Command {
         this.log('');
         try {
             const service = new HyperdriveSigV4Service(flags.domain);
-            const result = await service.deploymentCreate({
+            // Fetch module to get moduleType (for CDK detection optimization)
+            const module = await service.moduleGet({ slug: flags.moduleSlug });
+            const moduleType = module.moduleType;
+            const deploymentPayload = {
                 commit: flags.commit,
                 launch: flags.launch,
                 name: flags.name,
                 projectSlug: flags.moduleSlug, // API still expects projectSlug (backend terminology)
                 regions: flags.regions,
                 stage: flags.stage,
-            });
+            };
+            // Include moduleType only when present (omit for legacy modules → builder auto-detects)
+            if (moduleType) {
+                deploymentPayload.moduleType = moduleType;
+            }
+            const result = await service.deploymentCreate(deploymentPayload);
             // Check if API returned logging config (for real-time streaming)
             const loggingConfig = result.logging;
             if (flags.noStream || !loggingConfig) {

package/dist/commands/domain/{switch.d.ts → set-production.d.ts}

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-export default class DomainSwitch extends Command {
+export default class DomainSetProduction extends Command {
     static args: {
         domain: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };

package/dist/commands/domain/set-production.js

@@ -0,0 +1,27 @@
+import { Args, Command } from '@oclif/core';
+import chalk from 'chalk';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class DomainSetProduction extends Command {
+    static args = {
+        domain: Args.string({
+            description: 'The production domain to register (e.g. acme.com)',
+            required: true,
+        }),
+    };
+    static description = 'Set or update the production domain for the current tenant';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> acme.com',
+    ];
+    async run() {
+        const { args } = await this.parse(DomainSetProduction);
+        const api = new HyperdriveSigV4Service();
+        this.log(chalk.gray(`Setting production domain to ${chalk.cyan(args.domain)}...`));
+        const result = await api.domainSetProduction({ domain: args.domain });
+        this.log('');
+        this.log(chalk.green(`Production domain set: ${chalk.cyan(result.domain)}`));
+        this.log(chalk.gray(`  Status: ${result.status}`));
+        this.log(chalk.gray(`  Tenant: ${result.tenantId}`));
+        this.log('');
+        this.log(chalk.gray('DNS validation will begin automatically. Check status with `hd domain current`.'));
+    }
+}

package/dist/commands/git/list-open-prs.d.ts

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

package/dist/commands/git/list-open-prs.js

@@ -0,0 +1,87 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { getProviderByName } from '../../lib/git-providers/index.js';
+import { printTable } from '../../utils/table.js';
+export default class ListOpenPrs extends Command {
+    static description = 'List open pull requests (GitHub) or merge requests (GitLab) for a repository';
+    static examples = [
+        '<%= config.bin %> git list-open-prs --provider=github --repo=devsquad/super-repo',
+        '<%= config.bin %> git list-open-prs --provider=gitlab --repo=dev_squad/repo/web-apps/sign',
+        '<%= config.bin %> git list-open-prs --provider=github --repo=devsquad/super-repo --json',
+        '<%= config.bin %> git list-open-prs --provider=gitlab --repo=dev_squad/repo/web-apps/sign --token=glpat-xxx',
+    ];
+    static flags = {
+        json: Flags.boolean({
+            default: false,
+            description: 'Output in JSON format',
+        }),
+        provider: Flags.string({
+            char: 'p',
+            description: 'Git provider',
+            options: ['github', 'gitlab'],
+            required: true,
+        }),
+        repo: Flags.string({
+            char: 'r',
+            description: 'Repository (owner/repo for GitHub, project path for GitLab)',
+            required: true,
+        }),
+        token: Flags.string({
+            char: 't',
+            description: 'API token (overrides GITHUB_TOKEN / GITLAB_TOKEN env var)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ListOpenPrs);
+        const provider = getProviderByName(flags.provider);
+        const providerLabel = flags.provider === 'github' ? 'GitHub PRs' : 'GitLab MRs';
+        try {
+            const pullRequests = await provider.listOpenPullRequests({
+                repo: flags.repo,
+                token: flags.token,
+            });
+            if (flags.json) {
+                this.log(JSON.stringify(pullRequests, null, 2));
+                return;
+            }
+            if (pullRequests.length === 0) {
+                this.log(chalk.yellow(`\nNo open ${providerLabel} found for ${flags.repo}`));
+                return;
+            }
+            this.log(chalk.blue(`\nOpen ${providerLabel} for ${chalk.bold(flags.repo)} (${pullRequests.length}):\n`));
+            const tableData = pullRequests.map(pr => ({
+                author: pr.author,
+                number: pr.number,
+                sourceBranch: pr.sourceBranch,
+                title: pr.title,
+                url: pr.url,
+            }));
+            printTable(tableData, {
+                number: {
+                    header: '#',
+                    get: (row) => chalk.cyan(String(row.number)),
+                },
+                title: {
+                    header: 'Title',
+                    get: (row) => row.title.length > 60 ? `${row.title.slice(0, 57)}...` : row.title,
+                },
+                sourceBranch: {
+                    header: 'Branch',
+                    get: (row) => chalk.green(row.sourceBranch),
+                },
+                author: {
+                    header: 'Author',
+                    get: (row) => chalk.gray(row.author),
+                },
+                url: {
+                    header: 'URL',
+                    get: (row) => chalk.gray(row.url),
+                },
+            }, (msg) => this.log(msg));
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.error(`Failed to list open ${providerLabel}: ${errorMessage}`);
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+import { Command } from '@oclif/core';
+export default class HookAdd extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'action-config': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'action-type': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        conditions: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        cron: 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>;
+        event: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'flexible-window': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        order: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        timezone: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private handleApiError;
+    private printSuccess;
+    private runInteractive;
+    private runNonInteractive;
+}