ai-cli-mcp 2.15.0 → 2.17.0

package/dist/parsers.js

@@ -1,4 +1,102 @@
 import { debugLog } from './cli-utils.js';
+function isGeminiAssistantMessageEvent(parsed) {
+    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) {
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) && GEMINI_STREAM_EVENT_TYPES.has(parsed.type);
+}
+function extractPeekMessagesFromParsedEvent(agent, parsed, observedAt) {
+    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) => content?.type === 'text' && typeof content.text === 'string' && content.text.trim())
+            .map((content) => ({ 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 {
+    agent;
+    pending = '';
+    geminiAssistantBuffer = '';
+    constructor(agent) {
+        this.agent = agent;
+    }
+    push(chunk, observedAt = new Date().toISOString()) {
+        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()) {
+        const messages = [];
+        if (this.pending) {
+            const line = this.pending;
+            this.pending = '';
+            messages.push(...this.extractLines([line], observedAt));
+        }
+        messages.push(...this.flushGeminiAssistantBuffer(observedAt));
+        return messages;
+    }
+    extractLines(lines, observedAt) {
+        const messages = [];
+        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;
+    }
+    extractParsedEvent(parsed, observedAt) {
+        if (this.agent !== 'gemini') {
+            return extractPeekMessagesFromParsedEvent(this.agent, parsed, observedAt);
+        }
+        if (isGeminiAssistantMessageEvent(parsed)) {
+            this.geminiAssistantBuffer += parsed.content;
+            return [];
+        }
+        return this.flushGeminiAssistantBuffer(observedAt);
+    }
+    flushGeminiAssistantBuffer(observedAt) {
+        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) {
     if (!stdout)
         return null;
@@ -137,12 +235,97 @@ export function parseGeminiOutput(stdout) {
     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 = null;
+    let assistantBuffer = '';
+    let lastMessage = null;
+    let stats = null;
+    const toolsById = new Map();
+    const toolsWithoutId = [];
+    const flushAssistantMessage = () => {
+        if (assistantBuffer.trim()) {
+            lastMessage = assistantBuffer;
+        }
+        assistantBuffer = '';
+    };
+    for (const line of stdout.split('\n')) {
+        if (!line.trim()) {
+            continue;
+        }
+        let parsed;
+        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) {
     if (!stdout)

package/dist/peek.js

@@ -0,0 +1,56 @@
+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 function validatePeekPids(value) {
+    if (!Array.isArray(value)) {
+        throw new Error('Missing or invalid required parameter: pids (must be an array of positive safe integers)');
+    }
+    const deduped = [];
+    const seen = new Set();
+    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) {
+    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) {
+    return {
+        pid,
+        agent: null,
+        status: 'not_found',
+        messages: [],
+        truncated: false,
+        error: 'process not found',
+    };
+}
+export function appendPeekMessages(target, messages) {
+    for (const message of messages) {
+        if (target.messages.length < PEEK_MESSAGE_CAP) {
+            target.messages.push(message);
+        }
+        else {
+            target.truncated = true;
+        }
+    }
+}
+export function observedDurationSec(startedAtMs, endedAtMs = Date.now()) {
+    return Number(((endedAtMs - startedAtMs) / 1000).toFixed(2));
+}

package/dist/process-service.js

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import { buildCliCommand } 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, } from './peek.js';
 import { buildProcessResult } from './process-result.js';
 function parseAgentOutput(agent, stdout, stderr) {
     if (agent === 'codex') {
@@ -155,6 +156,85 @@ export class ProcessService {
             }
         }
     }
+    async peekProcesses(pids, peekTimeSec = 10) {
+        const targetPids = validatePeekPids(pids);
+        const targetPeekTimeSec = validatePeekTimeSec(peekTimeSec);
+        const processes = [];
+        const observers = [];
+        for (const pid of targetPids) {
+            const entry = this.processManager.get(pid);
+            if (!entry) {
+                processes.push(buildNotFoundPeekProcess(pid));
+                continue;
+            }
+            const result = {
+                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) => {
+                appendPeekMessages(result, stdoutExtractor.push(data.toString(), new Date().toISOString()));
+            };
+            const onStderr = (data) => {
+                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;
+        const timeoutPromise = new Promise((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,
+        };
+    }
+    waitForProcessTerminal(processEntry) {
+        if (processEntry.status !== 'running') {
+            return Promise.resolve();
+        }
+        return new Promise((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) {
         const processEntry = this.processManager.get(pid);
         if (!processEntry) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-cli-mcp",
-  "version": "2.15.0",
+  "version": "2.17.0",
   "mcpName": "io.github.mkXultra/ai-cli-mcp",
   "description": "MCP server for AI CLI tools (Claude, Codex, Gemini, Forge, and OpenCode) with background process management",
   "author": "mkXultra",

package/src/__tests__/app-cli.test.ts

@@ -3,6 +3,7 @@ import {
   CLI_HELP_TEXT,
   DOCTOR_HELP_TEXT,
   MODELS_HELP_TEXT,
+  PEEK_HELP_TEXT,
   RESULT_HELP_TEXT,
   RUN_HELP_TEXT,
   WAIT_HELP_TEXT,
@@ -199,6 +200,64 @@ describe('ai-cli app', () => {
     expect(waitForProcesses).not.toHaveBeenCalled();
   });
 
+  it('dispatches peek with deduped pid arguments and time', async () => {
+    const stdout = vi.fn();
+    const stderr = vi.fn();
+    const peekProcesses = vi.fn().mockResolvedValue({
+      peek_started_at: '2026-04-11T12:34:56.789Z',
+      observed_duration_sec: 0.01,
+      processes: [],
+    });
+
+    const exitCode = await runCli(
+      ['peek', '123', '456', '123', '--time', '5'],
+      {
+        stdout,
+        stderr,
+        peekProcesses,
+      }
+    );
+
+    expect(exitCode).toBe(0);
+    expect(peekProcesses).toHaveBeenCalledWith([123, 456], 5);
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"peek_started_at"'));
+    expect(stderr).not.toHaveBeenCalled();
+  });
+
+  it('defaults peek time and rejects --follow', async () => {
+    const stdout = vi.fn();
+    const stderr = vi.fn();
+    const peekProcesses = vi.fn().mockResolvedValue({
+      peek_started_at: '2026-04-11T12:34:56.789Z',
+      observed_duration_sec: 0.01,
+      processes: [],
+    });
+
+    const defaultExitCode = await runCli(['peek', '123'], { stdout, stderr, peekProcesses });
+    expect(defaultExitCode).toBe(0);
+    expect(peekProcesses).toHaveBeenCalledWith([123], 10);
+
+    const followExitCode = await runCli(['peek', '123', '--follow'], { stdout, stderr, peekProcesses });
+    expect(followExitCode).toBe(1);
+    expect(stderr).toHaveBeenCalledWith('peek does not support --follow in v1\n');
+  });
+
+  it('rejects invalid peek time values', async () => {
+    const stdout = vi.fn();
+    const stderr = vi.fn();
+    const peekProcesses = vi.fn();
+
+    const exitCode = await runCli(['peek', '123', '--time', '1.5'], {
+      stdout,
+      stderr,
+      peekProcesses,
+    });
+
+    expect(exitCode).toBe(1);
+    expect(stderr).toHaveBeenCalledWith(expect.stringContaining('peek_time_sec must be a positive integer'));
+    expect(peekProcesses).not.toHaveBeenCalled();
+  });
+
   it('dispatches ps, result, and kill', async () => {
     const stdout = vi.fn();
     const stderr = vi.fn();
@@ -354,6 +413,18 @@ describe('ai-cli app', () => {
     expect(stderr).not.toHaveBeenCalled();
   });
 
+  it('prints detailed help for peek --help', async () => {
+    const stdout = vi.fn();
+    const stderr = vi.fn();
+
+    const exitCode = await runCli(['peek', '--help'], { stdout, stderr });
+
+    expect(exitCode).toBe(0);
+    expect(stdout).toHaveBeenCalledWith(PEEK_HELP_TEXT);
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('No --follow mode'));
+    expect(stderr).not.toHaveBeenCalled();
+  });
+
   it('prints detailed help for models --help', async () => {
     const stdout = vi.fn();
     const stderr = vi.fn();

package/src/__tests__/cli-builder.test.ts

@@ -314,7 +314,8 @@ describe('cli-builder', () => {
         expect(cmd.agent).toBe('codex');
         expect(cmd.cliPath).toBe('/usr/bin/codex');
         expect(cmd.args).toContain('exec');
-        expect(cmd.args).toContain('--full-auto');
+        expect(cmd.args).toContain('--dangerously-bypass-approvals-and-sandbox');
+        expect(cmd.args).not.toContain('--full-auto');
         expect(cmd.args).toContain('--json');
         expect(cmd.args).toContain('--model');
         expect(cmd.args).toContain('gpt-5.2-codex');
@@ -388,7 +389,7 @@ describe('cli-builder', () => {
         expect(cmd.cliPath).toBe('/usr/bin/gemini');
         expect(cmd.args).toContain('-y');
         expect(cmd.args).toContain('--output-format');
-        expect(cmd.args).toContain('json');
+        expect(cmd.args).toContain('stream-json');
         expect(cmd.args).toContain('--model');
         expect(cmd.args).toContain('gemini-2.5-pro');
       });

package/src/__tests__/cli-process-service.test.ts

@@ -122,6 +122,74 @@ describe('CliProcessService', () => {
     expect(readFileSync(join(processDir, 'meta.json'), 'utf-8')).toContain('"status": "completed"');
   });
 
+  it('peeks only appended natural-language messages from detached logs', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+    tempDirs.push(root);
+    const scriptPath = join(root, 'mock-claude-peek');
+    writeFileSync(
+      scriptPath,
+      `#!/bin/bash
+printf '%s\n' '{"type":"assistant","message":{"content":[{"type":"text","text":"old cli message"}]}}'
+sleep 2
+printf '%s\n' '{"type":"assistant","message":{"content":[{"type":"text","text":"new cli message"},{"type":"tool_use","id":"tool-1","name":"Read","input":{"file_path":"/tmp/a"}}]}}'
+printf '%s\n' '{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"tool-1","content":"secret"}]}}'
+`
+    );
+    chmodSync(scriptPath, 0o755);
+    const stateDir = join(root, 'state');
+    const workFolder = join(root, 'work');
+    mkdirSync(workFolder, { recursive: true });
+
+    const service = new CliProcessService({
+      stateDir,
+      cliPaths: {
+        claude: scriptPath,
+        codex: scriptPath,
+        gemini: scriptPath,
+        forge: scriptPath,
+        opencode: scriptPath,
+      },
+    });
+
+    const runResult = await service.startProcess({
+      prompt: 'hello peek',
+      cwd: workFolder,
+    });
+
+    const processDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)), String(runResult.pid));
+    const stdoutPath = join(processDir, 'stdout.log');
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < 5000 && !readFileSync(stdoutPath, 'utf-8').includes('old cli message')) {
+      await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+    expect(readFileSync(stdoutPath, 'utf-8')).toContain('old cli message');
+
+    const peekResult = await service.peekProcesses([runResult.pid, runResult.pid, 999999], 3);
+
+    expect(peekResult.processes).toHaveLength(2);
+    expect(peekResult.processes[0]).toMatchObject({
+      pid: runResult.pid,
+      agent: 'claude',
+      status: 'completed',
+      messages: [
+        {
+          ts: expect.any(String),
+          text: 'new cli message',
+        },
+      ],
+      truncated: false,
+      error: null,
+    });
+    expect(peekResult.processes[1]).toEqual({
+      pid: 999999,
+      agent: null,
+      status: 'not_found',
+      messages: [],
+      truncated: false,
+      error: 'process not found',
+    });
+  });
+
   it('returns compact results by default and full results when verbose is true', async () => {
     const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
     tempDirs.push(root);

package/src/__tests__/e2e.test.ts

@@ -39,7 +39,7 @@ describe('Claude Code MCP E2E Tests', () => {
     it('should register run tool', async () => {
       const tools = await client.listTools();
       
-      expect(tools).toHaveLength(6);
+      expect(tools).toHaveLength(7);
       const claudeCodeTool = tools.find((t: any) => t.name === 'run');
       expect(claudeCodeTool.inputSchema.properties.model.description).toContain('sonnet');
       expect(claudeCodeTool.inputSchema.properties.model.description).toContain('opencode');
@@ -49,6 +49,7 @@ describe('Claude Code MCP E2E Tests', () => {
       // Verify other tools exist
       expect(tools.some((t: any) => t.name === 'list_processes')).toBe(true);
       expect(tools.some((t: any) => t.name === 'get_result')).toBe(true);
+      expect(tools.some((t: any) => t.name === 'peek')).toBe(true);
       expect(tools.some((t: any) => t.name === 'kill_process')).toBe(true);
     });
   });

package/src/__tests__/mcp-contract.test.ts

@@ -96,6 +96,7 @@ describe('MCP Contract Tests', () => {
       'get_result',
       'kill_process',
       'list_processes',
+      'peek',
       'run',
       'wait',
     ]);
@@ -132,6 +133,14 @@ describe('MCP Contract Tests', () => {
       'timeout',
       'verbose',
     ]);
+
+    const peekTool = tools.find((tool: any) => tool.name === 'peek');
+    expect(peekTool.inputSchema.required).toEqual(['pids']);
+    expect(Object.keys(peekTool.inputSchema.properties).sort()).toEqual([
+      'peek_time_sec',
+      'pids',
+    ]);
+    expect(peekTool.description).toContain('One-shot');
   });
 
   it('preserves the stdio MCP smoke flow and response shapes', async () => {