@aion0/forge 0.5.26 → 0.5.28

package/.forge/worktrees/pipeline-4dd8dc2d/lib/claude-process.ts

@@ -0,0 +1,361 @@
+/**
+ * Claude Code Process Manager
+ *
+ * Uses `claude -p --verbose --output-format stream-json` for structured output.
+ * Runs on your Claude Code subscription, not API key.
+ */
+
+import { spawn, type ChildProcess } from 'node:child_process';
+import { loadSettings } from './settings';
+
+export interface ClaudeMessage {
+  type: 'system' | 'assistant' | 'result';
+  subtype?: string;    // e.g. 'tool_use', 'text', 'init'
+  content: string;
+  tool?: string;       // tool name if tool_use
+  costUSD?: number;
+  sessionId?: string;
+  timestamp: string;
+}
+
+export interface ClaudeProcess {
+  id: string;
+  projectName: string;
+  projectPath: string;
+  status: 'running' | 'idle' | 'exited';
+  createdAt: string;
+  messages: ClaudeMessage[];
+  conversationId?: string;
+}
+
+interface ManagedProcess {
+  info: ClaudeProcess;
+  child: ChildProcess | null;
+  listeners: Set<(msg: ClaudeMessage) => void>;
+}
+
+const processes = new Map<string, ManagedProcess>();
+
+/**
+ * Create a new Claude Code session for a project.
+ */
+export function createClaudeSession(projectName: string, projectPath: string): ClaudeProcess {
+  const id = `claude-${projectName}-${Date.now().toString(36)}`;
+
+  const info: ClaudeProcess = {
+    id,
+    projectName,
+    projectPath,
+    status: 'idle',
+    createdAt: new Date().toISOString(),
+    messages: [],
+  };
+
+  const managed: ManagedProcess = {
+    info,
+    child: null,
+    listeners: new Set(),
+  };
+
+  processes.set(id, managed);
+  return info;
+}
+
+/**
+ * Send a message to Claude Code and stream the response.
+ */
+export function sendToClaudeSession(
+  id: string,
+  message: string,
+  conversationId?: string
+): boolean {
+  const managed = processes.get(id);
+  if (!managed) return false;
+  if (managed.info.status === 'running') return false; // Already processing
+
+  const settings = loadSettings();
+  const claudePath = settings.claudePath || process.env.CLAUDE_PATH || 'claude';
+
+  // Build command args — --verbose is required for stream-json
+  const args = ['-p', '--verbose', '--output-format', 'stream-json'];
+
+  // Continue conversation if we have a session ID
+  const continueId = conversationId || managed.info.conversationId;
+  if (continueId) {
+    args.push('--resume', continueId);
+  }
+
+  // Message passed as CLI arg (pushed above).
+  // Spawn without shell to prevent zsh from interpreting special chars
+  // in the message (${}, backticks, quotes in code diffs).
+
+  // Remove CLAUDECODE env var to avoid nesting detection
+  const env = { ...process.env };
+  delete env.CLAUDECODE;
+
+  // Resolve full path so spawn works without shell for PATH lookup
+  let resolvedClaude = claudePath;
+  if (!claudePath.startsWith('/')) {
+    try {
+      const { execSync: execS } = require('node:child_process');
+      resolvedClaude = execS(`which ${claudePath}`, { encoding: 'utf-8', env }).trim() || claudePath;
+    } catch {}
+  }
+
+  const child = spawn(resolvedClaude, args, {
+    cwd: managed.info.projectPath,
+    env,
+    stdio: ['ignore', 'pipe', 'pipe'],  // ignore stdin — prompt is in args, no stdin needed
+  });
+
+  managed.child = child;
+  managed.info.status = 'running';
+
+  // Add user message
+  const userMsg: ClaudeMessage = {
+    type: 'system',
+    subtype: 'user_input',
+    content: message,
+    timestamp: new Date().toISOString(),
+  };
+  managed.info.messages.push(userMsg);
+  broadcast(managed, userMsg);
+
+  let buffer = '';
+
+  child.stdout?.on('data', (data: Buffer) => {
+    buffer += data.toString();
+    // stream-json outputs one JSON object per line
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || ''; // Keep incomplete line in buffer
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const parsed = JSON.parse(line);
+        const messages = parseClaudeOutput(parsed);
+        for (const msg of messages) {
+          managed.info.messages.push(msg);
+
+          // Capture session ID for conversation continuity
+          if (parsed.session_id && !managed.info.conversationId) {
+            managed.info.conversationId = parsed.session_id;
+          }
+
+          broadcast(managed, msg);
+        }
+      } catch {
+        // Non-JSON line, treat as text
+        const msg: ClaudeMessage = {
+          type: 'assistant',
+          subtype: 'text',
+          content: line,
+          timestamp: new Date().toISOString(),
+        };
+        managed.info.messages.push(msg);
+        broadcast(managed, msg);
+      }
+    }
+  });
+
+  child.stderr?.on('data', (data: Buffer) => {
+    const text = data.toString().trim();
+    if (!text) return;
+    const msg: ClaudeMessage = {
+      type: 'system',
+      subtype: 'error',
+      content: text,
+      timestamp: new Date().toISOString(),
+    };
+    managed.info.messages.push(msg);
+    broadcast(managed, msg);
+  });
+
+  child.on('exit', (code) => {
+    // Process remaining buffer
+    if (buffer.trim()) {
+      try {
+        const parsed = JSON.parse(buffer);
+        const messages = parseClaudeOutput(parsed);
+        for (const msg of messages) {
+          managed.info.messages.push(msg);
+          broadcast(managed, msg);
+        }
+      } catch {}
+      buffer = '';
+    }
+
+    managed.info.status = 'idle';
+    managed.child = null;
+
+    const msg: ClaudeMessage = {
+      type: 'system',
+      subtype: 'complete',
+      content: `Done (exit ${code})`,
+      timestamp: new Date().toISOString(),
+    };
+    managed.info.messages.push(msg);
+    broadcast(managed, msg);
+  });
+
+  return true;
+}
+
+/**
+ * Parse actual claude stream-json output into ClaudeMessage(s).
+ *
+ * Real format examples:
+ * - {type: "system", subtype: "init", session_id: "...", model: "...", ...}
+ * - {type: "assistant", message: {content: [{type: "text", text: "..."}, {type: "tool_use", name: "...", input: {...}}]}, session_id: "..."}
+ * - {type: "result", subtype: "success", result: "...", total_cost_usd: 0.06, session_id: "..."}
+ */
+function parseClaudeOutput(parsed: any): ClaudeMessage[] {
+  const msgs: ClaudeMessage[] = [];
+  const ts = new Date().toISOString();
+
+  // System init message
+  if (parsed.type === 'system' && parsed.subtype === 'init') {
+    msgs.push({
+      type: 'system',
+      subtype: 'init',
+      content: `Model: ${parsed.model || 'unknown'}`,
+      sessionId: parsed.session_id,
+      timestamp: ts,
+    });
+    return msgs;
+  }
+
+  // Assistant message — contains content array with text and tool_use blocks
+  if (parsed.type === 'assistant' && parsed.message?.content) {
+    const content = parsed.message.content;
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block.type === 'text' && block.text) {
+          msgs.push({
+            type: 'assistant',
+            subtype: 'text',
+            content: block.text,
+            sessionId: parsed.session_id,
+            timestamp: ts,
+          });
+        } else if (block.type === 'tool_use') {
+          msgs.push({
+            type: 'assistant',
+            subtype: 'tool_use',
+            content: typeof block.input === 'string'
+              ? block.input
+              : JSON.stringify(block.input || {}),
+            tool: block.name,
+            sessionId: parsed.session_id,
+            timestamp: ts,
+          });
+        } else if (block.type === 'tool_result') {
+          msgs.push({
+            type: 'assistant',
+            subtype: 'tool_result',
+            content: typeof block.content === 'string'
+              ? block.content
+              : JSON.stringify(block.content || ''),
+            tool: block.tool_use_id,
+            sessionId: parsed.session_id,
+            timestamp: ts,
+          });
+        }
+      }
+    }
+    return msgs;
+  }
+
+  // Result message
+  if (parsed.type === 'result') {
+    msgs.push({
+      type: 'result',
+      subtype: parsed.subtype || 'success',
+      content: typeof parsed.result === 'string'
+        ? parsed.result
+        : JSON.stringify(parsed.result || ''),
+      costUSD: parsed.total_cost_usd,
+      sessionId: parsed.session_id,
+      timestamp: ts,
+    });
+    return msgs;
+  }
+
+  // Skip rate_limit_event and other internal events silently
+  if (parsed.type === 'rate_limit_event') {
+    return msgs;
+  }
+
+  // Generic fallback — still show it
+  msgs.push({
+    type: 'assistant',
+    subtype: parsed.type || 'unknown',
+    content: JSON.stringify(parsed),
+    timestamp: ts,
+  });
+  return msgs;
+}
+
+function broadcast(managed: ManagedProcess, msg: ClaudeMessage) {
+  for (const listener of managed.listeners) {
+    try { listener(msg); } catch {}
+  }
+}
+
+/**
+ * Attach a listener to receive messages from a Claude session.
+ */
+export function attachToProcess(id: string, onMessage: (msg: ClaudeMessage) => void): (() => void) | null {
+  const managed = processes.get(id);
+  if (!managed) return null;
+
+  // Send history first
+  for (const msg of managed.info.messages) {
+    onMessage(msg);
+  }
+
+  managed.listeners.add(onMessage);
+  return () => { managed.listeners.delete(onMessage); };
+}
+
+/**
+ * Kill current running command (not the session).
+ */
+export function killProcess(id: string): boolean {
+  const managed = processes.get(id);
+  if (!managed) return false;
+  if (managed.child) {
+    managed.child.kill('SIGTERM');
+    managed.info.status = 'idle';
+  }
+  return true;
+}
+
+/**
+ * Delete a session entirely.
+ */
+export function deleteSession(id: string): boolean {
+  const managed = processes.get(id);
+  if (!managed) return false;
+  if (managed.child) managed.child.kill('SIGTERM');
+  processes.delete(id);
+  return true;
+}
+
+/**
+ * List all sessions.
+ */
+export function listProcesses(): ClaudeProcess[] {
+  return Array.from(processes.values()).map(m => ({
+    ...m.info,
+    messages: [], // Don't send full history in list
+  }));
+}
+
+/**
+ * Get a single session.
+ */
+export function getProcess(id: string): ClaudeProcess | null {
+  const managed = processes.get(id);
+  return managed?.info || null;
+}

package/.forge/worktrees/pipeline-4dd8dc2d/lib/claude-sessions.ts

@@ -0,0 +1,266 @@
+/**
+ * Claude Sessions — read Claude Code's on-disk session JSONL files.
+ * Enables live-tailing of local CLI sessions from the web UI.
+ */
+
+import { existsSync, readFileSync, statSync, readdirSync, watch, openSync, readSync, closeSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { getClaudeDir } from './dirs';
+import { getProjectInfo } from './projects';
+
+export interface ClaudeSessionInfo {
+  sessionId: string;
+  summary?: string;
+  firstPrompt?: string;
+  messageCount?: number;
+  created?: string;
+  modified?: string;
+  gitBranch?: string;
+  fileSize: number;
+}
+
+export interface SessionEntry {
+  type: 'user' | 'assistant_text' | 'tool_use' | 'tool_result' | 'thinking' | 'system';
+  content: string;
+  toolName?: string;
+  model?: string;
+  timestamp?: string;
+}
+
+/**
+ * Convert a project path to the Claude projects directory.
+ * Claude uses: ~/.claude/projects/<path-with-slashes-replaced-by-dashes>/
+ */
+export function projectPathToClaudeDir(projectPath: string): string {
+  // Claude Code encodes paths by replacing all non-alphanumeric chars with '-'
+  const hash = projectPath.replace(/[^a-zA-Z0-9]/g, '-');
+  return join(getClaudeDir(), 'projects', hash);
+}
+
+/**
+ * Get the Claude sessions directory for a project by name.
+ */
+export function getClaudeDirForProject(projectName: string): string | null {
+  const project = getProjectInfo(projectName);
+  if (!project) return null;
+  const dir = projectPathToClaudeDir(project.path);
+  return existsSync(dir) ? dir : null;
+}
+
+/**
+ * List all sessions for a project.
+ */
+export function listClaudeSessions(projectName: string): ClaudeSessionInfo[] {
+  const dir = getClaudeDirForProject(projectName);
+  if (!dir) return [];
+
+  // Scan .jsonl files on disk (authoritative source)
+  let diskSessions: ClaudeSessionInfo[] = [];
+  try {
+    const files = readdirSync(dir).filter(f => f.endsWith('.jsonl'));
+    diskSessions = files.map(f => {
+      const sessionId = f.replace('.jsonl', '');
+      const fp = join(dir, f);
+      const stat = statSync(fp);
+      return {
+        sessionId,
+        fileSize: stat.size,
+        modified: stat.mtime.toISOString(),
+        created: stat.birthtime.toISOString(),
+      };
+    }).sort((a, b) => (b.modified || '').localeCompare(a.modified || ''));
+  } catch {
+    return [];
+  }
+
+  // Enrich with metadata from sessions-index.json if available
+  const indexPath = join(dir, 'sessions-index.json');
+  if (existsSync(indexPath)) {
+    try {
+      const index = JSON.parse(readFileSync(indexPath, 'utf-8'));
+      const indexMap = new Map<string, any>();
+      for (const e of (index.entries || [])) {
+        if (e.sessionId) indexMap.set(e.sessionId, e);
+      }
+      for (const s of diskSessions) {
+        const meta = indexMap.get(s.sessionId);
+        if (meta) {
+          s.summary = meta.summary;
+          s.firstPrompt = meta.firstPrompt;
+          s.messageCount = meta.messageCount;
+          s.gitBranch = meta.gitBranch;
+        }
+      }
+    } catch {}
+  }
+
+  return diskSessions;
+}
+
+/**
+ * Parse a single JSONL line into displayable SessionEntry items.
+ * One JSONL line can produce multiple entries (e.g., assistant message with text + tool_use).
+ */
+export function parseSessionLine(line: string): SessionEntry[] {
+  try {
+    const obj = JSON.parse(line);
+    const entries: SessionEntry[] = [];
+    const ts = obj.timestamp;
+
+    // Skip internal types
+    if (obj.type === 'queue-operation' || obj.type === 'last-prompt' || obj.type === 'rate_limit_event') {
+      return [];
+    }
+
+    // User message
+    if (obj.type === 'user' && obj.message) {
+      const content = typeof obj.message.content === 'string'
+        ? obj.message.content
+        : JSON.stringify(obj.message.content);
+      entries.push({ type: 'user', content, timestamp: ts });
+      return entries;
+    }
+
+    // Assistant message — can contain multiple content blocks
+    if (obj.type === 'assistant' && obj.message?.content) {
+      const model = obj.message.model;
+      for (const block of obj.message.content) {
+        if (block.type === 'thinking' && block.thinking) {
+          entries.push({ type: 'thinking', content: block.thinking, model, timestamp: ts });
+        } else if (block.type === 'text' && block.text) {
+          entries.push({ type: 'assistant_text', content: block.text, model, timestamp: ts });
+        } else if (block.type === 'tool_use') {
+          entries.push({
+            type: 'tool_use',
+            content: JSON.stringify(block.input || {}, null, 2),
+            toolName: block.name,
+            model,
+            timestamp: ts,
+          });
+        } else if (block.type === 'tool_result') {
+          const resultContent = typeof block.content === 'string'
+            ? block.content
+            : JSON.stringify(block.content);
+          entries.push({ type: 'tool_result', content: resultContent, timestamp: ts });
+        }
+      }
+      return entries;
+    }
+
+    // Tool result message (separate line)
+    if (obj.type === 'tool_result' && obj.message?.content) {
+      for (const block of obj.message.content) {
+        if (block.type === 'tool_result') {
+          const content = typeof block.content === 'string'
+            ? block.content
+            : JSON.stringify(block.content);
+          entries.push({ type: 'tool_result', content, timestamp: ts });
+        }
+      }
+      return entries;
+    }
+
+    // System messages
+    if (obj.type === 'system') {
+      entries.push({ type: 'system', content: obj.content || JSON.stringify(obj), timestamp: ts });
+      return entries;
+    }
+
+    return entries;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get the JSONL file path for a session.
+ */
+export function getSessionFilePath(projectName: string, sessionId: string): string | null {
+  const dir = getClaudeDirForProject(projectName);
+  if (!dir) return null;
+  const fp = join(dir, `${sessionId}.jsonl`);
+  return existsSync(fp) ? fp : null;
+}
+
+/**
+ * Read all entries from a session file.
+ */
+export function readSessionEntries(filePath: string): SessionEntry[] {
+  const content = readFileSync(filePath, 'utf-8');
+  const entries: SessionEntry[] = [];
+  for (const line of content.split('\n')) {
+    if (!line.trim()) continue;
+    entries.push(...parseSessionLine(line));
+  }
+  return entries;
+}
+
+/**
+ * Delete a session file and its cache entry.
+ */
+export function deleteSession(projectName: string, sessionId: string): boolean {
+  const dir = getClaudeDirForProject(projectName);
+  if (!dir) return false;
+  const fp = join(dir, `${sessionId}.jsonl`);
+  if (!existsSync(fp)) return false;
+  unlinkSync(fp);
+  return true;
+}
+
+/**
+ * Tail a session file — calls onNewEntries when new lines are appended.
+ * Returns a cleanup function.
+ */
+export function tailSessionFile(
+  filePath: string,
+  onNewEntries: (entries: SessionEntry[], raw: string) => void,
+  onError?: (err: Error) => void,
+): () => void {
+  let bytesRead = 0;
+
+  try {
+    bytesRead = statSync(filePath).size;
+  } catch {}
+
+  const readNewBytes = () => {
+    try {
+      const stat = statSync(filePath);
+      if (stat.size <= bytesRead) return;
+
+      const fd = openSync(filePath, 'r');
+      const buf = Buffer.alloc(stat.size - bytesRead);
+      readSync(fd, buf, 0, buf.length, bytesRead);
+      closeSync(fd);
+      bytesRead = stat.size;
+
+      const newText = buf.toString('utf-8');
+      const lines = newText.split('\n').filter(l => l.trim());
+      const entries: SessionEntry[] = [];
+      for (const line of lines) {
+        entries.push(...parseSessionLine(line));
+      }
+      if (entries.length > 0) {
+        onNewEntries(entries, newText);
+      }
+    } catch (err) {
+      onError?.(err as Error);
+    }
+  };
+
+  // Use both fs.watch AND polling as fallback (fs.watch is unreliable on macOS)
+  const watcher = watch(filePath, (eventType) => {
+    if (eventType === 'change') {
+      readNewBytes();
+    }
+  });
+
+  watcher.on('error', (err) => onError?.(err));
+
+  // Poll every 1 second as fallback (fs.watch is unreliable on macOS)
+  const pollTimer = setInterval(readNewBytes, 1000);
+
+  return () => {
+    watcher.close();
+    clearInterval(pollTimer);
+  };
+}