@aion0/forge 0.6.1 → 0.6.3

package/.forge/worktrees/pipeline-0a33c50d/lib/claude-process.ts

@@ -1,352 +0,0 @@
-/**
- * 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 goes last
-  args.push(message);
-
-  // Remove CLAUDECODE env var to avoid nesting detection
-  const env = { ...process.env };
-  delete env.CLAUDECODE;
-
-  const child = spawn(claudePath, args, {
-    cwd: managed.info.projectPath,
-    env,
-    stdio: ['pipe', 'pipe', 'pipe'],
-    shell: '/bin/zsh',
-  });
-
-  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-0a33c50d/lib/claude-sessions.ts

@@ -1,266 +0,0 @@
-/**
- * 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);
-  };
-}