agent-gear 1.1.5 → 1.1.7

package/tests/acp-wire-elicitation.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { readFileSync, rmSync, mkdtempSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// Force the real (unmocked) ACP SDK through the vite pipeline (same rationale
+// as acp-wire-mcp.test.ts): keep actual SDK serialization behavior on the wire.
+vi.mock('@agentclientprotocol/sdk', async (importOriginal) => {
+  return await importOriginal<typeof import('@agentclientprotocol/sdk')>();
+});
+
+import { AcpSessionBridge } from '../../src/acp/bridge.js';
+import { AcpSpawner } from '../../src/acp/spawner.js';
+
+const FAKE_AGENT = join(dirname(fileURLToPath(import.meta.url)), 'fixtures', 'fake-acp-agent.mjs');
+
+interface CapturedEntry {
+  method: string;
+  params?: Record<string, unknown>;
+  response?: Record<string, unknown> | null;
+}
+
+// Wire-level test: drives a REAL ACP client connection against a fake agent
+// process that issues `elicitation/create` (the same wire behavior as an
+// eliciting agent such as opencode), and asserts both the Socket.IO payload
+// emitted by the bridge and the exact JSON-RPC response that goes back over
+// stdio — no mocked ClientSideConnection.
+describe('AcpSessionBridge - Elicitation wire format (ACP spec)', () => {
+  let workdir: string;
+  let captureFile: string;
+  let bridge: AcpSessionBridge | null = null;
+
+  afterEach(async () => {
+    delete process.env.CAPTURE_FILE;
+    delete process.env.FAKE_AGENT_ELICITATION;
+    if (bridge) {
+      await bridge.stop().catch(() => {});
+      bridge = null;
+    }
+    if (workdir) rmSync(workdir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  function setup(mode: 'form' | 'url') {
+    workdir = mkdtempSync(join(tmpdir(), 'acp-wire-elic-'));
+    captureFile = join(workdir, 'capture.jsonl');
+    process.env.CAPTURE_FILE = captureFile;
+    process.env.FAKE_AGENT_ELICITATION = mode;
+    const spawner = new AcpSpawner({
+      sessionId: 'sess-wire',
+      cwd: workdir,
+      command: process.execPath,
+      args: [FAKE_AGENT],
+    });
+    const socket = { emit: vi.fn(), on: vi.fn(), off: vi.fn() };
+    bridge = new AcpSessionBridge(socket as never, {
+      sessionId: 'sess-wire',
+      cwd: workdir,
+    }, spawner);
+    return socket;
+  }
+
+  function readCapture(): CapturedEntry[] {
+    if (!existsSync(captureFile)) return [];
+    return readFileSync(captureFile, 'utf8').trim().split('\n').filter(Boolean).map((l) => JSON.parse(l));
+  }
+
+  function emittedCall(socket: { emit: ReturnType<typeof vi.fn> }, event: string) {
+    return socket.emit.mock.calls.find((c) => c[0] === event);
+  }
+
+  it('should advertise elicitation capabilities in initialize on the wire', async () => {
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    setup('form');
+
+    await bridge!.start();
+
+    const init = readCapture().find((e) => e.method === 'initialize');
+    expect(init).toBeDefined();
+    const capabilities = init!.params!.clientCapabilities as Record<string, unknown>;
+    expect(capabilities.elicitation).toEqual({ form: {}, url: {} });
+  }, 15000);
+
+  it('should forward form elicitation and respond with spec-compliant payload', async () => {
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    const socket = setup('form');
+
+    await bridge!.start();
+    bridge!.sendInput({ type: 'text', content: 'please refactor this' });
+
+    // The agent's elicitation/create must surface as an acp:elicitation socket event
+    await vi.waitFor(() => {
+      expect(emittedCall(socket, 'acp:elicitation')).toBeDefined();
+    }, { timeout: 10000 });
+
+    const [, payload] = emittedCall(socket, 'acp:elicitation')!;
+    expect(payload.sessionId).toBe('sess-wire');
+    expect(payload.mode).toBe('form');
+    expect(payload.message).toBe('How should I approach this refactoring?');
+    expect(payload.requestedSchema.required).toEqual(['strategy']);
+    expect(payload.requestId).toMatch(/^elic_/);
+
+    // Simulate the server returning the user's answer
+    bridge!.handleElicitationResponse(payload.requestId, 'accept', { strategy: 'balanced' });
+
+    // The agent must receive a spec-compliant CreateElicitationResponse on the wire
+    await vi.waitFor(() => {
+      const elicitation = readCapture().find((e) => e.method === 'elicitation/create');
+      expect(elicitation?.response).toBeDefined();
+    }, { timeout: 10000 });
+
+    const elicitation = readCapture().find((e) => e.method === 'elicitation/create');
+    expect(elicitation!.response).toEqual({ action: 'accept', content: { strategy: 'balanced' } });
+
+    // Prompt completes after the elicitation resolves
+    await vi.waitFor(() => {
+      expect(emittedCall(socket, 'acp:prompt:complete')).toBeDefined();
+    }, { timeout: 10000 });
+  }, 20000);
+
+  it('should forward url elicitation and relay the completion notification', async () => {
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    const socket = setup('url');
+
+    await bridge!.start();
+    bridge!.sendInput({ type: 'text', content: 'connect my account' });
+
+    await vi.waitFor(() => {
+      expect(emittedCall(socket, 'acp:elicitation')).toBeDefined();
+    }, { timeout: 10000 });
+
+    const [, payload] = emittedCall(socket, 'acp:elicitation')!;
+    expect(payload.mode).toBe('url');
+    expect(payload.elicitationId).toBe('fake-oauth-001');
+    expect(payload.url).toBe('https://agent.example.com/connect?elicitationId=fake-oauth-001');
+    expect(payload.message).toBe('Please authorize access to your repositories.');
+
+    // User consented to open the URL (accept without content)
+    bridge!.handleElicitationResponse(payload.requestId, 'accept');
+
+    await vi.waitFor(() => {
+      const elicitation = readCapture().find((e) => e.method === 'elicitation/create');
+      expect(elicitation?.response).toBeDefined();
+    }, { timeout: 10000 });
+
+    const elicitation = readCapture().find((e) => e.method === 'elicitation/create');
+    expect(elicitation!.response).toEqual({ action: 'accept' });
+
+    // The agent's elicitation/complete notification must be forwarded
+    await vi.waitFor(() => {
+      expect(emittedCall(socket, 'acp:elicitation:complete')).toBeDefined();
+    }, { timeout: 10000 });
+
+    const [, completePayload] = emittedCall(socket, 'acp:elicitation:complete')!;
+    expect(completePayload).toEqual({ sessionId: 'sess-wire', elicitationId: 'fake-oauth-001' });
+  }, 20000);
+});

package/tests/acp-wire-mcp.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { readFileSync, rmSync, mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// Force the real (unmocked) ACP SDK through the vite pipeline: returning the
+// original module keeps actual SDK serialization behavior while avoiding the
+// node-native externalization that breaks .js -> .ts source resolution.
+vi.mock('@agentclientprotocol/sdk', async (importOriginal) => {
+  return await importOriginal<typeof import('@agentclientprotocol/sdk')>();
+});
+
+import { AcpSessionBridge } from '../../src/acp/bridge.js';
+import { AcpSpawner } from '../../src/acp/spawner.js';
+
+const FAKE_AGENT = join(dirname(fileURLToPath(import.meta.url)), 'fixtures', 'fake-acp-agent.mjs');
+
+// Wire-level test: drives a REAL ACP client connection (SDK serialization,
+// ndJsonStream) against a fake agent process, and asserts the exact JSON-RPC
+// payload that goes over stdin — no mocked ClientSideConnection.
+describe('AcpSessionBridge - MCP wire format (ACP spec)', () => {
+  let workdir: string;
+  let captureFile: string;
+  let bridge: AcpSessionBridge | null = null;
+
+  afterEach(async () => {
+    delete process.env.CAPTURE_FILE;
+    if (bridge) {
+      await bridge.stop().catch(() => {});
+      bridge = null;
+    }
+    if (workdir) rmSync(workdir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  function setup() {
+    workdir = mkdtempSync(join(tmpdir(), 'acp-wire-'));
+    captureFile = join(workdir, 'capture.jsonl');
+    process.env.CAPTURE_FILE = captureFile;
+    const spawner = new AcpSpawner({
+      sessionId: 'sess-wire',
+      cwd: workdir,
+      command: process.execPath,
+      args: [FAKE_AGENT],
+    });
+    const socket = { emit: vi.fn(), on: vi.fn(), off: vi.fn() };
+    bridge = new AcpSessionBridge(socket as never, {
+      sessionId: 'sess-wire',
+      cwd: workdir,
+      mcpEndpoint: {
+        url: 'http://gateway/mcp/sess-wire',
+        token: 'wire-token',
+        serverNames: ['fluentui-mcp', 'fs-mcp'],
+      },
+    }, spawner);
+    return socket;
+  }
+
+  function readCapture(): Array<{ method: string; params: Record<string, unknown> }> {
+    return readFileSync(captureFile, 'utf8').trim().split('\n').map((l) => JSON.parse(l));
+  }
+
+  it('should send session/new with spec-compliant mcpServers on the wire', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    setup();
+
+    await bridge!.start();
+
+    const captured = readCapture();
+    expect(captured).toHaveLength(1);
+    expect(captured[0].method).toBe('session/new');
+    // ACP spec (session/new): mcpServers entries for HTTP transport are
+    // { type: "http", name, url, headers: [{ name, value }] }
+    expect(captured[0].params.mcpServers).toEqual([
+      {
+        type: 'http',
+        name: 'fluentui-mcp',
+        url: 'http://gateway/mcp/sess-wire/fluentui-mcp',
+        headers: [{ name: 'Authorization', value: 'Bearer wire-token' }],
+      },
+      {
+        type: 'http',
+        name: 'fs-mcp',
+        url: 'http://gateway/mcp/sess-wire/fs-mcp',
+        headers: [{ name: 'Authorization', value: 'Bearer wire-token' }],
+      },
+    ]);
+    expect(captured[0].params.cwd).toBe(workdir);
+
+    // The MCP handoff must be visible in logs, without leaking the token
+    const logLines = logSpy.mock.calls.map((c) => String(c[0]));
+    const mcpLog = logLines.find((l) => l.includes('passing MCP servers via session/new'));
+    expect(mcpLog).toBeDefined();
+    expect(mcpLog).toContain('fluentui-mcp(type=http, url=http://gateway/mcp/sess-wire/fluentui-mcp, headers=Authorization)');
+    expect(mcpLog).not.toContain('wire-token');
+  }, 15000);
+
+  it('should send session/resume with spec-compliant mcpServers on the wire', async () => {
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    setup();
+
+    await bridge!.resume('ext-session-1');
+
+    const captured = readCapture();
+    expect(captured).toHaveLength(1);
+    expect(captured[0].method).toBe('session/resume');
+    expect(captured[0].params.sessionId).toBe('ext-session-1');
+    expect(captured[0].params.mcpServers).toEqual([
+      expect.objectContaining({ type: 'http', name: 'fluentui-mcp' }),
+      expect.objectContaining({ type: 'http', name: 'fs-mcp' }),
+    ]);
+  }, 15000);
+});

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, {});
+  }
+});