genbox 1.0.209 → 1.0.211

package/dist/commands/provider-command.js

@@ -444,7 +444,7 @@ async function startLocalMultipass(genbox) {
  * Create and attach to a session on a genbox
  */
 async function startSessionOnGenbox(provider, genbox, options = {}) {
-    const { initialPrompt } = options;
+    const { initialPrompt, background = false } = options;
     let targetGenbox = genbox;
     let sshTarget;
     let sshPortArgs = [];
@@ -592,13 +592,32 @@ exec ${cliCommand}
     // 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(`Image auto-upload: ${chalk_1.default.green('enabled')} - Paste local image paths, they'll be uploaded automatically`));
-    console.log(chalk_1.default.dim('Tip: Detach with Ctrl+\\\n'));
-    // Attach to session using SSH proxy with image path interception
     // Extract IP address from sshTarget (format: dev@IP or dev@localhost)
     const attachIpAddress = sshTarget.split('@')[1];
-    // Get port from sshPortArgs if it's a Docker container
     const sshPort = sshPortArgs.length >= 2 ? parseInt(sshPortArgs[1], 10) : undefined;
+    // Background mode: inject prompt and return immediately
+    if (background) {
+        if (initialPrompt) {
+            console.log(chalk_1.default.dim('Injecting prompt in background...'));
+            // Spawn background process to attach, inject prompt, then detach
+            const { injectPromptInBackground } = await Promise.resolve().then(() => __importStar(require('../utils/ssh-proxy')));
+            injectPromptInBackground({
+                ipAddress: attachIpAddress === 'localhost' ? '127.0.0.1' : attachIpAddress,
+                keyPath,
+                genboxName: targetGenbox.name,
+                socketPath,
+                user: 'dev',
+                port: sshPort,
+                prompt: initialPrompt,
+            });
+        }
+        console.log(chalk_1.default.dim(`\nSession running in background.`));
+        console.log(chalk_1.default.dim(`Attach with: ${chalk_1.default.cyan(`gb ${provider} attach ${sessionName}`)}`));
+        return;
+    }
+    // Interactive mode: attach to session
+    console.log(chalk_1.default.dim(`Image auto-upload: ${chalk_1.default.green('enabled')} - Paste local image paths, they'll be uploaded automatically`));
+    console.log(chalk_1.default.dim('Tip: Detach with Ctrl+\\\n'));
     const proc = (0, ssh_proxy_1.attachWithProxy)({
         ipAddress: attachIpAddress === 'localhost' ? '127.0.0.1' : attachIpAddress,
         keyPath,
@@ -611,7 +630,7 @@ exec ${cliCommand}
     });
     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}`)}`));
+    console.log(chalk_1.default.dim(`Reattach with: ${chalk_1.default.cyan(`gb ${provider} attach ${sessionName}`)}`));
 }
 /**
  * Attach to an existing session
@@ -944,7 +963,7 @@ async function runInteractiveFlow(provider) {
  * 5. Starts session with the composed prompt
  */
 async function runPromptModeFlow(provider, options = {}) {
-    const { useEditor = false } = options;
+    const { useEditor = false, background = false } = options;
     console.log(chalk_1.default.bold(`\n${provider.charAt(0).toUpperCase() + provider.slice(1)} - Interactive Prompt Mode`));
     if (useEditor) {
         console.log(chalk_1.default.dim('Compose your prompt in $EDITOR with optional images\n'));
@@ -1053,7 +1072,7 @@ async function runPromptModeFlow(provider, options = {}) {
                 finalPrompt = text;
             }
             // Start session with prompt
-            await startSessionOnGenbox(provider, genbox, { initialPrompt: finalPrompt });
+            await startSessionOnGenbox(provider, genbox, { initialPrompt: finalPrompt, background });
             break;
         }
         case 'create-genbox': {
@@ -1085,7 +1104,7 @@ async function runPromptModeFlow(provider, options = {}) {
             else {
                 finalPrompt = text;
             }
-            await startSessionOnGenbox(provider, genbox, { initialPrompt: finalPrompt });
+            await startSessionOnGenbox(provider, genbox, { initialPrompt: finalPrompt, background });
             break;
         }
         case 'direct': {
@@ -1410,11 +1429,13 @@ function createProviderCommand(provider) {
         .option('-y, --yes', 'Skip confirmations')
         .option('-p, --prompt-mode', 'Interactive prompt mode: compose prompt with optional images')
         .option('-e, --editor', 'Use $EDITOR for prompt input (with -p)')
+        .option('-b, --background', 'Run session in background (with -p), attach later')
         .addHelpText('after', `
 Examples:
   gb ${provider}                        Interactive mode
   gb ${provider} -p                     Prompt mode: inline multiline input
   gb ${provider} -p -e                  Prompt mode: open $EDITOR for input
+  gb ${provider} -p -b                  Prompt mode: run in background
   gb ${provider} list                   List all ${provider} sessions
   gb ${provider} attach [session]       Attach to a session
   gb ${provider} stop [session]         Stop a session
@@ -1427,7 +1448,10 @@ Examples:
         try {
             // -p / --prompt-mode: Interactive prompt with optional images
             if (options.promptMode) {
-                await runPromptModeFlow(provider, { useEditor: options.editor });
+                await runPromptModeFlow(provider, {
+                    useEditor: options.editor,
+                    background: options.background,
+                });
                 return;
             }
             // --on: Use specific genbox

package/dist/commands/session/index.js

@@ -65,6 +65,10 @@ const stop_1 = require("./stop");
 const kill_1 = require("./kill");
 const migrate_1 = require("./migrate");
 const attach_1 = require("./attach");
+const watch_1 = require("./watch");
+const logs_1 = require("./logs");
+const show_1 = require("./show");
+const send_1 = require("./send");
 const child_process_1 = require("child_process");
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
@@ -1768,6 +1772,10 @@ exports.sessionCommand = new commander_1.Command('session')
     .addCommand(stop_1.sessionStopCommand)
     .addCommand(kill_1.sessionKillCommand)
     .addCommand(migrate_1.sessionMigrateCommand)
+    .addCommand(watch_1.sessionWatchCommand)
+    .addCommand(logs_1.sessionLogsCommand)
+    .addCommand(show_1.sessionShowCommand)
+    .addCommand(send_1.sessionSendCommand)
     .action(async (sessionArg, providerArgs, options) => {
     try {
         // Clean up stale sockets on startup (silently)

package/dist/commands/session/logs.js

@@ -0,0 +1,387 @@
+"use strict";
+/**
+ * Session Logs Command
+ *
+ * Stream session transcript and activity logs.
+ * Shows real-time updates of what the AI is doing.
+ *
+ * Usage:
+ *   gb session logs <session>        # Show session transcript
+ *   gb session logs <session> -f     # Follow mode (like tail -f)
+ *   gb session logs <session> --json # JSON output
+ */
+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.sessionLogsCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const unified_session_1 = require("../../lib/unified-session");
+const api_1 = require("../../api");
+/**
+ * Get SSH key path
+ */
+function getPrivateSshKey() {
+    const home = os.homedir();
+    const potentialKeys = [
+        path.join(home, '.ssh', 'id_ed25519'),
+        path.join(home, '.ssh', 'id_rsa'),
+    ];
+    for (const keyPath of potentialKeys) {
+        if (fs.existsSync(keyPath)) {
+            return keyPath;
+        }
+    }
+    return null;
+}
+/**
+ * Format timestamp
+ */
+function formatTime(date) {
+    const d = typeof date === 'string' ? new Date(date) : date;
+    return d.toLocaleTimeString('en-US', { hour12: false });
+}
+/**
+ * Find session by name or ID
+ */
+async function findSession(nameOrId) {
+    const result = await (0, unified_session_1.listAllSessions)({ includeEnded: true });
+    // Check local sessions
+    for (const session of result.sessions) {
+        if (session.name === nameOrId ||
+            session.id === nameOrId ||
+            session.id.startsWith(nameOrId) ||
+            session.name.includes(nameOrId)) {
+            return { session };
+        }
+    }
+    // Check remote sessions
+    for (const remote of result.remoteSessions) {
+        if (remote.name === nameOrId ||
+            remote.name.includes(nameOrId)) {
+            return { remoteSession: remote };
+        }
+    }
+    return null;
+}
+/**
+ * Fetch messages from API
+ */
+async function fetchMessages(sessionId, limit = 50) {
+    try {
+        const response = await (0, api_1.fetchApi)(`/sessions/v2/${sessionId}/messages?limit=${limit}`);
+        return response.messages || [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Fetch events from API
+ */
+async function fetchEvents(sessionId, limit = 100) {
+    try {
+        const response = await (0, api_1.fetchApi)(`/sessions/v2/${sessionId}/events?limit=${limit}`);
+        return response.events || [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get role icon
+ */
+function getRoleIcon(role) {
+    switch (role) {
+        case 'user':
+            return '💬';
+        case 'assistant':
+            return '🤖';
+        default:
+            return '📝';
+    }
+}
+/**
+ * Get event icon
+ */
+function getEventIcon(event) {
+    switch (event) {
+        case 'session_start':
+            return '🚀';
+        case 'session_end':
+            return '🏁';
+        case 'prompt_submitted':
+            return '💬';
+        case 'response_started':
+            return '🤔';
+        case 'response_completed':
+            return '✅';
+        case 'tool_started':
+            return '⚙';
+        case 'tool_completed':
+            return '✓';
+        case 'tool_error':
+            return '❌';
+        case 'state_change':
+            return '🔄';
+        case 'error':
+            return '⚠';
+        default:
+            return '•';
+    }
+}
+/**
+ * Format a message for display
+ */
+function formatMessage(msg) {
+    const icon = getRoleIcon(msg.role);
+    const time = chalk_1.default.dim(`[${formatTime(msg.createdAt)}]`);
+    const roleColor = msg.role === 'user' ? chalk_1.default.cyan : chalk_1.default.green;
+    const roleLabel = roleColor(msg.role === 'user' ? 'User' : 'Assistant');
+    let output = `${time} ${icon} ${roleLabel}:`;
+    if (msg.textPreview) {
+        // Wrap text for readability
+        const preview = msg.textPreview.substring(0, 200);
+        output += ` ${preview}${msg.textPreview.length > 200 ? '...' : ''}`;
+    }
+    if (msg.toolsUsed && msg.toolsUsed.length > 0) {
+        output += chalk_1.default.dim(` [Tools: ${msg.toolsUsed.join(', ')}]`);
+    }
+    return output;
+}
+/**
+ * Format an event for display
+ */
+function formatEvent(evt) {
+    const icon = getEventIcon(evt.event);
+    const time = chalk_1.default.dim(`[${formatTime(evt.createdAt)}]`);
+    const eventLabel = evt.event.replace(/_/g, ' ');
+    let output = `${time} ${icon} ${eventLabel}`;
+    if (evt.data) {
+        if (evt.data.toolName) {
+            output += chalk_1.default.cyan(` ${evt.data.toolName}`);
+        }
+        if (evt.data.filePath) {
+            output += chalk_1.default.dim(` ${evt.data.filePath}`);
+        }
+        if (evt.data.currentState) {
+            output += chalk_1.default.yellow(` → ${evt.data.currentState}`);
+        }
+        if (evt.data.error) {
+            output += chalk_1.default.red(` ${evt.data.error}`);
+        }
+    }
+    return output;
+}
+/**
+ * Format for JSON output
+ */
+function formatJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+/**
+ * Display transcript from API
+ */
+async function displayApiTranscript(session, options) {
+    const sessionId = session.apiSessionIdV2;
+    if (!sessionId) {
+        console.log(chalk_1.default.yellow('\nSession is not synced to API. No transcript available.'));
+        console.log(chalk_1.default.dim('Enable sync with: gb session start --sync'));
+        return;
+    }
+    const limit = parseInt(options.tail || '50');
+    if (options.json) {
+        const messages = await fetchMessages(sessionId, limit);
+        const events = options.events ? await fetchEvents(sessionId, limit) : undefined;
+        formatJson({ messages, events });
+        return;
+    }
+    if (options.events) {
+        // Show events
+        console.log(chalk_1.default.bold(`\nSession Events: ${session.name}`));
+        console.log(chalk_1.default.dim('─'.repeat(70)));
+        const events = await fetchEvents(sessionId, limit);
+        if (events.length === 0) {
+            console.log(chalk_1.default.dim('\nNo events recorded.\n'));
+            return;
+        }
+        for (const evt of events.reverse()) {
+            console.log(formatEvent(evt));
+        }
+        console.log('');
+        return;
+    }
+    // Show messages
+    console.log(chalk_1.default.bold(`\nSession Transcript: ${session.name}`));
+    console.log(chalk_1.default.dim('─'.repeat(70)));
+    const messages = await fetchMessages(sessionId, limit);
+    if (messages.length === 0) {
+        console.log(chalk_1.default.dim('\nNo messages recorded.\n'));
+        return;
+    }
+    for (const msg of messages.reverse()) {
+        console.log(formatMessage(msg));
+    }
+    console.log('');
+}
+/**
+ * Follow mode - continuously poll for updates
+ */
+async function followMode(session, options) {
+    const sessionId = session.apiSessionIdV2;
+    if (!sessionId) {
+        console.log(chalk_1.default.yellow('\nSession is not synced to API. Follow mode unavailable.'));
+        return;
+    }
+    console.log(chalk_1.default.bold(`\nFollowing: ${session.name}`));
+    console.log(chalk_1.default.dim('─'.repeat(70)));
+    console.log(chalk_1.default.dim('Press Ctrl+C to stop\n'));
+    let lastMessageId = null;
+    let lastEventTime = null;
+    while (true) {
+        try {
+            if (options.events || options.tools) {
+                // Poll events
+                const events = await fetchEvents(sessionId, 20);
+                for (const evt of events.reverse()) {
+                    if (lastEventTime && new Date(evt.createdAt) <= new Date(lastEventTime)) {
+                        continue;
+                    }
+                    // Filter for tools only if --tools specified
+                    if (options.tools &&
+                        !evt.event.includes('tool') &&
+                        evt.event !== 'state_change') {
+                        continue;
+                    }
+                    console.log(formatEvent(evt));
+                    lastEventTime = evt.createdAt;
+                }
+            }
+            else {
+                // Poll messages
+                const messages = await fetchMessages(sessionId, 10);
+                for (const msg of messages.reverse()) {
+                    if (lastMessageId === msg.messageId)
+                        continue;
+                    if (lastMessageId) {
+                        console.log(formatMessage(msg));
+                    }
+                    lastMessageId = msg.messageId;
+                }
+            }
+        }
+        catch (error) {
+            // Silently continue on errors
+        }
+        await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+}
+/**
+ * Display local session info when no API sync
+ */
+function displayLocalSessionInfo(session) {
+    console.log(chalk_1.default.bold(`\nSession: ${session.name}`));
+    console.log(chalk_1.default.dim('─'.repeat(50)));
+    console.log(`  Type:     ${session.type}`);
+    console.log(`  Provider: ${session.provider}`);
+    console.log(`  Status:   ${session.status}`);
+    console.log(`  Created:  ${new Date(session.createdAt).toLocaleString()}`);
+    if (session.infrastructure?.dtachSocketPath) {
+        console.log(`  Socket:   ${session.infrastructure.dtachSocketPath}`);
+    }
+    console.log(chalk_1.default.dim('\nThis session is not synced to API. Transcript not available.'));
+    console.log(chalk_1.default.dim('To enable recording, start sessions with --sync flag.'));
+    console.log('');
+    console.log(chalk_1.default.bold('To attach to this session:'));
+    console.log(chalk_1.default.cyan(`  gb ${session.provider} attach ${session.name}\n`));
+}
+exports.sessionLogsCommand = new commander_1.Command('logs')
+    .description('View session transcript and activity logs')
+    .argument('<session>', 'Session name or ID')
+    .option('-f, --follow', 'Follow mode - continuously show new activity')
+    .option('--json', 'Output as JSON')
+    .option('-n, --tail <lines>', 'Number of messages to show (default: 50)')
+    .option('--events', 'Show events instead of messages')
+    .option('--tools', 'Show only tool executions (with -f)')
+    .addHelpText('after', `
+Examples:
+  gb session logs claude-swift-fox    # View transcript
+  gb session logs claude-swift-fox -f # Follow mode
+  gb session logs abc123 --events     # View events
+  gb session logs abc123 --json       # JSON output
+`)
+    .action(async (sessionArg, options) => {
+    try {
+        const found = await findSession(sessionArg);
+        if (!found) {
+            console.log(chalk_1.default.red(`\nSession not found: ${sessionArg}`));
+            console.log(chalk_1.default.dim('\nRun `gb session list` to see available sessions.\n'));
+            process.exit(1);
+        }
+        if (found.remoteSession) {
+            console.log(chalk_1.default.yellow(`\nRemote session: ${found.remoteSession.name}`));
+            console.log(chalk_1.default.dim(`Running on: ${found.remoteSession.genboxName}`));
+            console.log(chalk_1.default.dim('\nRemote sessions must be attached to view logs.'));
+            console.log(chalk_1.default.cyan(`\n  gb ${found.remoteSession.name.split('-')[0]} attach ${found.remoteSession.name}\n`));
+            process.exit(0);
+        }
+        const session = found.session;
+        // Check if session has API sync
+        if (!session.syncEnabled || !session.apiSessionIdV2) {
+            displayLocalSessionInfo(session);
+            process.exit(0);
+        }
+        if (options.follow) {
+            await followMode(session, options);
+        }
+        else {
+            await displayApiTranscript(session, options);
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        if (error instanceof api_1.AuthenticationError) {
+            console.error(chalk_1.default.red('\nNot logged in. Run `gb login` first.\n'));
+            process.exit(1);
+        }
+        console.error(chalk_1.default.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});