genbox 1.0.183 → 1.0.185

package/dist/commands/provider-command.js

@@ -0,0 +1,576 @@
+"use strict";
+/**
+ * Provider Command Factory
+ *
+ * Creates `gb claude`, `gb gemini`, and `gb codex` commands with a unified,
+ * user-friendly interactive experience that encourages genbox usage.
+ *
+ * Flow:
+ * 1. Show interactive menu:
+ *    - On a Genbox (Recommended)
+ *    - Attach to existing session (if any exist)
+ *    - Run directly on this machine (no isolation)
+ * 2. Handle user selection
+ * 3. Start or attach to session
+ */
+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.codexCommand = exports.geminiCommand = exports.claudeCommand = void 0;
+exports.createProviderCommand = createProviderCommand;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const select_1 = __importDefault(require("@inquirer/select"));
+const prompts_1 = require("@inquirer/prompts");
+const config_store_1 = require("../config-store");
+const api_1 = require("../api");
+const child_process_1 = require("child_process");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+// Helper functions
+function getPrivateSshKey() {
+    const keyPath = path.join(os.homedir(), '.ssh', 'genbox_key');
+    if (!fs.existsSync(keyPath)) {
+        throw new Error('SSH key not found. Run `gb login` first.');
+    }
+    return keyPath;
+}
+function getDtachSocketDir() {
+    return path.join(os.homedir(), '.genbox', 'sockets');
+}
+function getRemoteDtachSocketDir() {
+    return '/home/dev/.genbox/sockets';
+}
+function ensureLocalSocketDir() {
+    const dir = getDtachSocketDir();
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function isDtachSocketAlive(socketPath) {
+    if (!fs.existsSync(socketPath)) {
+        return false;
+    }
+    try {
+        // Try to check if process is still running by checking socket
+        const result = (0, child_process_1.spawnSync)('dtach', ['-a', socketPath, '-e', ''], {
+            timeout: 100,
+            stdio: 'ignore',
+        });
+        // If we can't attach, socket might be stale
+        return result.status === null || result.status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureDtachInstalled(ipAddress, keyPath) {
+    try {
+        (0, child_process_1.execSync)(`ssh -i "${keyPath}" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR dev@${ipAddress} "which dtach"`, { timeout: 10000, stdio: 'pipe' });
+    }
+    catch {
+        console.log(chalk_1.default.dim('Installing dtach on genbox...'));
+        (0, child_process_1.execSync)(`ssh -i "${keyPath}" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null dev@${ipAddress} "sudo apt-get update && sudo apt-get install -y dtach"`, { timeout: 60000, stdio: 'pipe' });
+    }
+}
+async function ensureLocalDtach() {
+    try {
+        (0, child_process_1.execSync)('which dtach', { stdio: 'pipe' });
+        return 'available';
+    }
+    catch {
+        console.log(chalk_1.default.yellow('\ndtach is not installed (required for session persistence).'));
+        const platform = os.platform();
+        if (platform === 'darwin') {
+            console.log(chalk_1.default.dim('Install with: brew install dtach'));
+        }
+        else if (platform === 'linux') {
+            console.log(chalk_1.default.dim('Install with: sudo apt-get install dtach'));
+        }
+        try {
+            const proceed = await (0, prompts_1.confirm)({
+                message: 'Continue without session persistence?',
+                default: false,
+            });
+            return proceed ? 'unavailable' : 'cancel';
+        }
+        catch {
+            return 'cancel';
+        }
+    }
+}
+/**
+ * Get list of running genboxes
+ */
+async function getGenboxes() {
+    try {
+        const response = await (0, api_1.fetchApi)('/genboxes');
+        return (response?.genboxes || []).filter(g => g.status === 'running' && g.ipAddress);
+    }
+    catch (error) {
+        if (error instanceof api_1.AuthenticationError) {
+            return [];
+        }
+        throw error;
+    }
+}
+/**
+ * Get existing sessions for a provider
+ */
+async function getExistingSessions(provider) {
+    const sessions = [];
+    // Check local (direct) sessions
+    const socketDir = getDtachSocketDir();
+    if (fs.existsSync(socketDir)) {
+        const files = fs.readdirSync(socketDir).filter(f => f.endsWith('.sock'));
+        for (const file of files) {
+            const socketPath = path.join(socketDir, file);
+            const sessionName = file.replace('.sock', '');
+            // Check if this session is for our provider
+            if (sessionName.toLowerCase().includes(provider)) {
+                if (isDtachSocketAlive(socketPath)) {
+                    sessions.push({
+                        name: sessionName,
+                        provider,
+                        location: 'direct',
+                    });
+                }
+            }
+        }
+    }
+    // Check cloud (genbox) sessions
+    try {
+        const genboxes = await getGenboxes();
+        const keyPath = getPrivateSshKey();
+        for (const genbox of genboxes) {
+            if (!genbox.ipAddress)
+                continue;
+            try {
+                const socketDir = getRemoteDtachSocketDir();
+                const output = (0, child_process_1.execSync)(`ssh -i "${keyPath}" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o ConnectTimeout=3 -o LogLevel=ERROR dev@${genbox.ipAddress} "ls -1 ${socketDir}/*.sock 2>/dev/null" 2>/dev/null`, { encoding: 'utf8', timeout: 5000 });
+                const lines = output.trim().split('\n').filter(l => l.includes('.sock'));
+                for (const line of lines) {
+                    const sessionName = path.basename(line, '.sock');
+                    if (sessionName.toLowerCase().includes(provider)) {
+                        sessions.push({
+                            name: sessionName,
+                            provider,
+                            location: 'genbox',
+                            genboxName: genbox.name,
+                            ipAddress: genbox.ipAddress,
+                        });
+                    }
+                }
+            }
+            catch {
+                // Can't connect or no sessions
+            }
+        }
+    }
+    catch {
+        // Not logged in or network error
+    }
+    return sessions;
+}
+/**
+ * Show first-time warning for direct mode
+ */
+async function showDirectModeWarning() {
+    if (config_store_1.ConfigStore.hasDirectModeConsent()) {
+        return true;
+    }
+    console.log('');
+    console.log(chalk_1.default.yellow('  ⚠️  Running without isolation'));
+    console.log('');
+    console.log(chalk_1.default.dim('  The AI will have direct access to your files and system.'));
+    console.log(chalk_1.default.dim('  For better security, consider using a Genbox.'));
+    console.log('');
+    try {
+        const proceed = await (0, prompts_1.confirm)({
+            message: 'Continue without isolation?',
+            default: false,
+        });
+        if (proceed) {
+            config_store_1.ConfigStore.setDirectModeConsent(true);
+            console.log(chalk_1.default.dim('\n  (This warning won\'t be shown again)\n'));
+        }
+        return proceed;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create and attach to a session on a genbox
+ */
+async function startSessionOnGenbox(provider, genbox) {
+    const keyPath = getPrivateSshKey();
+    const sessionName = `${provider}-${Date.now().toString(36)}`;
+    const cliCommand = provider === 'claude'
+        ? 'claude --dangerously-skip-permissions'
+        : provider === 'gemini'
+            ? 'gemini'
+            : 'codex';
+    console.log(chalk_1.default.dim(`\nStarting ${provider} on ${genbox.name}...`));
+    // Ensure dtach is installed
+    await ensureDtachInstalled(genbox.ipAddress, keyPath);
+    // Create session in background using nohup with dtach
+    const socketDir = getRemoteDtachSocketDir();
+    const socketPath = `${socketDir}/${sessionName}.sock`;
+    (0, child_process_1.execSync)(`ssh -i "${keyPath}" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null dev@${genbox.ipAddress} "mkdir -p ${socketDir} && nohup dtach -n ${socketPath} bash -c 'source ~/.nvm/nvm.sh 2>/dev/null; ${cliCommand}' > /dev/null 2>&1 &"`, { timeout: 30000 });
+    // Wait for session to start
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    console.log(chalk_1.default.green(`Session created: ${sessionName}`));
+    console.log(chalk_1.default.dim('Tip: Detach with Ctrl+\\\n'));
+    // Attach to session
+    const sshArgs = [
+        '-t',
+        '-i', keyPath,
+        '-o', 'StrictHostKeyChecking=no',
+        '-o', 'UserKnownHostsFile=/dev/null',
+        '-o', 'LogLevel=ERROR',
+        `dev@${genbox.ipAddress}`,
+        `dtach -a ${socketPath}`,
+    ];
+    const proc = (0, child_process_1.spawn)('ssh', sshArgs, { stdio: 'inherit' });
+    await new Promise(resolve => proc.on('close', () => resolve()));
+    console.log(chalk_1.default.dim('\nDetached from session.'));
+    console.log(chalk_1.default.dim(`Reattach with: ${chalk_1.default.cyan(`gb ${provider} --attach ${sessionName}`)}`));
+}
+/**
+ * Attach to an existing session
+ */
+async function attachToSession(session) {
+    if (session.location === 'direct') {
+        // Local dtach session
+        const socketPath = path.join(getDtachSocketDir(), `${session.name}.sock`);
+        console.log(chalk_1.default.dim(`\nAttaching to ${session.name}...`));
+        console.log(chalk_1.default.dim('Tip: Detach with Ctrl+\\\n'));
+        const proc = (0, child_process_1.spawn)('dtach', ['-a', socketPath], { stdio: 'inherit' });
+        await new Promise(resolve => proc.on('close', () => resolve()));
+        console.log(chalk_1.default.dim('\nDetached from session.'));
+    }
+    else {
+        // Cloud genbox session
+        const keyPath = getPrivateSshKey();
+        const socketDir = getRemoteDtachSocketDir();
+        const socketPath = `${socketDir}/${session.name}.sock`;
+        console.log(chalk_1.default.dim(`\nAttaching to ${session.name} on ${session.genboxName}...`));
+        console.log(chalk_1.default.dim('Tip: Detach with Ctrl+\\\n'));
+        const sshArgs = [
+            '-t',
+            '-i', keyPath,
+            '-o', 'StrictHostKeyChecking=no',
+            '-o', 'UserKnownHostsFile=/dev/null',
+            '-o', 'LogLevel=ERROR',
+            `dev@${session.ipAddress}`,
+            `dtach -a ${socketPath}`,
+        ];
+        const proc = (0, child_process_1.spawn)('ssh', sshArgs, { stdio: 'inherit' });
+        await new Promise(resolve => proc.on('close', () => resolve()));
+        console.log(chalk_1.default.dim('\nDetached from session.'));
+    }
+}
+/**
+ * Start a direct (no isolation) session
+ */
+async function startDirectSession(provider) {
+    // Check for dtach
+    const dtachStatus = await ensureLocalDtach();
+    if (dtachStatus === 'cancel') {
+        console.log(chalk_1.default.dim('\nCancelled.'));
+        return;
+    }
+    const useDtach = dtachStatus === 'available';
+    ensureLocalSocketDir();
+    const sessionName = `${provider}-${Date.now().toString(36)}`;
+    const cliCommand = provider === 'claude'
+        ? 'claude --dangerously-skip-permissions'
+        : provider === 'gemini'
+            ? 'gemini'
+            : 'codex';
+    console.log(chalk_1.default.dim(`\nStarting ${provider} session...`));
+    if (useDtach) {
+        console.log(chalk_1.default.dim('Tip: Detach with Ctrl+\\\n'));
+    }
+    else {
+        console.log(chalk_1.default.dim('Note: Session will end when you exit (no persistence)\n'));
+    }
+    const socketPath = path.join(getDtachSocketDir(), `${sessionName}.sock`);
+    let cmd;
+    if (useDtach) {
+        cmd = `dtach -A "${socketPath}" bash -c '${cliCommand}'`;
+    }
+    else {
+        cmd = cliCommand;
+    }
+    const proc = (0, child_process_1.spawn)('bash', ['-c', cmd], { stdio: 'inherit' });
+    await new Promise((resolve) => {
+        proc.on('close', () => {
+            if (useDtach && fs.existsSync(socketPath)) {
+                console.log(chalk_1.default.dim('\nDetached from session (still running in background).'));
+                console.log(chalk_1.default.dim(`Reattach with: ${chalk_1.default.cyan(`gb ${provider} --attach ${sessionName}`)}`));
+            }
+            else {
+                console.log(chalk_1.default.dim('\nSession ended.'));
+            }
+            resolve();
+        });
+    });
+}
+/**
+ * Main interactive flow
+ */
+async function runInteractiveFlow(provider) {
+    console.log(chalk_1.default.dim('\nFetching genboxes and sessions...'));
+    // Gather data in parallel
+    const [genboxes, existingSessions] = await Promise.all([
+        getGenboxes(),
+        getExistingSessions(provider),
+    ]);
+    const choices = [];
+    // Option 1: On a Genbox (Recommended)
+    if (genboxes.length > 0) {
+        choices.push({
+            name: chalk_1.default.green('●') + ' On a Genbox ' + chalk_1.default.dim('(Recommended)'),
+            value: { type: 'select-genbox' },
+        });
+    }
+    else {
+        choices.push({
+            name: chalk_1.default.green('+') + ' Create a Genbox ' + chalk_1.default.dim('(Recommended)'),
+            value: { type: 'create-genbox' },
+        });
+    }
+    // Option 2: Attach to existing session (only if sessions exist)
+    if (existingSessions.length > 0) {
+        choices.push({
+            name: chalk_1.default.dim('─────────────────────────────────'),
+            value: { type: 'cancel' },
+            disabled: true,
+        });
+        for (const session of existingSessions) {
+            const locationLabel = session.location === 'genbox'
+                ? chalk_1.default.blue(`on ${session.genboxName}`)
+                : chalk_1.default.yellow('direct');
+            choices.push({
+                name: `  ${chalk_1.default.cyan('↩')} Attach to ${session.name} ${chalk_1.default.dim(`(${locationLabel})`)}`,
+                value: { type: 'attach', session },
+            });
+        }
+    }
+    // Option 3: Run directly (no isolation)
+    choices.push({
+        name: chalk_1.default.dim('─────────────────────────────────'),
+        value: { type: 'cancel' },
+        disabled: true,
+    });
+    choices.push({
+        name: chalk_1.default.dim('  Run directly on this machine (no isolation)'),
+        value: { type: 'direct' },
+    });
+    // Show menu
+    console.log('');
+    let action;
+    try {
+        action = await (0, select_1.default)({
+            message: `How would you like to run ${chalk_1.default.bold(provider)}?`,
+            choices: choices.filter(c => !c.disabled),
+        });
+    }
+    catch {
+        console.log(chalk_1.default.dim('\nCancelled.'));
+        return;
+    }
+    // Handle selection
+    switch (action.type) {
+        case 'select-genbox': {
+            // Show genbox selection
+            const genboxChoices = [
+                ...genboxes.map(g => ({
+                    name: `${g.name} ${chalk_1.default.dim(`(${g.ipAddress})`)}`,
+                    value: g,
+                })),
+                {
+                    name: chalk_1.default.dim('─────────────────────────────────'),
+                    value: null,
+                    disabled: true,
+                },
+                {
+                    name: chalk_1.default.green('+') + ' Create new Genbox',
+                    value: null,
+                },
+            ];
+            let selectedGenbox;
+            try {
+                selectedGenbox = await (0, select_1.default)({
+                    message: 'Select a Genbox:',
+                    choices: genboxChoices.filter(c => !c.disabled),
+                });
+            }
+            catch {
+                console.log(chalk_1.default.dim('\nCancelled.'));
+                return;
+            }
+            if (selectedGenbox === null) {
+                // Create new genbox
+                console.log(chalk_1.default.yellow('\nTo create a new Genbox, run:'));
+                console.log(chalk_1.default.cyan('  gb create <name>\n'));
+                return;
+            }
+            await startSessionOnGenbox(provider, selectedGenbox);
+            break;
+        }
+        case 'create-genbox':
+            console.log(chalk_1.default.yellow('\nTo create a Genbox, run:'));
+            console.log(chalk_1.default.cyan('  gb create <name>\n'));
+            break;
+        case 'attach':
+            await attachToSession(action.session);
+            break;
+        case 'direct': {
+            const proceed = await showDirectModeWarning();
+            if (!proceed) {
+                console.log(chalk_1.default.dim('\nCancelled.'));
+                return;
+            }
+            await startDirectSession(provider);
+            break;
+        }
+        case 'cancel':
+            console.log(chalk_1.default.dim('\nCancelled.'));
+            break;
+    }
+}
+/**
+ * Create a provider command (claude, gemini, or codex)
+ */
+function createProviderCommand(provider) {
+    const providerName = provider.charAt(0).toUpperCase() + provider.slice(1);
+    return new commander_1.Command(provider)
+        .description(`Start or attach to a ${providerName} AI session`)
+        .option('--on <genbox>', 'Use specific genbox')
+        .option('--direct', 'Run directly on this machine (no isolation)')
+        .option('--attach <session>', 'Attach to existing session')
+        .option('--list', 'List all sessions')
+        .option('--kill', 'Kill session')
+        .option('-y, --yes', 'Skip confirmations')
+        .addHelpText('after', `
+Examples:
+  gb ${provider}                        Interactive mode
+  gb ${provider} --on my-genbox         Use specific genbox
+  gb ${provider} --attach swift-fox     Attach to existing session
+  gb ${provider} --direct               Run without isolation
+  gb ${provider} --list                 List all ${provider} sessions
+`)
+        .action(async (options) => {
+        try {
+            // --list: Show all sessions for this provider
+            if (options.list) {
+                console.log(chalk_1.default.dim(`\nFetching ${provider} sessions...`));
+                const sessions = await getExistingSessions(provider);
+                if (sessions.length === 0) {
+                    console.log(chalk_1.default.dim(`\n  No ${provider} sessions found.\n`));
+                    return;
+                }
+                console.log('');
+                for (const session of sessions) {
+                    const locationLabel = session.location === 'genbox'
+                        ? chalk_1.default.blue(`on ${session.genboxName}`)
+                        : chalk_1.default.yellow('direct');
+                    console.log(`  ${chalk_1.default.green('●')} ${session.name} ${chalk_1.default.dim(`(${locationLabel})`)}`);
+                }
+                console.log('');
+                return;
+            }
+            // --attach: Attach to specific session
+            if (options.attach) {
+                const sessions = await getExistingSessions(provider);
+                const session = sessions.find(s => s.name === options.attach || s.name.includes(options.attach));
+                if (!session) {
+                    console.log(chalk_1.default.red(`\nSession not found: ${options.attach}`));
+                    console.log(chalk_1.default.dim(`Run 'gb ${provider} --list' to see available sessions.\n`));
+                    return;
+                }
+                await attachToSession(session);
+                return;
+            }
+            // --on: Use specific genbox
+            if (options.on) {
+                const genboxes = await getGenboxes();
+                const genbox = genboxes.find(g => g.name === options.on || g.name.includes(options.on));
+                if (!genbox) {
+                    console.log(chalk_1.default.red(`\nGenbox not found: ${options.on}`));
+                    console.log(chalk_1.default.dim('Run \'gb list\' to see available genboxes.\n'));
+                    return;
+                }
+                await startSessionOnGenbox(provider, genbox);
+                return;
+            }
+            // --direct: Run without isolation
+            if (options.direct) {
+                if (!options.yes) {
+                    const proceed = await showDirectModeWarning();
+                    if (!proceed) {
+                        console.log(chalk_1.default.dim('\nCancelled.'));
+                        return;
+                    }
+                }
+                await startDirectSession(provider);
+                return;
+            }
+            // Default: Interactive mode
+            await runInteractiveFlow(provider);
+        }
+        catch (error) {
+            if (error instanceof api_1.AuthenticationError) {
+                (0, api_1.handleApiError)(error);
+                return;
+            }
+            if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
+                console.log(chalk_1.default.dim('\nCancelled.'));
+                return;
+            }
+            console.error(chalk_1.default.red(`Error: ${error.message}`));
+        }
+    });
+}
+// Export individual commands
+exports.claudeCommand = createProviderCommand('claude');
+exports.geminiCommand = createProviderCommand('gemini');
+exports.codexCommand = createProviderCommand('codex');

package/dist/commands/session/index.js

@@ -59,6 +59,7 @@ const local_genbox_provisioner_1 = require("../../lib/local-genbox-provisioner")
 const native_session_manager_1 = require("../../lib/native-session-manager");
 const hooks_configurator_1 = require("../../lib/hooks-configurator");
 const api_1 = require("../../api");
+const genbox_selector_1 = require("../../genbox-selector");
 const prompts_1 = require("@inquirer/prompts");
 const list_1 = require("./list");
 const start_1 = require("./start");
@@ -675,7 +676,7 @@ function isDtachSocketAlive(socketPath) {
     try {
         // Try to send an empty string to test if socket is alive
         // Using timeout to avoid hanging on dead sockets
-        (0, child_process_1.execSync)(`echo -n "" | dtach -p "${socketPath}" 2>/dev/null`, {
+        (0, child_process_1.execSync)(`printf '' | dtach -p "${socketPath}" 2>/dev/null`, {
             timeout: 2000,
             stdio: 'ignore'
         });
@@ -698,7 +699,7 @@ function isDtachSocketAlive(socketPath) {
  */
 function isRemoteDtachSocketAlive(ipAddress, keyPath, socketPath) {
     try {
-        (0, child_process_1.execSync)(`ssh -i "${keyPath}" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o ConnectTimeout=3 dev@${ipAddress} "echo -n '' | dtach -p ${socketPath}" 2>/dev/null`, { timeout: 5000, stdio: 'ignore' });
+        (0, child_process_1.execSync)(`ssh -i "${keyPath}" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o ConnectTimeout=3 dev@${ipAddress} "printf '' | dtach -p ${socketPath}" 2>/dev/null`, { timeout: 5000, stdio: 'ignore' });
         return true;
     }
     catch {
@@ -1056,11 +1057,16 @@ async function getAllGenboxesWithSessions(options) {
     }
     // Get cloud genboxes
     try {
-        const endpoint = options.all
-            ? '/genboxes'
-            : `/genboxes?projectPath=${encodeURIComponent(process.cwd())}`;
-        const response = await (0, api_1.fetchApi)(endpoint);
-        const genboxes = response?.genboxes || [];
+        // Fetch all genboxes and filter by project name (same approach as gb list)
+        const response = await (0, api_1.fetchApi)('/genboxes');
+        let genboxes = response || [];
+        // Filter by project name unless --all is specified
+        if (!options.all) {
+            const projectName = (0, genbox_selector_1.getProjectContext)();
+            if (projectName) {
+                genboxes = genboxes.filter(g => g.project === projectName || g.workspace === projectName);
+            }
+        }
         for (const genbox of genboxes) {
             if (genbox.status !== 'running' || !genbox.ipAddress) {
                 continue;

package/dist/config-store.js

@@ -66,5 +66,14 @@ class ConfigStore {
             fs.unlinkSync(CONFIG_FILE);
         }
     }
+    static hasDirectModeConsent() {
+        const config = this.load();
+        return config.directModeConsent === true;
+    }
+    static setDirectModeConsent(consent) {
+        const config = this.load();
+        config.directModeConsent = consent;
+        this.save(config);
+    }
 }
 exports.ConfigStore = ConfigStore;

package/dist/index.js

@@ -71,6 +71,7 @@ const start_1 = require("./commands/start");
 const template_1 = require("./commands/template");
 const run_prompt_1 = require("./commands/run-prompt");
 const session_1 = require("./commands/session");
+const provider_command_1 = require("./commands/provider-command");
 const cp_1 = require("./commands/cp");
 const completion_1 = require("./commands/completion");
 const doctor_1 = require("./commands/doctor");
@@ -129,12 +130,17 @@ if (earlyArgs.includes('--version') || earlyArgs.includes('-v')) {
     }
 }
 const commandCategories = {
+    'AI SESSIONS': [
+        { name: 'claude', aliases: [], description: 'Start Claude AI session' },
+        { name: 'gemini', aliases: [], description: 'Start Gemini AI session' },
+        { name: 'codex', aliases: [], description: 'Start Codex AI session' },
+        { name: 'session', aliases: [], description: 'Advanced session management' },
+    ],
     'CORE COMMANDS': [
         { name: 'create', aliases: [], description: 'Create a new Genbox environment' },
         { name: 'list', aliases: ['ls'], description: 'List genboxes' },
         { name: 'destroy', aliases: ['delete'], description: 'Destroy a Genbox' },
         { name: 'connect', aliases: [], description: 'SSH into a Genbox' },
-        { name: 'session', aliases: [], description: 'Manage AI CLI sessions (local & cloud)' },
         { name: 'status', aliases: [], description: 'Check Genbox status and services' },
     ],
     'LIFECYCLE': [
@@ -262,6 +268,9 @@ program
     .addCommand(destroy_1.destroyCommand)
     .addCommand(connect_1.connectCommand)
     .addCommand(session_1.sessionCommand)
+    .addCommand(provider_command_1.claudeCommand)
+    .addCommand(provider_command_1.geminiCommand)
+    .addCommand(provider_command_1.codexCommand)
     .addCommand(cp_1.cpCommand)
     .addCommand(balance_1.balanceCommand)
     .addCommand(login_1.loginCommand)

package/dist/lib/local-session-manager.js

@@ -311,7 +311,7 @@ class LocalSessionManager {
         }
         try {
             // Try to send an empty string to test if socket is alive
-            (0, child_process_1.execSync)(`echo -n "" | dtach -p "${socketPath}" 2>/dev/null`, {
+            (0, child_process_1.execSync)(`printf '' | dtach -p "${socketPath}" 2>/dev/null`, {
                 timeout: 2000,
                 stdio: 'ignore'
             });

package/dist/lib/native-session-manager.js

@@ -254,7 +254,7 @@ class NativeSessionManager {
         try {
             // Try to send an empty string to test if socket is alive
             const { execSync } = require('child_process');
-            execSync(`echo -n "" | dtach -p "${socketPath}" 2>/dev/null`, {
+            execSync(`printf '' | dtach -p "${socketPath}" 2>/dev/null`, {
                 timeout: 2000,
                 stdio: 'ignore'
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genbox",
-  "version": "1.0.183",
+  "version": "1.0.185",
   "description": "Genbox CLI - AI-Powered Development Environments",
   "main": "dist/index.js",
   "bin": {