ai-cli-mcp 2.14.1 → 2.16.0

package/src/process-service.ts

@@ -1,9 +1,18 @@
 import { spawn, type ChildProcess } from 'node:child_process';
 import { buildCliCommand, type BuildCliCommandOptions } from './cli-builder.js';
-import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput, PeekMessageExtractor } from './parsers.js';
+import {
+  appendPeekMessages,
+  buildNotFoundPeekProcess,
+  observedDurationSec,
+  validatePeekPids,
+  validatePeekTimeSec,
+  type PeekProcessResult,
+  type PeekResponse,
+} from './peek.js';
 import { buildProcessResult } from './process-result.js';
 
-export type AgentType = 'claude' | 'codex' | 'gemini' | 'forge';
+export type AgentType = 'claude' | 'codex' | 'gemini' | 'forge' | 'opencode';
 export type ProcessStatus = 'running' | 'completed' | 'failed';
 
 interface TrackedProcess {
@@ -37,6 +46,31 @@ interface ProcessServiceOptions {
   cliPaths: BuildCliCommandOptions['cliPaths'];
 }
 
+function parseAgentOutput(agent: AgentType, stdout: string, stderr: string): any {
+  if (agent === 'codex') {
+    return parseCodexOutput(`${stdout || ''}\n${stderr || ''}`);
+  }
+
+  if (!stdout) {
+    return null;
+  }
+
+  if (agent === 'claude') {
+    return parseClaudeOutput(stdout);
+  }
+  if (agent === 'gemini') {
+    return parseGeminiOutput(stdout);
+  }
+  if (agent === 'forge') {
+    return parseForgeOutput(stdout);
+  }
+  if (agent === 'opencode') {
+    return parseOpenCodeOutput(stdout);
+  }
+
+  return null;
+}
+
 export class ProcessService {
   private readonly processManager = new Map<number, TrackedProcess>();
   private readonly cliPaths: BuildCliCommandOptions['cliPaths'];
@@ -136,19 +170,7 @@ export class ProcessService {
       throw new Error(`Process with PID ${pid} not found`);
     }
 
-    let agentOutput: any = null;
-    if (process.toolType === 'codex') {
-      const combinedOutput = (process.stdout || '') + '\n' + (process.stderr || '');
-      agentOutput = parseCodexOutput(combinedOutput);
-    } else if (process.stdout) {
-      if (process.toolType === 'claude') {
-        agentOutput = parseClaudeOutput(process.stdout);
-      } else if (process.toolType === 'gemini') {
-        agentOutput = parseGeminiOutput(process.stdout);
-      } else if (process.toolType === 'forge') {
-        agentOutput = parseForgeOutput(process.stdout);
-      }
-    }
+    const agentOutput = parseAgentOutput(process.toolType, process.stdout, process.stderr);
 
     return buildProcessResult({
       pid,
@@ -204,6 +226,103 @@ export class ProcessService {
     }
   }
 
+  async peekProcesses(pids: number[], peekTimeSec = 10): Promise<PeekResponse> {
+    const targetPids = validatePeekPids(pids);
+    const targetPeekTimeSec = validatePeekTimeSec(peekTimeSec);
+    const processes: PeekProcessResult[] = [];
+    const observers: Array<{
+      entry: TrackedProcess;
+      result: PeekProcessResult;
+      stdoutExtractor: PeekMessageExtractor;
+      stderrExtractor: PeekMessageExtractor;
+      onStdout: (data: Buffer | string) => void;
+      onStderr: (data: Buffer | string) => void;
+    }> = [];
+
+    for (const pid of targetPids) {
+      const entry = this.processManager.get(pid);
+      if (!entry) {
+        processes.push(buildNotFoundPeekProcess(pid));
+        continue;
+      }
+
+      const result: PeekProcessResult = {
+        pid,
+        agent: entry.toolType,
+        status: entry.status,
+        messages: [],
+        truncated: false,
+        error: null,
+      };
+      processes.push(result);
+
+      const stdoutExtractor = new PeekMessageExtractor(entry.toolType);
+      const stderrExtractor = new PeekMessageExtractor(entry.toolType);
+      const onStdout = (data: Buffer | string) => {
+        appendPeekMessages(result, stdoutExtractor.push(data.toString(), new Date().toISOString()));
+      };
+      const onStderr = (data: Buffer | string) => {
+        appendPeekMessages(result, stderrExtractor.push(data.toString(), new Date().toISOString()));
+      };
+
+      if (entry.status === 'running') {
+        entry.process.stdout?.on('data', onStdout);
+        entry.process.stderr?.on('data', onStderr);
+      }
+
+      observers.push({ entry, result, stdoutExtractor, stderrExtractor, onStdout, onStderr });
+    }
+
+    const startedAt = new Date();
+    const startedAtMs = Date.now();
+    const runningObservers = observers.filter((observer) => observer.entry.status === 'running');
+    const terminalPromise = Promise.all(runningObservers.map((observer) => this.waitForProcessTerminal(observer.entry)));
+    let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+    const timeoutPromise = new Promise<void>((resolve) => {
+      timeoutHandle = setTimeout(resolve, targetPeekTimeSec * 1000);
+      timeoutHandle.unref?.();
+    });
+
+    try {
+      await Promise.race([terminalPromise, timeoutPromise]);
+    } finally {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+
+      const flushTs = new Date().toISOString();
+      for (const observer of observers) {
+        observer.entry.process.stdout?.off('data', observer.onStdout);
+        observer.entry.process.stderr?.off('data', observer.onStderr);
+        appendPeekMessages(observer.result, observer.stdoutExtractor.flush(flushTs));
+        appendPeekMessages(observer.result, observer.stderrExtractor.flush(flushTs));
+        observer.result.status = observer.entry.status;
+      }
+    }
+
+    return {
+      peek_started_at: startedAt.toISOString(),
+      observed_duration_sec: observedDurationSec(startedAtMs),
+      processes,
+    };
+  }
+
+  private waitForProcessTerminal(processEntry: TrackedProcess): Promise<void> {
+    if (processEntry.status !== 'running') {
+      return Promise.resolve();
+    }
+
+    return new Promise<void>((resolve) => {
+      const done = () => {
+        processEntry.process.off('close', done);
+        processEntry.process.off('error', done);
+        resolve();
+      };
+      processEntry.process.once('close', done);
+      processEntry.process.once('error', done);
+    });
+  }
+
   killProcess(pid: number): { pid: number; status: string; message: string } {
     const processEntry = this.processManager.get(pid);
     if (!processEntry) {

package/src/server.ts

@@ -1,5 +1,5 @@
-#!/usr/bin/env node
-export { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
+import { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli, findOpencodeCli } from './cli-utils.js';
+export { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli, findOpencodeCli } from './cli-utils.js';
 export { resolveModelAlias } from './cli-builder.js';
 export { ClaudeCodeServer, runMcpServer, spawnAsync } from './app/mcp.js';
 

package/vitest.config.unit.ts

@@ -17,13 +17,12 @@ export default defineConfig({
     },
     exclude: [
       'node_modules/**',
+      'dist/**',
       'src/__tests__/e2e.test.ts',
       'src/__tests__/edge-cases.test.ts',
-      'dist/__tests__/e2e.test.js',
-      'dist/__tests__/edge-cases.test.js',
     ],
     mockReset: true,
     clearMocks: true,
     restoreMocks: true,
   },
-});
+});