ai-cli-mcp 2.15.0 → 2.17.0

package/src/cli-process-service.ts

@@ -5,11 +5,13 @@ import {
   existsSync,
   mkdirSync,
   openSync,
+  readSync,
   readFileSync,
   readdirSync,
   realpathSync,
   renameSync,
   rmSync,
+  statSync,
   unlinkSync,
   writeFileSync,
 } from 'node:fs';
@@ -17,8 +19,17 @@ import { join, basename, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { buildCliCommand, type BuildCliCommandOptions } from './cli-builder.js';
 import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli, findOpencodeCli } from './cli-utils.js';
-import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput } from './parsers.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput, PeekMessageExtractor } from './parsers.js';
 import { buildProcessResult } from './process-result.js';
+import {
+  appendPeekMessages,
+  buildNotFoundPeekProcess,
+  observedDurationSec,
+  validatePeekPids,
+  validatePeekTimeSec,
+  type PeekProcessResult,
+  type PeekResponse,
+} from './peek.js';
 import type { AgentType, ProcessListItem } from './process-service.js';
 
 interface StoredProcess {
@@ -244,6 +255,97 @@ export class CliProcessService {
     }
   }
 
+  async peekProcesses(pids: number[], peekTimeSec = 10): Promise<PeekResponse> {
+    const targetPids = validatePeekPids(pids);
+    const targetPeekTimeSec = validatePeekTimeSec(peekTimeSec);
+    const processes: PeekProcessResult[] = [];
+    const observers: Array<{
+      process: StoredProcess;
+      result: PeekProcessResult;
+      stdoutExtractor: PeekMessageExtractor;
+      stderrExtractor: PeekMessageExtractor;
+      stdoutOffset: number;
+      stderrOffset: number;
+    }> = [];
+
+    for (const pid of targetPids) {
+      let process: StoredProcess;
+      try {
+        process = this.refreshStatus(this.readProcess(pid));
+      } catch {
+        processes.push(buildNotFoundPeekProcess(pid));
+        continue;
+      }
+
+      const result: PeekProcessResult = {
+        pid,
+        agent: process.toolType,
+        status: process.status,
+        messages: [],
+        truncated: false,
+        error: null,
+      };
+      processes.push(result);
+      observers.push({
+        process,
+        result,
+        stdoutExtractor: new PeekMessageExtractor(process.toolType),
+        stderrExtractor: new PeekMessageExtractor(process.toolType),
+        stdoutOffset: this.fileSizeSafe(process.stdoutPath),
+        stderrOffset: this.fileSizeSafe(process.stderrPath),
+      });
+    }
+
+    const startedAt = new Date();
+    const startedAtMs = Date.now();
+    const deadlineMs = startedAtMs + targetPeekTimeSec * 1000;
+
+    while (Date.now() <= deadlineMs) {
+      const observedAt = new Date().toISOString();
+      let allTerminal = true;
+
+      for (const observer of observers) {
+        const stdoutRead = this.readTextFromOffset(observer.process.stdoutPath, observer.stdoutOffset);
+        observer.stdoutOffset = stdoutRead.offset;
+        appendPeekMessages(observer.result, observer.stdoutExtractor.push(stdoutRead.text, observedAt));
+
+        const stderrRead = this.readTextFromOffset(observer.process.stderrPath, observer.stderrOffset);
+        observer.stderrOffset = stderrRead.offset;
+        appendPeekMessages(observer.result, observer.stderrExtractor.push(stderrRead.text, observedAt));
+
+        observer.process = this.refreshStatus(this.readProcess(observer.process.pid));
+        observer.result.status = observer.process.status;
+        if (observer.process.status === 'running') {
+          allTerminal = false;
+        }
+      }
+
+      if (allTerminal) {
+        break;
+      }
+
+      const remainingMs = deadlineMs - Date.now();
+      if (remainingMs <= 0) {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, Math.min(50, remainingMs)));
+    }
+
+    const flushTs = new Date().toISOString();
+    for (const observer of observers) {
+      observer.process = this.refreshStatus(this.readProcess(observer.process.pid));
+      observer.result.status = observer.process.status;
+      appendPeekMessages(observer.result, observer.stdoutExtractor.flush(flushTs));
+      appendPeekMessages(observer.result, observer.stderrExtractor.flush(flushTs));
+    }
+
+    return {
+      peek_started_at: startedAt.toISOString(),
+      observed_duration_sec: observedDurationSec(startedAtMs),
+      processes,
+    };
+  }
+
   async killProcess(pid: number): Promise<{ pid: number; status: string; message: string }> {
     const process = this.readProcess(pid);
     const refreshed = this.refreshStatus(process);
@@ -445,6 +547,37 @@ export class CliProcessService {
     return readFileSync(filePath, 'utf-8');
   }
 
+  private fileSizeSafe(filePath: string): number {
+    if (!existsSync(filePath)) {
+      return 0;
+    }
+    return statSync(filePath).size;
+  }
+
+  private readTextFromOffset(filePath: string, offset: number): { text: string; offset: number } {
+    if (!existsSync(filePath)) {
+      return { text: '', offset };
+    }
+
+    const size = statSync(filePath).size;
+    if (size <= offset) {
+      return { text: '', offset: size };
+    }
+
+    const fd = openSync(filePath, 'r');
+    try {
+      const length = size - offset;
+      const buffer = Buffer.alloc(length);
+      const bytesRead = readSync(fd, buffer, 0, length, offset);
+      return {
+        text: buffer.subarray(0, bytesRead).toString('utf-8'),
+        offset: size,
+      };
+    } finally {
+      closeSync(fd);
+    }
+  }
+
   private resolveCwdsDir(): string {
     return join(this.stateDir, 'cwds');
   }

package/src/parsers.ts

@@ -1,5 +1,131 @@
 import { debugLog } from './cli-utils.js';
 
+export interface PeekMessage {
+  ts: string;
+  text: string;
+}
+
+type PeekAgent = 'claude' | 'codex' | string | null;
+
+function isGeminiAssistantMessageEvent(parsed: any): boolean {
+  return parsed.type === 'message' && parsed.role === 'assistant' && typeof parsed.content === 'string';
+}
+
+const GEMINI_STREAM_EVENT_TYPES = new Set([
+  'init',
+  'message',
+  'tool_use',
+  'tool_result',
+  'result',
+  'error',
+  'stats',
+]);
+
+function isGeminiStreamJsonEvent(parsed: any): boolean {
+  return parsed && typeof parsed === 'object' && !Array.isArray(parsed) && GEMINI_STREAM_EVENT_TYPES.has(parsed.type);
+}
+
+function extractPeekMessagesFromParsedEvent(agent: PeekAgent, parsed: any, observedAt: string): PeekMessage[] {
+  if (agent === 'codex') {
+    if (parsed.item?.type === 'agent_message' && typeof parsed.item.text === 'string' && parsed.item.text.trim()) {
+      return [{ ts: observedAt, text: parsed.item.text }];
+    }
+    if (parsed.msg?.type === 'agent_message' && typeof parsed.msg.message === 'string' && parsed.msg.message.trim()) {
+      return [{ ts: observedAt, text: parsed.msg.message }];
+    }
+    return [];
+  }
+
+  if (agent === 'claude' && parsed.type === 'assistant' && Array.isArray(parsed.message?.content)) {
+    return parsed.message.content
+      .filter((content: any) => content?.type === 'text' && typeof content.text === 'string' && content.text.trim())
+      .map((content: any) => ({ ts: observedAt, text: content.text }));
+  }
+
+  if (agent === 'opencode' && parsed.type === 'text' && parsed.part?.type === 'text' && typeof parsed.part.text === 'string' && parsed.part.text.trim()) {
+    return [{ ts: observedAt, text: parsed.part.text }];
+  }
+
+  return [];
+}
+
+export class PeekMessageExtractor {
+  private pending = '';
+  private geminiAssistantBuffer = '';
+
+  constructor(private readonly agent: PeekAgent) {}
+
+  push(chunk: string, observedAt = new Date().toISOString()): PeekMessage[] {
+    if (!chunk) {
+      return [];
+    }
+
+    const lines = `${this.pending}${chunk}`.split(/\r?\n/);
+    this.pending = lines.pop() || '';
+    return this.extractLines(lines, observedAt);
+  }
+
+  flush(observedAt = new Date().toISOString()): PeekMessage[] {
+    const messages: PeekMessage[] = [];
+
+    if (this.pending) {
+      const line = this.pending;
+      this.pending = '';
+      messages.push(...this.extractLines([line], observedAt));
+    }
+
+    messages.push(...this.flushGeminiAssistantBuffer(observedAt));
+    return messages;
+  }
+
+  private extractLines(lines: string[], observedAt: string): PeekMessage[] {
+    const messages: PeekMessage[] = [];
+
+    for (const line of lines) {
+      if (!line.trim()) {
+        continue;
+      }
+
+      try {
+        messages.push(...this.extractParsedEvent(JSON.parse(line), observedAt));
+      } catch {
+        debugLog(`[Debug] Skipping invalid peek JSON line: ${line}`);
+        messages.push(...this.flushGeminiAssistantBuffer(observedAt));
+      }
+    }
+
+    return messages;
+  }
+
+  private extractParsedEvent(parsed: any, observedAt: string): PeekMessage[] {
+    if (this.agent !== 'gemini') {
+      return extractPeekMessagesFromParsedEvent(this.agent, parsed, observedAt);
+    }
+
+    if (isGeminiAssistantMessageEvent(parsed)) {
+      this.geminiAssistantBuffer += parsed.content;
+      return [];
+    }
+
+    return this.flushGeminiAssistantBuffer(observedAt);
+  }
+
+  private flushGeminiAssistantBuffer(observedAt: string): PeekMessage[] {
+    if (this.agent !== 'gemini' || !this.geminiAssistantBuffer) {
+      return [];
+    }
+
+    const text = this.geminiAssistantBuffer;
+    this.geminiAssistantBuffer = '';
+
+    if (!text.trim()) {
+      return [];
+    }
+
+    return [{ ts: observedAt, text }];
+  }
+}
+
 export function parseCodexOutput(stdout: string): any {
   if (!stdout) return null;
 
@@ -142,11 +268,105 @@ export function parseGeminiOutput(stdout: string): any {
   if (!stdout) return null;
 
   try {
-    return JSON.parse(stdout);
+    const parsed = JSON.parse(stdout.trim());
+    if (!isGeminiStreamJsonEvent(parsed)) {
+      return parsed;
+    }
   } catch (e) {
     debugLog(`[Debug] Failed to parse Gemini JSON output: ${e}`);
-    return null;
   }
+
+  let sessionId: string | null = null;
+  let assistantBuffer = '';
+  let lastMessage: string | null = null;
+  let stats: any = null;
+  const toolsById = new Map<string, any>();
+  const toolsWithoutId: any[] = [];
+  const flushAssistantMessage = () => {
+    if (assistantBuffer.trim()) {
+      lastMessage = assistantBuffer;
+    }
+    assistantBuffer = '';
+  };
+
+  for (const line of stdout.split('\n')) {
+    if (!line.trim()) {
+      continue;
+    }
+
+    let parsed: any;
+    try {
+      parsed = JSON.parse(line);
+    } catch (e) {
+      debugLog(`[Debug] Skipping invalid Gemini stream-json line: ${line}`);
+      flushAssistantMessage();
+      continue;
+    }
+
+    if (parsed.type === 'init' && typeof parsed.session_id === 'string' && parsed.session_id) {
+      sessionId = parsed.session_id;
+      continue;
+    }
+
+    if (isGeminiAssistantMessageEvent(parsed)) {
+      assistantBuffer += parsed.content;
+      continue;
+    }
+
+    flushAssistantMessage();
+
+    if (parsed.type === 'result') {
+      if (parsed.stats) {
+        stats = parsed.stats;
+      }
+      continue;
+    }
+
+    if (parsed.type === 'tool_use') {
+      const tool = {
+        tool: parsed.tool_name || parsed.name || 'tool_use',
+        input: parsed.parameters ?? parsed.input ?? null,
+        output: null,
+        status: null,
+      };
+      if (typeof parsed.tool_id === 'string' && parsed.tool_id) {
+        toolsById.set(parsed.tool_id, tool);
+      } else {
+        toolsWithoutId.push(tool);
+      }
+      continue;
+    }
+
+    if (parsed.type === 'tool_result') {
+      const toolId = typeof parsed.tool_id === 'string' ? parsed.tool_id : '';
+      const tool = toolId ? toolsById.get(toolId) : null;
+      if (tool) {
+        tool.output = parsed.output ?? parsed.result ?? null;
+        tool.status = parsed.status ?? null;
+      } else {
+        toolsWithoutId.push({
+          tool: 'tool_result',
+          input: null,
+          output: parsed.output ?? parsed.result ?? null,
+          status: parsed.status ?? null,
+        });
+      }
+    }
+  }
+
+  flushAssistantMessage();
+  const tools = [...toolsById.values(), ...toolsWithoutId];
+
+  if (lastMessage || sessionId || stats || tools.length > 0) {
+    return {
+      message: lastMessage,
+      session_id: sessionId,
+      stats: stats || undefined,
+      tools: tools.length > 0 ? tools : undefined,
+    };
+  }
+
+  return null;
 }
 
 export function parseForgeOutput(stdout: string): any {

package/src/peek.ts

@@ -0,0 +1,88 @@
+import type { PeekMessage } from './parsers.js';
+import type { AgentType, ProcessStatus } from './process-service.js';
+
+export const DEFAULT_PEEK_TIME_SEC = 10;
+export const MAX_PEEK_TIME_SEC = 60;
+export const MAX_PEEK_PIDS = 32;
+export const PEEK_MESSAGE_CAP = 50;
+
+export type PeekStatus = ProcessStatus | 'not_found';
+export type PeekAgent = AgentType | string | null;
+
+export interface PeekProcessResult {
+  pid: number;
+  agent: PeekAgent;
+  status: PeekStatus;
+  messages: PeekMessage[];
+  truncated: boolean;
+  error: string | null;
+}
+
+export interface PeekResponse {
+  peek_started_at: string;
+  observed_duration_sec: number;
+  processes: PeekProcessResult[];
+}
+
+export function validatePeekPids(value: unknown): number[] {
+  if (!Array.isArray(value)) {
+    throw new Error('Missing or invalid required parameter: pids (must be an array of positive safe integers)');
+  }
+
+  const deduped: number[] = [];
+  const seen = new Set<number>();
+
+  for (const pid of value) {
+    if (typeof pid !== 'number' || !Number.isSafeInteger(pid) || pid <= 0) {
+      throw new Error('All pids must be positive safe integers');
+    }
+
+    if (!seen.has(pid)) {
+      seen.add(pid);
+      deduped.push(pid);
+    }
+  }
+
+  if (deduped.length === 0 || deduped.length > MAX_PEEK_PIDS) {
+    throw new Error(`pids must contain 1..${MAX_PEEK_PIDS} entries after dedupe`);
+  }
+
+  return deduped;
+}
+
+export function validatePeekTimeSec(value: unknown): number {
+  if (value === undefined || value === null) {
+    return DEFAULT_PEEK_TIME_SEC;
+  }
+
+  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0 || value > MAX_PEEK_TIME_SEC) {
+    throw new Error(`peek_time_sec must be a positive integer no greater than ${MAX_PEEK_TIME_SEC}`);
+  }
+
+  return value;
+}
+
+export function buildNotFoundPeekProcess(pid: number): PeekProcessResult {
+  return {
+    pid,
+    agent: null,
+    status: 'not_found',
+    messages: [],
+    truncated: false,
+    error: 'process not found',
+  };
+}
+
+export function appendPeekMessages(target: PeekProcessResult, messages: PeekMessage[]): void {
+  for (const message of messages) {
+    if (target.messages.length < PEEK_MESSAGE_CAP) {
+      target.messages.push(message);
+    } else {
+      target.truncated = true;
+    }
+  }
+}
+
+export function observedDurationSec(startedAtMs: number, endedAtMs = Date.now()): number {
+  return Number(((endedAtMs - startedAtMs) / 1000).toFixed(2));
+}

package/src/process-service.ts

@@ -1,6 +1,15 @@
 import { spawn, type ChildProcess } from 'node:child_process';
 import { buildCliCommand, type BuildCliCommandOptions } from './cli-builder.js';
-import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput } 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' | 'opencode';
@@ -217,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) {