@bevel-software/platform-core-backend 0.15.1 → 0.20.0

package/src/modules/mcp/__tests__/mcp.routes.local-token.test.ts

@@ -74,7 +74,7 @@ async function exchange(baseUrl: string, authorization?: string): Promise<Respon
 describe('POST /mcp/local-token', () => {
   it('exchanges a valid OAuth access token for an internal token with the loopback identity + TTL', async () => {
     const oauth = makeOAuthProvider(async () => ({
-      extra: { userId: 'user-5', userEmail: 'eve@example.com' },
+      extra: { userId: 'user-5', userEmail: 'eve@example.com', connectionId: 'conn-9' },
       // A grant with plenty of life left: the loopback constant is the binding cap.
       expiresAt: Math.floor(Date.now() / 1000) + 24 * 60 * 60,
     }));
@@ -88,21 +88,41 @@ describe('POST /mcp/local-token', () => {
     // above outlives it, so the constant is the cap that binds.
     expect(body.expiresInMs).toBe(MCP_LOOPBACK_TOKEN_TTL_MS);
     // The minted token verifies to the resolved user with the externalProxy
-    // flag — identical shape to the hosted session's loopback bearer.
-    expect(internalTokens.verify(body.token)).toEqual({ userId: 'user-5', externalProxy: true });
+    // flag — identical shape to the hosted session's loopback bearer — plus
+    // the grant's agent connection, so the local server's calls stay
+    // attributed to that agent in the Audit log.
+    expect(internalTokens.verify(body.token)).toEqual({
+      userId: 'user-5',
+      externalProxy: true,
+      connectionId: 'conn-9',
+    });
     // …and the tool-auth verifier resolves it to source 'external', exactly
     // how /api/agent/* will treat the local server.
     const verify = createTokenVerifier(
       { looksLikeExternalApiKey: () => false } as unknown as IExternalApiKeyService,
       internalTokens,
     );
+    // …carrying the agent connection, which the REST recorder attributes
+    // the local server's direct tool calls to.
     await expect(verify(body.token)).resolves.toEqual({
       ok: true,
-      auth: { source: 'external', userId: 'user-5', scope: 'write' },
+      auth: { source: 'external', userId: 'user-5', connectionId: 'conn-9', scope: 'write' },
     });
     expect((oauth as any).verifyAccessToken).toHaveBeenCalledWith('bevel-mcp_valid123');
   });
 
+  it('mints without a connection claim for a grant that carries none (a token from before connections existed)', async () => {
+    const oauth = makeOAuthProvider(async () => ({
+      extra: { userId: 'user-5', userEmail: 'eve@example.com' },
+      expiresAt: Math.floor(Date.now() / 1000) + 24 * 60 * 60,
+    }));
+    const { baseUrl, internalTokens } = await mount(oauth);
+    const res = await exchange(baseUrl, 'Bearer bevel-mcp_valid123');
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { token: string };
+    expect(internalTokens.verify(body.token)).toEqual({ userId: 'user-5', externalProxy: true });
+  });
+
   /**
    * The binding that keeps the exchange from OUTLIVING its grant: an access
    * token with less life left than the loopback constant caps the minted

package/src/modules/mcp/__tests__/mcp.routes.stateless.test.ts

@@ -0,0 +1,182 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import type { McpCaller } from '../mcp.service.js';
+import { closeMountedRoutes, mountMcpRoutes } from './mcp-routes-harness.js';
+
+/**
+ * The transport routes of the STATELESS MCP endpoint — what `/api/mcp` owes a
+ * request, independent of the proxy behind it.
+ *
+ * Locked down here:
+ *   - no request is ever answered with a session id, and none is ever refused
+ *     for lacking one or for carrying one the process does not know;
+ *   - every request gets its OWN server, built from THAT request's caller, and
+ *     the server is closed once the response is done — nothing outlives it;
+ *   - GET and DELETE are retired with 405, never reaching the proxy;
+ *   - a failure building the server is a JSON-RPC 500, not a hung request.
+ *
+ * What is NOT here: that a manual committed between two requests reaches the
+ * second one. A stub service proves nothing about that — it would pass just as
+ * happily if `McpService` cached its tool surface across requests — so it is
+ * asserted against the real service, in `mcp.service.test.ts` ("a tool
+ * released between two requests is in the second request's answer"). What this
+ * file owes that property is the second point above: a server per request,
+ * closed with its response, so there is nothing left over to be stale.
+ *
+ * The service is a stand-in whose `createRequestServer` returns a REAL SDK
+ * `Server`, so what is asserted is the route driving a real stateless
+ * transport, not a mock's idea of one.
+ */
+
+afterEach(async () => {
+  await closeMountedRoutes();
+  vi.restoreAllMocks();
+});
+
+/** A stand-in service: each server lists one tool named after the caller it was built for. */
+function makeMcpService() {
+  const servers: Array<{ caller: McpCaller; close: ReturnType<typeof vi.spyOn> }> = [];
+  const createRequestServer = vi.fn(async (caller: McpCaller) => {
+    const server = new Server({ name: 'stub', version: '0' }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [{ name: `for-${caller.userId}`, inputSchema: { type: 'object' as const } }],
+    }));
+    servers.push({ caller, close: vi.spyOn(server, 'close') });
+    return server;
+  });
+  return { createRequestServer, servers };
+}
+
+const INITIALIZE = {
+  jsonrpc: '2.0',
+  id: 0,
+  method: 'initialize',
+  params: { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'c', version: '0' } },
+};
+const TOOLS_LIST = { jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} };
+
+async function send(
+  baseUrl: string,
+  opts: { method?: string; sessionId?: string; body?: unknown; user?: string } = {},
+): Promise<Response> {
+  const { method = 'POST', sessionId, body, user } = opts;
+  return fetch(`${baseUrl}/api/mcp`, {
+    method,
+    headers: {
+      'Content-Type': 'application/json',
+      Accept: 'application/json, text/event-stream',
+      ...(sessionId ? { 'mcp-session-id': sessionId } : {}),
+      ...(user ? { 'x-test-user': user } : {}),
+    },
+    ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+  });
+}
+
+/** The JSON-RPC messages in a response body, whether it came back as SSE or JSON. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- raw JSON-RPC bodies, read by shape
+async function messagesOf(res: Response): Promise<Array<{ result?: any; error?: any }>> {
+  const text = await res.text();
+  if ((res.headers.get('content-type') ?? '').includes('text/event-stream')) {
+    return text
+      .split('\n')
+      .filter((line) => line.startsWith('data:'))
+      .map((line) => JSON.parse(line.slice('data:'.length)));
+  }
+  return [JSON.parse(text)];
+}
+
+async function waitFor(assertion: () => void): Promise<void> {
+  for (let i = 0; i < 50; i++) {
+    try {
+      assertion();
+      return;
+    } catch {
+      await new Promise((r) => setTimeout(r, 10));
+    }
+  }
+  assertion();
+}
+
+describe('POST /mcp (stateless)', () => {
+  it('answers initialize without ever issuing a session id', async () => {
+    const mcpService = makeMcpService();
+    const baseUrl = await mountMcpRoutes({ mcpService });
+    const res = await send(baseUrl, { body: INITIALIZE });
+    expect(res.status).toBe(200);
+    expect(res.headers.get('mcp-session-id')).toBeNull();
+    expect((await messagesOf(res))[0].result.serverInfo.name).toBe('stub');
+    // The messages reach the service, so it can tell an initialize apart.
+    expect(mcpService.createRequestServer).toHaveBeenCalledWith(
+      { userId: 'user-A', tokenId: null, connectionId: null, bearer: '' },
+      INITIALIZE,
+    );
+  });
+
+  it('serves a request that was never preceded by an initialize', async () => {
+    const baseUrl = await mountMcpRoutes({ mcpService: makeMcpService() });
+    const res = await send(baseUrl, { body: TOOLS_LIST });
+    expect(res.status).toBe(200);
+    expect((await messagesOf(res))[0].result.tools).toEqual([{ name: 'for-user-A', inputSchema: { type: 'object' } }]);
+  });
+
+  it('ignores a stale session id instead of answering "Session not found"', async () => {
+    const baseUrl = await mountMcpRoutes({ mcpService: makeMcpService() });
+    const res = await send(baseUrl, { sessionId: 'sess-from-before-the-restart', body: TOOLS_LIST });
+    expect(res.status).toBe(200);
+    const [message] = await messagesOf(res);
+    expect(message.error).toBeUndefined();
+    expect(message.result.tools[0].name).toBe('for-user-A');
+  });
+
+  it('builds a server per request from that request\'s caller, and closes each one after its response', async () => {
+    const mcpService = makeMcpService();
+    const baseUrl = await mountMcpRoutes({ mcpService });
+    const resA = await send(baseUrl, { body: TOOLS_LIST });
+    const resB = await send(baseUrl, { body: TOOLS_LIST, user: 'user-B' });
+    const resA2 = await send(baseUrl, { body: TOOLS_LIST });
+
+    expect((await messagesOf(resA))[0].result.tools[0].name).toBe('for-user-A');
+    expect((await messagesOf(resB))[0].result.tools[0].name).toBe('for-user-B');
+    expect((await messagesOf(resA2))[0].result.tools[0].name).toBe('for-user-A');
+
+    expect(mcpService.servers.map((s) => s.caller.userId)).toEqual(['user-A', 'user-B', 'user-A']);
+    await waitFor(() => {
+      for (const s of mcpService.servers) expect(s.close).toHaveBeenCalled();
+    });
+  });
+
+  it('answers a failure building the server with a JSON-RPC 500', async () => {
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    const baseUrl = await mountMcpRoutes({
+      mcpService: {
+        createRequestServer: async () => {
+          throw new Error('Bevel tool discovery failed: loopback down');
+        },
+      },
+    });
+    const res = await send(baseUrl, { body: TOOLS_LIST });
+    expect(res.status).toBe(500);
+    await expect(res.json()).resolves.toEqual({
+      jsonrpc: '2.0',
+      error: { code: -32603, message: 'Bevel tool discovery failed: loopback down' },
+      id: null,
+    });
+  });
+});
+
+describe.each(['GET', 'DELETE'])('%s /mcp (retired)', (method) => {
+  it('answers 405 with Allow: POST and never builds a server', async () => {
+    const mcpService = makeMcpService();
+    const baseUrl = await mountMcpRoutes({ mcpService });
+    const res = await send(baseUrl, { method, sessionId: 'any-session' });
+    expect(res.status).toBe(405);
+    expect(res.headers.get('allow')).toBe('POST');
+    await expect(res.json()).resolves.toEqual({
+      jsonrpc: '2.0',
+      error: { code: -32000, message: 'Method not allowed.' },
+      id: null,
+    });
+    expect(mcpService.createRequestServer).not.toHaveBeenCalled();
+  });
+});