agent-gear 1.1.6 → 1.1.8

package/tests/acp-bridge.test.ts

@@ -20,6 +20,10 @@ let mockConnInstance = buildMockConn();
 vi.mock('@agentclientprotocol/sdk', () => ({
   ndJsonStream: vi.fn(() => ({})),
   ClientSideConnection: vi.fn(function () { return mockConnInstance; }),
+  CreateElicitationRequest: {
+    isForm: (v: { mode?: string }) => v.mode === 'form',
+    isUrl: (v: { mode?: string }) => v.mode === 'url',
+  },
 }));
 
 import { AcpSessionBridge, extractConfigOptions } from '../../src/acp/bridge.js';
@@ -80,6 +84,7 @@ describe('AcpSessionBridge', () => {
           session: {
             configOptions: { boolean: {} },
           },
+          elicitation: { form: {}, url: {} },
         },
         clientInfo: { name: 'agent-gear', version: '1.1.5' },
       });
@@ -235,6 +240,7 @@ describe('AcpSessionBridge', () => {
       expect(mc().resumeSession).toHaveBeenCalledWith({
         sessionId: 'existing-sess-id',
         cwd: '/home/user',
+        mcpServers: [],
       });
       expect(emitSpy).toHaveBeenCalledWith(expect.objectContaining({
         sessionId: 'sess-1',
@@ -525,6 +531,119 @@ describe('AcpSessionBridge', () => {
     });
   });
 
+  describe('unstable_createElicitation', () => {
+    it('form 模式：emit acp:elicitation 并在响应后 resolve accept + content', async () => {
+      const bridge = createBridge();
+      const requestedSchema = {
+        type: 'object',
+        properties: { name: { type: 'string' } },
+        required: ['name'],
+      };
+
+      const promise = bridge.unstable_createElicitation({
+        mode: 'form',
+        message: 'Need your name',
+        sessionId: 'acp-sess-abc',
+        toolCallId: 'tc-1',
+        requestedSchema,
+      } as never);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:elicitation', expect.objectContaining({
+        sessionId: 'sess-1',
+        mode: 'form',
+        message: 'Need your name',
+        toolCallId: 'tc-1',
+        requestedSchema,
+      }));
+
+      const emitCall = mockSocket.emit.mock.calls.find((c: unknown[]) => c[0] === 'acp:elicitation');
+      const requestId = (emitCall![1] as { requestId: string }).requestId;
+      expect(requestId).toMatch(/^elic_/);
+
+      bridge.handleElicitationResponse(requestId, 'accept', { name: 'ash' });
+
+      const result = await promise;
+      expect(result).toEqual({ action: 'accept', content: { name: 'ash' } });
+    });
+
+    it('url 模式：透传 elicitationId 与 url', async () => {
+      const bridge = createBridge();
+
+      const promise = bridge.unstable_createElicitation({
+        mode: 'url',
+        message: 'Authorize access',
+        sessionId: 'acp-sess-abc',
+        elicitationId: 'elic-agent-1',
+        url: 'https://example.com/auth',
+      } as never);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:elicitation', expect.objectContaining({
+        sessionId: 'sess-1',
+        mode: 'url',
+        message: 'Authorize access',
+        elicitationId: 'elic-agent-1',
+        url: 'https://example.com/auth',
+      }));
+
+      const emitCall = mockSocket.emit.mock.calls.find((c: unknown[]) => c[0] === 'acp:elicitation');
+      const requestId = (emitCall![1] as { requestId: string }).requestId;
+      bridge.handleElicitationResponse(requestId, 'decline');
+
+      const result = await promise;
+      expect(result).toEqual({ action: 'decline' });
+    });
+
+    it('custom/未知模式：立即返回 cancel 且不 emit socket 事件', async () => {
+      const bridge = createBridge();
+
+      const result = await bridge.unstable_createElicitation({
+        mode: '_vendor_custom',
+        message: 'custom request',
+        sessionId: 'acp-sess-abc',
+      } as never);
+
+      expect(result).toEqual({ action: 'cancel' });
+      expect(mockSocket.emit).not.toHaveBeenCalledWith('acp:elicitation', expect.anything());
+    });
+
+    it('65s 超时自动 resolve cancel', async () => {
+      const bridge = createBridge();
+
+      const promise = bridge.unstable_createElicitation({
+        mode: 'form',
+        message: 'm',
+        sessionId: 'acp-sess-abc',
+        requestedSchema: { type: 'object' },
+      } as never);
+
+      await vi.advanceTimersByTimeAsync(65_000);
+
+      const result = await promise;
+      expect(result).toEqual({ action: 'cancel' });
+    });
+
+    it('handleElicitationResponse 未知 requestId 打 warn 不抛错', () => {
+      const bridge = createBridge();
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      expect(() => bridge.handleElicitationResponse('elic_unknown', 'cancel')).not.toThrow();
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('elic_unknown'));
+    });
+  });
+
+  describe('unstable_completeElicitation', () => {
+    it('emit acp:elicitation:complete', async () => {
+      const bridge = createBridge();
+
+      await bridge.unstable_completeElicitation({ elicitationId: 'elic-agent-1' } as never);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:elicitation:complete', {
+        sessionId: 'sess-1',
+        elicitationId: 'elic-agent-1',
+      });
+    });
+  });
+
   describe('setMode', () => {
     it('should call connection.setSessionMode', async () => {
       const bridge = createBridge();

package/tests/acp-spawner.test.ts

@@ -68,7 +68,34 @@ describe('AcpSpawner', () => {
       spawner.start();
       const stderr = mockProcess.stderr as Readable;
       stderr.emit('data', Buffer.from('some warning\n'));
-      expect(consoleErrorSpy).toHaveBeenCalledWith('ACP stderr: some warning\n');
+      expect(consoleErrorSpy).toHaveBeenCalledWith('ACP stderr (session=sess-1): some warning\n');
+    });
+
+    it('should log resolved command, args and cwd on start', () => {
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      spawner.start();
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'Starting ACP server: session=sess-1 cmd=/usr/bin/opencode args=["acp"] cwd=/tmp/project',
+      );
+    });
+
+    it('should log exit code, signal and spawn params on process exit', () => {
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      spawner.start();
+      mockProcess.emit('exit', 1, null);
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'ACP process exited: session=sess-1 code=1 signal=null cmd=/usr/bin/opencode args=["acp"]',
+      );
+    });
+
+    it('should log process error with session and command', () => {
+      spawner.start();
+      const error = new Error('spawn opencode ENOENT');
+      mockProcess.emit('error', error);
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'ACP process error (session=sess-1, cmd=/usr/bin/opencode):',
+        error,
+      );
     });
 
     it('should resolve closed on process exit', async () => {

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