jettypod 4.4.120 → 4.4.121

package/apps/dashboard/lib/claude-process-manager.ts

@@ -1,529 +0,0 @@
-import { spawn, ChildProcess } from 'child_process';
-import { EventEmitter } from 'events';
-
-/**
- * Manages persistent Claude CLI processes for dashboard sessions.
- *
- * Instead of spawning a new Claude process per message (-p mode),
- * we spawn a persistent process with --input-format stream-json
- * and pipe messages via stdin. This enables Claude's agentic loop
- * to work properly - Claude continues until it decides to stop.
- */
-
-interface ClaudeProcess {
-  process: ChildProcess;
-  emitter: EventEmitter;
-  sessionId: string;
-  createdAt: number;
-  lastActivityAt: number;
-}
-
-// Singleton map of session ID -> Claude process
-const processes = new Map<string, ClaudeProcess>();
-
-// Sessions pinned by the UI (active in a tab) — exempt from idle cleanup
-const pinnedSessions = new Set<string>();
-
-// Maximum concurrent Claude processes allowed
-const MAX_PROCESSES = 8;
-
-// Timeout for idle processes (2 hours, only applies to unpinned sessions).
-// Longer timeout reduces process respawn frequency, avoiding the cost of
-// context restoration (dumping full conversation history into a single message).
-const IDLE_TIMEOUT_MS = 2 * 60 * 60 * 1000;
-
-// ============================================================================
-// Auto Gate Emission
-// ============================================================================
-
-// Track last tool_use per session to correlate with tool_result
-const lastToolUse = new Map<string, { name: string; input: Record<string, unknown>; id: string }>();
-
-// Track whether implementing gate has been emitted this session (debounce)
-const implementingEmitted = new Map<string, number>();
-
-// Debounce interval for implementing gate (don't re-emit within 30s)
-const IMPLEMENTING_DEBOUNCE_MS = 30_000;
-
-/**
- * Pattern to detect work item creation from tool result content.
- * Matches: "Created chore #12345: Title Here"
- */
-const WORK_CREATED_PATTERN = /Created (chore|feature|bug|epic) #(\d+): ([^\n]+)/;
-
-/**
- * Pattern to detect worktree creation from tool result content.
- * Matches: "✅ Created worktree: /path/to/worktree"
- */
-const WORKTREE_STARTED_PATTERN = /Created worktree: ([^\n]+)/;
-
-/**
- * Check a parsed stream event for workflow patterns and emit synthetic gate events.
- * Returns an array of gate events to inject into the stream (may be empty).
- */
-function detectGates(
-  sessionId: string,
-  parsed: Record<string, unknown>
-): Array<Record<string, unknown>> {
-  const gates: Array<Record<string, unknown>> = [];
-
-  // Track tool_use from assistant messages
-  if (parsed.type === 'assistant' && parsed.message) {
-    const msg = parsed.message as { content?: Array<{ type: string; name?: string; input?: Record<string, unknown>; id?: string }> };
-    if (Array.isArray(msg.content)) {
-      for (const block of msg.content) {
-        if (block.type === 'tool_use' && block.name && block.id) {
-          lastToolUse.set(sessionId, {
-            name: block.name,
-            input: block.input || {},
-            id: block.id,
-          });
-
-          // Emit implementing gate for Edit/Write tool_use (debounced)
-          if (block.name === 'Edit' || block.name === 'Write') {
-            const lastEmit = implementingEmitted.get(sessionId) || 0;
-            if (Date.now() - lastEmit > IMPLEMENTING_DEBOUNCE_MS) {
-              const filePath = (block.input as Record<string, string>)?.file_path || '';
-              const fileName = filePath.split('/').pop() || filePath;
-              gates.push(buildGateEvent('implementing', {
-                description: `Editing ${fileName}`,
-                files: [fileName],
-              }));
-              implementingEmitted.set(sessionId, Date.now());
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // Check tool_result from user messages for workflow command outputs
-  if (parsed.type === 'user' && parsed.message) {
-    const msg = parsed.message as { content?: Array<{ type: string; content?: string | Array<{ type: string; text?: string }> }> };
-    if (Array.isArray(msg.content)) {
-      for (const block of msg.content) {
-        if (block.type === 'tool_result') {
-          const resultText = typeof block.content === 'string'
-            ? block.content
-            : Array.isArray(block.content)
-              ? block.content.filter(p => p.type === 'text').map(p => p.text || '').join('')
-              : '';
-
-          // Check for work item creation
-          const workCreated = resultText.match(WORK_CREATED_PATTERN);
-          if (workCreated) {
-            gates.push(buildGateEvent('work-created', {
-              id: parseInt(workCreated[2], 10),
-              title: workCreated[3].trim(),
-              type: workCreated[1],
-            }));
-          }
-
-          // Check for worktree creation
-          const worktreeStarted = resultText.match(WORKTREE_STARTED_PATTERN);
-          if (worktreeStarted) {
-            gates.push(buildGateEvent('worktree-started', {
-              path: worktreeStarted[1].trim(),
-            }));
-          }
-
-          // Check for test runs
-          const lastTool = lastToolUse.get(sessionId);
-          if (lastTool?.name === 'Bash') {
-            const cmd = (lastTool.input as Record<string, string>)?.command || '';
-
-            // Test running detection
-            if (cmd.includes('cucumber-js') || cmd.includes('jest') || cmd.includes('npm test') || cmd.includes('npx test')) {
-              gates.push(buildGateEvent('tests-running', {}));
-
-              // If tests passed (exit code 0 implied by non-error result)
-              if (!resultText.includes('failing') && !resultText.includes('FAIL') && !resultText.includes('Error:')) {
-                gates.push(buildGateEvent('tests-passed', {}));
-              }
-            }
-
-            // Merge detection
-            if (cmd.includes('jettypod work merge')) {
-              gates.push(buildGateEvent('merging', {}));
-            }
-
-            // Completion detection
-            if (cmd.includes('jettypod work status') && cmd.includes('done')) {
-              gates.push(buildGateEvent('complete', {
-                summary: 'Work complete',
-              }));
-            }
-          }
-        }
-      }
-    }
-  }
-
-  return gates;
-}
-
-/**
- * Build a synthetic gate event in the format that session-stream-manager expects.
- * Wraps the gate marker in a tool_result-style user message.
- */
-function buildGateEvent(gateType: string, data: Record<string, unknown>): Record<string, unknown> {
-  const gateMarker = `[GATE:${gateType}]${JSON.stringify(data)}[/GATE]`;
-  return {
-    type: 'user',
-    message: {
-      role: 'user',
-      content: [{
-        type: 'tool_result',
-        tool_use_id: `synthetic-gate-${Date.now()}`,
-        content: gateMarker,
-      }],
-    },
-    isSyntheticGate: true,
-  };
-}
-
-/**
- * Clean up gate tracking state for a session.
- */
-function cleanupGateState(sessionId: string): void {
-  lastToolUse.delete(sessionId);
-  implementingEmitted.delete(sessionId);
-}
-
-// ============================================================================
-// Process Management
-// ============================================================================
-
-/**
- * Get or create a persistent Claude process for a session.
- * Returns an EventEmitter that emits 'data', 'error', and 'close' events.
- * Returns error if max process limit is reached.
- */
-export function getOrCreateProcess(
-  sessionId: string,
-  cwd: string,
-  settingsPath?: string,
-  options?: { model?: string }
-): { emitter: EventEmitter; isNew: boolean } | { error: string } {
-  const existing = processes.get(sessionId);
-
-  // Check if existing process is actually healthy (not just "not killed")
-  if (existing && isProcessHealthy(existing)) {
-    existing.lastActivityAt = Date.now();
-    return { emitter: existing.emitter, isNew: false };
-  }
-
-  // Clean up dead/unhealthy process if exists
-  if (existing) {
-    killProcess(sessionId);
-  }
-
-  // Check if we've hit the max process limit
-  const activeCount = getActiveProcessCount();
-  if (activeCount >= MAX_PROCESSES) {
-    return { error: `Maximum concurrent processes (${MAX_PROCESSES}) reached. Please close an existing session first.` };
-  }
-
-  const emitter = new EventEmitter();
-
-  // Build args for persistent mode
-  const args = [
-    '-p',  // Print mode (required for input-format)
-    '--input-format', 'stream-json',
-    '--output-format', 'stream-json',
-    '--verbose',
-    '--permission-mode', 'bypassPermissions',
-  ];
-
-  if (settingsPath) {
-    args.push('--settings', settingsPath);
-  }
-
-  if (options?.model) {
-    args.push('--model', options.model);
-  }
-
-  const claudeProcess = spawn('claude', args, {
-    cwd,
-    env: { ...process.env, JETTYPOD_SESSION_ID: sessionId },
-    stdio: ['pipe', 'pipe', 'pipe'],
-  });
-
-  // Handle stdout - stream JSON responses.
-  // Buffer incomplete lines across data events. Node.js delivers arbitrary
-  // chunks on pipes, so a single JSON line can be split across two events.
-  // Without buffering, split lines fail JSON.parse and critical events like
-  // `result` are lost — causing the chat panel to hang forever.
-  let stdoutBuffer = '';
-  claudeProcess.stdout.on('data', (data: Buffer) => {
-    stdoutBuffer += data.toString();
-    const lines = stdoutBuffer.split('\n');
-    // Last element is either '' (chunk ended with \n) or an incomplete line
-    stdoutBuffer = lines.pop() || '';
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      try {
-        const parsed = JSON.parse(trimmed);
-
-        // Auto-detect workflow events and emit synthetic gate events
-        const syntheticGates = detectGates(sessionId, parsed);
-        for (const gate of syntheticGates) {
-          emitter.emit('data', gate);
-        }
-
-        emitter.emit('data', parsed);
-      } catch {
-        // Non-JSON line, emit as raw text
-        emitter.emit('data', { type: 'text', content: trimmed });
-      }
-    }
-  });
-
-  // Handle stderr
-  claudeProcess.stderr.on('data', (data: Buffer) => {
-    emitter.emit('error', { type: 'stderr', content: data.toString() });
-  });
-
-  // Handle process close
-  claudeProcess.on('close', (code) => {
-    emitter.emit('close', { exitCode: code });
-    cleanupGateState(sessionId);
-    processes.delete(sessionId);
-  });
-
-  // Handle process error
-  claudeProcess.on('error', (err) => {
-    emitter.emit('error', { type: 'process_error', content: err.message });
-    cleanupGateState(sessionId);
-    processes.delete(sessionId);
-  });
-
-  const claudeProc: ClaudeProcess = {
-    process: claudeProcess,
-    emitter,
-    sessionId,
-    createdAt: Date.now(),
-    lastActivityAt: Date.now(),
-  };
-
-  processes.set(sessionId, claudeProc);
-
-  return { emitter, isNew: true };
-}
-
-/**
- * Send a user message to a session's Claude process via stdin.
- * The message is formatted as stream-json.
- */
-export function sendMessage(sessionId: string, message: string, images?: Array<{ type: string; data: string }>): boolean {
-  const proc = processes.get(sessionId);
-
-  if (!proc || !isProcessHealthy(proc)) {
-    // Clean up dead process if it exists
-    if (proc) {
-      killProcess(sessionId);
-    }
-    return false;
-  }
-
-  proc.lastActivityAt = Date.now();
-
-  // Build content: plain string when no images, content blocks array when images present
-  let content: string | Array<Record<string, unknown>> = message;
-  if (images && images.length > 0) {
-    const contentBlocks: Array<Record<string, unknown>> = [];
-    for (const img of images) {
-      // Frontend sends dataUrl like "data:image/png;base64,iVBOR..."
-      // Strip the data URL prefix to get raw base64
-      const base64Data = img.data.replace(/^data:[^;]+;base64,/, '');
-      contentBlocks.push({
-        type: 'image',
-        source: {
-          type: 'base64',
-          media_type: img.type,
-          data: base64Data,
-        },
-      });
-    }
-    contentBlocks.push({ type: 'text', text: message });
-    content = contentBlocks;
-  }
-
-  // Format as stream-json message
-  const jsonMessage = JSON.stringify({
-    type: 'user',
-    message: {
-      role: 'user',
-      content,
-    },
-  });
-
-  // Write to stdin with newline delimiter
-  // Safety check: stdin should exist since isProcessHealthy verified it
-  proc.process.stdin!.write(jsonMessage + '\n');
-
-  return true;
-}
-
-/**
- * Kill a session's Claude process.
- */
-export function killProcess(sessionId: string): boolean {
-  const proc = processes.get(sessionId);
-
-  if (!proc) {
-    return false;
-  }
-
-  if (!proc.process.killed) {
-    proc.process.kill('SIGTERM');
-  }
-
-  cleanupGateState(sessionId);
-  processes.delete(sessionId);
-  return true;
-}
-
-/**
- * Check if a process is truly alive and responsive.
- * Returns true if the process is healthy, false if dead/unresponsive.
- *
- * Checks:
- * 1. Process hasn't been killed
- * 2. Process hasn't exited (exitCode is null for running processes)
- * 3. stdin is still writable
- */
-function isProcessHealthy(proc: ClaudeProcess): boolean {
-  const childProcess = proc.process;
-
-  // Check if process was explicitly killed
-  if (childProcess.killed) {
-    return false;
-  }
-
-  // Check if process has exited (exitCode is non-null when exited)
-  if (childProcess.exitCode !== null) {
-    return false;
-  }
-
-  // Check if stdin is still writable
-  if (!childProcess.stdin || childProcess.stdin.destroyed || !childProcess.stdin.writable) {
-    return false;
-  }
-
-  return true;
-}
-
-/**
- * Check process health and clean up if dead.
- * Returns true if process is healthy, false if dead (and cleaned up).
- */
-export function checkProcessHealth(sessionId: string): boolean {
-  const proc = processes.get(sessionId);
-
-  if (!proc) {
-    return false;
-  }
-
-  if (!isProcessHealthy(proc)) {
-    // Process is dead - clean it up
-    killProcess(sessionId);
-    return false;
-  }
-
-  return true;
-}
-
-/**
- * Check if a session has an active process.
- * Now includes health check to detect dead/zombie processes.
- */
-export function hasActiveProcess(sessionId: string): boolean {
-  return checkProcessHealth(sessionId);
-}
-
-/**
- * Get count of currently active (healthy) processes.
- */
-export function getActiveProcessCount(): number {
-  let count = 0;
-  for (const proc of processes.values()) {
-    if (isProcessHealthy(proc)) {
-      count++;
-    }
-  }
-  return count;
-}
-
-/**
- * Get stats about active processes (for debugging).
- * Now uses health check to accurately report active processes.
- */
-export function getProcessStats(): {
-  activeCount: number;
-  sessions: Array<{ sessionId: string; ageMs: number; idleMs: number; healthy: boolean }>;
-} {
-  const now = Date.now();
-  const sessions = Array.from(processes.entries())
-    .map(([sessionId, proc]) => ({
-      sessionId,
-      ageMs: now - proc.createdAt,
-      idleMs: now - proc.lastActivityAt,
-      healthy: isProcessHealthy(proc),
-    }));
-
-  return {
-    activeCount: sessions.filter(s => s.healthy).length,
-    sessions,
-  };
-}
-
-/**
- * Pin a session to prevent idle cleanup (session is active in UI).
- */
-export function pinSession(sessionId: string): void {
-  pinnedSessions.add(sessionId);
-}
-
-/**
- * Unpin a session to allow idle cleanup (session closed/switched away).
- */
-export function unpinSession(sessionId: string): void {
-  pinnedSessions.delete(sessionId);
-}
-
-/**
- * Check if a session is pinned.
- */
-export function isSessionPinned(sessionId: string): boolean {
-  return pinnedSessions.has(sessionId);
-}
-
-/**
- * Cleanup idle processes. Call this periodically.
- * Skips pinned sessions (active in UI).
- */
-export function cleanupIdleProcesses(): number {
-  const now = Date.now();
-  let cleaned = 0;
-
-  for (const [sessionId, proc] of processes.entries()) {
-    // Never kill pinned sessions — they're active in the UI
-    if (pinnedSessions.has(sessionId)) {
-      continue;
-    }
-    if (now - proc.lastActivityAt > IDLE_TIMEOUT_MS) {
-      killProcess(sessionId);
-      cleaned++;
-    }
-  }
-
-  return cleaned;
-}
-
-// Start periodic cleanup (every 15 minutes)
-setInterval(() => {
-  cleanupIdleProcesses();
-}, 15 * 60 * 1000);