mcpose 2.1.1 → 3.0.0

package/src/__tests__/eventStore.test.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect, vi } from 'vitest';
+import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+import { createInMemoryEventStore, scopeEventStore } from '../eventStore.js';
+
+function msg(id: number): JSONRPCMessage {
+  return { jsonrpc: '2.0', method: 'notifications/test', params: { id } };
+}
+
+describe('createInMemoryEventStore()', () => {
+  it('assigns monotonically increasing event ids', async () => {
+    const store = createInMemoryEventStore();
+    const a = await store.storeEvent('stream-a', msg(1));
+    const b = await store.storeEvent('stream-a', msg(2));
+    expect(parseInt(b, 10)).toBeGreaterThan(parseInt(a, 10));
+  });
+
+  it('resolves the stream id for a stored event', async () => {
+    const store = createInMemoryEventStore();
+    const id = await store.storeEvent('stream-a', msg(1));
+    expect(await store.getStreamIdForEventId?.(id)).toBe('stream-a');
+  });
+
+  describe('replayEventsAfter', () => {
+    it('replays only events belonging to the same stream', async () => {
+      const store = createInMemoryEventStore();
+      const a1 = await store.storeEvent('stream-a', msg(1));
+      await store.storeEvent('stream-b', msg(2));
+      const a2 = await store.storeEvent('stream-a', msg(3));
+      await store.storeEvent('stream-b', msg(4));
+
+      const send = vi.fn().mockResolvedValue(undefined);
+      const streamId = await store.replayEventsAfter(a1, { send });
+
+      expect(streamId).toBe('stream-a');
+      expect(send).toHaveBeenCalledTimes(1);
+      expect(send).toHaveBeenCalledWith(a2, msg(3));
+    });
+
+    it('replays nothing for an unknown Last-Event-ID', async () => {
+      const store = createInMemoryEventStore();
+      await store.storeEvent('stream-a', msg(1));
+      await store.storeEvent('stream-a', msg(2));
+
+      const send = vi.fn().mockResolvedValue(undefined);
+      const streamId = await store.replayEventsAfter('does-not-exist', {
+        send,
+      });
+
+      expect(streamId).toBe('');
+      expect(send).not.toHaveBeenCalled();
+    });
+
+    it('replays nothing for a malformed Last-Event-ID', async () => {
+      const store = createInMemoryEventStore();
+      await store.storeEvent('stream-a', msg(1));
+
+      const send = vi.fn().mockResolvedValue(undefined);
+      const streamId = await store.replayEventsAfter('not-a-number', { send });
+
+      expect(streamId).toBe('');
+      expect(send).not.toHaveBeenCalled();
+    });
+
+    it('replays nothing for an evicted Last-Event-ID', async () => {
+      const store = createInMemoryEventStore(2);
+      const first = await store.storeEvent('stream-a', msg(1));
+      await store.storeEvent('stream-a', msg(2));
+      await store.storeEvent('stream-a', msg(3)); // evicts `first`
+
+      const send = vi.fn().mockResolvedValue(undefined);
+      const streamId = await store.replayEventsAfter(first, { send });
+
+      expect(streamId).toBe('');
+      expect(send).not.toHaveBeenCalled();
+    });
+  });
+
+  it('evicts FIFO once maxEvents is reached', async () => {
+    const store = createInMemoryEventStore(2);
+    const first = await store.storeEvent('stream-a', msg(1));
+    const second = await store.storeEvent('stream-a', msg(2));
+    const third = await store.storeEvent('stream-a', msg(3));
+
+    expect(await store.getStreamIdForEventId?.(first)).toBeUndefined();
+    expect(await store.getStreamIdForEventId?.(second)).toBe('stream-a');
+    expect(await store.getStreamIdForEventId?.(third)).toBe('stream-a');
+  });
+});
+
+describe('scopeEventStore()', () => {
+  it('namespaces stream ids by session and strips the prefix on the way out', async () => {
+    const inner = createInMemoryEventStore();
+    const scoped = scopeEventStore(inner, 'session-a');
+    const id = await scoped.storeEvent('_GET_stream', msg(1));
+    const id2 = await scoped.storeEvent('_GET_stream', msg(2));
+
+    expect(await inner.getStreamIdForEventId?.(id)).toBe(
+      'session-a:_GET_stream',
+    );
+    expect(await scoped.getStreamIdForEventId?.(id)).toBe('_GET_stream');
+
+    const send = vi.fn().mockResolvedValue(undefined);
+    expect(await scoped.replayEventsAfter(id, { send })).toBe('_GET_stream');
+    expect(send).toHaveBeenCalledWith(id2, msg(2));
+  });
+
+  it("treats another session's cursor as unknown and replays nothing (#154)", async () => {
+    const inner = createInMemoryEventStore();
+    const a = scopeEventStore(inner, 'session-a');
+    const b = scopeEventStore(inner, 'session-b');
+    const cursor = await a.storeEvent('_GET_stream', msg(1));
+    await a.storeEvent('_GET_stream', msg(2));
+
+    expect(await b.getStreamIdForEventId?.(cursor)).toBeUndefined();
+    const send = vi.fn().mockResolvedValue(undefined);
+    expect(await b.replayEventsAfter(cursor, { send })).toBe('');
+    expect(send).not.toHaveBeenCalled();
+  });
+
+  it('learns the owner by a silent replay when the store has no getStreamIdForEventId', async () => {
+    const inner = createInMemoryEventStore();
+    const bare = {
+      storeEvent: inner.storeEvent,
+      replayEventsAfter: inner.replayEventsAfter,
+    };
+    const a = scopeEventStore(bare, 'session-a');
+    const b = scopeEventStore(bare, 'session-b');
+    const cursor = await a.storeEvent('_GET_stream', msg(1));
+    const next = await a.storeEvent('_GET_stream', msg(2));
+
+    expect(await a.getStreamIdForEventId?.(cursor)).toBe('_GET_stream');
+    expect(await b.getStreamIdForEventId?.(cursor)).toBeUndefined();
+    expect(await a.getStreamIdForEventId?.('unknown')).toBeUndefined();
+
+    const send = vi.fn().mockResolvedValue(undefined);
+    expect(await b.replayEventsAfter(cursor, { send })).toBe('');
+    expect(send).not.toHaveBeenCalled();
+    expect(await a.replayEventsAfter(cursor, { send })).toBe('_GET_stream');
+    expect(send).toHaveBeenCalledWith(next, msg(2));
+  });
+});

package/src/__tests__/mapToolResult.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi } from 'vitest';
+import { mapToolResult } from '../core.js';
+import type { ToolResultHandlers } from '../core.js';
+import type {
+  CallToolResult,
+  CompatibilityCallToolResult,
+} from '@modelcontextprotocol/sdk/types.js';
+
+/** Handlers that pass every channel through unchanged. */
+const identity: ToolResultHandlers = {
+  onText: (block) => block,
+  onOther: (block) => block,
+  onStructured: (structured) => structured,
+};
+
+describe('mapToolResult()', () => {
+  it('maps text blocks through onText', () => {
+    const result: CallToolResult = {
+      content: [{ type: 'text', text: 'ssn 123456789' }],
+    };
+
+    const mapped = mapToolResult(result, {
+      ...identity,
+      onText: (block) => ({ ...block, text: '[REDACTED]' }),
+    });
+
+    expect(mapped.content).toEqual([{ type: 'text', text: '[REDACTED]' }]);
+  });
+
+  it('routes non-text blocks through onOther, and null drops the block', () => {
+    const result: CallToolResult = {
+      content: [
+        { type: 'text', text: 'keep' },
+        { type: 'image', data: 'aGk=', mimeType: 'image/png' },
+      ],
+    };
+    const onOther = vi.fn().mockReturnValue(null);
+
+    const mapped = mapToolResult(result, { ...identity, onOther });
+
+    expect(onOther).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'image' }),
+    );
+    expect(mapped.content).toEqual([{ type: 'text', text: 'keep' }]);
+  });
+
+  it('null from onText drops the block too', () => {
+    const result: CallToolResult = {
+      content: [{ type: 'text', text: 'drop me' }],
+    };
+
+    const mapped = mapToolResult(result, { ...identity, onText: () => null });
+    expect(mapped.content).toEqual([]);
+  });
+
+  it('calls onStructured only when structuredContent is present', () => {
+    const onStructured = vi.fn().mockReturnValue({ ok: true });
+
+    mapToolResult({ content: [] }, { ...identity, onStructured });
+    expect(onStructured).not.toHaveBeenCalled();
+
+    const mapped = mapToolResult(
+      { content: [], structuredContent: { secret: 'x' } },
+      { ...identity, onStructured },
+    );
+    expect(onStructured).toHaveBeenCalledWith({ secret: 'x' });
+    expect(mapped.structuredContent).toEqual({ ok: true });
+  });
+
+  it('undefined from onStructured removes the field', () => {
+    const mapped = mapToolResult(
+      { content: [], structuredContent: { secret: 'x' } },
+      { ...identity, onStructured: () => undefined },
+    );
+    expect(mapped).not.toHaveProperty('structuredContent');
+  });
+
+  it('returns the legacy { toolResult } shape untouched', () => {
+    const legacy: CompatibilityCallToolResult = { toolResult: { raw: true } };
+    const onText = vi.fn();
+
+    expect(mapToolResult(legacy, { ...identity, onText })).toBe(legacy);
+    expect(onText).not.toHaveBeenCalled();
+  });
+
+  it('preserves isError, result _meta, and unknown extra keys', () => {
+    const result: CallToolResult = {
+      content: [],
+      isError: true,
+      _meta: { forwarded: 'deliberately' },
+      vendorKey: 'kept',
+    };
+
+    const mapped = mapToolResult(result, identity);
+    expect(mapped).toMatchObject({
+      isError: true,
+      _meta: { forwarded: 'deliberately' },
+      vendorKey: 'kept',
+    });
+  });
+});

package/src/__tests__/middleware.edge.test.ts

@@ -0,0 +1,126 @@
+import { describe, it, expect } from 'vitest';
+import { compose, pipe, type Middleware } from '../middleware.js';
+import { createProxyContext, type ProxyContext } from '../proxyContext.js';
+
+type Req = { value: number };
+type Res = { result: number };
+
+const passthroughNext = async (r: Req): Promise<Res> => ({ result: r.value });
+
+describe('compose() — edge cases', () => {
+  it('rejects (not throws synchronously) when next() is called twice in the same middleware', async () => {
+    let secondCallReturn: unknown;
+    const dbl: Middleware<Req, Res> = async (req, next) => {
+      const first = next(req);
+      secondCallReturn = next(req);
+      await first;
+      return { result: 0 };
+    };
+
+    const pipeline = compose([dbl]);
+    const promise = pipeline({ value: 1 }, passthroughNext);
+
+    expect(secondCallReturn).toBeInstanceOf(Promise);
+    await expect(secondCallReturn as Promise<Res>).rejects.toThrow(
+      'next() called multiple times',
+    );
+    await expect(promise).resolves.toBeDefined();
+  });
+
+  it('rejects on a second next() call even after the first has settled', async () => {
+    let captured: Promise<Res> | undefined;
+    const mw: Middleware<Req, Res> = async (req, next) => {
+      const first = await next(req);
+      captured = next(req);
+      return first;
+    };
+
+    const pipeline = compose([mw]);
+    await pipeline({ value: 1 }, passthroughNext);
+
+    await expect(captured).rejects.toThrow('next() called multiple times');
+  });
+
+  it('does not mutate a frozen middleware array', async () => {
+    const mw: Middleware<Req, Res> = (req, next) =>
+      next({ value: req.value + 1 });
+    const arr = Object.freeze([mw]);
+
+    const pipeline = compose(arr);
+    const result = await pipeline({ value: 2 }, passthroughNext);
+
+    expect(result).toEqual({ result: 3 });
+    expect(arr).toHaveLength(1);
+  });
+
+  it('generates a fresh requestId for each invocation when no context is provided', async () => {
+    const seen: string[] = [];
+    const capture: Middleware<Req, Res> = async (req, next, context) => {
+      seen.push(context.requestId);
+      return next(req);
+    };
+
+    const pipeline = compose([capture]);
+    await pipeline({ value: 1 }, passthroughNext);
+    await pipeline({ value: 1 }, passthroughNext);
+
+    expect(seen).toHaveLength(2);
+    expect(seen[0]).not.toEqual(seen[1]);
+  });
+
+  it('propagates errors thrown from inner-most next through wrappers', async () => {
+    const wrap: Middleware<Req, Res> = async (req, next) => next(req);
+    const pipeline = compose([wrap, wrap, wrap]);
+
+    await expect(
+      pipeline({ value: 0 }, async () => {
+        throw new Error('inner boom');
+      }),
+    ).rejects.toThrow('inner boom');
+  });
+
+  it('passes the same context reference to every middleware', async () => {
+    const refs: ProxyContext[] = [];
+    const capture: Middleware<Req, Res> = async (req, next, context) => {
+      refs.push(context);
+      return next(req);
+    };
+    const ctx = createProxyContext({ requestId: 'fixed-id' });
+
+    await compose([capture, capture, capture])(
+      { value: 1 },
+      passthroughNext,
+      ctx,
+    );
+
+    expect(refs).toHaveLength(3);
+    expect(refs[0]).toBe(ctx);
+    expect(refs[1]).toBe(ctx);
+    expect(refs[2]).toBe(ctx);
+  });
+});
+
+describe('pipe() — edge cases', () => {
+  it('does not mutate the input array (reverse on a copy)', async () => {
+    const a: Middleware<Req, Res> = (req, next) =>
+      next({ value: req.value + 1 });
+    const b: Middleware<Req, Res> = (req, next) =>
+      next({ value: req.value * 2 });
+    const arr = [a, b];
+    const snapshot = [...arr];
+
+    await pipe(arr)({ value: 1 }, passthroughNext);
+
+    expect(arr).toEqual(snapshot);
+  });
+
+  it('accepts a frozen input array', async () => {
+    const a: Middleware<Req, Res> = (req, next) =>
+      next({ value: req.value + 1 });
+    const arr = Object.freeze([a]);
+
+    const result = await pipe(arr)({ value: 1 }, passthroughNext);
+
+    expect(result).toEqual({ result: 2 });
+  });
+});

package/src/__tests__/middleware.test.ts

@@ -0,0 +1,233 @@
+import { describe, it, expect } from 'vitest';
+import { compose, pipe, type Middleware } from '../middleware.js';
+import type { ProxyContext } from '../proxyContext.js';
+
+type Req = { value: number };
+type Res = { result: number };
+
+const identity: Middleware<Req, Res> = (req, next) => next(req);
+
+describe('compose()', () => {
+  it('calls innermost next when middlewares array is empty', async () => {
+    const pipeline = compose<Req, Res>([]);
+    const result = await pipeline({ value: 1 }, async (r) => ({
+      result: r.value * 10,
+    }));
+    expect(result).toEqual({ result: 10 });
+  });
+
+  it('passes through a single identity middleware', async () => {
+    const pipeline = compose([identity]);
+    const result = await pipeline({ value: 3 }, async (r) => ({
+      result: r.value,
+    }));
+    expect(result).toEqual({ result: 3 });
+  });
+
+  it('passes ProxyContext through the entire middleware chain unchanged', async () => {
+    const context: ProxyContext = {
+      requestId: 'req-1',
+      transport: 'http',
+      sessionId: 'sess-1',
+    };
+    const seen: ProxyContext[] = [];
+
+    const outer: Middleware<Req, Res> = async (req, next, currentContext) => {
+      seen.push(currentContext);
+      return next(req);
+    };
+
+    const inner: Middleware<Req, Res> = async (req, next, currentContext) => {
+      seen.push(currentContext);
+      return next(req);
+    };
+
+    const pipeline = compose([outer, inner]);
+    await pipeline({ value: 1 }, async (r) => ({ result: r.value }), context);
+
+    expect(seen).toEqual([context, context]);
+  });
+
+  it('creates a default ProxyContext when one is omitted', async () => {
+    let seenContext: ProxyContext | undefined;
+
+    const capture: Middleware<Req, Res> = async (req, next, context) => {
+      seenContext = context;
+      return next(req);
+    };
+
+    const pipeline = compose([capture]);
+    await pipeline({ value: 2 }, async (r) => ({ result: r.value }));
+
+    expect(seenContext?.transport).toBe('stdio');
+    expect(seenContext?.requestId).toEqual(expect.any(String));
+  });
+
+  it('executes middlewares in order — outer first, inner last', async () => {
+    const order: string[] = [];
+
+    const outer: Middleware<Req, Res> = async (req, next) => {
+      order.push('outer-enter');
+      const res = await next(req);
+      order.push('outer-exit');
+      return res;
+    };
+
+    const inner: Middleware<Req, Res> = async (req, next) => {
+      order.push('inner-enter');
+      const res = await next(req);
+      order.push('inner-exit');
+      return res;
+    };
+
+    const pipeline = compose([outer, inner]);
+    await pipeline({ value: 0 }, async () => ({ result: 0 }));
+
+    expect(order).toEqual([
+      'outer-enter',
+      'inner-enter',
+      'inner-exit',
+      'outer-exit',
+    ]);
+  });
+
+  it('allows outer middleware to transform the response', async () => {
+    const doubler: Middleware<Req, Res> = async (req, next) => {
+      const res = await next(req);
+      return { result: res.result * 2 };
+    };
+
+    const pipeline = compose([doubler]);
+    const result = await pipeline({ value: 5 }, async (r) => ({
+      result: r.value,
+    }));
+    expect(result).toEqual({ result: 10 });
+  });
+
+  it('allows middleware to transform the request before passing on', async () => {
+    const incrementer: Middleware<Req, Res> = (req, next) =>
+      next({ value: req.value + 1 });
+
+    const pipeline = compose([incrementer]);
+    const result = await pipeline({ value: 4 }, async (r) => ({
+      result: r.value,
+    }));
+    expect(result).toEqual({ result: 5 });
+  });
+
+  it('chains multiple transformations correctly', async () => {
+    const add1: Middleware<Req, Res> = (req, next) =>
+      next({ value: req.value + 1 });
+    const mul2: Middleware<Req, Res> = (req, next) =>
+      next({ value: req.value * 2 });
+
+    // add1 outer: value = (original + 1) * 2
+    const pipeline = compose([add1, mul2]);
+    const result = await pipeline({ value: 3 }, async (r) => ({
+      result: r.value,
+    }));
+    expect(result).toEqual({ result: 8 }); // (3 + 1) * 2 = 8
+  });
+
+  it('throws if next() is called more than once', async () => {
+    const doubleNext: Middleware<Req, Res> = async (req, next) => {
+      await next(req);
+      return next(req); // second call — should throw
+    };
+
+    const pipeline = compose([doubleNext]);
+    await expect(
+      pipeline({ value: 0 }, async () => ({ result: 0 })),
+    ).rejects.toThrow('next() called multiple times');
+  });
+
+  it('propagates errors from the inner next', async () => {
+    const pipeline = compose([identity]);
+    await expect(
+      pipeline({ value: 0 }, async () => {
+        throw new Error('upstream error');
+      }),
+    ).rejects.toThrow('upstream error');
+  });
+
+  it('propagates errors thrown inside a middleware', async () => {
+    const failing: Middleware<Req, Res> = async () => {
+      throw new Error('middleware error');
+    };
+
+    const pipeline = compose([failing]);
+    await expect(
+      pipeline({ value: 0 }, async () => ({ result: 0 })),
+    ).rejects.toThrow('middleware error');
+  });
+});
+
+describe('pipe()', () => {
+  it('pipe([A, B]) is equivalent to compose([B, A])', async () => {
+    const add1: Middleware<Req, Res> = (req, next) =>
+      next({ value: req.value + 1 });
+    const mul2: Middleware<Req, Res> = (req, next) =>
+      next({ value: req.value * 2 });
+
+    // pipe([add1, mul2]) ≡ compose([mul2, add1])
+    // mul2 outer: value = (original * 2) + 1 = 7
+    const pipePipeline = pipe([add1, mul2]);
+    const composePipeline = compose([mul2, add1]);
+
+    const baseNext = async (r: Req): Promise<Res> => ({ result: r.value });
+    expect(await pipePipeline({ value: 3 }, baseNext)).toEqual({ result: 7 });
+    expect(await composePipeline({ value: 3 }, baseNext)).toEqual({
+      result: 7,
+    });
+  });
+
+  it('executes in data-flow order — first element processes the response first', async () => {
+    const order: string[] = [];
+
+    // first element in pipe() = innermost = processes response first
+    const innerMW: Middleware<Req, Res> = async (req, next) => {
+      order.push('inner-enter');
+      const res = await next(req);
+      order.push('inner-exit');
+      return res;
+    };
+
+    const outerMW: Middleware<Req, Res> = async (req, next) => {
+      order.push('outer-enter');
+      const res = await next(req);
+      order.push('outer-exit');
+      return res;
+    };
+
+    // pipe([innerMW, outerMW]) — outerMW wraps innerMW
+    const pipeline = pipe([innerMW, outerMW]);
+    await pipeline({ value: 0 }, async () => ({ result: 0 }));
+
+    expect(order).toEqual([
+      'outer-enter',
+      'inner-enter',
+      'inner-exit',
+      'outer-exit',
+    ]);
+  });
+
+  it('keeps the same ProxyContext while reversing response-processing order', async () => {
+    const context: ProxyContext = { requestId: 'req-2', transport: 'stdio' };
+    const seen: string[] = [];
+
+    const innerMW: Middleware<Req, Res> = async (req, next, currentContext) => {
+      seen.push(`inner:${currentContext.requestId}`);
+      return next(req);
+    };
+
+    const outerMW: Middleware<Req, Res> = async (req, next, currentContext) => {
+      seen.push(`outer:${currentContext.requestId}`);
+      return next(req);
+    };
+
+    const pipeline = pipe([innerMW, outerMW]);
+    await pipeline({ value: 1 }, async (r) => ({ result: r.value }), context);
+
+    expect(seen).toEqual(['outer:req-2', 'inner:req-2']);
+  });
+});