mcpose 2.1.1 → 3.1.0

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']);
+  });
+});

package/src/__tests__/proxyContext.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest';
+import type { Identity } from '../identity.js';
+import {
+  createProxyContext,
+  outboundDelegationChain,
+} from '../proxyContext.js';
+
+describe('createProxyContext()', () => {
+  it('defaults to stdio transport with a generated request ID', () => {
+    const context = createProxyContext();
+
+    expect(context.transport).toBe('stdio');
+    expect(context.requestId).toEqual(expect.any(String));
+    expect(context.requestId.length).toBeGreaterThan(0);
+    expect(context.sessionId).toBeUndefined();
+    expect(context.headers).toBeUndefined();
+  });
+
+  it('preserves supplied context fields', () => {
+    const headers = { authorization: 'Bearer token' };
+    const context = createProxyContext({
+      requestId: 'req-123',
+      transport: 'http',
+      sessionId: 'session-1',
+      headers,
+    });
+
+    expect(context).toEqual({
+      requestId: 'req-123',
+      transport: 'http',
+      sessionId: 'session-1',
+      headers,
+    });
+  });
+
+  it('carries a stamped policy decision through', () => {
+    const policy = { decision: 'allow', ruleId: 'r1' } as const;
+    expect(createProxyContext({ policy }).policy).toEqual(policy);
+  });
+
+  it('omits sessionId/headers/signal keys when they are not provided', () => {
+    const ctx = createProxyContext({ transport: 'http' });
+
+    expect('sessionId' in ctx).toBe(false);
+    expect('headers' in ctx).toBe(false);
+    expect('signal' in ctx).toBe(false);
+  });
+
+  it('omits signal key when explicitly passed as undefined', () => {
+    const ctx = createProxyContext({ signal: undefined });
+
+    expect('signal' in ctx).toBe(false);
+  });
+
+  it('preserves an AbortSignal reference', () => {
+    const controller = new AbortController();
+    const ctx = createProxyContext({ signal: controller.signal });
+
+    expect(ctx.signal).toBe(controller.signal);
+  });
+
+  it('keeps the original headers reference (Readonly is shallow)', () => {
+    const headers = { 'x-trace': 'abc' };
+    const ctx = createProxyContext({ headers });
+
+    expect(ctx.headers).toBe(headers);
+  });
+
+  it('regenerates a UUID when requestId is provided as an empty string', () => {
+    const ctx = createProxyContext({ requestId: '' });
+
+    expect(ctx.requestId).not.toBe('');
+    expect(ctx.requestId.length).toBeGreaterThan(0);
+  });
+
+  it('generates distinct requestIds across calls', () => {
+    const a = createProxyContext();
+    const b = createProxyContext();
+
+    expect(a.requestId).not.toEqual(b.requestId);
+  });
+
+  it('preserves the proxy identity reference and omits the key when absent', () => {
+    const proxy = { name: 'payments-proxy', version: '1.2.3' };
+
+    expect(createProxyContext({ proxy }).proxy).toBe(proxy);
+    expect('proxy' in createProxyContext()).toBe(false);
+    expect('proxy' in createProxyContext({ proxy: undefined })).toBe(false);
+  });
+});
+
+describe('outboundDelegationChain()', () => {
+  const identity = (sub: string): Identity => ({
+    sub,
+    type: 'agent',
+    roles: [],
+    claims: {},
+    resolvedAt: '2026-01-01T00:00:00Z',
+    source: 'custom',
+  });
+
+  it('appends identity after the existing delegatedFrom chain oldest-first', () => {
+    const root = identity('root');
+    const mid = identity('mid');
+    const caller = identity('caller');
+    const ctx = createProxyContext({
+      identity: caller,
+      delegatedFrom: [root, mid],
+    });
+
+    expect(outboundDelegationChain(ctx)).toEqual([root, mid, caller]);
+  });
+
+  it('returns an empty array when neither identity nor delegatedFrom is set', () => {
+    expect(outboundDelegationChain(createProxyContext())).toEqual([]);
+  });
+
+  it('returns only the identity when delegatedFrom is absent', () => {
+    const caller = identity('caller');
+    const ctx = createProxyContext({ identity: caller });
+
+    expect(outboundDelegationChain(ctx)).toEqual([caller]);
+  });
+
+  it('returns a fresh array and does not mutate or alias ctx.delegatedFrom', () => {
+    const root = identity('root');
+    const delegatedFrom = [root];
+    const ctx = createProxyContext({
+      identity: identity('caller'),
+      delegatedFrom,
+    });
+
+    const chain = outboundDelegationChain(ctx);
+
+    expect(chain).not.toBe(delegatedFrom);
+    expect(ctx.delegatedFrom).toBe(delegatedFrom);
+    expect(ctx.delegatedFrom).toEqual([root]);
+    expect(outboundDelegationChain(ctx)).not.toBe(chain);
+  });
+});