genbox 1.0.131 → 1.0.133

package/README.md

@@ -193,8 +193,7 @@ Environments auto-destroy after 58 minutes of inactivity to save credits.
 
 - **Website**: [genbox.dev](https://genbox.dev)
 - **Documentation**: [genbox.dev/docs](https://genbox.dev/docs)
-- **GitHub**: [github.com/goodpass-co/genbox](https://github.com/goodpass-co/genbox)
-- **Issues**: [github.com/goodpass-co/genbox/issues](https://github.com/goodpass-co/genbox/issues)
+- **Support**: [genbox.dev/support](https://genbox.dev/support)
 
 ## License
 

package/dist/commands/balance.js

@@ -9,9 +9,17 @@ const chalk_1 = __importDefault(require("chalk"));
 const api_1 = require("../api");
 exports.balanceCommand = new commander_1.Command('balance')
     .description('Show current credit balance')
-    .action(async () => {
+    .option('--json', 'Output as JSON (for scripting)')
+    .action(async (options) => {
     try {
         const user = await (0, api_1.fetchApi)('/users/me');
+        if (options.json) {
+            console.log(JSON.stringify({
+                userId: user.externalId,
+                credits: user.credits,
+            }, null, 2));
+            return;
+        }
         console.log(chalk_1.default.bold('User ID:'), user.externalId);
         console.log(chalk_1.default.bold('Credits:'), chalk_1.default.green(user.credits));
     }

package/dist/commands/completion.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.completionCommand = void 0;
+exports.completeCommand = exports.completionCommand = void 0;
 exports.isCompletionInstalledForCurrentShell = isCompletionInstalledForCurrentShell;
 exports.getCompletionHint = getCompletionHint;
 const commander_1 = require("commander");
@@ -44,6 +44,59 @@ const chalk_1 = __importDefault(require("chalk"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
+const api_1 = require("../api");
+const genbox_selector_1 = require("../genbox-selector");
+// Cache file for genbox names (for fast completion)
+const CACHE_FILE = path.join(os.homedir(), '.genbox', 'completion-cache.json');
+const CACHE_TTL = 60 * 1000; // 1 minute cache
+/**
+ * Get cached genbox names or fetch fresh ones
+ */
+async function getCachedGenboxNames() {
+    const project = (0, genbox_selector_1.getProjectContext)() || undefined;
+    // Try to read from cache first
+    try {
+        if (fs.existsSync(CACHE_FILE)) {
+            const cache = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'));
+            const age = Date.now() - cache.timestamp;
+            // Use cache if fresh and same project context
+            if (age < CACHE_TTL && cache.project === project) {
+                return cache.genboxNames;
+            }
+        }
+    }
+    catch {
+        // Cache read failed, continue to fetch
+    }
+    // Fetch fresh data
+    try {
+        const genboxes = await (0, api_1.fetchApi)('/genboxes');
+        const names = genboxes
+            .filter(g => g.status !== 'terminated')
+            .map(g => g.name);
+        // Save to cache
+        try {
+            const cacheDir = path.dirname(CACHE_FILE);
+            if (!fs.existsSync(cacheDir)) {
+                fs.mkdirSync(cacheDir, { recursive: true });
+            }
+            const cache = {
+                genboxNames: names,
+                timestamp: Date.now(),
+                project,
+            };
+            fs.writeFileSync(CACHE_FILE, JSON.stringify(cache));
+        }
+        catch {
+            // Cache write failed, ignore
+        }
+        return names;
+    }
+    catch {
+        // API call failed, return empty
+        return [];
+    }
+}
 // Get all command names for completion
 const commands = [
     'init', 'create', 'list', 'ls', 'destroy', 'delete', 'connect', 'balance',
@@ -141,6 +194,11 @@ function generateBashCompletion() {
 # Or save to a file:
 #   gb completion bash > /etc/bash_completion.d/gb
 
+# Get genbox names dynamically
+_genbox_names() {
+    gb __complete genbox-names 2>/dev/null
+}
+
 _genbox_completions() {
     local cur prev commands
     COMPREPLY=()
@@ -186,9 +244,10 @@ _genbox_completions() {
             COMPREPLY=( $(compgen -W "bash zsh fish --install" -- "\${cur}") )
             return 0
             ;;
-        # Commands that take genbox names - could be enhanced with dynamic completion
-        create|destroy|delete|connect|status|urls|forward|push|restart|stop|start|resume|extend|rebuild|run|run-prompt)
-            # For now, no completion for genbox names (would need API call)
+        # Commands that take genbox names - dynamic completion
+        destroy|delete|connect|status|urls|forward|push|restart|stop|start|resume|extend|rebuild|run|run-prompt|backup|restore-db)
+            local genbox_names=$(_genbox_names)
+            COMPREPLY=( $(compgen -W "\${genbox_names}" -- "\${cur}") )
             return 0
             ;;
         -s|--size)
@@ -264,6 +323,13 @@ function generateZshCompletion() {
 # Or save to a file in your fpath:
 #   gb completion zsh > ~/.zsh/completions/_gb
 
+# Get genbox names dynamically
+_genbox_names() {
+    local -a names
+    names=(\${(f)"$(gb __complete genbox-names 2>/dev/null)"})
+    _describe -t genboxes 'genbox name' names
+}
+
 _genbox() {
     local -a commands
     commands=(
@@ -386,29 +452,29 @@ _genbox() {
                         '(-y --yes)'{-y,--yes}'[Skip confirmation]' \\
                         '(-a --all)'{-a,--all}'[Bulk delete mode]' \\
                         '--save-changes[Handle changes]:action:(save trash skip)' \\
-                        '1:name:'
+                        '1:name:_genbox_names'
                     ;;
                 status)
                     _arguments \\
                         '(-a --all)'{-a,--all}'[Select from all]' \\
                         '(-w --watch)'{-w,--watch}'[Watch mode]' \\
-                        '1:name:'
+                        '1:name:_genbox_names'
                     ;;
                 connect|urls|restart|stop)
                     _arguments \\
                         '(-a --all)'{-a,--all}'[Select from all]' \\
-                        '1:name:'
+                        '1:name:_genbox_names'
                     ;;
                 start|resume)
                     _arguments \\
                         '(-a --all)'{-a,--all}'[Select from all]' \\
-                        '1:name:'
+                        '1:name:_genbox_names'
                     ;;
                 forward)
                     _arguments \\
                         '(-a --all)'{-a,--all}'[Select from all]' \\
                         '(-p --ports)'{-p,--ports}'[Additional ports]:ports:' \\
-                        '1:name:'
+                        '1:name:_genbox_names'
                     ;;
                 extend)
                     _arguments \\
@@ -416,13 +482,13 @@ _genbox() {
                         '--hours[Hours to extend]:hours:' \\
                         '--disable-auto-destroy[Disable auto-destroy]' \\
                         '--enable-auto-destroy[Enable auto-destroy]' \\
-                        '1:name:'
+                        '1:name:_genbox_names'
                     ;;
                 rebuild)
                     _arguments \\
                         '(-a --all)'{-a,--all}'[Select from all]' \\
                         '(-y --yes)'{-y,--yes}'[Skip confirmation]' \\
-                        '1:name:'
+                        '1:name:_genbox_names'
                     ;;
                 help)
                     _values 'command' init create status connect forward restore-db urls push destroy
@@ -446,6 +512,11 @@ function generateFishCompletion() {
 complete -c genbox -f
 complete -c gb -f
 
+# Function to get genbox names dynamically
+function __fish_genbox_names
+    gb __complete genbox-names 2>/dev/null
+end
+
 # Main commands
 complete -c genbox -c gb -n "__fish_use_subcommand" -a "init" -d "Initialize genbox.yaml configuration"
 complete -c genbox -c gb -n "__fish_use_subcommand" -a "create" -d "Create a new Genbox environment"
@@ -533,6 +604,9 @@ complete -c genbox -c gb -n "__fish_seen_subcommand_from extend" -l hours -d "Ho
 complete -c genbox -c gb -n "__fish_seen_subcommand_from extend" -l disable-auto-destroy -d "Disable auto-destroy"
 complete -c genbox -c gb -n "__fish_seen_subcommand_from extend" -l enable-auto-destroy -d "Enable auto-destroy"
 
+# Dynamic genbox name completion for commands that take a genbox name
+complete -c genbox -c gb -n "__fish_seen_subcommand_from destroy delete connect status urls forward push restart stop start resume extend rebuild backup restore-db run run-prompt" -a "(__fish_genbox_names)" -d "Genbox name"
+
 # Global options
 complete -c genbox -c gb -s h -l help -d "Show help"
 complete -c genbox -c gb -s v -l version -d "Show version"
@@ -633,3 +707,27 @@ function getCompletionHint() {
     return `${chalk_1.default.dim('Enable tab completion for a better experience:')}
   ${chalk_1.default.cyan(`gb completion ${shellName} --install`)}`;
 }
+/**
+ * Hidden __complete command for dynamic completion support
+ * Used by shell completion scripts to get genbox names
+ */
+exports.completeCommand = new commander_1.Command('__complete')
+    .description('Internal command for shell completions')
+    .argument('<type>', 'Completion type: genbox-names')
+    .action(async (type) => {
+    switch (type) {
+        case 'genbox-names':
+            try {
+                const names = await getCachedGenboxNames();
+                // Output names, one per line (for shell parsing)
+                names.forEach(name => console.log(name));
+            }
+            catch {
+                // Silently fail - don't break completion
+            }
+            break;
+        default:
+            // Unknown type, output nothing
+            break;
+    }
+});

package/dist/commands/destroy.js

@@ -323,6 +323,7 @@ exports.destroyCommand = new commander_1.Command('destroy')
     .option('-y, --yes', 'Skip confirmation and save-work prompts')
     .option('-a, --all', 'Bulk delete mode - select multiple genboxes to destroy')
     .option('--save-changes <action>', 'Handle uncommitted changes: save (commit/push/PR), trash (discard), skip (ignore)')
+    .addHelpText('after', '\nAliases: gb delete')
     .action(async (name, options) => {
     try {
         // Bulk delete mode when --all is used without a specific name

package/dist/commands/doctor.js

@@ -0,0 +1,357 @@
+"use strict";
+/**
+ * Doctor Command
+ *
+ * Diagnoses CLI setup and reports any issues.
+ */
+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.doctorCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const config_store_1 = require("../config-store");
+const api_1 = require("../api");
+async function runChecks() {
+    const results = [];
+    // 1. Check Node.js version
+    const nodeVersion = process.version;
+    const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0], 10);
+    if (majorVersion >= 18) {
+        results.push({
+            name: 'Node.js',
+            status: 'ok',
+            message: `${nodeVersion} installed`,
+        });
+    }
+    else {
+        results.push({
+            name: 'Node.js',
+            status: 'error',
+            message: `${nodeVersion} is too old`,
+            hint: 'Genbox CLI requires Node.js 18 or higher',
+        });
+    }
+    // 2. Check authentication
+    const config = config_store_1.ConfigStore.load();
+    if (config.auth?.token) {
+        const user = config.auth.user;
+        if (user?.email) {
+            results.push({
+                name: 'Authentication',
+                status: 'ok',
+                message: `Logged in as ${user.email}`,
+            });
+        }
+        else {
+            results.push({
+                name: 'Authentication',
+                status: 'ok',
+                message: 'Authenticated',
+            });
+        }
+        // 3. Check API connectivity (only if authenticated)
+        try {
+            await (0, api_1.fetchApi)('/user/profile');
+            results.push({
+                name: 'API Connection',
+                status: 'ok',
+                message: 'Connected to API',
+            });
+        }
+        catch (error) {
+            if (error.message?.includes('401') || error.message?.includes('Unauthorized')) {
+                results.push({
+                    name: 'API Connection',
+                    status: 'error',
+                    message: 'Token expired or invalid',
+                    hint: 'Run `gb login` to re-authenticate',
+                });
+            }
+            else {
+                results.push({
+                    name: 'API Connection',
+                    status: 'warning',
+                    message: `Could not reach API: ${error.message}`,
+                    hint: 'Check your internet connection',
+                });
+            }
+        }
+    }
+    else {
+        results.push({
+            name: 'Authentication',
+            status: 'warning',
+            message: 'Not logged in',
+            hint: 'Run `gb login` to authenticate',
+        });
+    }
+    // 4. Check SSH configuration
+    const sshConfigPath = path.join(os.homedir(), '.ssh', 'config');
+    if (fs.existsSync(sshConfigPath)) {
+        try {
+            const sshConfig = fs.readFileSync(sshConfigPath, 'utf8');
+            const hasGenboxHosts = sshConfig.includes('# Genbox') || sshConfig.includes('genbox.dev');
+            if (hasGenboxHosts) {
+                results.push({
+                    name: 'SSH Config',
+                    status: 'ok',
+                    message: 'Genbox hosts configured',
+                });
+            }
+            else {
+                results.push({
+                    name: 'SSH Config',
+                    status: 'ok',
+                    message: 'SSH config exists (no genbox hosts yet)',
+                });
+            }
+        }
+        catch {
+            results.push({
+                name: 'SSH Config',
+                status: 'warning',
+                message: 'Could not read SSH config',
+                hint: 'Check permissions on ~/.ssh/config',
+            });
+        }
+    }
+    else {
+        results.push({
+            name: 'SSH Config',
+            status: 'warning',
+            message: 'No SSH config file',
+            hint: 'SSH config will be created when you create a genbox',
+        });
+    }
+    // 5. Check SSH key
+    const sshKeyPath = path.join(os.homedir(), '.ssh', 'id_ed25519');
+    const sshKeyPathRsa = path.join(os.homedir(), '.ssh', 'id_rsa');
+    if (fs.existsSync(sshKeyPath)) {
+        results.push({
+            name: 'SSH Key',
+            status: 'ok',
+            message: 'Ed25519 key found',
+        });
+    }
+    else if (fs.existsSync(sshKeyPathRsa)) {
+        results.push({
+            name: 'SSH Key',
+            status: 'ok',
+            message: 'RSA key found',
+        });
+    }
+    else {
+        results.push({
+            name: 'SSH Key',
+            status: 'warning',
+            message: 'No SSH key found',
+            hint: 'Run `ssh-keygen -t ed25519` to create one',
+        });
+    }
+    // 6. Check genbox.yaml in current directory
+    const genboxYamlPath = path.join(process.cwd(), 'genbox.yaml');
+    if (fs.existsSync(genboxYamlPath)) {
+        try {
+            const yaml = require('js-yaml');
+            const content = fs.readFileSync(genboxYamlPath, 'utf8');
+            const config = yaml.load(content);
+            if (config.version && config.project_name) {
+                results.push({
+                    name: 'Project Config',
+                    status: 'ok',
+                    message: `genbox.yaml found (v${config.version}, project: ${config.project_name})`,
+                });
+            }
+            else {
+                results.push({
+                    name: 'Project Config',
+                    status: 'warning',
+                    message: 'genbox.yaml missing required fields',
+                    hint: 'Ensure version and project_name are set',
+                });
+            }
+        }
+        catch (error) {
+            results.push({
+                name: 'Project Config',
+                status: 'error',
+                message: 'Invalid genbox.yaml',
+                hint: error.message,
+            });
+        }
+    }
+    else {
+        results.push({
+            name: 'Project Config',
+            status: 'ok',
+            message: 'No genbox.yaml in current directory',
+        });
+    }
+    // 7. Check .env.genbox
+    const envGenboxPath = path.join(process.cwd(), '.env.genbox');
+    if (fs.existsSync(genboxYamlPath)) {
+        if (fs.existsSync(envGenboxPath)) {
+            results.push({
+                name: 'Environment',
+                status: 'ok',
+                message: '.env.genbox found',
+            });
+        }
+        else {
+            results.push({
+                name: 'Environment',
+                status: 'warning',
+                message: 'No .env.genbox file',
+                hint: 'Create .env.genbox for secrets (GITHUB_PAT, etc.)',
+            });
+        }
+    }
+    // 8. Check git
+    try {
+        (0, child_process_1.execSync)('git --version', { stdio: 'pipe' });
+        results.push({
+            name: 'Git',
+            status: 'ok',
+            message: 'Git installed',
+        });
+    }
+    catch {
+        results.push({
+            name: 'Git',
+            status: 'warning',
+            message: 'Git not found',
+            hint: 'Git is recommended for version control',
+        });
+    }
+    // 9. Check shell completion
+    const shell = process.env.SHELL || '';
+    let completionInstalled = false;
+    const home = os.homedir();
+    if (shell.includes('zsh')) {
+        const zshrc = path.join(home, '.zshrc');
+        if (fs.existsSync(zshrc)) {
+            const content = fs.readFileSync(zshrc, 'utf8');
+            completionInstalled = content.includes('gb completion');
+        }
+    }
+    else if (shell.includes('bash')) {
+        const bashrc = path.join(home, '.bashrc');
+        const bashProfile = path.join(home, '.bash_profile');
+        for (const file of [bashrc, bashProfile]) {
+            if (fs.existsSync(file)) {
+                const content = fs.readFileSync(file, 'utf8');
+                if (content.includes('gb completion')) {
+                    completionInstalled = true;
+                    break;
+                }
+            }
+        }
+    }
+    else if (shell.includes('fish')) {
+        const fishCompletion = path.join(home, '.config', 'fish', 'completions', 'gb.fish');
+        completionInstalled = fs.existsSync(fishCompletion);
+    }
+    if (completionInstalled) {
+        results.push({
+            name: 'Shell Completion',
+            status: 'ok',
+            message: 'Tab completion installed',
+        });
+    }
+    else {
+        const shellName = shell.includes('zsh') ? 'zsh' : shell.includes('fish') ? 'fish' : 'bash';
+        results.push({
+            name: 'Shell Completion',
+            status: 'ok',
+            message: 'Tab completion not installed (optional)',
+            hint: `Run \`gb completion ${shellName} --install\` to enable`,
+        });
+    }
+    return results;
+}
+exports.doctorCommand = new commander_1.Command('doctor')
+    .description('Check CLI configuration and diagnose issues')
+    .action(async () => {
+    console.log('');
+    console.log(chalk_1.default.bold('Genbox CLI Diagnostics'));
+    console.log('');
+    const results = await runChecks();
+    // Display results
+    let hasErrors = false;
+    let hasWarnings = false;
+    for (const result of results) {
+        let statusIcon;
+        let statusColor;
+        switch (result.status) {
+            case 'ok':
+                statusIcon = chalk_1.default.green('✓');
+                statusColor = chalk_1.default;
+                break;
+            case 'warning':
+                statusIcon = chalk_1.default.yellow('⚠');
+                statusColor = chalk_1.default.yellow;
+                hasWarnings = true;
+                break;
+            case 'error':
+                statusIcon = chalk_1.default.red('✗');
+                statusColor = chalk_1.default.red;
+                hasErrors = true;
+                break;
+        }
+        console.log(`${statusIcon} ${chalk_1.default.bold(result.name)}: ${statusColor(result.message)}`);
+        if (result.hint) {
+            console.log(`  ${chalk_1.default.dim(result.hint)}`);
+        }
+    }
+    // Summary
+    console.log('');
+    if (hasErrors) {
+        console.log(chalk_1.default.red('Some issues need to be fixed before using Genbox CLI.'));
+    }
+    else if (hasWarnings) {
+        console.log(chalk_1.default.yellow('Some optional improvements are available.'));
+    }
+    else {
+        console.log(chalk_1.default.green('Everything looks good!'));
+    }
+    console.log('');
+});