genbox 1.0.211 → 1.0.213

package/dist/commands/session/index.js

@@ -69,6 +69,7 @@ const watch_1 = require("./watch");
 const logs_1 = require("./logs");
 const show_1 = require("./show");
 const send_1 = require("./send");
+const templates_1 = require("./templates");
 const child_process_1 = require("child_process");
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
@@ -1776,6 +1777,7 @@ exports.sessionCommand = new commander_1.Command('session')
     .addCommand(logs_1.sessionLogsCommand)
     .addCommand(show_1.sessionShowCommand)
     .addCommand(send_1.sessionSendCommand)
+    .addCommand(templates_1.sessionTemplatesCommand)
     .action(async (sessionArg, providerArgs, options) => {
     try {
         // Clean up stale sockets on startup (silently)

package/dist/commands/session/send.js

@@ -2,13 +2,13 @@
 /**
  * Session Send Command
  *
- * Send a prompt to a running session without attaching.
- * Useful for orchestration and automation.
+ * Send a prompt to running session(s) without attaching.
+ * Supports single session or multi-session broadcasting.
  *
  * Usage:
- *   gb session send <session> "prompt"     # Send inline prompt
- *   gb session send <session> -f file.txt  # Send from file
- *   gb session send <session> -e           # Open editor
+ *   gb session send <session> "prompt"     # Send to single session
+ *   gb session send --all "prompt"         # Broadcast to all sessions
+ *   gb session send --provider claude "prompt"  # Send to all Claude sessions
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -72,6 +72,56 @@ function getPrivateSshKey() {
     }
     return null;
 }
+/**
+ * Find all active sessions matching filters
+ */
+async function findAllSessions(options) {
+    const result = await (0, unified_session_1.listAllSessions)({ includeEnded: false });
+    const targets = [];
+    // Process local sessions
+    for (const session of result.sessions) {
+        if (session.status !== 'running' && session.status !== 'active' && session.status !== 'idle') {
+            continue;
+        }
+        // Filter by provider
+        if (options.provider && session.provider !== options.provider)
+            continue;
+        // Filter by genbox
+        if (options.genbox) {
+            const genboxName = session.infrastructure?.genboxName ||
+                session.infrastructure?.vmName ||
+                session.infrastructure?.containerName ||
+                session.name;
+            if (!genboxName.toLowerCase().includes(options.genbox.toLowerCase()))
+                continue;
+        }
+        targets.push({
+            name: session.name,
+            type: session.type === 'native' ? 'local' :
+                session.type === 'docker' ? 'docker' :
+                    session.type === 'multipass' ? 'multipass' : 'cloud',
+            session,
+        });
+    }
+    // Process remote sessions
+    for (const remote of result.remoteSessions) {
+        // Filter by provider
+        if (options.provider && remote.provider !== options.provider)
+            continue;
+        // Filter by genbox
+        if (options.genbox && !remote.genboxName.toLowerCase().includes(options.genbox.toLowerCase()))
+            continue;
+        targets.push({
+            name: remote.name,
+            type: 'remote',
+            remoteSession: {
+                ...remote,
+                provider: remote.provider,
+            },
+        });
+    }
+    return targets;
+}
 /**
  * Find session by name or ID
  */
@@ -86,7 +136,13 @@ async function findSession(nameOrId) {
             session.id === nameOrId ||
             session.id.startsWith(nameOrId) ||
             session.name.includes(nameOrId)) {
-            return { session };
+            return {
+                name: session.name,
+                type: session.type === 'native' ? 'local' :
+                    session.type === 'docker' ? 'docker' :
+                        session.type === 'multipass' ? 'multipass' : 'cloud',
+                session,
+            };
         }
     }
     // Check remote sessions
@@ -94,10 +150,12 @@ async function findSession(nameOrId) {
         if (remote.name === nameOrId ||
             remote.name.includes(nameOrId)) {
             return {
+                name: remote.name,
+                type: 'remote',
                 remoteSession: {
                     ...remote,
                     provider: remote.provider,
-                }
+                },
             };
         }
     }
@@ -122,6 +180,7 @@ function getPromptFromEditor() {
     // Create temp file with instructions
     fs.writeFileSync(tmpFile, `# Enter your prompt below (lines starting with # are ignored)
 # Save and close the editor when done
+# This prompt will be sent to the session(s)
 
 `);
     // Open editor
@@ -154,11 +213,13 @@ function getDtachSocketDir() {
 /**
  * Send prompt to local native session via dtach
  */
-async function sendToLocalSession(session, prompt, options) {
+async function sendToLocalSession(session, prompt) {
+    const start = Date.now();
     const socketPath = session.infrastructure?.dtachSocketPath ||
         path.join(getDtachSocketDir(), `${session.name}.sock`);
     if (!fs.existsSync(socketPath)) {
         return {
+            session: session.name,
             success: false,
             message: `Socket not found: ${socketPath}. Session may not be running.`,
         };
@@ -169,8 +230,6 @@ async function sendToLocalSession(session, prompt, options) {
             .replace(/\\/g, '\\\\')
             .replace(/'/g, "'\\''")
             .replace(/\n/g, '\\n');
-        // Use printf to send prompt to dtach session
-        // The -p flag attaches briefly to push input
         const result = (0, child_process_1.spawnSync)('bash', [
             '-c',
             `printf '%s\\n' '${escapedPrompt}' | dtach -p "${socketPath}"`,
@@ -180,17 +239,21 @@ async function sendToLocalSession(session, prompt, options) {
         });
         if (result.status !== 0) {
             return {
+                session: session.name,
                 success: false,
                 message: `Failed to send prompt: ${result.stderr || 'Unknown error'}`,
             };
         }
         return {
+            session: session.name,
             success: true,
-            message: `Prompt sent to ${session.name}`,
+            message: `Prompt sent`,
+            duration: Date.now() - start,
         };
     }
     catch (error) {
         return {
+            session: session.name,
             success: false,
             message: `Error: ${error.message}`,
         };
@@ -200,9 +263,11 @@ async function sendToLocalSession(session, prompt, options) {
  * Send prompt to remote session via SSH + dtach
  */
 async function sendToRemoteSession(ipAddress, sessionName, prompt, sshPort) {
+    const start = Date.now();
     const keyPath = getPrivateSshKey();
     if (!keyPath) {
         return {
+            session: sessionName,
             success: false,
             message: 'SSH key not found. Run `gb login` first.',
         };
@@ -232,17 +297,21 @@ async function sendToRemoteSession(ipAddress, sessionName, prompt, sshPort) {
         });
         if (result.status !== 0) {
             return {
+                session: sessionName,
                 success: false,
                 message: `Failed to send prompt: ${result.stderr || 'Unknown error'}`,
             };
         }
         return {
+            session: sessionName,
             success: true,
-            message: `Prompt sent to ${sessionName}`,
+            message: `Prompt sent`,
+            duration: Date.now() - start,
         };
     }
     catch (error) {
         return {
+            session: sessionName,
             success: false,
             message: `Error: ${error.message}`,
         };
@@ -251,7 +320,8 @@ async function sendToRemoteSession(ipAddress, sessionName, prompt, sshPort) {
 /**
  * Send prompt via API remote control
  */
-async function sendViaApi(sessionId, prompt) {
+async function sendViaApi(sessionId, sessionName, prompt) {
+    const start = Date.now();
     try {
         await (0, api_1.fetchApi)(`/sessions/v2/${sessionId}/command`, {
             method: 'POST',
@@ -262,34 +332,111 @@ async function sendViaApi(sessionId, prompt) {
             }),
         });
         return {
+            session: sessionName,
             success: true,
             message: 'Prompt queued via API',
+            duration: Date.now() - start,
         };
     }
     catch (error) {
         return {
+            session: sessionName,
             success: false,
             message: `API error: ${error.message}`,
         };
     }
 }
+/**
+ * Send prompt to a single target
+ */
+async function sendToTarget(target, prompt) {
+    if (target.remoteSession) {
+        return sendToRemoteSession(target.remoteSession.ipAddress, target.remoteSession.name, prompt);
+    }
+    const session = target.session;
+    if (target.type === 'local') {
+        return sendToLocalSession(session, prompt);
+    }
+    else if (target.type === 'cloud' && session.infrastructure?.ipAddress) {
+        return sendToRemoteSession(session.infrastructure.ipAddress, session.name, prompt);
+    }
+    else if (target.type === 'docker' || target.type === 'multipass') {
+        const ip = target.type === 'docker' ? '127.0.0.1' : session.infrastructure?.vmIpAddress;
+        const port = session.infrastructure?.sshPort;
+        if (!ip) {
+            return {
+                session: session.name,
+                success: false,
+                message: 'Cannot determine session IP address',
+            };
+        }
+        return sendToRemoteSession(ip, session.name, prompt, port);
+    }
+    else if (session.syncEnabled && session.apiSessionIdV2) {
+        return sendViaApi(session.apiSessionIdV2, session.name, prompt);
+    }
+    return {
+        session: session.name,
+        success: false,
+        message: `Cannot send to session type: ${session.type}`,
+    };
+}
+/**
+ * Send to multiple sessions
+ */
+async function sendToMultipleSessions(targets, prompt, parallel) {
+    if (parallel) {
+        // Send in parallel
+        return Promise.all(targets.map(target => sendToTarget(target, prompt)));
+    }
+    // Send sequentially
+    const results = [];
+    for (const target of targets) {
+        results.push(await sendToTarget(target, prompt));
+    }
+    return results;
+}
 exports.sessionSendCommand = new commander_1.Command('send')
-    .description('Send a prompt to a running session')
-    .argument('<session>', 'Session name or ID')
+    .description('Send a prompt to running session(s)')
+    .argument('[session]', 'Session name or ID (not needed with --all)')
     .argument('[prompt]', 'Prompt text (or use -f/-e)')
     .option('-f, --file <path>', 'Read prompt from file')
     .option('-e, --editor', 'Open $EDITOR to compose prompt')
-    .option('--wait', 'Wait for response (if API sync enabled)')
+    .option('--all', 'Send to ALL active sessions (broadcast)')
+    .option('--provider <provider>', 'Filter by provider when using --all (claude, gemini, codex)')
+    .option('--genbox <name>', 'Filter by genbox name when using --all')
+    .option('--parallel', 'Send to all sessions in parallel (default: sequential)')
     .option('--json', 'Output result as JSON')
     .addHelpText('after', `
 Examples:
+  # Single session
   gb session send claude-fox "Add unit tests"    # Inline prompt
   gb session send claude-fox -f prompt.txt       # From file
   gb session send claude-fox -e                  # Open editor
-  gb session send abc123 "Fix bug" --json        # JSON output
+
+  # Multi-session broadcast
+  gb session send --all "Run the test suite"           # All sessions
+  gb session send --all --provider claude "Fix bugs"   # All Claude sessions
+  gb session send --all --genbox dusty "Deploy"        # All on dusty genbox
+  gb session send --all --parallel "Check status"      # Parallel broadcast
+
+  # JSON output (for scripting)
+  gb session send --all --json "Hello"           # JSON results
 `)
     .action(async (sessionArg, promptArg, options) => {
     try {
+        // Validate arguments
+        if (!options.all && !sessionArg) {
+            console.log(chalk_1.default.red('\nNo session specified.'));
+            console.log(chalk_1.default.dim('Use: gb session send <session> "prompt"'));
+            console.log(chalk_1.default.dim('  or: gb session send --all "prompt"\n'));
+            process.exit(1);
+        }
+        // Handle the case where session arg might actually be the prompt for --all
+        let actualPromptArg = promptArg;
+        if (options.all && sessionArg && !promptArg) {
+            actualPromptArg = sessionArg;
+        }
         // Get the prompt
         let prompt;
         if (options.file) {
@@ -298,17 +445,88 @@ Examples:
         else if (options.editor) {
             prompt = getPromptFromEditor();
         }
-        else if (promptArg) {
-            prompt = promptArg;
+        else if (actualPromptArg) {
+            prompt = actualPromptArg;
         }
         else {
             console.log(chalk_1.default.red('\nNo prompt provided.'));
             console.log(chalk_1.default.dim('Use: gb session send <session> "prompt"'));
-            console.log(chalk_1.default.dim('  or: gb session send <session> -f file.txt'));
-            console.log(chalk_1.default.dim('  or: gb session send <session> -e\n'));
+            console.log(chalk_1.default.dim('  or: gb session send --all -f prompt.txt'));
+            console.log(chalk_1.default.dim('  or: gb session send --all -e\n'));
             process.exit(1);
         }
-        // Find the session
+        // Handle multi-session broadcast
+        if (options.all) {
+            const targets = await findAllSessions({
+                provider: options.provider,
+                genbox: options.genbox,
+            });
+            if (targets.length === 0) {
+                const output = {
+                    success: false,
+                    error: 'No active sessions found matching filters',
+                    filters: {
+                        provider: options.provider,
+                        genbox: options.genbox,
+                    },
+                };
+                if (options.json) {
+                    console.log(JSON.stringify(output));
+                }
+                else {
+                    console.log(chalk_1.default.red('\nNo active sessions found matching filters.'));
+                    if (options.provider)
+                        console.log(chalk_1.default.dim(`  Provider: ${options.provider}`));
+                    if (options.genbox)
+                        console.log(chalk_1.default.dim(`  Genbox: ${options.genbox}`));
+                    console.log(chalk_1.default.dim('\nRun `gb session list` to see active sessions.\n'));
+                }
+                process.exit(1);
+            }
+            if (!options.json) {
+                console.log(chalk_1.default.bold(`\nBroadcasting to ${targets.length} session(s)...`));
+                console.log(chalk_1.default.dim(`Prompt: "${prompt.substring(0, 50)}${prompt.length > 50 ? '...' : ''}"`));
+                console.log('');
+            }
+            const results = await sendToMultipleSessions(targets, prompt, !!options.parallel);
+            // Output results
+            if (options.json) {
+                const successCount = results.filter(r => r.success).length;
+                console.log(JSON.stringify({
+                    success: successCount === results.length,
+                    total: results.length,
+                    succeeded: successCount,
+                    failed: results.length - successCount,
+                    promptLength: prompt.length,
+                    results,
+                }, null, 2));
+            }
+            else {
+                let successCount = 0;
+                let failCount = 0;
+                for (const result of results) {
+                    if (result.success) {
+                        successCount++;
+                        console.log(chalk_1.default.green(`  ✓ ${result.session}`) + chalk_1.default.dim(` (${result.duration}ms)`));
+                    }
+                    else {
+                        failCount++;
+                        console.log(chalk_1.default.red(`  ✗ ${result.session}: ${result.message}`));
+                    }
+                }
+                console.log('');
+                if (failCount === 0) {
+                    console.log(chalk_1.default.green(`✓ Sent to all ${successCount} session(s)`));
+                }
+                else {
+                    console.log(chalk_1.default.yellow(`Sent to ${successCount}/${results.length} sessions (${failCount} failed)`));
+                }
+                console.log('');
+            }
+            const anyFailed = results.some(r => !r.success);
+            process.exit(anyFailed ? 1 : 0);
+        }
+        // Single session send
         const found = await findSession(sessionArg);
         if (!found) {
             const output = {
@@ -324,67 +542,27 @@ Examples:
             }
             process.exit(1);
         }
-        let result;
-        if (found.remoteSession) {
-            // Remote session on cloud genbox
-            if (!options.json) {
-                console.log(chalk_1.default.dim(`\nSending to remote session: ${found.remoteSession.name}`));
-                console.log(chalk_1.default.dim(`  Genbox: ${found.remoteSession.genboxName}`));
-            }
-            result = await sendToRemoteSession(found.remoteSession.ipAddress, found.remoteSession.name, prompt);
-        }
-        else {
-            const session = found.session;
-            if (!options.json) {
-                console.log(chalk_1.default.dim(`\nSending to session: ${session.name}`));
-            }
-            // Try different methods based on session type
-            if (session.type === 'native') {
-                // Local native session - use dtach directly
-                result = await sendToLocalSession(session, prompt, options);
-            }
-            else if (session.type === 'cloud' && session.infrastructure?.ipAddress) {
-                // Cloud session - use SSH
-                result = await sendToRemoteSession(session.infrastructure.ipAddress, session.name, prompt);
-            }
-            else if (session.type === 'docker' || session.type === 'multipass') {
-                // Local VM/Docker - use SSH to localhost with port
-                const ip = session.type === 'docker' ? '127.0.0.1' : session.infrastructure?.vmIpAddress;
-                const port = session.infrastructure?.sshPort;
-                if (!ip) {
-                    result = { success: false, message: 'Cannot determine session IP address' };
-                }
-                else {
-                    result = await sendToRemoteSession(ip, session.name, prompt, port);
-                }
-            }
-            else if (session.syncEnabled && session.apiSessionIdV2) {
-                // Fall back to API remote control
-                result = await sendViaApi(session.apiSessionIdV2, prompt);
-            }
-            else {
-                result = {
-                    success: false,
-                    message: `Cannot send to session type: ${session.type}`,
-                };
-            }
+        if (!options.json) {
+            console.log(chalk_1.default.dim(`\nSending to session: ${found.name}`));
         }
+        const result = await sendToTarget(found, prompt);
         // Output result
         if (options.json) {
             console.log(JSON.stringify({
                 success: result.success,
                 message: result.message,
-                session: found.session?.name || found.remoteSession?.name,
+                session: result.session,
                 promptLength: prompt.length,
+                duration: result.duration,
             }));
         }
         else {
             if (result.success) {
-                console.log(chalk_1.default.green(`\n✓ ${result.message}`));
+                console.log(chalk_1.default.green(`\n✓ ${result.message} to ${result.session}`));
                 console.log(chalk_1.default.dim(`  Prompt: "${prompt.substring(0, 50)}${prompt.length > 50 ? '...' : ''}"`));
                 console.log('');
                 console.log(chalk_1.default.dim('View progress:'));
-                console.log(chalk_1.default.cyan(`  gb session logs ${found.session?.name || found.remoteSession?.name} -f\n`));
+                console.log(chalk_1.default.cyan(`  gb session logs ${result.session} -f\n`));
             }
             else {
                 console.log(chalk_1.default.red(`\n✗ ${result.message}\n`));