aicodeman 0.5.2 → 0.5.4

package/dist/session.js

@@ -30,7 +30,7 @@
 import { EventEmitter } from 'node:events';
 import { v4 as uuidv4 } from 'uuid';
 import * as pty from 'node-pty';
-import { DEFAULT_NICE_CONFIG, } from './types.js';
+import { DEFAULT_NICE_CONFIG, getErrorMessage, } from './types.js';
 import { TaskTracker } from './task-tracker.js';
 import { RalphTracker } from './ralph-tracker.js';
 import { BashToolParser } from './bash-tool-parser.js';
@@ -595,33 +595,75 @@ export class Session extends EventEmitter {
      * session.write('help me with this code\r');
      * ```
      */
+    async _setupOrAttachMuxSession(options) {
+        const mux = this._mux;
+        // Verify stale mux session — tmux may have been destroyed (e.g., killed externally)
+        if (this._muxSession && !mux.muxSessionExists(this._muxSession.muxName)) {
+            console.log('[Session] Stale mux session detected (tmux gone):', this._muxSession.muxName);
+            this._muxSession = null;
+        }
+        // Check if session exists but pane is dead (remain-on-exit keeps it alive)
+        // Respawn the pane instead of creating a whole new session — preserves tmux scrollback
+        let needsNewSession = false;
+        if (this._muxSession && mux.isPaneDead(this._muxSession.muxName)) {
+            console.log('[Session] Dead pane detected, respawning:', this._muxSession.muxName);
+            const newPid = await mux.respawnPane(options.respawnPaneOptions);
+            if (!newPid) {
+                console.error('[Session] Failed to respawn pane, will create new session');
+                needsNewSession = true;
+            }
+            else {
+                // Wait a moment for the respawned process to fully start
+                await new Promise((resolve) => setTimeout(resolve, MUX_STARTUP_DELAY_MS));
+            }
+        }
+        // Check if we already have a mux session (restored session)
+        const isRestored = this._muxSession !== null && !needsNewSession;
+        if (isRestored) {
+            console.log('[Session] Attaching to existing mux session:', this._muxSession.muxName);
+        }
+        else {
+            // Create a new mux session
+            this._muxSession = await mux.createSession(options.createSessionOptions);
+            console.log('[Session] Created mux session:', this._muxSession.muxName);
+            // No extra sleep — createSession() already waits for tmux readiness
+        }
+        // Attach to the mux session via PTY
+        try {
+            this.ptyProcess = pty.spawn(mux.getAttachCommand(), mux.getAttachArgs(this._muxSession.muxName), {
+                name: 'xterm-256color',
+                cols: 120,
+                rows: 40,
+                cwd: this.workingDir,
+                env: buildMuxAttachEnv(),
+            });
+        }
+        catch (spawnErr) {
+            console.error(`[Session] Failed to spawn PTY for ${options.spawnErrLabel}:`, spawnErr);
+            this.emit('error', `Failed to attach to mux session: ${spawnErr}`);
+            throw spawnErr;
+        }
+        return { isRestored };
+    }
+    _handleTerminalOutput(data) {
+        // BufferAccumulator handles auto-trimming when max size exceeded
+        this._terminalBuffer.append(data);
+        this._lastActivityAt = Date.now();
+        this.emit('terminal', data);
+        this.emit('output', data);
+    }
     async startInteractive() {
         if (this.ptyProcess) {
             throw new Error('Session already has a running process');
         }
-        this._status = 'busy';
-        this._terminalBuffer.clear();
-        this._textOutput.clear();
-        this._errorBuffer = '';
-        this._messages = [];
-        this._lineBuffer = '';
-        this._lastActivityAt = Date.now();
+        this._resetBuffers();
         const modeLabel = this.mode === 'opencode' ? 'OpenCode' : 'Claude';
         console.log(`[Session] Starting interactive ${modeLabel} session` + (this._useMux ? ` (with ${this._mux.backend})` : ''));
         // If mux wrapping is enabled, create or attach to a mux session
         if (this._useMux && this._mux) {
             try {
-                // Verify stale mux session — tmux may have been destroyed (e.g., killed externally)
-                if (this._muxSession && !this._mux.muxSessionExists(this._muxSession.muxName)) {
-                    console.log('[Session] Stale mux session detected (tmux gone):', this._muxSession.muxName);
-                    this._muxSession = null;
-                }
-                // Check if session exists but pane is dead (remain-on-exit keeps it alive)
-                // Respawn the pane instead of creating a whole new session — preserves tmux scrollback
-                let needsNewSession = false;
-                if (this._muxSession && this._mux.isPaneDead(this._muxSession.muxName)) {
-                    console.log('[Session] Dead pane detected, respawning:', this._muxSession.muxName);
-                    const newPid = await this._mux.respawnPane({
+                const { isRestored } = await this._setupOrAttachMuxSession({
+                    respawnPaneOptions: {
                         sessionId: this.id,
                         workingDir: this.workingDir,
                         mode: this.mode,
@@ -631,24 +673,8 @@ export class Session extends EventEmitter {
                         allowedTools: this._allowedTools,
                         openCodeConfig: this._openCodeConfig,
                         resumeSessionId: this._resumeSessionId,
-                    });
-                    if (!newPid) {
-                        console.error('[Session] Failed to respawn pane, will create new session');
-                        needsNewSession = true;
-                    }
-                    else {
-                        // Wait a moment for the respawned process to fully start
-                        await new Promise((resolve) => setTimeout(resolve, MUX_STARTUP_DELAY_MS));
-                    }
-                }
-                // Check if we already have a mux session (restored session)
-                const isRestoredSession = this._muxSession !== null && !needsNewSession;
-                if (isRestoredSession) {
-                    console.log('[Session] Attaching to existing mux session:', this._muxSession.muxName);
-                }
-                else {
-                    // Create a new mux session
-                    this._muxSession = await this._mux.createSession({
+                    },
+                    createSessionOptions: {
                         sessionId: this.id,
                         workingDir: this.workingDir,
                         mode: this.mode,
@@ -659,30 +685,14 @@ export class Session extends EventEmitter {
                         allowedTools: this._allowedTools,
                         openCodeConfig: this._openCodeConfig,
                         resumeSessionId: this._resumeSessionId,
-                    });
-                    console.log('[Session] Created mux session:', this._muxSession.muxName);
-                    // No extra sleep — createSession() already waits for tmux readiness
-                }
-                // Attach to the mux session via PTY
-                try {
-                    this.ptyProcess = pty.spawn(this._mux.getAttachCommand(), this._mux.getAttachArgs(this._muxSession.muxName), {
-                        name: 'xterm-256color',
-                        cols: 120,
-                        rows: 40,
-                        cwd: this.workingDir,
-                        env: buildMuxAttachEnv(),
-                    });
-                    // Set claudeSessionId — when resuming, the Claude conversation ID is the resumed one.
-                    this._claudeSessionId = this._resumeSessionId || this.id;
-                }
-                catch (spawnErr) {
-                    console.error('[Session] Failed to spawn PTY for mux attachment:', spawnErr);
-                    this.emit('error', `Failed to attach to mux session: ${spawnErr}`);
-                    throw spawnErr;
-                }
+                    },
+                    spawnErrLabel: 'mux attachment',
+                });
+                // Set claudeSessionId — when resuming, the Claude conversation ID is the resumed one.
+                this._claudeSessionId = this._resumeSessionId || this.id;
                 // For NEW mux sessions: wait for readiness then clean buffer
                 // For RESTORED mux sessions: don't do anything - client will fetch buffer on tab switch
-                if (!isRestoredSession) {
+                if (!isRestored) {
                     if (this.mode === 'opencode') {
                         // OpenCode uses Bubble Tea TUI — no ❯ prompt to detect.
                         // Wait for TUI to stabilize (output stops changing), then mark ready.
@@ -769,11 +779,7 @@ export class Session extends EventEmitter {
             const data = rawData.replace(FOCUS_ESCAPE_FILTER, '').replace(CTRL_L_PATTERN, ''); // Remove Ctrl+L
             if (!data)
                 return; // Skip if only filtered sequences
-            // BufferAccumulator handles auto-trimming when max size exceeded
-            this._terminalBuffer.append(data);
-            this._lastActivityAt = Date.now();
-            this.emit('terminal', data);
-            this.emit('output', data);
+            this._handleTerminalOutput(data);
             // === Idle/working detection runs on every chunk (latency-sensitive) ===
             // Detect if Claude is working or at prompt
             // The prompt line contains "❯" when waiting for input
@@ -958,77 +964,32 @@ export class Session extends EventEmitter {
         if (this.ptyProcess) {
             throw new Error('Session already has a running process');
         }
-        this._status = 'busy';
-        this._terminalBuffer.clear();
-        this._textOutput.clear();
-        this._errorBuffer = '';
-        this._messages = [];
-        this._lineBuffer = '';
-        this._lastActivityAt = Date.now();
+        this._resetBuffers();
         // Use user's default shell or bash
         const shell = process.env.SHELL || '/bin/bash';
         console.log('[Session] Starting shell session with:', shell + (this._useMux ? ` (with ${this._mux.backend})` : ''));
         // If mux wrapping is enabled, create or attach to a mux session
         if (this._useMux && this._mux) {
             try {
-                // Verify stale mux session — tmux may have been destroyed externally
-                if (this._muxSession && !this._mux.muxSessionExists(this._muxSession.muxName)) {
-                    console.log('[Session] Stale mux session detected (tmux gone):', this._muxSession.muxName);
-                    this._muxSession = null;
-                }
-                // Check if session exists but pane is dead (remain-on-exit keeps it alive)
-                let needsNewSession = false;
-                if (this._muxSession && this._mux.isPaneDead(this._muxSession.muxName)) {
-                    console.log('[Session] Dead pane detected, respawning:', this._muxSession.muxName);
-                    const newPid = await this._mux.respawnPane({
+                const { isRestored } = await this._setupOrAttachMuxSession({
+                    respawnPaneOptions: {
                         sessionId: this.id,
                         workingDir: this.workingDir,
                         mode: 'shell',
                         niceConfig: this._niceConfig,
-                    });
-                    if (!newPid) {
-                        console.error('[Session] Failed to respawn pane, will create new session');
-                        needsNewSession = true;
-                    }
-                    else {
-                        await new Promise((resolve) => setTimeout(resolve, MUX_STARTUP_DELAY_MS));
-                    }
-                }
-                // Check if we already have a mux session (restored session)
-                const isRestoredSession = this._muxSession !== null && !needsNewSession;
-                if (isRestoredSession) {
-                    console.log('[Session] Attaching to existing mux session:', this._muxSession.muxName);
-                }
-                else {
-                    // Create a new mux session
-                    this._muxSession = await this._mux.createSession({
+                    },
+                    createSessionOptions: {
                         sessionId: this.id,
                         workingDir: this.workingDir,
                         mode: 'shell',
                         name: this._name,
                         niceConfig: this._niceConfig,
-                    });
-                    console.log('[Session] Created mux session:', this._muxSession.muxName);
-                    // No extra sleep — createSession() already waits for tmux readiness
-                }
-                // Attach to the mux session via PTY
-                try {
-                    this.ptyProcess = pty.spawn(this._mux.getAttachCommand(), this._mux.getAttachArgs(this._muxSession.muxName), {
-                        name: 'xterm-256color',
-                        cols: 120,
-                        rows: 40,
-                        cwd: this.workingDir,
-                        env: buildMuxAttachEnv(),
-                    });
-                }
-                catch (spawnErr) {
-                    console.error('[Session] Failed to spawn PTY for shell mux attachment:', spawnErr);
-                    this.emit('error', `Failed to attach to mux session: ${spawnErr}`);
-                    throw spawnErr;
-                }
+                    },
+                    spawnErrLabel: 'shell mux attachment',
+                });
                 // For NEW sessions: clear by sending 'clear' command to the shell
                 // For RESTORED sessions: don't clear - we want to see the existing output
-                if (!isRestoredSession) {
+                if (!isRestored) {
                     setTimeout(() => {
                         if (this.ptyProcess) {
                             this._terminalBuffer.clear();
@@ -1068,11 +1029,7 @@ export class Session extends EventEmitter {
             const data = rawData.replace(FOCUS_ESCAPE_FILTER, '');
             if (!data)
                 return; // Skip if only focus sequences
-            // BufferAccumulator handles auto-trimming when max size exceeded
-            this._terminalBuffer.append(data);
-            this._lastActivityAt = Date.now();
-            this.emit('terminal', data);
-            this.emit('output', data);
+            this._handleTerminalOutput(data);
         });
         this.ptyProcess.onExit(({ exitCode }) => {
             console.log('[Session] Shell PTY exited with code:', exitCode);
@@ -1130,13 +1087,7 @@ export class Session extends EventEmitter {
                 reject(new Error('Session already has a running process'));
                 return;
             }
-            this._status = 'busy';
-            this._terminalBuffer.clear();
-            this._textOutput.clear();
-            this._errorBuffer = '';
-            this._messages = [];
-            this._lineBuffer = '';
-            this._lastActivityAt = Date.now();
+            this._resetBuffers();
             this._promptResolved = false; // Reset race condition guard
             this.resolvePromise = resolve;
             this.rejectPromise = reject;
@@ -1167,11 +1118,7 @@ export class Session extends EventEmitter {
                     const data = rawData.replace(FOCUS_ESCAPE_FILTER, '');
                     if (!data)
                         return; // Skip if only focus sequences
-                    // BufferAccumulator handles auto-trimming when max size exceeded
-                    this._terminalBuffer.append(data);
-                    this._lastActivityAt = Date.now();
-                    this.emit('terminal', data);
-                    this.emit('output', data);
+                    this._handleTerminalOutput(data);
                     // Also try to parse JSON lines for structured data
                     this.processOutput(data);
                 });
@@ -1197,9 +1144,11 @@ export class Session extends EventEmitter {
                         this._status = 'idle';
                         const cost = resultMsg.total_cost_usd || 0;
                         this._totalCost += cost;
-                        this.emit('completion', resultMsg.result || '', cost);
+                        // Claude CLI stream-json may return empty result field — fall back to accumulated text output
+                        const result = resultMsg.result || this._textOutput.value || '';
+                        this.emit('completion', result, cost);
                         if (resolve) {
-                            resolve({ result: resultMsg.result || '', cost });
+                            resolve({ result, cost });
                         }
                     }
                     else if (exitCode !== 0 || (resultMsg && resultMsg.is_error)) {
@@ -1229,6 +1178,99 @@ export class Session extends EventEmitter {
             }
         });
     }
+    _resetBuffers() {
+        this._status = 'busy';
+        this._terminalBuffer.clear();
+        this._textOutput.clear();
+        this._errorBuffer = '';
+        this._messages = [];
+        this._lineBuffer = '';
+        this._lastActivityAt = Date.now();
+    }
+    _clearAllTimers() {
+        // Clear activity timeout to prevent memory leak
+        if (this.activityTimeout) {
+            clearTimeout(this.activityTimeout);
+            this.activityTimeout = null;
+        }
+        // Clear line buffer flush timer
+        if (this._lineBufferFlushTimer) {
+            clearTimeout(this._lineBufferFlushTimer);
+            this._lineBufferFlushTimer = null;
+        }
+        // Destroy auto-compact/auto-clear automation (clears its timers)
+        this._autoOps.destroy();
+        // Clear prompt check timers
+        if (this._promptCheckInterval) {
+            clearInterval(this._promptCheckInterval);
+            this._promptCheckInterval = null;
+        }
+        if (this._promptCheckTimeout) {
+            clearTimeout(this._promptCheckTimeout);
+            this._promptCheckTimeout = null;
+        }
+        // Clear shell idle timer
+        if (this._shellIdleTimer) {
+            clearTimeout(this._shellIdleTimer);
+            this._shellIdleTimer = null;
+        }
+        // Clear expensive processing timer
+        if (this._expensiveProcessTimer) {
+            clearTimeout(this._expensiveProcessTimer);
+            this._expensiveProcessTimer = null;
+        }
+        this._pendingCleanData = '';
+    }
+    _handleJsonMessage(cleanLine, rawLine) {
+        try {
+            const msg = JSON.parse(cleanLine);
+            this._messages.push(msg);
+            this.emit('message', msg);
+            // Trim messages array for long-running sessions
+            if (this._messages.length > MAX_MESSAGES) {
+                this._messages = this._messages.slice(-Math.floor(MAX_MESSAGES * 0.8));
+            }
+            // Extract Claude session ID from messages (can be in any message type)
+            // Support both sessionId (camelCase) and session_id (snake_case)
+            const msgSessionId = msg.sessionId ?? msg.session_id;
+            if (msgSessionId && !this._claudeSessionId) {
+                this._claudeSessionId = msgSessionId;
+            }
+            // Process message for task tracking
+            this._taskTracker.processMessage(msg);
+            if (msg.type === 'assistant' && msg.message?.content) {
+                for (const block of msg.message.content) {
+                    if (block.type === 'text' && block.text) {
+                        this._textOutput.append(block.text);
+                    }
+                }
+                // Track tokens from usage (with validation)
+                if (msg.message.usage) {
+                    const inputDelta = msg.message.usage.input_tokens || 0;
+                    const outputDelta = msg.message.usage.output_tokens || 0;
+                    // Sanity check: max 100k tokens per message (generous limit)
+                    const MAX_TOKENS_PER_MESSAGE = 100_000;
+                    if (inputDelta > 0 && inputDelta <= MAX_TOKENS_PER_MESSAGE) {
+                        this._totalInputTokens += inputDelta;
+                    }
+                    if (outputDelta > 0 && outputDelta <= MAX_TOKENS_PER_MESSAGE) {
+                        this._totalOutputTokens += outputDelta;
+                    }
+                    // Check if we should auto-compact or auto-clear
+                    this._autoOps.checkAutoCompact();
+                    this._autoOps.checkAutoClear();
+                }
+            }
+            if (msg.type === 'result' && msg.total_cost_usd) {
+                this._totalCost = msg.total_cost_usd;
+            }
+        }
+        catch (parseErr) {
+            // Not JSON, just regular output - this is expected for non-JSON lines
+            console.debug('[Session] Line not JSON (expected for text output):', parseErr instanceof Error ? parseErr.message : parseErr);
+            this._textOutput.append(rawLine + '\n');
+        }
+    }
     processOutput(data) {
         // Early return if session is stopped to prevent any processing or timer creation
         if (this._isStopped)
@@ -1264,54 +1306,7 @@ export class Session extends EventEmitter {
             // Remove ANSI escape codes for JSON parsing (use pre-compiled pattern)
             const cleanLine = trimmed.replace(ANSI_ESCAPE_PATTERN_FULL, '');
             if (cleanLine.startsWith('{') && cleanLine.endsWith('}')) {
-                try {
-                    const msg = JSON.parse(cleanLine);
-                    this._messages.push(msg);
-                    this.emit('message', msg);
-                    // Trim messages array for long-running sessions
-                    if (this._messages.length > MAX_MESSAGES) {
-                        this._messages = this._messages.slice(-Math.floor(MAX_MESSAGES * 0.8));
-                    }
-                    // Extract Claude session ID from messages (can be in any message type)
-                    // Support both sessionId (camelCase) and session_id (snake_case)
-                    const msgSessionId = msg.sessionId ?? msg.session_id;
-                    if (msgSessionId && !this._claudeSessionId) {
-                        this._claudeSessionId = msgSessionId;
-                    }
-                    // Process message for task tracking
-                    this._taskTracker.processMessage(msg);
-                    if (msg.type === 'assistant' && msg.message?.content) {
-                        for (const block of msg.message.content) {
-                            if (block.type === 'text' && block.text) {
-                                this._textOutput.append(block.text);
-                            }
-                        }
-                        // Track tokens from usage (with validation)
-                        if (msg.message.usage) {
-                            const inputDelta = msg.message.usage.input_tokens || 0;
-                            const outputDelta = msg.message.usage.output_tokens || 0;
-                            // Sanity check: max 100k tokens per message (generous limit)
-                            const MAX_TOKENS_PER_MESSAGE = 100_000;
-                            if (inputDelta > 0 && inputDelta <= MAX_TOKENS_PER_MESSAGE) {
-                                this._totalInputTokens += inputDelta;
-                            }
-                            if (outputDelta > 0 && outputDelta <= MAX_TOKENS_PER_MESSAGE) {
-                                this._totalOutputTokens += outputDelta;
-                            }
-                            // Check if we should auto-compact or auto-clear
-                            this._autoOps.checkAutoCompact();
-                            this._autoOps.checkAutoClear();
-                        }
-                    }
-                    if (msg.type === 'result' && msg.total_cost_usd) {
-                        this._totalCost = msg.total_cost_usd;
-                    }
-                }
-                catch (parseErr) {
-                    // Not JSON, just regular output - this is expected for non-JSON lines
-                    console.debug('[Session] Line not JSON (expected for text output):', parseErr instanceof Error ? parseErr.message : parseErr);
-                    this._textOutput.append(line + '\n');
-                }
+                this._handleJsonMessage(cleanLine, line);
             }
             else if (trimmed) {
                 this._textOutput.append(line + '\n');
@@ -1572,7 +1567,7 @@ export class Session extends EventEmitter {
         this._status = 'busy';
         this._lastActivityAt = Date.now();
         this.runPrompt(input).catch((err) => {
-            const errorMsg = err instanceof Error ? err.message : String(err);
+            const errorMsg = getErrorMessage(err);
             // Clean up task state so the task queue doesn't get stuck
             if (this._currentTaskId) {
                 const taskId = this._currentTaskId;
@@ -1642,38 +1637,7 @@ export class Session extends EventEmitter {
     async stop(killMux = true) {
         // Set stopped flag first to prevent new timers from being created
         this._isStopped = true;
-        // Clear activity timeout to prevent memory leak
-        if (this.activityTimeout) {
-            clearTimeout(this.activityTimeout);
-            this.activityTimeout = null;
-        }
-        // Clear line buffer flush timer
-        if (this._lineBufferFlushTimer) {
-            clearTimeout(this._lineBufferFlushTimer);
-            this._lineBufferFlushTimer = null;
-        }
-        // Destroy auto-compact/auto-clear automation (clears its timers)
-        this._autoOps.destroy();
-        // Clear prompt check timers
-        if (this._promptCheckInterval) {
-            clearInterval(this._promptCheckInterval);
-            this._promptCheckInterval = null;
-        }
-        if (this._promptCheckTimeout) {
-            clearTimeout(this._promptCheckTimeout);
-            this._promptCheckTimeout = null;
-        }
-        // Clear shell idle timer
-        if (this._shellIdleTimer) {
-            clearTimeout(this._shellIdleTimer);
-            this._shellIdleTimer = null;
-        }
-        // Clear expensive processing timer
-        if (this._expensiveProcessTimer) {
-            clearTimeout(this._expensiveProcessTimer);
-            this._expensiveProcessTimer = null;
-        }
-        this._pendingCleanData = '';
+        this._clearAllTimers();
         // Immediately cleanup Promise callbacks to prevent orphaned references
         // during the rest of stop() processing (e.g., if mux kill times out)
         if (this.rejectPromise && !this._promptResolved) {