agenticreplay 0.1.0 → 0.1.2

package/packages/mcp-shim/test/mock.test.ts

@@ -1,200 +0,0 @@
-import { PassThrough } from 'node:stream';
-import { describe, expect, it } from 'vitest';
-import {
-  indexFrames,
-  keyOf,
-  runMock,
-  type JsonRpcMessage,
-  type RecordedFrame,
-} from '../src/mock.js';
-
-/**
- * Serving an MCP client from a recording.
- *
- * Capture was only half of what this layer is for. The reason to record a server's traffic is that
- * the run stays reproducible once the server is not — the token revoked, the repository moved, the
- * service retired. Replay used to re-instrument the same config and start the real server again,
- * so an MCP recording could be read but not reproduced, and came apart on the first call when the
- * server had gone.
- */
-
-/** Ids are explicit: a counter shared across tests silently pairs a request with another's reply. */
-function req(id: number, method: string, params?: unknown): RecordedFrame {
-  return {
-    server: 's',
-    direction: 'in',
-    at: '2026-01-01T00:00:00.000Z',
-    id,
-    method,
-    message: { jsonrpc: '2.0', id, method, ...(params === undefined ? {} : { params }) },
-  };
-}
-function res(id: number, result: unknown): RecordedFrame {
-  return {
-    server: 's',
-    direction: 'out',
-    at: '2026-01-01T00:00:00.000Z',
-    id,
-    message: { jsonrpc: '2.0', id, result },
-  };
-}
-
-/** Drive the mock with a list of client messages and collect what it wrote back. */
-async function ask(frames: RecordedFrame[], sent: JsonRpcMessage[]): Promise<JsonRpcMessage[]> {
-  const stdin = new PassThrough();
-  const stdout = new PassThrough();
-  const out: JsonRpcMessage[] = [];
-  stdout.on('data', (chunk: Buffer) => {
-    for (const line of chunk.toString('utf8').split('\n')) {
-      if (line.trim() !== '') out.push(JSON.parse(line) as JsonRpcMessage);
-    }
-  });
-  const done = runMock({ name: 's', frames, stdin, stdout });
-  for (const message of sent) stdin.write(`${JSON.stringify(message)}\n`);
-  stdin.end();
-  await done;
-  return out;
-}
-
-describe('keyOf', () => {
-  /**
-   * `_meta` is the protocol's own side channel and every client fills it with values that are new
-   * each run — Claude Code puts the tool-use id and a progress token there. Comparing it made an
-   * exact match impossible for `tools/call`, which is the one call anybody replays.
-   */
-  it('ignores the per-run identifiers MCP carries beside the arguments', () => {
-    const bare = keyOf({ method: 'tools/call', params: { name: 'x', arguments: {} } });
-    const withMeta = keyOf({
-      method: 'tools/call',
-      params: { name: 'x', arguments: {}, _meta: { 'claudecode/toolUseId': 'toolu_abc' } },
-    });
-    expect(withMeta).toBe(bare);
-  });
-
-  it('separates calls that differ in their real arguments', () => {
-    expect(keyOf({ method: 'tools/call', params: { name: 'a' } })).not.toBe(
-      keyOf({ method: 'tools/call', params: { name: 'b' } }),
-    );
-  });
-});
-
-describe('indexFrames', () => {
-  it('ties each response to the question its id answered', () => {
-    const { byKey, byMethod } = indexFrames([
-      req(1, 'tools/list'),
-      res(1, { tools: [] }),
-      req(2, 'tools/call', { name: 'x' }),
-      res(2, { content: 'first' }),
-    ]);
-    expect(byKey.get(keyOf({ method: 'tools/call', params: { name: 'x' } }))).toEqual([
-      { jsonrpc: '2.0', id: 2, result: { content: 'first' } },
-    ]);
-    expect(byMethod.get('tools/list')).toHaveLength(1);
-  });
-});
-
-describe('runMock', () => {
-  it('answers a repeated call in the order the recording answered it', async () => {
-    const frames = [
-      req(1, 'tools/call', { name: 'next' }),
-      res(1, { content: 'first' }),
-      req(2, 'tools/call', { name: 'next' }),
-      res(2, { content: 'second' }),
-    ];
-    const out = await ask(frames, [
-      { jsonrpc: '2.0', id: 10, method: 'tools/call', params: { name: 'next' } },
-      { jsonrpc: '2.0', id: 11, method: 'tools/call', params: { name: 'next' } },
-    ]);
-    expect(out.map((m) => m.result)).toEqual([{ content: 'first' }, { content: 'second' }]);
-    // The recorded id belonged to the recorded session; the client is waiting on its own.
-    expect(out.map((m) => m.id)).toEqual([10, 11]);
-  });
-
-  /**
-   * The call anybody actually replays. Claude Code puts a fresh `claudecode/toolUseId` in `_meta`
-   * on every run, so comparing it made an exact match impossible for `tools/call` — the recording
-   * was there and the answer never came out of it.
-   */
-  it('answers a tools/call whose _meta is new this run', async () => {
-    const frames = [
-      req(1, 'tools/call', {
-        name: 'magic',
-        arguments: {},
-        _meta: { 'claudecode/toolUseId': 'toolu_recorded' },
-      }),
-      res(1, { content: [{ type: 'text', text: 'MAGIC-7788' }] }),
-    ];
-    const out = await ask(frames, [
-      {
-        jsonrpc: '2.0',
-        id: 42,
-        method: 'tools/call',
-        params: {
-          name: 'magic',
-          arguments: {},
-          _meta: { 'claudecode/toolUseId': 'toolu_totally_different', progressToken: 9 },
-        },
-      },
-    ]);
-    expect(out[0]?.result).toEqual({ content: [{ type: 'text', text: 'MAGIC-7788' }] });
-  });
-
-  /**
-   * `initialize` carries the client's own version and capabilities, so it can never match
-   * byte-for-byte across runs — and nothing else in a session happens until it is answered.
-   */
-  it('answers by method when the arguments could not repeat', async () => {
-    const frames = [
-      req(1, 'initialize', { protocolVersion: '2025-11-25', clientInfo: { name: 'recorded' } }),
-      res(1, { serverInfo: { name: 'srv' } }),
-    ];
-    const out = await ask(frames, [
-      {
-        jsonrpc: '2.0',
-        id: 7,
-        method: 'initialize',
-        params: { protocolVersion: '2024-11-05', clientInfo: { name: 'different' } },
-      },
-    ]);
-    expect(out).toEqual([{ jsonrpc: '2.0', id: 7, result: { serverInfo: { name: 'srv' } } }]);
-  });
-
-  // Answering one would desynchronise a client that is not waiting for a reply.
-  it('says nothing to a notification', async () => {
-    const out = await ask(
-      [req(1, 'tools/list'), res(1, { tools: [] })],
-      [{ jsonrpc: '2.0', method: 'notifications/initialized' }],
-    );
-    expect(out).toEqual([]);
-  });
-
-  // Silence is a hang, and a hang is the failure a client cannot recover from or report.
-  it('answers a method the recording never saw with an error rather than nothing', async () => {
-    const misses: string[] = [];
-    const stdin = new PassThrough();
-    const stdout = new PassThrough();
-    const seen: JsonRpcMessage[] = [];
-    stdout.on('data', (c: Buffer) => seen.push(JSON.parse(c.toString('utf8')) as JsonRpcMessage));
-    const done = runMock({
-      name: 's',
-      frames: [],
-      stdin,
-      stdout,
-      onMiss: (method) => misses.push(method),
-    });
-    stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'resources/read' })}\n`);
-    stdin.end();
-    await done;
-    expect(misses).toEqual(['resources/read']);
-    expect((seen[0]?.error as { code: number }).code).toBe(-32601);
-  });
-
-  it('repeats the last answer rather than failing when a client asks once more', async () => {
-    const frames = [req(1, 'tools/call', { name: 'x' }), res(1, { content: 'only' })];
-    const out = await ask(frames, [
-      { jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: 'x' } },
-      { jsonrpc: '2.0', id: 2, method: 'tools/call', params: { name: 'x' } },
-    ]);
-    expect(out.map((m) => m.result)).toEqual([{ content: 'only' }, { content: 'only' }]);
-  });
-});

package/packages/mcp-shim/test/shim.test.ts

@@ -1,287 +0,0 @@
-import { PassThrough } from 'node:stream';
-import { describe, expect, it } from 'vitest';
-import type { JsonRpcFrame } from '../src/index.js';
-import { runShim } from '../src/index.js';
-
-/** A fake MCP server: echoes a JSON-RPC response per request, then reports what it received. */
-const ECHO_SERVER = `
-let buf = '';
-const seen = [];
-process.stdin.on('data', (d) => {
-  seen.push(Buffer.from(d));
-  buf += d.toString('utf8');
-  let i;
-  while ((i = buf.indexOf('\\n')) >= 0) {
-    const line = buf.slice(0, i);
-    buf = buf.slice(i + 1);
-    if (!line.trim()) continue;
-    let msg;
-    try { msg = JSON.parse(line); } catch { continue; }
-    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: msg.id, result: { echo: msg.method } }) + '\\n');
-  }
-});
-process.stdin.on('end', () => {
-  // No process.exit: writes to a pipe are async, and exiting drops whatever is still queued.
-  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', method: 'received', params: { b64: Buffer.concat(seen).toString('base64') } }) + '\\n');
-});
-`;
-
-interface Collector {
-  /** What has been emitted so far — for polling while the child is still running. */
-  bytes: () => Buffer;
-  /**
-   * Everything, once the stream has drained. The child closing does not mean the destination has
-   * emitted its buffered bytes yet, so a same-tick read of `bytes()` is a race.
-   */
-  drained: () => Promise<Buffer>;
-}
-
-function collect(stream: PassThrough): Collector {
-  const chunks: Buffer[] = [];
-  stream.on('data', (c: Buffer) => chunks.push(Buffer.from(c)));
-  return {
-    bytes: () => Buffer.concat(chunks),
-    drained: () =>
-      new Promise<Buffer>((resolve) => {
-        stream.on('end', () => resolve(Buffer.concat(chunks)));
-        stream.end();
-      }),
-  };
-}
-
-function io() {
-  const stdin = new PassThrough();
-  const stdout = new PassThrough();
-  const stderr = new PassThrough();
-  return { stdin, stdout, stderr, out: collect(stdout), err: collect(stderr) };
-}
-
-describe('runShim', () => {
-  it('forwards stdin to the child byte for byte', async () => {
-    const { stdin, stdout, stderr, out } = io();
-    const written = Buffer.from(
-      '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"t":"\u{1F419} é"}}\n' +
-        '{"jsonrpc":"2.0","id":2,"method":"ping"}\n',
-      'utf8',
-    );
-    const done = runShim({
-      name: 'echo',
-      command: process.execPath,
-      args: ['-e', ECHO_SERVER],
-      stdin,
-      stdout,
-      stderr,
-    });
-    // Split mid-multibyte so the tee cannot get away with re-encoding what it decoded.
-    const cut = written.indexOf(Buffer.from('\u{1F419}', 'utf8')) + 2;
-    expect(cut).toBeGreaterThan(2);
-    stdin.write(written.subarray(0, cut));
-    stdin.write(written.subarray(cut));
-    stdin.end();
-    expect(await done).toBe(0);
-
-    const lines = (await out.drained())
-      .toString('utf8')
-      .trim()
-      .split('\n')
-      .map((l) => JSON.parse(l));
-    const received = lines.find((l) => l.method === 'received');
-    expect(Buffer.from(received.params.b64, 'base64').equals(written)).toBe(true);
-  });
-
-  it('forwards child stdout to our stdout byte for byte', async () => {
-    // The head carries the awkward bytes; the tail is one line far larger than any pipe buffer.
-    // Only the head crosses argv — a 200 kB command line trips the OS argument limit.
-    const head = Buffer.from(
-      '{"jsonrpc":"2.0","id":1,"result":{"text":"\u{1F419} café -ish"}}\n' + 'not json at all\n',
-      'utf8',
-    );
-    const tail = Buffer.from(
-      `{"jsonrpc":"2.0","id":2,"result":{"pad":"${'x'.repeat(200_000)}"}}\n`,
-      'utf8',
-    );
-    const payload = Buffer.concat([head, tail]);
-    const server = `
-      const b = Buffer.concat([
-        Buffer.from(${JSON.stringify(head.toString('base64'))}, 'base64'),
-        Buffer.from('{"jsonrpc":"2.0","id":2,"result":{"pad":"' + 'x'.repeat(200000) + '"}}\\n'),
-      ]);
-      let i = 0;
-      const tick = () => {
-        if (i >= b.length) return;
-        const n = Math.min(7, b.length - i);
-        process.stdout.write(b.subarray(i, i + n));
-        i += n;
-        setImmediate(tick);
-      };
-      tick();
-    `;
-    const { stdin, stdout, stderr, out } = io();
-    const code = await runShim({
-      name: 'echo',
-      command: process.execPath,
-      args: ['-e', server],
-      stdin,
-      stdout,
-      stderr,
-    });
-    expect(code).toBe(0);
-    expect((await out.drained()).equals(payload)).toBe(true);
-  });
-
-  it('observes frames in both directions', async () => {
-    const { stdin, stdout, stderr } = io();
-    const seen: Array<[string, JsonRpcFrame]> = [];
-    const done = runShim({
-      name: 'echo',
-      command: process.execPath,
-      args: ['-e', ECHO_SERVER],
-      onFrame: (dir, frame) => seen.push([dir, frame]),
-      stdin,
-      stdout,
-      stderr,
-    });
-    stdin.write('{"jsonrpc":"2.0","id":1,"method":"tools/list"}\n');
-    stdin.end();
-    await done;
-
-    const inbound = seen.filter(([d]) => d === 'in').map(([, f]) => f);
-    const outbound = seen.filter(([d]) => d === 'out').map(([, f]) => f);
-    expect(inbound).toHaveLength(1);
-    expect(inbound[0]?.method).toBe('tools/list');
-    expect(inbound[0]?.kind).toBe('request');
-    expect(outbound.some((f) => f.kind === 'response' && f.id === 1)).toBe(true);
-  });
-
-  it('forwards a non-zero child exit code', async () => {
-    const { stdin, stdout, stderr } = io();
-    const code = await runShim({
-      name: 'boom',
-      command: process.execPath,
-      args: ['-e', 'process.exit(23)'],
-      stdin,
-      stdout,
-      stderr,
-    });
-    expect(code).toBe(23);
-  });
-
-  it('passes the child stderr through untouched', async () => {
-    const { stdin, stdout, stderr, err } = io();
-    await runShim({
-      name: 'noisy',
-      command: process.execPath,
-      args: ['-e', 'process.stderr.write("server warning \u{1F419}\\n")'],
-      stdin,
-      stdout,
-      stderr,
-    });
-    expect((await err.drained()).toString('utf8')).toBe('server warning \u{1F419}\n');
-  });
-
-  it('survives a malformed frame from the server', async () => {
-    const { stdin, stdout, stderr, out } = io();
-    const kinds: string[] = [];
-    const code = await runShim({
-      name: 'bad',
-      command: process.execPath,
-      args: [
-        '-e',
-        'process.stdout.write("<<<not json>>>\\n{\\"jsonrpc\\":\\"2.0\\",\\"id\\":1,\\"result\\":1}\\n")',
-      ],
-      onFrame: (_dir, f) => kinds.push(f.kind),
-      stdin,
-      stdout,
-      stderr,
-    });
-    expect(code).toBe(0);
-    expect(kinds).toEqual(['unknown', 'response']);
-    expect((await out.drained()).toString('utf8')).toBe(
-      '<<<not json>>>\n{"jsonrpc":"2.0","id":1,"result":1}\n',
-    );
-  });
-
-  it('keeps the stream flowing when the capture callback throws', async () => {
-    const { stdin, stdout, stderr, out } = io();
-    const code = await runShim({
-      name: 'echo',
-      command: process.execPath,
-      args: ['-e', 'process.stdout.write("{\\"id\\":1,\\"result\\":1}\\n")'],
-      onFrame: () => {
-        throw new Error('capture side blew up');
-      },
-      stdin,
-      stdout,
-      stderr,
-    });
-    expect(code).toBe(0);
-    expect((await out.drained()).toString('utf8')).toBe('{"id":1,"result":1}\n');
-  });
-
-  it('names the command when it cannot be spawned', async () => {
-    const { stdin, stdout, stderr } = io();
-    await expect(
-      runShim({
-        name: 'missing',
-        command: 'agenticreplay-no-such-mcp-server',
-        args: [],
-        stdin,
-        stdout,
-        stderr,
-      }),
-    ).rejects.toThrow(/agenticreplay-no-such-mcp-server/);
-  });
-
-  it('reports a launch that fails synchronously, naming the server', async () => {
-    const { stdin, stdout, stderr } = io();
-    // An argv over the OS limit makes spawn throw rather than emit 'error'.
-    await expect(
-      runShim({
-        name: 'oversized',
-        command: process.execPath,
-        args: ['-e', 'x'.repeat(4_000_000)],
-        stdin,
-        stdout,
-        stderr,
-      }),
-    ).rejects.toThrow(/oversized/);
-  });
-
-  /**
-   * Windows has no SIGTERM. `process.emit('SIGTERM')` runs the handler, but the child never
-   * receives a signal and exits with its own code instead of the one the handler forwards —
-   * there is no mechanism here to test, rather than a mechanism that is broken.
-   */
-  it.skipIf(process.platform === 'win32')(
-    'forwards SIGTERM to the child and unregisters its handlers afterwards',
-    async () => {
-      const before = process.listenerCount('SIGTERM');
-      const { stdin, stdout, stderr, out } = io();
-      const done = runShim({
-        name: 'trapper',
-        command: process.execPath,
-        args: [
-          '-e',
-          'const t = setInterval(() => {}, 1000);' +
-            'process.on("SIGTERM", () => { process.stdout.write("terminated\\n"); process.exitCode = 7; clearInterval(t); });' +
-            'process.stdout.write("ready\\n");',
-        ],
-        stdin,
-        stdout,
-        stderr,
-      });
-      await new Promise<void>((resolve) => {
-        const wait = (): void => {
-          if (out.bytes().toString('utf8').includes('ready')) resolve();
-          else setTimeout(wait, 10);
-        };
-        wait();
-      });
-      expect(process.listenerCount('SIGTERM')).toBe(before + 1);
-      process.emit('SIGTERM');
-      expect(await done).toBe(7);
-      expect((await out.drained()).toString('utf8')).toContain('terminated');
-      expect(process.listenerCount('SIGTERM')).toBe(before);
-    },
-  );
-});

package/packages/mcp-shim/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": { "outDir": "dist", "rootDir": "src" },
-  "include": ["src/**/*.ts"]
-}

package/packages/node-instrument/package.json

@@ -1,23 +0,0 @@
-{
-  "name": "@agenticreplay/node-instrument",
-  "version": "0.5.0",
-  "type": "module",
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/askdkc/AgenticReplay.git",
-    "directory": "packages/node-instrument"
-  },
-  "description": "Capture model traffic from a JS agent that reads no base-URL variable",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": "./dist/index.js"
-  },
-  "files": [
-    "dist"
-  ],
-  "engines": {
-    "node": ">=24.0.0"
-  }
-}