genbox 1.0.0

package/dist/importer.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importLegacyScript = importLegacyScript;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+function importLegacyScript(scriptPath, outputDir) {
+    console.log(chalk_1.default.blue(`Importing legacy script: ${scriptPath}`));
+    const content = fs.readFileSync(scriptPath, 'utf-8');
+    const extractedScripts = [];
+    const extractedFiles = [];
+    // Regex to find write_files blocks
+    // Matches: - path: <path>\n ... content: |\n<content>
+    // We'll capture path and content until the next indentation change or list item
+    // This is a heuristic parser.
+    const fileRegex = /-\s+path: ([\w/.-]+)\s+(?:permissions: '(\d+)'\s+)?(?:owner: [\w:]+\s+)?(?:defer: \w+\s+)?content: \|\n((?: {6,}.*\n)+)/g;
+    let match;
+    while ((match = fileRegex.exec(content)) !== null) {
+        const remotePath = match[1];
+        const permissions = match[2];
+        const rawBody = match[3];
+        const fileName = path.basename(remotePath);
+        // De-indent
+        // Find base indentation of first line
+        const firstLineParams = rawBody.match(/^(\s+)/);
+        const indent = firstLineParams ? firstLineParams[1].length : 0;
+        const cleanBody = rawBody.split('\n').map(line => {
+            if (line.trim() === '')
+                return '';
+            return line.substring(indent);
+        }).join('\n');
+        // Determine destination
+        let localSubDir = 'files';
+        if (fileName.endsWith('.sh')) {
+            localSubDir = 'scripts';
+        }
+        const localDir = path.join(outputDir, localSubDir);
+        if (!fs.existsSync(localDir)) {
+            fs.mkdirSync(localDir, { recursive: true });
+        }
+        const localPath = path.join(localDir, fileName);
+        fs.writeFileSync(localPath, cleanBody);
+        console.log(chalk_1.default.dim(`  Extracted ${fileName}`));
+        const relativeLocalPath = path.join(localSubDir, fileName);
+        if (localSubDir === 'scripts') {
+            // We'll add this to scripts if it looks like a setup script
+            // For parity, the script runs specific ones.
+            // setup-goodpass.sh is main. install-caddy.sh is aux.
+            // We'll add all .sh files to 'files' bundle, and user can choose which to RUN in 'scripts' config.
+            // Wait, genbox config 'scripts' are executed. 'files' are just placed.
+            // The legacy script executed 'install-caddy.sh' then 'setup-goodpass.sh'.
+            // We should treat them as files first.
+        }
+        extractedFiles.push({
+            source: relativeLocalPath,
+            target: remotePath,
+            permissions: permissions || '0644'
+        });
+        if (fileName === 'setup-goodpass.sh') {
+            extractedScripts.push(relativeLocalPath); // Mark for execution
+        }
+        else if (fileName === 'install-caddy.sh') {
+            extractedScripts.push(relativeLocalPath);
+        }
+    }
+    return { scripts: extractedScripts, files: extractedFiles };
+}

package/dist/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_1 = require("./commands/init");
+const program = new commander_1.Command();
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { version } = require('../package.json');
+program
+    .name('genbox')
+    .description('Genbox CLI - AI-Powered Development Environments')
+    .version(version, '-v, --version', 'Output the current version');
+const create_1 = require("./commands/create");
+const list_1 = require("./commands/list");
+const destroy_1 = require("./commands/destroy");
+const connect_1 = require("./commands/connect");
+const balance_1 = require("./commands/balance");
+const login_1 = require("./commands/login");
+const urls_1 = require("./commands/urls");
+const push_1 = require("./commands/push");
+const status_1 = require("./commands/status");
+const forward_1 = require("./commands/forward");
+const restore_db_1 = require("./commands/restore-db");
+const help_1 = require("./commands/help");
+program
+    .addCommand(init_1.initCommand)
+    .addCommand(create_1.createCommand)
+    .addCommand(list_1.listCommand)
+    .addCommand(destroy_1.destroyCommand)
+    .addCommand(connect_1.connectCommand)
+    .addCommand(balance_1.balanceCommand)
+    .addCommand(login_1.loginCommand)
+    .addCommand(urls_1.urlsCommand)
+    .addCommand(push_1.pushCommand)
+    .addCommand(status_1.statusCommand)
+    .addCommand(forward_1.forwardCommand)
+    .addCommand(restore_db_1.restoreDbCommand)
+    .addCommand(help_1.helpCommand);
+program.parse(process.argv);

package/dist/scan.js

@@ -0,0 +1,247 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectSshKeys = detectSshKeys;
+exports.getGitUrlType = getGitUrlType;
+exports.sshToHttps = sshToHttps;
+exports.httpsToSsh = httpsToSsh;
+exports.scanProject = scanProject;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+/**
+ * Detect available SSH keys in ~/.ssh/
+ */
+function detectSshKeys() {
+    const sshDir = path.join(os.homedir(), '.ssh');
+    const keys = [];
+    if (!fs.existsSync(sshDir)) {
+        return keys;
+    }
+    const files = fs.readdirSync(sshDir);
+    // Common private key patterns (not .pub files)
+    const keyPatterns = [
+        { pattern: /^id_rsa$/, type: 'rsa' },
+        { pattern: /^id_ed25519$/, type: 'ed25519' },
+        { pattern: /^id_ecdsa$/, type: 'ecdsa' },
+        { pattern: /^.*_rsa$/, type: 'rsa' },
+        { pattern: /^.*_ed25519$/, type: 'ed25519' },
+        { pattern: /^.*_github$/, type: 'other' },
+        { pattern: /^github$/, type: 'other' },
+    ];
+    for (const file of files) {
+        // Skip public keys and known non-key files
+        if (file.endsWith('.pub') || file === 'known_hosts' || file === 'config' || file === 'authorized_keys') {
+            continue;
+        }
+        const filePath = path.join(sshDir, file);
+        // Check if it's a file (not directory)
+        try {
+            const stat = fs.statSync(filePath);
+            if (!stat.isFile())
+                continue;
+            // Try to read first line to verify it's a private key
+            const content = fs.readFileSync(filePath, 'utf8').substring(0, 100);
+            if (!content.includes('PRIVATE KEY') && !content.includes('OPENSSH')) {
+                continue;
+            }
+            // Determine key type
+            let keyType = 'other';
+            for (const { pattern, type } of keyPatterns) {
+                if (pattern.test(file)) {
+                    keyType = type;
+                    break;
+                }
+            }
+            keys.push({
+                path: filePath,
+                name: file,
+                type: keyType,
+            });
+        }
+        catch (e) {
+            // Skip files we can't read
+        }
+    }
+    return keys;
+}
+/**
+ * Check if a URL is SSH or HTTPS
+ */
+function getGitUrlType(url) {
+    if (url.startsWith('git@') || url.startsWith('ssh://')) {
+        return 'ssh';
+    }
+    return 'https';
+}
+/**
+ * Convert SSH URL to HTTPS URL
+ */
+function sshToHttps(sshUrl) {
+    // git@github.com:user/repo.git -> https://github.com/user/repo.git
+    const match = sshUrl.match(/^git@([^:]+):(.+)$/);
+    if (match) {
+        return `https://${match[1]}/${match[2]}`;
+    }
+    return sshUrl;
+}
+/**
+ * Convert HTTPS URL to SSH URL
+ */
+function httpsToSsh(httpsUrl) {
+    // https://github.com/user/repo.git -> git@github.com:user/repo.git
+    const match = httpsUrl.match(/^https?:\/\/([^/]+)\/(.+)$/);
+    if (match) {
+        return `git@${match[1]}:${match[2]}`;
+    }
+    return httpsUrl;
+}
+/**
+ * Detect port from various project files
+ */
+function detectPort(root) {
+    // 1. Check .env or .env.local for PORT
+    const envFiles = ['.env.local', '.env', '.env.development'];
+    for (const envFile of envFiles) {
+        const envPath = path.join(root, envFile);
+        if (fs.existsSync(envPath)) {
+            const content = fs.readFileSync(envPath, 'utf8');
+            const portMatch = content.match(/^PORT\s*=\s*(\d+)/m);
+            if (portMatch) {
+                return parseInt(portMatch[1], 10);
+            }
+        }
+    }
+    // 2. Check package.json scripts for port
+    const pkgPath = path.join(root, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            const scripts = pkg.scripts || {};
+            // Check dev/start scripts for --port, -p, or PORT=
+            for (const scriptName of ['dev', 'start', 'serve']) {
+                const script = scripts[scriptName];
+                if (script) {
+                    // Match patterns like: --port 3000, -p 3000, PORT=3000
+                    const portMatch = script.match(/(?:--port\s+|(?:^|\s)-p\s+|PORT=)(\d+)/);
+                    if (portMatch) {
+                        return parseInt(portMatch[1], 10);
+                    }
+                    // Match patterns like: vite --port=5173
+                    const portEqMatch = script.match(/--port=(\d+)/);
+                    if (portEqMatch) {
+                        return parseInt(portEqMatch[1], 10);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            // Invalid JSON, skip
+        }
+    }
+    // 3. Check docker-compose for exposed ports
+    const dockerComposeFiles = ['docker-compose.yml', 'docker-compose.yaml'];
+    for (const dcFile of dockerComposeFiles) {
+        const dcPath = path.join(root, dcFile);
+        if (fs.existsSync(dcPath)) {
+            const content = fs.readFileSync(dcPath, 'utf8');
+            // Simple regex to find first ports mapping like "3000:3000" or "- 3000:3000"
+            const portMatch = content.match(/ports:\s*\n\s*-\s*["']?(\d+):/m);
+            if (portMatch) {
+                return parseInt(portMatch[1], 10);
+            }
+        }
+    }
+    // 4. Check vite.config.ts/js for server.port
+    const viteConfigs = ['vite.config.ts', 'vite.config.js'];
+    for (const viteConfig of viteConfigs) {
+        const vitePath = path.join(root, viteConfig);
+        if (fs.existsSync(vitePath)) {
+            const content = fs.readFileSync(vitePath, 'utf8');
+            const portMatch = content.match(/port:\s*(\d+)/);
+            if (portMatch) {
+                return parseInt(portMatch[1], 10);
+            }
+        }
+    }
+    // 5. Check next.config.js for custom port (rare, but possible)
+    // Next.js typically uses 3000 by default, which we'll fall back to
+    return undefined;
+}
+function scanProject(root) {
+    const info = {
+        name: path.basename(root),
+        languages: {},
+        hasDocker: false,
+        foundScripts: [],
+    };
+    // 1. Detect Languages/Frameworks
+    if (fs.existsSync(path.join(root, 'package.json')))
+        info.languages.node = true;
+    if (fs.existsSync(path.join(root, 'requirements.txt')))
+        info.languages.python = true;
+    if (fs.existsSync(path.join(root, 'Gemfile')))
+        info.languages.ruby = true;
+    if (fs.existsSync(path.join(root, 'go.mod')))
+        info.languages.go = true;
+    // 2. Detect Docker
+    // Check for various docker compose names
+    const files = fs.readdirSync(root);
+    const dockerFiles = files.filter(f => f.startsWith('docker-compose') && (f.endsWith('.yml') || f.endsWith('.yaml')));
+    if (dockerFiles.length > 0)
+        info.hasDocker = true;
+    // 3. Detect Scripts (Standard)
+    const scriptsDir = path.join(root, 'scripts');
+    if (fs.existsSync(scriptsDir)) {
+        const scriptFiles = fs.readdirSync(scriptsDir);
+        info.foundScripts = scriptFiles
+            .filter(f => f.endsWith('.sh') && f !== 'hetzner-dev-env.sh')
+            .map(f => `scripts/${f}`);
+    }
+    // 4. Detect Git Repo
+    try {
+        const remote = require('child_process').execSync('git remote get-url origin', { cwd: root, stdio: 'pipe' }).toString().trim();
+        if (remote) {
+            info.gitRemote = remote;
+            info.gitRemoteType = getGitUrlType(remote);
+        }
+    }
+    catch (e) {
+        // Not a git repo or no remote
+    }
+    // 5. Detect Port
+    info.detectedPort = detectPort(root);
+    return info;
+}

package/dist/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ssh-config.js

@@ -0,0 +1,216 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSshConfigEntry = addSshConfigEntry;
+exports.removeSshConfigEntry = removeSshConfigEntry;
+exports.updateSshConfigEntry = updateSshConfigEntry;
+exports.hasSshConfigEntry = hasSshConfigEntry;
+exports.getSshAlias = getSshAlias;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const SSH_CONFIG_PATH = path.join(os.homedir(), '.ssh', 'config');
+const GENBOX_MARKER_START = '# Genbox Environment:';
+const GENBOX_MARKER_END = '# End Genbox Environment:';
+/**
+ * Ensure ~/.ssh directory exists
+ */
+function ensureSshDir() {
+    const sshDir = path.join(os.homedir(), '.ssh');
+    if (!fs.existsSync(sshDir)) {
+        fs.mkdirSync(sshDir, { mode: 0o700 });
+    }
+}
+/**
+ * Read current SSH config content
+ */
+function readSshConfig() {
+    ensureSshDir();
+    if (!fs.existsSync(SSH_CONFIG_PATH)) {
+        return '';
+    }
+    return fs.readFileSync(SSH_CONFIG_PATH, 'utf8');
+}
+/**
+ * Write SSH config content
+ */
+function writeSshConfig(content) {
+    ensureSshDir();
+    fs.writeFileSync(SSH_CONFIG_PATH, content, { mode: 0o600 });
+}
+/**
+ * Find the best available SSH key
+ */
+function findSshKey() {
+    const home = os.homedir();
+    const keyPaths = [
+        path.join(home, '.ssh', 'id_ed25519'),
+        path.join(home, '.ssh', 'id_rsa'),
+    ];
+    for (const keyPath of keyPaths) {
+        if (fs.existsSync(keyPath)) {
+            return keyPath;
+        }
+    }
+    return null;
+}
+/**
+ * Add an SSH config entry for a Genbox
+ */
+function addSshConfigEntry(entry) {
+    try {
+        const config = readSshConfig();
+        const hostAlias = `genbox-${entry.name}`;
+        const marker = `${GENBOX_MARKER_START} ${entry.name}`;
+        const endMarker = `${GENBOX_MARKER_END} ${entry.name}`;
+        // Check if entry already exists
+        if (config.includes(marker)) {
+            // Update existing entry
+            removeSshConfigEntry(entry.name);
+        }
+        // Find SSH key
+        const keyPath = entry.keyPath || findSshKey();
+        // Build config block
+        const configBlock = [
+            '',
+            marker,
+            `Host ${hostAlias}`,
+            `  HostName ${entry.ipAddress}`,
+            `  User ${entry.user || 'dev'}`,
+            '  StrictHostKeyChecking no',
+            '  UserKnownHostsFile /dev/null',
+            '  LogLevel ERROR',
+        ];
+        if (keyPath) {
+            configBlock.push(`  IdentityFile ${keyPath}`);
+            configBlock.push('  IdentitiesOnly yes');
+        }
+        configBlock.push(endMarker);
+        configBlock.push('');
+        // Append to config
+        const newConfig = config.trimEnd() + '\n' + configBlock.join('\n');
+        writeSshConfig(newConfig);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Remove an SSH config entry for a Genbox
+ */
+function removeSshConfigEntry(name) {
+    try {
+        const config = readSshConfig();
+        const marker = `${GENBOX_MARKER_START} ${name}`;
+        const endMarker = `${GENBOX_MARKER_END} ${name}`;
+        if (!config.includes(marker)) {
+            return true; // Nothing to remove
+        }
+        // Find and remove the block
+        const startIdx = config.indexOf(marker);
+        let endIdx = config.indexOf(endMarker);
+        if (endIdx === -1) {
+            // Malformed entry, try to find next Host line
+            endIdx = config.indexOf('\nHost ', startIdx + 1);
+            if (endIdx === -1) {
+                endIdx = config.length;
+            }
+        }
+        else {
+            endIdx += endMarker.length;
+        }
+        // Remove leading newline if present
+        let removeStart = startIdx;
+        if (removeStart > 0 && config[removeStart - 1] === '\n') {
+            removeStart--;
+        }
+        // Remove trailing newline if present
+        let removeEnd = endIdx;
+        if (removeEnd < config.length && config[removeEnd] === '\n') {
+            removeEnd++;
+        }
+        const newConfig = config.slice(0, removeStart) + config.slice(removeEnd);
+        writeSshConfig(newConfig.trim() + '\n');
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Update an existing SSH config entry with a new IP
+ */
+function updateSshConfigEntry(name, newIpAddress) {
+    const config = readSshConfig();
+    const marker = `${GENBOX_MARKER_START} ${name}`;
+    if (!config.includes(marker)) {
+        return false;
+    }
+    // Find and update the HostName line
+    const lines = config.split('\n');
+    let inBlock = false;
+    let updated = false;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].includes(marker)) {
+            inBlock = true;
+        }
+        if (inBlock && lines[i].trim().startsWith('HostName ')) {
+            lines[i] = `  HostName ${newIpAddress}`;
+            updated = true;
+        }
+        if (lines[i].includes(`${GENBOX_MARKER_END} ${name}`)) {
+            break;
+        }
+    }
+    if (updated) {
+        writeSshConfig(lines.join('\n'));
+    }
+    return updated;
+}
+/**
+ * Check if an SSH config entry exists for a Genbox
+ */
+function hasSshConfigEntry(name) {
+    const config = readSshConfig();
+    const marker = `${GENBOX_MARKER_START} ${name}`;
+    return config.includes(marker);
+}
+/**
+ * Get the SSH alias for a Genbox
+ */
+function getSshAlias(name) {
+    return `genbox-${name}`;
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "genbox",
+  "version": "1.0.0",
+  "description": "Genbox CLI - AI-Powered Development Environments",
+  "main": "dist/index.js",
+  "bin": {
+    "genbox": "./dist/index.js"
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "prepublishOnly": "npm run build",
+    "publish:patch": "./scripts/publish.sh patch",
+    "publish:minor": "./scripts/publish.sh minor",
+    "publish:major": "./scripts/publish.sh major",
+    "release": "./scripts/publish.sh patch",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "genbox",
+    "ai",
+    "development",
+    "environments",
+    "cloud",
+    "cli",
+    "dev-environment",
+    "sandbox",
+    "hetzner"
+  ],
+  "author": "GoodPass",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/goodpass-co/genbox.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://genbox.dev",
+  "bugs": {
+    "url": "https://github.com/goodpass-co/genbox/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^24.10.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "dotenv": "^17.2.3",
+    "inquirer": "^13.0.2",
+    "js-yaml": "^4.1.1",
+    "ora": "^9.0.0"
+  }
+}