genbox 1.0.225 → 1.0.226

package/dist/commands/session/show.js

@@ -103,17 +103,120 @@ fi
 }
 /**
  * Query genbox daemon for events
+ * First finds the matching session by provider (from CLI session name prefix),
+ * then queries events using the daemon's internal session UUID
  */
-async function queryGenboxDaemonEvents(genboxName, limit = 50) {
+async function queryGenboxDaemonEvents(genboxName, cliSessionName, limit = 50) {
     try {
-        const result = (0, child_process_1.execSync)(`ssh genbox-${genboxName} 'curl -s "http://127.0.0.1:47191/api/storage/events?limit=${limit}" 2>/dev/null || curl -s "http://127.0.0.1:47192/api/storage/events?limit=${limit}" 2>/dev/null' 2>/dev/null`, { encoding: 'utf8', timeout: 10000 });
-        const data = JSON.parse(result);
-        return data.events || [];
+        // First get all sessions to find the UUID
+        const sessionsResult = (0, child_process_1.execSync)(`ssh -o ConnectTimeout=5 -o BatchMode=yes genbox-${genboxName} 'curl -s http://127.0.0.1:47191/api/storage/sessions 2>/dev/null || curl -s http://127.0.0.1:47192/api/storage/sessions 2>/dev/null' 2>/dev/null`, { encoding: 'utf8', timeout: 10000 });
+        const sessionsData = JSON.parse(sessionsResult);
+        const sessions = sessionsData.sessions || [];
+        if (sessions.length === 0) {
+            return [];
+        }
+        // Extract provider from CLI session name (e.g., "claude-mjy6oh8l" -> "claude")
+        const provider = cliSessionName.split('-')[0];
+        // Find matching session by provider, preferring the most recent active one
+        let matchingSession = sessions
+            .filter((s) => s.provider === provider)
+            .sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0))[0];
+        // Fallback to most recent session if no provider match
+        if (!matchingSession && sessions.length > 0) {
+            matchingSession = sessions
+                .sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0))[0];
+        }
+        if (!matchingSession) {
+            return [];
+        }
+        // Now query events using the daemon's session UUID
+        const eventsResult = (0, child_process_1.execSync)(`ssh -o ConnectTimeout=5 -o BatchMode=yes genbox-${genboxName} 'curl -s "http://127.0.0.1:47191/api/storage/events?sessionId=${matchingSession.id}&limit=${limit}" 2>/dev/null || curl -s "http://127.0.0.1:47192/api/storage/events?sessionId=${matchingSession.id}&limit=${limit}" 2>/dev/null' 2>/dev/null`, { encoding: 'utf8', timeout: 10000 });
+        const eventsData = JSON.parse(eventsResult);
+        return eventsData.events || [];
     }
     catch {
         return [];
     }
 }
+/**
+ * Format events into a readable activity log
+ */
+function formatEventsAsActivityLog(events) {
+    if (!events || events.length === 0) {
+        return '';
+    }
+    const lines = [];
+    // Sort events by timestamp (oldest first for reading order)
+    const sortedEvents = [...events].sort((a, b) => {
+        const timeA = new Date(a.timestamp || a.createdAt || 0).getTime();
+        const timeB = new Date(b.timestamp || b.createdAt || 0).getTime();
+        return timeA - timeB;
+    });
+    for (const event of sortedEvents.slice(-30)) { // Last 30 events
+        const eventType = event.type || event.eventType || '';
+        const timestamp = event.timestamp || event.createdAt;
+        const timeStr = timestamp ? new Date(timestamp).toLocaleTimeString() : '';
+        switch (eventType) {
+            case 'before_prompt':
+            case 'user_prompt':
+            case 'prompt_submitted':
+                const prompt = event.data?.prompt || event.prompt || event.data?.message || '';
+                if (prompt) {
+                    const truncated = prompt.substring(0, 80).replace(/\n/g, ' ');
+                    lines.push(chalk_1.default.dim(`[${timeStr}]`) + chalk_1.default.cyan(' You: ') + truncated + (prompt.length > 80 ? '...' : ''));
+                }
+                break;
+            case 'after_prompt':
+            case 'response_completed':
+            case 'response':
+                // For response_completed, extract meaningful info if available
+                const response = event.data?.response || event.data?.message || event.response || '';
+                const stopReason = event.data?.stopReason || '';
+                if (response) {
+                    const truncated = response.substring(0, 80).replace(/\n/g, ' ');
+                    lines.push(chalk_1.default.dim(`[${timeStr}]`) + chalk_1.default.green(' Claude: ') + truncated + (response.length > 80 ? '...' : ''));
+                }
+                else if (stopReason === '' || stopReason === 'end_turn') {
+                    lines.push(chalk_1.default.dim(`[${timeStr}]`) + chalk_1.default.green(' ✓ Response completed'));
+                }
+                break;
+            case 'before_tool':
+            case 'tool_started':
+                const toolName = event.data?.toolName || event.toolName || event.data?.tool_name || '';
+                if (toolName) {
+                    // Shorten long MCP tool names
+                    const shortName = toolName.replace(/^mcp__plugin_playwright_playwright__/, 'pw:');
+                    lines.push(chalk_1.default.dim(`[${timeStr}]`) + chalk_1.default.yellow(' ⚙ Tool: ') + shortName);
+                }
+                break;
+            case 'after_tool':
+            case 'tool_completed':
+                const completedTool = event.data?.toolName || event.toolName || event.data?.tool_name || '';
+                const success = event.data?.success !== false;
+                if (completedTool) {
+                    const shortName = completedTool.replace(/^mcp__plugin_playwright_playwright__/, 'pw:');
+                    const statusIcon = success ? chalk_1.default.green('✓') : chalk_1.default.red('✗');
+                    lines.push(chalk_1.default.dim(`[${timeStr}]`) + ` ${statusIcon} ${shortName} completed`);
+                }
+                break;
+            case 'notification':
+                const message = event.data?.message || '';
+                if (message) {
+                    lines.push(chalk_1.default.dim(`[${timeStr}]`) + chalk_1.default.blue(' ℹ ') + message);
+                }
+                break;
+            case 'session_start':
+            case 'session_started':
+                lines.push(chalk_1.default.dim(`[${timeStr}]`) + chalk_1.default.blue(' ▶ Session started'));
+                break;
+            case 'session_end':
+            case 'session_ended':
+                lines.push(chalk_1.default.dim(`[${timeStr}]`) + chalk_1.default.red(' ■ Session ended'));
+                break;
+        }
+    }
+    return lines.join('\n');
+}
 /**
  * Find session by name or ID
  */
@@ -228,97 +331,235 @@ function calculateCacheHitRate(cacheRead, totalInput) {
 function stripAnsi(str) {
     // eslint-disable-next-line no-control-regex
     return str
+        // Proper ANSI sequences (with ESC character)
         .replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '') // Standard ANSI sequences
         .replace(/\x1B\[[\d;]*[A-Za-z]/g, '') // CSI sequences like [38;2;...m
         .replace(/\x1B\[\??\d+[hl]/g, '') // Mode sequences like [?25h
-        .replace(/[\x00-\x09\x0B\x0C\x0E-\x1F]/g, ''); // Control chars except \n and \r
+        // Broken ANSI sequences (missing ESC char, common from dtach capture)
+        .replace(/\[([0-9]+;)*[0-9]*m/g, '') // SGR codes like [2m, [38;2;153;153;153m
+        .replace(/\[\?[0-9]+[hl]/g, '') // Mode codes like [?25h
+        .replace(/\[[0-9]*[ABCDJKH]/g, '') // Cursor movement like [1A, [2K, [H
+        .replace(/\[[0-9]*G/g, '') // Column positioning
+        // Control chars except \n and \r
+        .replace(/[\x00-\x09\x0B\x0C\x0E-\x1F]/g, '')
+        .replace(/\x1B/g, ''); // Leftover ESC characters
 }
 /**
  * Clean terminal output for display (remove cursor movement, preserve colors)
+ *
+ * Terminal captures include screen-clear and line-erase sequences that would
+ * result in empty output if processed literally. We extract meaningful content
+ * by finding lines with actual visible text.
  */
 function cleanTerminalOutput(output) {
-    return output
-        // Remove cursor positioning sequences
-        .replace(/\x1B\[\d*[ABCD]/g, '') // Cursor movement (up/down/forward/back)
-        .replace(/\x1B\[\d*G/g, '') // Cursor horizontal absolute
-        .replace(/\x1B\[[\d;]*H/g, '') // Cursor position
-        .replace(/\x1B\[\d*[JK]/g, '') // Erase sequences (clear screen/line)
-        .replace(/\x1B\[\?25[hl]/g, '') // Show/hide cursor
-        .replace(/\x1B\[\?\d+[hl]/g, '') // Other private mode sequences
-        // Remove script header/footer
+    // Remove script command header/footer first
+    let cleaned = output
         .replace(/Script started on.*\n?/g, '')
-        .replace(/Script done on.*\n?/g, '')
-        // Clean up empty lines and duplicates
-        .split('\n')
-        .filter((line, index, array) => {
-        // Remove lines that are just whitespace
-        if (!line.trim())
-            return index === 0 || array[index - 1]?.trim();
-        return true;
-    })
-        .join('\n');
+        .replace(/Script done on.*\n?/g, '');
+    // The dtach/script capture often loses the ESC character, leaving raw codes like [2m or [38;2;...
+    // We need to handle both proper ANSI sequences (\x1B[...) and broken ones ([...)
+    // Find the last occurrence of screen clear - check both proper and broken formats
+    const lastClearIndex = Math.max(cleaned.lastIndexOf('\x1B[H\x1B[J'), cleaned.lastIndexOf('\x1B[2J'), cleaned.lastIndexOf('[H[J'), cleaned.lastIndexOf('[2J'));
+    if (lastClearIndex > 0) {
+        // Take content after the last screen clear
+        cleaned = cleaned.substring(lastClearIndex);
+    }
+    // Strip ALL ANSI sequences - both proper (\x1B[...) and broken ([...)
+    // This is more aggressive but ensures clean output
+    cleaned = cleaned
+        // Proper ANSI CSI sequences
+        .replace(/\x1B\[[0-9;]*[A-Za-z]/g, '')
+        .replace(/\x1B\[\?[0-9;]+[hl]/g, '')
+        .replace(/\x1B\][^\x07]*\x07/g, '') // OSC sequences
+        .replace(/\x1B[()][AB012]/g, '') // Character set sequences
+        .replace(/\x1B[=>]/g, '') // Keypad modes
+        // Broken ANSI sequences (missing ESC character) - very common from dtach capture
+        .replace(/\[([0-9]+;)*[0-9]*m/g, '') // SGR codes like [2m, [38;2;153;153;153m
+        .replace(/\[\?[0-9]+[hl]/g, '') // Mode codes like [?25h
+        .replace(/\[[0-9]*[ABCDJKH]/g, '') // Cursor movement like [1A, [2K, [H
+        .replace(/\[[0-9]*G/g, '') // Column positioning
+        // Control characters
+        .replace(/[\x00-\x08\x0B-\x0C\x0E-\x1F]/g, '')
+        .replace(/\x1B/g, ''); // Leftover ESC characters
+    // Split into lines and filter
+    const lines = cleaned.split('\n');
+    const resultLines = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Keep lines that have actual visible content (not just dashes/decoration)
+        if (trimmed.length > 0 && !/^[-─═]+$/.test(trimmed)) {
+            resultLines.push(line);
+        }
+    }
+    // If we got nothing meaningful, try extracting any recognizable text
+    if (resultLines.length === 0) {
+        const words = cleaned.match(/[a-zA-Z][a-zA-Z0-9\s]{2,}/g);
+        if (words && words.length > 0) {
+            return words.join(' ').substring(0, 200);
+        }
+        return '(no displayable content)';
+    }
+    return resultLines.join('\n');
 }
 /**
- * Render terminal output in a box
+ * Render terminal output - display raw terminal content with colors preserved
+ * This matches the Claude Code display style with full-width output
  */
 function renderTerminalOutput(output, maxLines = 30) {
     const termWidth = process.stdout.columns || 100;
-    const boxWidth = Math.min(termWidth - 4, 120);
-    const contentWidth = boxWidth - 4;
-    // Clean up the terminal output before rendering
-    const cleanedOutput = cleanTerminalOutput(output);
-    const lines = cleanedOutput.split('\n').slice(-maxLines);
-    console.log(chalk_1.default.dim('╭─ ' + chalk_1.default.bold('Terminal Output') + ' ' + '─'.repeat(Math.max(0, boxWidth - 20)) + '╮'));
-    for (const line of lines) {
-        // Preserve ANSI codes but truncate if too long
-        const stripped = stripAnsi(line);
-        let displayLine = line;
-        if (stripped.length > contentWidth) {
-            // Truncate the line, trying to keep ANSI codes intact
-            displayLine = line.substring(0, contentWidth + (line.length - stripped.length)) + chalk_1.default.dim('…');
+    // Remove script headers
+    let display = output
+        .replace(/Script started on.*\n?/g, '')
+        .replace(/Script done on.*\n?/g, '');
+    // Fix broken ANSI codes (ESC character lost during dtach capture)
+    // Convert [32m to \x1B[32m (add back the ESC character)
+    // Handle various SGR patterns: [0m, [1m, [22m, [38;2;r;g;bm, [7m, [27m, etc.
+    display = display.replace(/(?<!\x1B)\[(\d+(?:;\d+)*)?m/g, '\x1B[$1m');
+    // Also fix broken CSI sequences for bold, dim, etc.
+    // [1m (bold), [2m (dim), [7m (reverse), [22m (normal), [27m (no reverse)
+    display = display.replace(/(?<!\x1B)\[([0-9]+)m/g, '\x1B[$1m');
+    // Find the last complete screen frame (after last clear or cursor home)
+    const clearPatterns = [
+        '\x1B[H\x1B[J', // Home + Clear
+        '\x1B[2J', // Clear screen
+        '\x1B[H\x1B[2J', // Home + Clear all
+    ];
+    let lastClearIndex = -1;
+    for (const pattern of clearPatterns) {
+        const idx = display.lastIndexOf(pattern);
+        if (idx > lastClearIndex) {
+            lastClearIndex = idx + pattern.length;
+        }
+    }
+    // If we found a clear, start from there; otherwise use all content
+    let lastFrame = lastClearIndex > 0 ? display.substring(lastClearIndex) : display;
+    // Remove control sequences that cause display issues, but KEEP color codes
+    lastFrame = lastFrame
+        // Remove cursor visibility commands
+        .replace(/\x1B\[\?25[hl]/g, '')
+        .replace(/\[\?25[hl]/g, '')
+        // Remove alternate screen buffer commands
+        .replace(/\x1B\[\?1049[hl]/g, '')
+        .replace(/\[\?1049[hl]/g, '')
+        // Remove other private mode commands
+        .replace(/\x1B\[\?\d+[hl]/g, '')
+        .replace(/\[\?\d+[hl]/g, '')
+        // Remove cursor movement
+        .replace(/\x1B\[\d*G/g, '') // Cursor to column
+        .replace(/\[\d*G/g, '')
+        .replace(/\x1B\[\d*A/g, '') // Cursor up
+        .replace(/\[\d*A/g, '')
+        .replace(/\x1B\[\d*B/g, '') // Cursor down
+        .replace(/\[\d*B/g, '')
+        .replace(/\x1B\[\d*C/g, '') // Cursor forward
+        .replace(/\[\d*C/g, '')
+        .replace(/\x1B\[\d*D/g, '') // Cursor back
+        .replace(/\[\d*D/g, '')
+        .replace(/\x1B\[\d*H/g, '') // Cursor position
+        .replace(/\[\d*H/g, '')
+        .replace(/\x1B\[\d*;\d*H/g, '') // Cursor position with row;col
+        .replace(/\[\d*;\d*H/g, '')
+        // Remove line clearing
+        .replace(/\x1B\[\d*K/g, '')
+        .replace(/\[\d*K/g, '')
+        // Remove screen clearing
+        .replace(/\x1B\[\d*J/g, '')
+        .replace(/\[\d*J/g, '')
+        // Clean up carriage returns and normalize newlines
+        .replace(/\r\n/g, '\n')
+        .replace(/\r/g, '\n')
+        // Collapse multiple newlines
+        .replace(/\n{3,}/g, '\n\n');
+    // Split into lines and filter out empty ones
+    const rawLines = lastFrame.split('\n')
+        .filter(l => l.trim().length > 0);
+    // Deduplicate similar lines (spinner frames show same content with different spinner chars)
+    const lines = [];
+    const seenSignatures = new Set();
+    for (let i = rawLines.length - 1; i >= 0 && lines.length < maxLines; i--) {
+        const line = rawLines[i];
+        // Create a signature by removing spinner characters and ANSI codes
+        const sig = line
+            .replace(/[✢✶✻·*⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/g, '') // spinner chars
+            .replace(/\x1B\[[0-9;]*m/g, '') // ANSI color codes
+            .trim()
+            .substring(0, 60);
+        // For short signatures (likely just spinner), always add
+        // For longer signatures, dedupe
+        if (sig.length <= 10 || !seenSignatures.has(sig)) {
+            lines.unshift(line);
+            if (sig.length > 10) {
+                seenSignatures.add(sig);
+            }
         }
-        // Pad to box width
-        const padding = ' '.repeat(Math.max(0, contentWidth - stripAnsi(displayLine).length));
-        console.log(chalk_1.default.dim('│ ') + displayLine + padding + chalk_1.default.dim(' │'));
     }
-    console.log(chalk_1.default.dim('╰' + '─'.repeat(boxWidth - 2) + '╯'));
+    // Output with full width, no left padding
+    console.log(chalk_1.default.dim('─'.repeat(termWidth - 1)));
+    if (lines.length === 0) {
+        console.log(chalk_1.default.dim('  (no displayable content)'));
+    }
+    else {
+        for (const line of lines) {
+            // Ensure line doesn't exceed terminal width
+            const visibleLength = stripAnsi(line).length;
+            if (visibleLength > termWidth) {
+                console.log(line.substring(0, termWidth + (line.length - visibleLength)));
+            }
+            else {
+                console.log(line);
+            }
+        }
+    }
+    console.log(chalk_1.default.dim('─'.repeat(termWidth - 1)));
 }
 /**
- * Follow terminal output in real-time
+ * Follow terminal output in real-time - full screen like Claude Code
  */
 async function followTerminalOutput(genboxName, sessionName, lines = 30) {
     let lastOutput = '';
     let running = true;
+    const termWidth = process.stdout.columns || 100;
+    const termHeight = process.stdout.rows || 24;
+    // Enter alternate screen buffer (like vim/htop)
+    process.stdout.write('\x1B[?1049h');
     // Hide cursor
     process.stdout.write('\x1B[?25l');
-    console.log(chalk_1.default.bold(`\nFollowing: ${sessionName}`));
-    console.log(chalk_1.default.dim('Press Ctrl+C to stop\n'));
     const cleanup = () => {
         running = false;
         // Show cursor
         process.stdout.write('\x1B[?25h');
-        console.log(chalk_1.default.dim('\nStopped following.\n'));
+        // Exit alternate screen buffer
+        process.stdout.write('\x1B[?1049l');
+        console.log(chalk_1.default.dim('Stopped following.\n'));
     };
     process.on('SIGINT', cleanup);
     process.on('SIGTERM', cleanup);
     while (running) {
         try {
             const output = await queryGenboxTerminalOutput(genboxName, sessionName, lines);
+            // Check if output changed
             if (output && output !== lastOutput) {
                 lastOutput = output;
-                // Clear screen and render new output
-                process.stdout.write('\x1B[2J\x1B[H');
-                console.log(chalk_1.default.bold.inverse(` ${sessionName} `) + chalk_1.default.dim(` on ${genboxName} - ${new Date().toLocaleTimeString()}`));
-                console.log('');
-                renderTerminalOutput(output, lines);
-                console.log('');
-                console.log(chalk_1.default.dim('  Press Ctrl+C to stop'));
+                // Clear screen and move to home
+                process.stdout.write('\x1B[H\x1B[J');
+                // Status bar at top - minimal, full width
+                const timestamp = new Date().toLocaleTimeString();
+                const leftPart = `● ${sessionName}`;
+                const rightPart = `${genboxName} • ${timestamp}`;
+                const padding = Math.max(0, termWidth - leftPart.length - rightPart.length - 2);
+                console.log(chalk_1.default.inverse(` ${leftPart}${' '.repeat(padding)}${rightPart} `));
+                // Calculate available lines for content
+                const contentLines = Math.max(10, termHeight - 3);
+                renderTerminalOutput(output, contentLines);
+                // Footer at bottom
+                const controls = chalk_1.default.dim('[Ctrl+C]') + ' Stop';
+                console.log(chalk_1.default.inverse(' ' + controls + ' '.repeat(Math.max(0, termWidth - stripAnsi(controls).length - 1))));
             }
         }
         catch {
             // Ignore errors, keep trying
         }
-        await new Promise(resolve => setTimeout(resolve, 1000));
+        await new Promise(resolve => setTimeout(resolve, 2000));
     }
 }
 /**
@@ -506,20 +747,23 @@ Examples:
                     await followTerminalOutput(found.remoteSession.genboxName, found.remoteSession.name, lines);
                     process.exit(0);
                 }
-                // One-shot mode: show current output and exit
+                // One-shot mode: show full terminal output
                 console.log('');
                 console.log(chalk_1.default.bold.inverse(` ${found.remoteSession.name} `) + chalk_1.default.dim(` on ${found.remoteSession.genboxName}`));
                 console.log('');
+                // Fetch terminal output
                 const output = await queryGenboxTerminalOutput(found.remoteSession.genboxName, found.remoteSession.name, lines);
-                if (output) {
+                if (output && output.trim()) {
                     renderTerminalOutput(output, lines);
                 }
                 else {
                     console.log(chalk_1.default.yellow('  No terminal output available.'));
-                    console.log(chalk_1.default.dim('  The session may be starting up or the daemon may not be running.'));
+                    console.log(chalk_1.default.dim('  The session may be starting up or waiting for input.'));
+                    console.log('');
                 }
                 console.log('');
                 console.log(chalk_1.default.dim('  Tip: Use --follow (-f) to continuously stream output'));
+                console.log(chalk_1.default.dim('       Use gb session logs <session> to view activity log'));
                 console.log(chalk_1.default.dim('       Use gb claude attach to interact with the session'));
                 console.log('');
                 process.exit(0);