genbox 1.0.210 → 1.0.211

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);
+    }
+});