ai-cli-mcp 2.14.1 → 2.16.0

package/src/__tests__/parsers.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { parseCodexOutput, parseClaudeOutput, parseForgeOutput } from '../parsers.js';
+import { parseCodexOutput, parseClaudeOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput, PeekMessageExtractor } from '../parsers.js';
 
 describe('parseCodexOutput', () => {
   it('should parse basic Codex output with message and session_id', () => {
@@ -65,6 +65,193 @@ INVALID_JSON
   });
 });
 
+describe('PeekMessageExtractor', () => {
+  const ts = '2026-04-11T12:34:56.789Z';
+
+  it('extracts only Codex agent_message text', () => {
+    const extractor = new PeekMessageExtractor('codex');
+    const output = [
+      '{"type":"item.completed","item":{"type":"reasoning","text":"hidden"}}',
+      '{"type":"item.completed","item":{"type":"command_execution","aggregated_output":"secret command output"}}',
+      '{"type":"item.completed","item":{"type":"agent_message","text":"Visible Codex message"}}',
+      '{"msg":{"type":"token_count","total":123}}',
+      '{"msg":{"type":"agent_message","message":"Visible legacy Codex message"}}',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([
+      { ts, text: 'Visible Codex message' },
+      { ts, text: 'Visible legacy Codex message' },
+    ]);
+  });
+
+  it('extracts only Claude assistant text content', () => {
+    const extractor = new PeekMessageExtractor('claude');
+    const output = [
+      '{"type":"assistant","message":{"content":[{"type":"text","text":"Visible Claude text"},{"type":"tool_use","id":"tool-1","name":"Read","input":{"file_path":"/tmp/a"}}]}}',
+      '{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"tool-1","content":"secret"}]}}',
+      '{"type":"result","result":"Final result is not peek assistant text"}',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([
+      { ts, text: 'Visible Claude text' },
+    ]);
+  });
+
+  it('extracts only Gemini assistant message content', () => {
+    const extractor = new PeekMessageExtractor('gemini');
+    const output = [
+      '{"type":"message","timestamp":"2026-04-11T14:44:42.294Z","role":"user","content":"hidden user text"}',
+      '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"Visible Gemini text","delta":true}',
+      '{"type":"tool_use","timestamp":"2026-04-11T14:44:53.821Z","tool_name":"run_shell_command","parameters":{"command":"echo secret"}}',
+      '{"type":"tool_result","timestamp":"2026-04-11T14:45:03.011Z","status":"success","output":"secret command output"}',
+      '{"type":"result","timestamp":"2026-04-11T14:45:10.380Z","status":"success","response":"Final result is not peek assistant text"}',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([
+      { ts, text: 'Visible Gemini text' },
+    ]);
+  });
+
+  it('joins split Gemini assistant chunks into one peek message on flush', () => {
+    const extractor = new PeekMessageExtractor('gemini');
+    const output = [
+      '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"Step 2 done. Starting step ","delta":true}',
+      '{"type":"message","timestamp":"2026-04-11T14:44:53.821Z","role":"assistant","content":"3.","delta":true}',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([]);
+    expect(extractor.flush('2026-04-11T12:34:59.000Z')).toEqual([
+      { ts: '2026-04-11T12:34:59.000Z', text: 'Step 2 done. Starting step 3.' },
+    ]);
+  });
+
+  it('emits separate Gemini peek messages when a boundary separates logical messages', () => {
+    const extractor = new PeekMessageExtractor('gemini');
+    const output = [
+      '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"Starting step ","delta":true}',
+      '{"type":"message","timestamp":"2026-04-11T14:44:53.821Z","role":"assistant","content":"1.","delta":true}',
+      '{"type":"tool_use","timestamp":"2026-04-11T14:44:53.822Z","tool_name":"run_shell_command","parameters":{"command":"echo secret"}}',
+      '{"type":"tool_result","timestamp":"2026-04-11T14:45:03.011Z","status":"success","output":"secret command output"}',
+      '{"type":"message","timestamp":"2026-04-11T14:45:10.315Z","role":"assistant","content":"Final ","delta":true}',
+      '{"type":"message","timestamp":"2026-04-11T14:45:10.316Z","role":"assistant","content":"answer.","delta":true}',
+      '{"type":"result","timestamp":"2026-04-11T14:45:10.380Z","status":"success","response":"Final result response is not peek text","stats":{"total_tokens":21999}}',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([
+      { ts, text: 'Starting step 1.' },
+      { ts, text: 'Final answer.' },
+    ]);
+    expect(extractor.flush(ts)).toEqual([]);
+  });
+
+  it('does not emit Gemini user, tool, tool result, stats, or result response text', () => {
+    const extractor = new PeekMessageExtractor('gemini');
+    const output = [
+      '{"type":"message","timestamp":"2026-04-11T14:44:42.294Z","role":"user","content":"hidden user text"}',
+      '{"type":"tool_use","timestamp":"2026-04-11T14:44:53.821Z","tool_name":"run_shell_command","parameters":{"command":"echo secret"}}',
+      '{"type":"tool_result","timestamp":"2026-04-11T14:45:03.011Z","status":"success","output":"secret command output"}',
+      '{"type":"result","timestamp":"2026-04-11T14:45:10.380Z","status":"success","response":"Final result response is not peek text","stats":{"total_tokens":21999}}',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([]);
+    expect(extractor.flush(ts)).toEqual([]);
+  });
+
+  it('denies unsupported agents and invalid shapes by default', () => {
+    const extractor = new PeekMessageExtractor('forge');
+    const output = [
+      '{"type":"assistant","message":{"content":[{"type":"text","text":"not supported here"}]}}',
+      '{"type":"item.completed","item":{"type":"agent_message","text":"not supported here"}}',
+      '{"type":"text","part":{"type":"text","text":"not supported here"}}',
+      '{"type":"message","role":"assistant","content":"not supported here"}',
+      'plain stdout',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([]);
+  });
+
+  it('extracts only OpenCode natural-language text events', () => {
+    const extractor = new PeekMessageExtractor('opencode');
+    const output = [
+      '{"type":"text","timestamp":1775918783605,"sessionID":"ses-1","part":{"type":"text","text":"OpenCode visible text"}}',
+      '{"type":"tool_use","timestamp":1775918783606,"sessionID":"ses-1","part":{"type":"tool","state":{"output":"secret command output"},"metadata":{"output":"secret metadata output"}}}',
+      '{"type":"text","timestamp":1775918783607,"sessionID":"ses-1","part":{"type":"tool","text":"wrong part type"}}',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([
+      { ts, text: 'OpenCode visible text' },
+    ]);
+  });
+
+  it('can flush a complete JSON event without a trailing newline', () => {
+    const extractor = new PeekMessageExtractor('codex');
+    expect(extractor.push('{"type":"item.completed","item":{"type":"agent_message","text":"pending"}}', ts)).toEqual([]);
+    expect(extractor.flush(ts)).toEqual([{ ts, text: 'pending' }]);
+  });
+});
+
+describe('parseGeminiOutput', () => {
+  it('should parse legacy final JSON output', () => {
+    const output = JSON.stringify({
+      session_id: 'gemini-session-json',
+      response: 'Legacy Gemini final response',
+      stats: {
+        total_tokens: 123,
+      },
+    });
+
+    expect(parseGeminiOutput(output)).toEqual({
+      session_id: 'gemini-session-json',
+      response: 'Legacy Gemini final response',
+      stats: {
+        total_tokens: 123,
+      },
+    });
+  });
+
+  it('should normalize a single-line Gemini assistant stream event', () => {
+    const output = '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"Only answer","delta":true}';
+
+    const result = parseGeminiOutput(output);
+
+    expect(result).toMatchObject({
+      message: 'Only answer',
+      session_id: null,
+    });
+    expect(result).not.toHaveProperty('type');
+    expect(result).not.toHaveProperty('content');
+  });
+
+  it('should parse Gemini stream-json NDJSON output', () => {
+    const output = [
+      '{"type":"init","timestamp":"2026-04-11T14:44:42.293Z","session_id":"gemini-session-stream","model":"gemini-3.1-pro-preview"}',
+      '{"type":"message","timestamp":"2026-04-11T14:44:42.294Z","role":"user","content":"hidden user text"}',
+      '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"First logical assistant response.","delta":true}',
+      '{"type":"tool_use","timestamp":"2026-04-11T14:44:53.821Z","tool_name":"run_shell_command","tool_id":"tool-1","parameters":{"command":"echo hidden"}}',
+      '{"type":"tool_result","timestamp":"2026-04-11T14:45:03.011Z","tool_id":"tool-1","status":"success","output":"hidden command output"}',
+      '{"type":"message","timestamp":"2026-04-11T14:45:10.315Z","role":"assistant","content":"Final assistant ","delta":true}',
+      '{"type":"message","timestamp":"2026-04-11T14:45:10.316Z","role":"assistant","content":"response.","delta":true}',
+      '{"type":"result","timestamp":"2026-04-11T14:45:10.380Z","status":"success","response":"Result response is not the parsed message","stats":{"total_tokens":21999}}',
+    ].join('\n') + '\n';
+
+    expect(parseGeminiOutput(output)).toEqual({
+      message: 'Final assistant response.',
+      session_id: 'gemini-session-stream',
+      stats: {
+        total_tokens: 21999,
+      },
+      tools: [
+        {
+          tool: 'run_shell_command',
+          input: { command: 'echo hidden' },
+          output: 'hidden command output',
+          status: 'success',
+        },
+      ],
+    });
+  });
+});
+
 describe('parseClaudeOutput', () => {
   it('should parse legacy JSON output', () => {
     const output = JSON.stringify({
@@ -149,3 +336,75 @@ still streaming`;
     expect(parseForgeOutput('plain text')).toBeNull();
   });
 });
+
+describe('parseOpenCodeOutput', () => {
+  it('parses a single completed OpenCode step', () => {
+    const output = `{"type":"step_start","sessionID":"ses_1"}
+{"type":"text","sessionID":"ses_1","part":{"type":"text","text":"Hello"}}
+{"type":"step_finish","sessionID":"ses_1","part":{"type":"step-finish","tokens":{"total":11833},"cost":0}}`;
+
+    expect(parseOpenCodeOutput(output)).toEqual({
+      message: 'Hello',
+      session_id: 'ses_1',
+      tokens: { total: 11833 },
+      cost: 0,
+    });
+  });
+
+  it('returns the last completed step for multi-step output', () => {
+    const output = `{"type":"step_start","sessionID":"ses_2"}
+{"type":"text","sessionID":"ses_2","part":{"type":"text","text":"First"}}
+{"type":"step_finish","sessionID":"ses_2","part":{"type":"step-finish","tokens":{"total":10},"cost":0}}
+{"type":"step_start","sessionID":"ses_2"}
+{"type":"text","sessionID":"ses_2","part":{"type":"text","text":"Second"}}
+{"type":"step_finish","sessionID":"ses_2","part":{"type":"step-finish","tokens":{"total":20},"cost":1}}`;
+
+    expect(parseOpenCodeOutput(output)).toEqual({
+      message: 'Second',
+      session_id: 'ses_2',
+      tokens: { total: 20 },
+      cost: 1,
+    });
+  });
+
+  it('resets the current-step buffer on each step_start', () => {
+    const output = `{"type":"step_start","sessionID":"ses_3"}
+{"type":"text","sessionID":"ses_3","part":{"type":"text","text":"Discard me"}}
+{"type":"step_start","sessionID":"ses_3"}
+{"type":"text","sessionID":"ses_3","part":{"type":"text","text":"Keep me"}}
+{"type":"step_finish","sessionID":"ses_3","part":{"type":"step-finish","tokens":{"total":5},"cost":0}}`;
+
+    expect(parseOpenCodeOutput(output)).toEqual({
+      message: 'Keep me',
+      session_id: 'ses_3',
+      tokens: { total: 5 },
+      cost: 0,
+    });
+  });
+
+  it('returns partial output when text exists without step_finish', () => {
+    const output = `{"type":"step_start","sessionID":"ses_4"}
+{"type":"text","sessionID":"ses_4","part":{"type":"text","text":"Partial"}}`;
+
+    expect(parseOpenCodeOutput(output)).toEqual({
+      message: 'Partial',
+      session_id: 'ses_4',
+    });
+  });
+
+  it('ignores malformed lines and unknown event types', () => {
+    const output = `not-json
+{"type":"unknown","sessionID":"ses_5"}
+{"type":"text","sessionID":"ses_5","part":{"type":"text","text":"Hello"}}`;
+
+    expect(parseOpenCodeOutput(output)).toEqual({
+      message: 'Hello',
+      session_id: 'ses_5',
+    });
+  });
+
+  it('returns null when no useful OpenCode events exist', () => {
+    expect(parseOpenCodeOutput('{"type":"unknown"}')).toBeNull();
+    expect(parseOpenCodeOutput('')).toBeNull();
+  });
+});

package/src/__tests__/peek.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import { appendPeekMessages, validatePeekPids, validatePeekTimeSec, type PeekProcessResult } from '../peek.js';
+
+describe('peek helpers', () => {
+  it('dedupes pids while preserving first occurrence order', () => {
+    expect(validatePeekPids([3, 1, 3, 2, 1])).toEqual([3, 1, 2]);
+  });
+
+  it('validates pid and time limits', () => {
+    expect(() => validatePeekPids([])).toThrow(/1..32/);
+    expect(() => validatePeekPids([1.5])).toThrow(/positive safe integers/);
+    expect(() => validatePeekPids([Number.MAX_SAFE_INTEGER + 1])).toThrow(/positive safe integers/);
+    expect(validatePeekTimeSec(undefined)).toBe(10);
+    expect(validatePeekTimeSec(60)).toBe(60);
+    expect(() => validatePeekTimeSec(0)).toThrow(/positive integer/);
+    expect(() => validatePeekTimeSec(1.5)).toThrow(/positive integer/);
+    expect(() => validatePeekTimeSec(61)).toThrow(/positive integer/);
+  });
+
+  it('keeps the first 50 messages and marks truncation when later messages are dropped', () => {
+    const process: PeekProcessResult = {
+      pid: 123,
+      agent: 'codex',
+      status: 'running',
+      messages: [],
+      truncated: false,
+      error: null,
+    };
+
+    appendPeekMessages(
+      process,
+      Array.from({ length: 55 }, (_, index) => ({
+        ts: '2026-04-11T12:34:56.789Z',
+        text: `message ${index}`,
+      })),
+    );
+
+    expect(process.messages).toHaveLength(50);
+    expect(process.messages[0].text).toBe('message 0');
+    expect(process.messages[49].text).toBe('message 49');
+    expect(process.truncated).toBe(true);
+  });
+});

package/src/__tests__/process-management.test.ts

@@ -68,7 +68,7 @@ describe('Process Management Tests', () => {
   async function setupServer() {
     const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
     
-    vi.mocked(Server).mockImplementation(() => {
+    vi.mocked(Server).mockImplementation(function(this: any) {
       mockServerInstance = {
         setRequestHandler: vi.fn((schema: any, handler: Function) => {
           handlers.set(schema.name, handler);
@@ -118,6 +118,190 @@ describe('Process Management Tests', () => {
       expect(response.message).toBe('claude process started successfully');
     });
 
+    it('should peek only natural-language messages observed after registration', async () => {
+      const { handlers } = await setupServer();
+
+      const mockProcess = new EventEmitter() as any;
+      mockProcess.pid = 12345;
+      mockProcess.stdout = new EventEmitter();
+      mockProcess.stderr = new EventEmitter();
+      mockProcess.kill = vi.fn();
+
+      mockSpawn.mockReturnValue(mockProcess);
+
+      const callToolHandler = handlers.get('callTool')!;
+      await callToolHandler!({
+        params: {
+          name: 'run',
+          arguments: {
+            prompt: 'test prompt',
+            workFolder: '/tmp'
+          }
+        }
+      });
+
+      mockProcess.stdout.emit('data', '{"type":"assistant","message":{"content":[{"type":"text","text":"old message"}]}}\n');
+
+      const peekPromise = callToolHandler!({
+        params: {
+          name: 'peek',
+          arguments: {
+            pids: [12345, 12345, 99999],
+            peek_time_sec: 1,
+          }
+        }
+      });
+
+      setTimeout(() => {
+        mockProcess.stdout.emit('data', '{"type":"assistant","message":{"content":[{"type":"text","text":"new message"},{"type":"tool_use","id":"tool-1","name":"Read","input":{"file_path":"/tmp/a"}}]}}\n');
+        mockProcess.stdout.emit('data', '{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"tool-1","content":"secret"}]}}\n');
+        mockProcess.emit('close', 0);
+      }, 10);
+
+      const result = await peekPromise;
+      const response = JSON.parse(result.content[0].text);
+
+      expect(response.processes).toHaveLength(2);
+      expect(response.processes[0]).toMatchObject({
+        pid: 12345,
+        agent: 'claude',
+        status: 'completed',
+        messages: [
+          {
+            ts: expect.any(String),
+            text: 'new message',
+          },
+        ],
+        truncated: false,
+        error: null,
+      });
+      expect(response.processes[1]).toEqual({
+        pid: 99999,
+        agent: null,
+        status: 'not_found',
+        messages: [],
+        truncated: false,
+        error: 'process not found',
+      });
+    });
+
+    it('should peek OpenCode text events and exclude OpenCode tool output', async () => {
+      const { handlers } = await setupServer();
+
+      const mockProcess = new EventEmitter() as any;
+      mockProcess.pid = 12346;
+      mockProcess.stdout = new EventEmitter();
+      mockProcess.stderr = new EventEmitter();
+      mockProcess.kill = vi.fn();
+
+      mockSpawn.mockReturnValue(mockProcess);
+
+      const callToolHandler = handlers.get('callTool')!;
+      await callToolHandler!({
+        params: {
+          name: 'run',
+          arguments: {
+            prompt: 'opencode peek prompt',
+            workFolder: '/tmp',
+            model: 'opencode',
+          }
+        }
+      });
+
+      const peekPromise = callToolHandler!({
+        params: {
+          name: 'peek',
+          arguments: {
+            pids: [12346],
+            peek_time_sec: 1,
+          }
+        }
+      });
+
+      setTimeout(() => {
+        mockProcess.stdout.emit('data', '{"type":"text","timestamp":1775918783605,"sessionID":"ses-1","part":{"type":"text","text":"OpenCode visible text"}}\n');
+        mockProcess.stdout.emit('data', '{"type":"tool_use","timestamp":1775918783606,"sessionID":"ses-1","part":{"type":"tool","state":{"output":"secret command output"},"metadata":{"output":"secret metadata output"}}}\n');
+        mockProcess.emit('close', 0);
+      }, 10);
+
+      const result = await peekPromise;
+      const response = JSON.parse(result.content[0].text);
+
+      expect(response.processes).toHaveLength(1);
+      expect(response.processes[0]).toMatchObject({
+        pid: 12346,
+        agent: 'opencode',
+        status: 'completed',
+        messages: [
+          {
+            ts: expect.any(String),
+            text: 'OpenCode visible text',
+          },
+        ],
+        truncated: false,
+        error: null,
+      });
+    });
+
+    it('should peek Gemini assistant message events and exclude tool output', async () => {
+      const { handlers } = await setupServer();
+
+      const mockProcess = new EventEmitter() as any;
+      mockProcess.pid = 12347;
+      mockProcess.stdout = new EventEmitter();
+      mockProcess.stderr = new EventEmitter();
+      mockProcess.kill = vi.fn();
+
+      mockSpawn.mockReturnValue(mockProcess);
+
+      const callToolHandler = handlers.get('callTool')!;
+      await callToolHandler!({
+        params: {
+          name: 'run',
+          arguments: {
+            prompt: 'gemini peek prompt',
+            workFolder: '/tmp',
+            model: 'gemini-2.5-pro',
+          }
+        }
+      });
+
+      const peekPromise = callToolHandler!({
+        params: {
+          name: 'peek',
+          arguments: {
+            pids: [12347],
+            peek_time_sec: 1,
+          }
+        }
+      });
+
+      setTimeout(() => {
+        mockProcess.stdout.emit('data', '{"type":"message","timestamp":"2026-04-11T14:44:42.294Z","role":"user","content":"hidden user text"}\n');
+        mockProcess.stdout.emit('data', '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"Visible Gemini text","delta":true}\n');
+        mockProcess.stdout.emit('data', '{"type":"tool_result","timestamp":"2026-04-11T14:45:03.011Z","status":"success","output":"secret command output"}\n');
+        mockProcess.emit('close', 0);
+      }, 10);
+
+      const result = await peekPromise;
+      const response = JSON.parse(result.content[0].text);
+
+      expect(response.processes).toHaveLength(1);
+      expect(response.processes[0]).toMatchObject({
+        pid: 12347,
+        agent: 'gemini',
+        status: 'completed',
+        messages: [
+          {
+            ts: expect.any(String),
+            text: 'Visible Gemini text',
+          },
+        ],
+        truncated: false,
+        error: null,
+      });
+    });
+
     it('should handle process with model parameter', async () => {
       const { handlers } = await setupServer();
       

package/src/__tests__/server.test.ts

@@ -201,6 +201,41 @@ describe('ClaudeCodeServer Unit Tests', () => {
     });
   });
 
+  describe('findOpencodeCli function', () => {
+    it('should fallback to PATH for OpenCode when no override is configured', async () => {
+      mockHomedir.mockReturnValue('/home/user');
+      mockExistsSync.mockImplementation((path) => path === '/usr/bin/opencode');
+      mockAccessSync.mockImplementation((filePath) => {
+        if (filePath === '/usr/bin/opencode') return undefined;
+        throw new Error('not executable');
+      });
+      process.env.PATH = '/usr/bin';
+
+      const module = await import('../server.js');
+      // @ts-ignore
+      const findOpencodeCli = module.default?.findOpencodeCli || module.findOpencodeCli;
+
+      expect(findOpencodeCli()).toBe('/usr/bin/opencode');
+    });
+
+    it('should use custom name from OPENCODE_CLI_NAME', async () => {
+      process.env.OPENCODE_CLI_NAME = 'opencode-custom';
+      mockHomedir.mockReturnValue('/home/user');
+      mockExistsSync.mockImplementation((path) => path === '/usr/bin/opencode-custom');
+      mockAccessSync.mockImplementation((filePath) => {
+        if (filePath === '/usr/bin/opencode-custom') return undefined;
+        throw new Error('not executable');
+      });
+      process.env.PATH = '/usr/bin';
+
+      const module = await import('../server.js');
+      // @ts-ignore
+      const findOpencodeCli = module.default?.findOpencodeCli || module.findOpencodeCli;
+
+      expect(findOpencodeCli()).toBe('opencode-custom');
+    });
+  });
+
   describe('spawnAsync function', () => {
     let mockProcess: any;
     
@@ -333,29 +368,29 @@ describe('ClaudeCodeServer Unit Tests', () => {
       );
     });
 
-    it('should set up tool handlers', async () => {
+    it('should include OpenCode in setup logging', async () => {
       mockHomedir.mockReturnValue('/home/user');
       mockExistsSync.mockReturnValue(true);
-      
-      const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
-      const mockSetRequestHandler = vi.fn();
+
       vi.mocked(Server).mockImplementation(function(this: any) {
-        this.setRequestHandler = mockSetRequestHandler;
+        this.setRequestHandler = vi.fn();
         this.connect = vi.fn();
         this.close = vi.fn();
         this.onerror = undefined;
         return this;
       });
-      
+
       const module = await import('../server.js');
       // @ts-ignore
       const { ClaudeCodeServer } = module;
-      
-      const server = new ClaudeCodeServer();
-      
-      expect(mockSetRequestHandler).toHaveBeenCalled();
+      new ClaudeCodeServer();
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[Setup] Using OpenCode CLI command/path:')
+      );
     });
 
+
     it('should set up error handler', async () => {
       mockHomedir.mockReturnValue('/home/user');
       mockExistsSync.mockReturnValue(true);
@@ -462,14 +497,15 @@ describe('ClaudeCodeServer Unit Tests', () => {
       const handler = listToolsCall[1];
       const result = await handler();
       
-      expect(result.tools).toHaveLength(6);
+      expect(result.tools).toHaveLength(7);
       expect(result.tools[0].name).toBe('run');
       expect(result.tools[0].description).toContain('AI Agent Runner');
       expect(result.tools[1].name).toBe('list_processes');
       expect(result.tools[2].name).toBe('get_result');
       expect(result.tools[3].name).toBe('wait');
-      expect(result.tools[4].name).toBe('kill_process');
-      expect(result.tools[5].name).toBe('cleanup_processes');
+      expect(result.tools[4].name).toBe('peek');
+      expect(result.tools[5].name).toBe('kill_process');
+      expect(result.tools[6].name).toBe('cleanup_processes');
     });
 
     it('should handle CallToolRequest', async () => {