agent-gear 1.1.6 → 1.1.7

package/tests/commands/mcp-proxy-dispatcher.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { EventEmitter } from 'events';
+import { PassThrough } from 'node:stream';
+import type { ChildProcess } from 'child_process';
+import { createStdioDispatcher } from '../../src/commands/mcp-proxy.js';
+
+function createFakeChild(): ChildProcess & EventEmitter {
+  const proc = new EventEmitter() as ChildProcess & EventEmitter;
+  Object.defineProperty(proc, 'stdin', { value: new PassThrough(), writable: true });
+  Object.defineProperty(proc, 'stdout', { value: new PassThrough(), writable: true });
+  Object.defineProperty(proc, 'stderr', { value: new PassThrough(), writable: true });
+  return proc;
+}
+
+function stdinWrites(child: ChildProcess): string[] {
+  const chunks: string[] = [];
+  (child.stdin as PassThrough).on('data', (d: Buffer) => chunks.push(d.toString()));
+  return chunks;
+}
+
+describe('createStdioDispatcher', () => {
+  let child: ChildProcess & EventEmitter;
+
+  beforeEach(() => {
+    child = createFakeChild();
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should forward notifications fire-and-forget without waiting for a response', async () => {
+    const writes = stdinWrites(child);
+    const dispatcher = createStdioDispatcher(child);
+
+    const start = Date.now();
+    const result = await dispatcher.forward({ jsonrpc: '2.0', method: 'notifications/initialized' });
+
+    // must resolve immediately — the MCP server never responds to notifications
+    expect(Date.now() - start).toBeLessThan(1000);
+    expect(result).toBeNull();
+    expect(writes.join('')).toContain('"method":"notifications/initialized"');
+  });
+
+  it('should resolve a request when the child responds with the matching id', async () => {
+    const dispatcher = createStdioDispatcher(child);
+
+    const promise = dispatcher.forward({ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} });
+    (child.stdout as PassThrough).write(JSON.stringify({ jsonrpc: '2.0', id: 1, result: { ok: true } }) + '\n');
+
+    await expect(promise).resolves.toEqual({ jsonrpc: '2.0', id: 1, result: { ok: true } });
+  });
+
+  it('should reassemble a JSON response split across multiple chunks', async () => {
+    const dispatcher = createStdioDispatcher(child);
+
+    const promise = dispatcher.forward({ jsonrpc: '2.0', id: 2, method: 'tools/list' });
+    const full = JSON.stringify({ jsonrpc: '2.0', id: 2, result: { tools: [{ name: 'probe_tool' }] } }) + '\n';
+    // TCP/stdio gives no message boundary guarantees: split the response
+    (child.stdout as PassThrough).write(full.slice(0, 10));
+    (child.stdout as PassThrough).write(full.slice(10, 40));
+    (child.stdout as PassThrough).write(full.slice(40));
+
+    await expect(promise).resolves.toEqual({ jsonrpc: '2.0', id: 2, result: { tools: [{ name: 'probe_tool' }] } });
+  });
+
+  it('should match concurrent responses to their requests by id, even out of order', async () => {
+    const dispatcher = createStdioDispatcher(child);
+
+    const p1 = dispatcher.forward({ jsonrpc: '2.0', id: 1, method: 'tools/list' });
+    const p2 = dispatcher.forward({ jsonrpc: '2.0', id: 2, method: 'tools/call' });
+
+    // second request answers first, and both arrive in one chunk
+    (child.stdout as PassThrough).write(
+      JSON.stringify({ jsonrpc: '2.0', id: 2, result: { content: [] } }) + '\n' +
+      JSON.stringify({ jsonrpc: '2.0', id: 1, result: { tools: [] } }) + '\n',
+    );
+
+    await expect(p1).resolves.toEqual({ jsonrpc: '2.0', id: 1, result: { tools: [] } });
+    await expect(p2).resolves.toEqual({ jsonrpc: '2.0', id: 2, result: { content: [] } });
+  });
+
+  it('should reject when the request times out', async () => {
+    vi.useFakeTimers();
+    try {
+      const dispatcher = createStdioDispatcher(child);
+
+      const promise = dispatcher.forward({ jsonrpc: '2.0', id: 9, method: 'tools/list' });
+      const assertion = expect(promise).rejects.toThrow('Request timeout waiting for tools/list');
+      await vi.advanceTimersByTimeAsync(30_000);
+      await assertion;
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('should reject all pending requests when the child exits', async () => {
+    const dispatcher = createStdioDispatcher(child);
+
+    const promise = dispatcher.forward({ jsonrpc: '2.0', id: 3, method: 'tools/list' });
+    child.emit('exit', 1);
+
+    await expect(promise).rejects.toThrow('MCP command exited with code 1');
+  });
+
+  it('should ignore non-JSON lines instead of failing the pending request', async () => {
+    const dispatcher = createStdioDispatcher(child);
+
+    const promise = dispatcher.forward({ jsonrpc: '2.0', id: 4, method: 'initialize' });
+    (child.stdout as PassThrough).write('[some log line that is not json]\n');
+    (child.stdout as PassThrough).write(JSON.stringify({ jsonrpc: '2.0', id: 4, result: {} }) + '\n');
+
+    await expect(promise).resolves.toEqual({ jsonrpc: '2.0', id: 4, result: {} });
+  });
+});

package/tests/fixtures/fake-acp-agent.mjs

@@ -0,0 +1,122 @@
+// Fake ACP agent used by acp-wire-mcp.test.ts and acp-wire-elicitation.test.ts.
+// Speaks ndjson JSON-RPC over stdio: answers initialize/session/new/session/resume
+// and records every session/new & session/resume params payload to CAPTURE_FILE
+// (one JSON per line) so tests can assert the exact wire format.
+//
+// When FAKE_AGENT_ELICITATION=form|url is set, a session/prompt makes the agent
+// behave like an eliciting agent (e.g. opencode asking a question):
+//   1. capture the initialize params (clientCapabilities advertisement)
+//   2. send an outgoing `elicitation/create` request and await the client response
+//   3. capture the elicitation response payload exactly as received on the wire
+//   4. reply to session/prompt with stopReason "end_turn"
+//   5. (url mode only) send an `elicitation/complete` notification afterwards
+import { appendFileSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+
+const captureFile = process.env.CAPTURE_FILE;
+const elicitationMode = process.env.FAKE_AGENT_ELICITATION; // 'form' | 'url' | undefined
+
+const rl = createInterface({ input: process.stdin });
+
+let nextOutgoingId = 1000;
+// outgoing request id -> continuation invoked with the client's response result
+const pendingOutgoing = new Map();
+
+function reply(id, result) {
+  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n');
+}
+
+function request(method, params, onResult) {
+  const id = nextOutgoingId++;
+  pendingOutgoing.set(id, onResult);
+  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+}
+
+function notify(method, params) {
+  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n');
+}
+
+function capture(entry) {
+  if (captureFile) {
+    appendFileSync(captureFile, JSON.stringify(entry) + '\n');
+  }
+}
+
+function handlePrompt(msg) {
+  if (!elicitationMode) {
+    reply(msg.id, { stopReason: 'end_turn' });
+    return;
+  }
+
+  const sessionId = msg.params?.sessionId ?? 'fake-acp-session-1';
+  const params =
+    elicitationMode === 'form'
+      ? {
+          sessionId,
+          mode: 'form',
+          message: 'How should I approach this refactoring?',
+          requestedSchema: {
+            type: 'object',
+            properties: {
+              strategy: { type: 'string', enum: ['conservative', 'balanced', 'aggressive'] },
+            },
+            required: ['strategy'],
+          },
+        }
+      : {
+          sessionId,
+          mode: 'url',
+          elicitationId: 'fake-oauth-001',
+          url: 'https://agent.example.com/connect?elicitationId=fake-oauth-001',
+          message: 'Please authorize access to your repositories.',
+        };
+
+  request('elicitation/create', params, (result) => {
+    capture({ method: 'elicitation/create', response: result ?? null });
+    reply(msg.id, { stopReason: 'end_turn' });
+    if (elicitationMode === 'url') {
+      notify('elicitation/complete', { elicitationId: 'fake-oauth-001' });
+    }
+  });
+}
+
+rl.on('line', (line) => {
+  let msg;
+  try { msg = JSON.parse(line); } catch { return; }
+
+  // Response to an outgoing request (has id, no method)
+  if (msg.id !== undefined && !msg.method) {
+    const continuation = pendingOutgoing.get(msg.id);
+    if (continuation) {
+      pendingOutgoing.delete(msg.id);
+      continuation(msg.result);
+    }
+    return;
+  }
+
+  if (msg.id === undefined || !msg.method) return; // ignore notifications
+
+  switch (msg.method) {
+    case 'initialize':
+      if (elicitationMode) {
+        capture({ method: 'initialize', params: msg.params });
+      }
+      reply(msg.id, {
+        protocolVersion: 1,
+        agentCapabilities: { mcpCapabilities: { http: true, sse: true } },
+        agentInfo: { name: 'fake-acp-agent', version: '0.0.1' },
+        authMethods: [],
+      });
+      break;
+    case 'session/new':
+    case 'session/resume':
+      capture({ method: msg.method, params: msg.params });
+      reply(msg.id, { sessionId: 'fake-acp-session-1' });
+      break;
+    case 'session/prompt':
+      handlePrompt(msg);
+      break;
+    default:
+      reply(msg.id, {});
+  }
+});