palaryn 0.1.0

package/dist/tests/unit/mcp-http-transport.test.js

@@ -0,0 +1,899 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const supertest_1 = __importDefault(require("supertest"));
+// ---------------------------------------------------------------------------
+// Mock Gateway
+// ---------------------------------------------------------------------------
+function buildToolResult(overrides) {
+    return {
+        tool_call_id: 'tc-001',
+        task_id: 'task-001',
+        status: 'ok',
+        policy: {
+            decision: 'allow',
+            rule_id: 'rule-1',
+            reasons: ['Allowed by default policy'],
+        },
+        dlp: {
+            detected: [],
+            redactions: [],
+            severity: 'low',
+        },
+        budget: {
+            estimated_cost_usd: 0.001,
+            spent_cost_usd_task: 0.005,
+            remaining_cost_usd_task: 1.995,
+        },
+        output: {
+            http_status: 200,
+            body: { data: 'test response' },
+        },
+        timing: {
+            started_at: new Date().toISOString(),
+            duration_ms: 42,
+        },
+        ...overrides,
+    };
+}
+function createMockGateway() {
+    return {
+        execute: jest.fn().mockResolvedValue(buildToolResult()),
+        shutdown: jest.fn(),
+        registerExecutor: jest.fn(),
+        preExecute: jest.fn(),
+        postExecute: jest.fn(),
+    };
+}
+// ---------------------------------------------------------------------------
+// Import after mocks
+// ---------------------------------------------------------------------------
+const http_transport_1 = require("../../src/mcp/http-transport");
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+function createTestApp(gateway, config) {
+    const app = (0, express_1.default)();
+    app.use(express_1.default.json());
+    const handler = (0, http_transport_1.createMCPHttpHandler)(gateway, config);
+    app.use('/mcp', handler.router);
+    return { app, handler };
+}
+const INIT_REQUEST = {
+    jsonrpc: '2.0',
+    id: 1,
+    method: 'initialize',
+    params: {
+        protocolVersion: '2025-03-26',
+        capabilities: {},
+        clientInfo: { name: 'test-client', version: '1.0.0' },
+    },
+};
+const INITIALIZED_NOTIFICATION = {
+    jsonrpc: '2.0',
+    method: 'notifications/initialized',
+};
+/**
+ * Initialize an MCP session and return the session ID.
+ * Sends initialize + initialized notification.
+ */
+async function initSession(app) {
+    const res = await (0, supertest_1.default)(app)
+        .post('/mcp')
+        .send(INIT_REQUEST)
+        .set('Accept', 'application/json, text/event-stream');
+    // Parse session ID from response headers
+    const sessionId = res.headers['mcp-session-id'];
+    if (!sessionId) {
+        throw new Error(`No session ID in response. Status: ${res.status}, Body: ${JSON.stringify(res.body)}`);
+    }
+    // Send initialized notification
+    await (0, supertest_1.default)(app)
+        .post('/mcp')
+        .send(INITIALIZED_NOTIFICATION)
+        .set('mcp-session-id', sessionId)
+        .set('Accept', 'application/json, text/event-stream');
+    return sessionId;
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('MCP HTTP Transport', () => {
+    let gateway;
+    let app;
+    let handler;
+    beforeEach(() => {
+        gateway = createMockGateway();
+        const result = createTestApp(gateway);
+        app = result.app;
+        handler = result.handler;
+    });
+    afterEach(async () => {
+        await handler.close();
+    });
+    // -- Initialization -------------------------------------------------------
+    describe('initialization', () => {
+        it('returns server info and session ID on initialize', async () => {
+            const res = await (0, supertest_1.default)(app)
+                .post('/mcp')
+                .send(INIT_REQUEST)
+                .set('Accept', 'application/json, text/event-stream');
+            expect(res.status).toBe(200);
+            expect(res.headers['mcp-session-id']).toBeDefined();
+            // Response may be SSE or JSON depending on transport
+            const body = parseSSEOrJSON(res);
+            expect(body.result).toBeDefined();
+            expect(body.result.protocolVersion).toBe('2025-03-26');
+            expect(body.result.serverInfo.name).toBe('palaryn-mcp');
+            expect(body.result.serverInfo.version).toBe('1.0.0');
+            expect(body.result.capabilities.tools).toBeDefined();
+        });
+        it('returns 404 for invalid session ID', async () => {
+            const res = await (0, supertest_1.default)(app)
+                .post('/mcp')
+                .send({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} })
+                .set('mcp-session-id', 'nonexistent-session')
+                .set('Accept', 'application/json, text/event-stream');
+            expect(res.status).toBe(404);
+        });
+    });
+    // -- Tool listing ---------------------------------------------------------
+    describe('tools/list', () => {
+        it('returns 3 tools', async () => {
+            const sessionId = await initSession(app);
+            const res = await (0, supertest_1.default)(app)
+                .post('/mcp')
+                .send({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            expect(res.status).toBe(200);
+            const body = parseSSEOrJSON(res);
+            expect(body.result.tools).toHaveLength(3);
+            const toolNames = body.result.tools.map((t) => t.name);
+            expect(toolNames).toContain('http_request');
+            expect(toolNames).toContain('http_get');
+            expect(toolNames).toContain('http_post');
+        });
+        it('http_get has readOnlyHint annotation', async () => {
+            const sessionId = await initSession(app);
+            const res = await (0, supertest_1.default)(app)
+                .post('/mcp')
+                .send({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            const body = parseSSEOrJSON(res);
+            const httpGet = body.result.tools.find((t) => t.name === 'http_get');
+            expect(httpGet.annotations.readOnlyHint).toBe(true);
+            expect(httpGet.annotations.destructiveHint).toBe(false);
+        });
+        it('http_request has destructiveHint annotation', async () => {
+            const sessionId = await initSession(app);
+            const res = await (0, supertest_1.default)(app)
+                .post('/mcp')
+                .send({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            const body = parseSSEOrJSON(res);
+            const httpReq = body.result.tools.find((t) => t.name === 'http_request');
+            expect(httpReq.annotations.destructiveHint).toBe(true);
+        });
+    });
+    // -- Tool execution -------------------------------------------------------
+    describe('tools/call', () => {
+        it('http_get rejects when no auth identity present (S1)', async () => {
+            const sessionId = await initSession(app);
+            const res = await (0, supertest_1.default)(app)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0',
+                id: 3,
+                method: 'tools/call',
+                params: {
+                    name: 'http_get',
+                    arguments: { url: 'https://api.example.com/data' },
+                },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            expect(res.status).toBe(200);
+            // gateway.execute should NOT have been called — auth rejection happens before execution
+            expect(gateway.execute).not.toHaveBeenCalled();
+            const body = parseSSEOrJSON(res);
+            expect(body.result.isError).toBe(true);
+            const errorPayload = JSON.parse(body.result.content[0].text);
+            expect(errorPayload.error_code).toBe('AUTH_REQUIRED');
+        });
+        it('http_post builds correct ToolCall with body (with auth)', async () => {
+            // Create app with auth middleware
+            const authApp = (0, express_1.default)();
+            authApp.use(express_1.default.json());
+            authApp.use((req, _res, next) => {
+                req.auth = { workspace_id: 'ws-test', actor_id: 'actor-test', permissions: ['tool:execute'] };
+                next();
+            });
+            const authHandler = (0, http_transport_1.createMCPHttpHandler)(gateway);
+            authApp.use('/mcp', authHandler.router);
+            const sessionId = await initSession(authApp);
+            await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0',
+                id: 3,
+                method: 'tools/call',
+                params: {
+                    name: 'http_post',
+                    arguments: {
+                        url: 'https://api.example.com/submit',
+                        body: '{"key":"value"}',
+                        headers: { 'Content-Type': 'application/json' },
+                    },
+                },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            expect(gateway.execute).toHaveBeenCalledTimes(1);
+            const toolCall = gateway.execute.mock.calls[0][0];
+            expect(toolCall.tool.name).toBe('http.post');
+            expect(toolCall.tool.capability).toBe('write');
+            expect(toolCall.args.method).toBe('POST');
+            expect(toolCall.args.body).toEqual({ key: 'value' }); // parsed JSON
+            await authHandler.close();
+        });
+        it('http_request with DELETE method has delete capability (with auth)', async () => {
+            const authApp = (0, express_1.default)();
+            authApp.use(express_1.default.json());
+            authApp.use((req, _res, next) => {
+                req.auth = { workspace_id: 'ws-test', actor_id: 'actor-test', permissions: ['tool:execute'] };
+                next();
+            });
+            const authHandler = (0, http_transport_1.createMCPHttpHandler)(gateway);
+            authApp.use('/mcp', authHandler.router);
+            const sessionId = await initSession(authApp);
+            await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0',
+                id: 3,
+                method: 'tools/call',
+                params: {
+                    name: 'http_request',
+                    arguments: { url: 'https://api.example.com/item/1', method: 'DELETE' },
+                },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            const toolCall = gateway.execute.mock.calls[0][0];
+            expect(toolCall.tool.name).toBe('http.request');
+            expect(toolCall.tool.capability).toBe('delete');
+            expect(toolCall.args.method).toBe('DELETE');
+            await authHandler.close();
+        });
+        it('http_request defaults to GET when no method specified (with auth)', async () => {
+            const authApp = (0, express_1.default)();
+            authApp.use(express_1.default.json());
+            authApp.use((req, _res, next) => {
+                req.auth = { workspace_id: 'ws-test', actor_id: 'actor-test', permissions: ['tool:execute'] };
+                next();
+            });
+            const authHandler = (0, http_transport_1.createMCPHttpHandler)(gateway);
+            authApp.use('/mcp', authHandler.router);
+            const sessionId = await initSession(authApp);
+            await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0',
+                id: 3,
+                method: 'tools/call',
+                params: {
+                    name: 'http_request',
+                    arguments: { url: 'https://api.example.com/data' },
+                },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            const toolCall = gateway.execute.mock.calls[0][0];
+            expect(toolCall.args.method).toBe('GET');
+            expect(toolCall.tool.capability).toBe('read');
+            await authHandler.close();
+        });
+        it('passes constraints and context from tool arguments (with auth)', async () => {
+            const authApp = (0, express_1.default)();
+            authApp.use(express_1.default.json());
+            authApp.use((req, _res, next) => {
+                req.auth = { workspace_id: 'ws-test', actor_id: 'actor-test', permissions: ['tool:execute'] };
+                next();
+            });
+            const authHandler = (0, http_transport_1.createMCPHttpHandler)(gateway);
+            authApp.use('/mcp', authHandler.router);
+            const sessionId = await initSession(authApp);
+            await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0',
+                id: 3,
+                method: 'tools/call',
+                params: {
+                    name: 'http_get',
+                    arguments: {
+                        url: 'https://api.example.com/data',
+                        timeout_ms: 5000,
+                        max_cost_usd: 0.01,
+                        purpose: 'Fetching user data',
+                        labels: ['user-data', 'read-only'],
+                    },
+                },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            const toolCall = gateway.execute.mock.calls[0][0];
+            expect(toolCall.constraints).toEqual({ timeout_ms: 5000, max_cost_usd: 0.01 });
+            expect(toolCall.context).toEqual({ purpose: 'Fetching user data', labels: ['user-data', 'read-only'] });
+            await authHandler.close();
+        });
+        it('returns formatted result with gateway metadata (with auth)', async () => {
+            const authApp = (0, express_1.default)();
+            authApp.use(express_1.default.json());
+            authApp.use((req, _res, next) => {
+                req.auth = { workspace_id: 'ws-test', actor_id: 'actor-test', permissions: ['tool:execute'] };
+                next();
+            });
+            const authHandler = (0, http_transport_1.createMCPHttpHandler)(gateway);
+            authApp.use('/mcp', authHandler.router);
+            const sessionId = await initSession(authApp);
+            const res = await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0',
+                id: 3,
+                method: 'tools/call',
+                params: {
+                    name: 'http_get',
+                    arguments: { url: 'https://api.example.com/data' },
+                },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            const body = parseSSEOrJSON(res);
+            expect(body.result.content).toHaveLength(2);
+            expect(body.result.content[0].type).toBe('text');
+            // Primary content should have the response body
+            const primary = JSON.parse(body.result.content[0].text);
+            expect(primary.data).toBe('test response');
+            // Metadata block
+            expect(body.result.content[1].text).toContain('Gateway Metadata');
+            expect(body.result.content[1].text).toContain('tc-001');
+            await authHandler.close();
+        });
+        it('returns isError for blocked results (with auth)', async () => {
+            gateway.execute.mockResolvedValueOnce(buildToolResult({
+                status: 'blocked',
+                error: 'Policy denied: domain not allowed',
+                policy: { decision: 'deny', rule_id: 'block-rule', reasons: ['Domain blocked'] },
+            }));
+            const authApp = (0, express_1.default)();
+            authApp.use(express_1.default.json());
+            authApp.use((req, _res, next) => {
+                req.auth = { workspace_id: 'ws-test', actor_id: 'actor-test', permissions: ['tool:execute'] };
+                next();
+            });
+            const authHandler = (0, http_transport_1.createMCPHttpHandler)(gateway);
+            authApp.use('/mcp', authHandler.router);
+            const sessionId = await initSession(authApp);
+            const res = await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0',
+                id: 3,
+                method: 'tools/call',
+                params: {
+                    name: 'http_get',
+                    arguments: { url: 'https://blocked.example.com' },
+                },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            const body = parseSSEOrJSON(res);
+            expect(body.result.isError).toBe(true);
+            expect(body.result.content[0].text).toContain('Policy denied');
+            await authHandler.close();
+        });
+    });
+    // -- Session management ---------------------------------------------------
+    describe('session management', () => {
+        it('GET without session ID returns 400', async () => {
+            const res = await (0, supertest_1.default)(app).get('/mcp');
+            expect(res.status).toBe(400);
+        });
+        it('DELETE without session ID returns 404', async () => {
+            const res = await (0, supertest_1.default)(app).delete('/mcp');
+            expect(res.status).toBe(404);
+        });
+        it('DELETE with invalid session ID returns 404', async () => {
+            const res = await (0, supertest_1.default)(app)
+                .delete('/mcp')
+                .set('mcp-session-id', 'invalid-session');
+            expect(res.status).toBe(404);
+        });
+    });
+    // -- Configuration --------------------------------------------------------
+    describe('configuration', () => {
+        it('uses authenticated identity and custom platform', async () => {
+            const customApp = (0, express_1.default)();
+            customApp.use(express_1.default.json());
+            customApp.use((req, _res, next) => {
+                req.auth = {
+                    workspace_id: 'custom-ws',
+                    actor_id: 'custom-actor',
+                    auth_method: 'api_key',
+                };
+                next();
+            });
+            const customHandler = (0, http_transport_1.createMCPHttpHandler)(gateway, {
+                platform: 'custom_platform',
+            });
+            customApp.use('/mcp', customHandler.router);
+            const sessionId = await initSession(customApp);
+            await (0, supertest_1.default)(customApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0',
+                id: 3,
+                method: 'tools/call',
+                params: {
+                    name: 'http_get',
+                    arguments: { url: 'https://example.com' },
+                },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            const toolCall = gateway.execute.mock.calls[0][0];
+            expect(toolCall.workspace_id).toBe('custom-ws');
+            expect(toolCall.actor.id).toBe('custom-actor');
+            expect(toolCall.source.platform).toBe('custom_platform');
+            await customHandler.close();
+        });
+    });
+    // -- Session limits and timeout -------------------------------------------
+    describe('session limits', () => {
+        it('evicts the oldest session when MAX_SESSIONS is reached', async () => {
+            const { MAX_SESSIONS } = require('../../src/mcp/http-transport');
+            // Create 2 sessions and verify both are accessible
+            const sessionId1 = await initSession(app);
+            const sessionId2 = await initSession(app);
+            const res1 = await (0, supertest_1.default)(app)
+                .post('/mcp')
+                .send({ jsonrpc: '2.0', id: 100, method: 'tools/list', params: {} })
+                .set('mcp-session-id', sessionId1)
+                .set('Accept', 'application/json, text/event-stream');
+            expect(res1.status).toBe(200);
+            const res2 = await (0, supertest_1.default)(app)
+                .post('/mcp')
+                .send({ jsonrpc: '2.0', id: 101, method: 'tools/list', params: {} })
+                .set('mcp-session-id', sessionId2)
+                .set('Accept', 'application/json, text/event-stream');
+            expect(res2.status).toBe(200);
+            expect(MAX_SESSIONS).toBe(1000);
+        });
+        it('updates session activity on POST with session ID', async () => {
+            const sessionId = await initSession(app);
+            await (0, supertest_1.default)(app)
+                .post('/mcp')
+                .send({ jsonrpc: '2.0', id: 50, method: 'ping' })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            const res = await (0, supertest_1.default)(app)
+                .post('/mcp')
+                .send({ jsonrpc: '2.0', id: 51, method: 'tools/list', params: {} })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            expect(res.status).toBe(200);
+        });
+        it('exports SESSION_TIMEOUT_MS constant', () => {
+            const { SESSION_TIMEOUT_MS } = require('../../src/mcp/http-transport');
+            expect(SESSION_TIMEOUT_MS).toBe(30 * 60 * 1000);
+        });
+    });
+    // -- Auth identity resolution -----------------------------------------------
+    describe('auth identity resolution', () => {
+        it('uses authenticated identity when authInfo present', async () => {
+            // Create app with middleware that sets req.auth (simulating auth middleware)
+            const authApp = (0, express_1.default)();
+            authApp.use(express_1.default.json());
+            authApp.use((req, _res, next) => {
+                req.auth = {
+                    workspace_id: 'ws-from-auth',
+                    actor_id: 'actor-from-auth',
+                    roles: ['agent'],
+                    permissions: ['tool:execute'],
+                    auth_method: 'api_key',
+                };
+                next();
+            });
+            const authHandler = (0, http_transport_1.createMCPHttpHandler)(gateway);
+            authApp.use('/mcp', authHandler.router);
+            const sessionId = await initSession(authApp);
+            await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0',
+                id: 3,
+                method: 'tools/call',
+                params: {
+                    name: 'http_get',
+                    arguments: { url: 'https://api.example.com/data' },
+                },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            expect(gateway.execute).toHaveBeenCalledTimes(1);
+            const toolCall = gateway.execute.mock.calls[0][0];
+            expect(toolCall.workspace_id).toBe('ws-from-auth');
+            expect(toolCall.actor.id).toBe('actor-from-auth');
+            await authHandler.close();
+        });
+        it('uses authenticated identity for http_post tool', async () => {
+            const authApp = (0, express_1.default)();
+            authApp.use(express_1.default.json());
+            authApp.use((req, _res, next) => {
+                req.auth = {
+                    workspace_id: 'ws-post-auth',
+                    actor_id: 'actor-post-auth',
+                    roles: ['agent'],
+                    permissions: ['tool:execute'],
+                    auth_method: 'api_key',
+                };
+                next();
+            });
+            const authHandler = (0, http_transport_1.createMCPHttpHandler)(gateway);
+            authApp.use('/mcp', authHandler.router);
+            const sessionId = await initSession(authApp);
+            await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0',
+                id: 3,
+                method: 'tools/call',
+                params: {
+                    name: 'http_post',
+                    arguments: { url: 'https://api.example.com/submit', body: '{"key":"value"}' },
+                },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            const toolCall = gateway.execute.mock.calls[0][0];
+            expect(toolCall.workspace_id).toBe('ws-post-auth');
+            expect(toolCall.actor.id).toBe('actor-post-auth');
+            await authHandler.close();
+        });
+        it('uses authenticated identity for http_request tool', async () => {
+            const authApp = (0, express_1.default)();
+            authApp.use(express_1.default.json());
+            authApp.use((req, _res, next) => {
+                req.auth = {
+                    workspace_id: 'ws-req-auth',
+                    actor_id: 'actor-req-auth',
+                    roles: ['agent'],
+                    permissions: ['tool:execute'],
+                    auth_method: 'api_key',
+                };
+                next();
+            });
+            const authHandler = (0, http_transport_1.createMCPHttpHandler)(gateway);
+            authApp.use('/mcp', authHandler.router);
+            const sessionId = await initSession(authApp);
+            await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0',
+                id: 3,
+                method: 'tools/call',
+                params: {
+                    name: 'http_request',
+                    arguments: { url: 'https://api.example.com/item/1', method: 'DELETE' },
+                },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            const toolCall = gateway.execute.mock.calls[0][0];
+            expect(toolCall.workspace_id).toBe('ws-req-auth');
+            expect(toolCall.actor.id).toBe('actor-req-auth');
+            await authHandler.close();
+        });
+        it('always uses auth identity — auth is the only way to run MCP', async () => {
+            const authApp = (0, express_1.default)();
+            authApp.use(express_1.default.json());
+            authApp.use((req, _res, next) => {
+                req.auth = {
+                    workspace_id: 'ws-always-used',
+                    actor_id: 'actor-always-used',
+                    roles: ['agent'],
+                    permissions: ['tool:execute'],
+                    auth_method: 'api_key',
+                };
+                next();
+            });
+            const authHandler = (0, http_transport_1.createMCPHttpHandler)(gateway);
+            authApp.use('/mcp', authHandler.router);
+            const sessionId = await initSession(authApp);
+            await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0',
+                id: 3,
+                method: 'tools/call',
+                params: {
+                    name: 'http_get',
+                    arguments: { url: 'https://api.example.com/data' },
+                },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            const toolCall = gateway.execute.mock.calls[0][0];
+            expect(toolCall.workspace_id).toBe('ws-always-used');
+            expect(toolCall.actor.id).toBe('actor-always-used');
+            await authHandler.close();
+        });
+        it('rejects with AUTH_REQUIRED when authInfo is missing fields (S1)', async () => {
+            const authApp = (0, express_1.default)();
+            authApp.use(express_1.default.json());
+            // Auth middleware sets req.auth but without workspace_id
+            authApp.use((req, _res, next) => {
+                req.auth = {
+                    actor_id: 'actor-only',
+                    roles: ['agent'],
+                    permissions: ['tool:execute'],
+                    auth_method: 'api_key',
+                };
+                next();
+            });
+            const authHandler = (0, http_transport_1.createMCPHttpHandler)(gateway);
+            authApp.use('/mcp', authHandler.router);
+            const sessionId = await initSession(authApp);
+            const res = await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0',
+                id: 3,
+                method: 'tools/call',
+                params: {
+                    name: 'http_get',
+                    arguments: { url: 'https://api.example.com/data' },
+                },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            // Missing workspace_id in authInfo → auth rejection, no fallback
+            expect(gateway.execute).not.toHaveBeenCalled();
+            const body = parseSSEOrJSON(res);
+            expect(body.result.isError).toBe(true);
+            const errorPayload = JSON.parse(body.result.content[0].text);
+            expect(errorPayload.error_code).toBe('AUTH_REQUIRED');
+            await authHandler.close();
+        });
+        it('rejects with AUTH_REQUIRED when no authInfo at all (S1)', async () => {
+            // No middleware sets req.auth
+            const authHandler = (0, http_transport_1.createMCPHttpHandler)(gateway);
+            const noAuthApp = (0, express_1.default)();
+            noAuthApp.use(express_1.default.json());
+            noAuthApp.use('/mcp', authHandler.router);
+            const sessionId = await initSession(noAuthApp);
+            const res = await (0, supertest_1.default)(noAuthApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0',
+                id: 3,
+                method: 'tools/call',
+                params: {
+                    name: 'http_get',
+                    arguments: { url: 'https://api.example.com/data' },
+                },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            // No authInfo → auth rejection, no fallback
+            expect(gateway.execute).not.toHaveBeenCalled();
+            const body = parseSSEOrJSON(res);
+            expect(body.result.isError).toBe(true);
+            const errorPayload = JSON.parse(body.result.content[0].text);
+            expect(errorPayload.error_code).toBe('AUTH_REQUIRED');
+            await authHandler.close();
+        });
+    });
+    // -- Capability-level RBAC (S10) ------------------------------------------
+    describe('capability-level RBAC (S10)', () => {
+        function createAuthApp(permissions) {
+            const authApp = (0, express_1.default)();
+            authApp.use(express_1.default.json());
+            authApp.use((req, _res, next) => {
+                req.auth = {
+                    workspace_id: 'ws-rbac',
+                    actor_id: 'actor-rbac',
+                    roles: ['agent'],
+                    permissions,
+                    auth_method: 'api_key',
+                };
+                next();
+            });
+            const authHandler = (0, http_transport_1.createMCPHttpHandler)(gateway);
+            authApp.use('/mcp', authHandler.router);
+            return { authApp, authHandler };
+        }
+        it('allows http_get when user has tool:execute:read permission', async () => {
+            const { authApp, authHandler } = createAuthApp(['tool:execute:read']);
+            const sessionId = await initSession(authApp);
+            await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0', id: 3, method: 'tools/call',
+                params: { name: 'http_get', arguments: { url: 'https://example.com' } },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            expect(gateway.execute).toHaveBeenCalledTimes(1);
+            await authHandler.close();
+        });
+        it('denies http_post when user only has tool:execute:read permission', async () => {
+            const { authApp, authHandler } = createAuthApp(['tool:execute:read']);
+            const sessionId = await initSession(authApp);
+            const res = await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0', id: 3, method: 'tools/call',
+                params: { name: 'http_post', arguments: { url: 'https://example.com', body: '{}' } },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            expect(gateway.execute).not.toHaveBeenCalled();
+            const body = parseSSEOrJSON(res);
+            expect(body.result.isError).toBe(true);
+            const errorPayload = JSON.parse(body.result.content[0].text);
+            expect(errorPayload.error_code).toBe('AUTH_INSUFFICIENT_PERMS');
+            expect(errorPayload.error).toContain('tool:execute:write');
+            await authHandler.close();
+        });
+        it('denies http_request DELETE when user only has tool:execute:write permission', async () => {
+            const { authApp, authHandler } = createAuthApp(['tool:execute:write']);
+            const sessionId = await initSession(authApp);
+            const res = await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0', id: 3, method: 'tools/call',
+                params: { name: 'http_request', arguments: { url: 'https://example.com/item/1', method: 'DELETE' } },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            expect(gateway.execute).not.toHaveBeenCalled();
+            const body = parseSSEOrJSON(res);
+            expect(body.result.isError).toBe(true);
+            const errorPayload = JSON.parse(body.result.content[0].text);
+            expect(errorPayload.error_code).toBe('AUTH_INSUFFICIENT_PERMS');
+            expect(errorPayload.error).toContain('tool:execute:delete');
+            await authHandler.close();
+        });
+        it('allows all capabilities with wildcard tool:execute permission', async () => {
+            const { authApp, authHandler } = createAuthApp(['tool:execute']);
+            const sessionId = await initSession(authApp);
+            // GET (read)
+            await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0', id: 3, method: 'tools/call',
+                params: { name: 'http_get', arguments: { url: 'https://example.com' } },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            expect(gateway.execute).toHaveBeenCalledTimes(1);
+            // POST (write)
+            await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0', id: 4, method: 'tools/call',
+                params: { name: 'http_post', arguments: { url: 'https://example.com', body: '{}' } },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            expect(gateway.execute).toHaveBeenCalledTimes(2);
+            // DELETE
+            await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0', id: 5, method: 'tools/call',
+                params: { name: 'http_request', arguments: { url: 'https://example.com/1', method: 'DELETE' } },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            expect(gateway.execute).toHaveBeenCalledTimes(3);
+            await authHandler.close();
+        });
+        it('allows all capabilities with admin:full permission', async () => {
+            const { authApp, authHandler } = createAuthApp(['admin:full']);
+            const sessionId = await initSession(authApp);
+            await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0', id: 3, method: 'tools/call',
+                params: { name: 'http_request', arguments: { url: 'https://example.com/1', method: 'DELETE' } },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            expect(gateway.execute).toHaveBeenCalledTimes(1);
+            await authHandler.close();
+        });
+        it('skips capability check when no permissions in authInfo (auth disabled)', async () => {
+            // Auth middleware sets identity but no permissions (simulating auth disabled)
+            const authApp = (0, express_1.default)();
+            authApp.use(express_1.default.json());
+            authApp.use((req, _res, next) => {
+                req.auth = { workspace_id: 'ws-noauth', actor_id: 'actor-noauth' };
+                next();
+            });
+            const authHandler = (0, http_transport_1.createMCPHttpHandler)(gateway);
+            authApp.use('/mcp', authHandler.router);
+            const sessionId = await initSession(authApp);
+            await (0, supertest_1.default)(authApp)
+                .post('/mcp')
+                .send({
+                jsonrpc: '2.0', id: 3, method: 'tools/call',
+                params: { name: 'http_post', arguments: { url: 'https://example.com', body: '{}' } },
+            })
+                .set('mcp-session-id', sessionId)
+                .set('Accept', 'application/json, text/event-stream');
+            // No permissions array → capability check skipped → execute allowed
+            expect(gateway.execute).toHaveBeenCalledTimes(1);
+            await authHandler.close();
+        });
+    });
+    // -- Close ----------------------------------------------------------------
+    describe('close', () => {
+        it('close() resolves without error', async () => {
+            await expect(handler.close()).resolves.toBeUndefined();
+        });
+        it('close() cleans up sessions', async () => {
+            await initSession(app);
+            await handler.close();
+            // After close, no sessions should remain — verify by trying to use one
+            // (the handler is closed, so this is a best-effort check)
+            await expect(handler.close()).resolves.toBeUndefined();
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// SSE / JSON response parser helper
+// ---------------------------------------------------------------------------
+/**
+ * The MCP Streamable HTTP transport may respond with either:
+ * - SSE (text/event-stream): `event: message\ndata: {...}\n\n`
+ * - JSON (application/json): `{...}`
+ *
+ * This helper parses both formats and returns the JSON-RPC response body.
+ */
+function parseSSEOrJSON(res) {
+    const contentType = res.headers['content-type'] || '';
+    if (contentType.includes('text/event-stream')) {
+        // Parse SSE format: find the last `data:` line
+        const text = res.text;
+        const lines = text.split('\n');
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i].trim();
+            if (line.startsWith('data:')) {
+                const data = line.slice(5).trim();
+                try {
+                    return JSON.parse(data);
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        throw new Error(`No parseable SSE data in response: ${text}`);
+    }
+    // JSON response (might be an array for batched responses)
+    if (Array.isArray(res.body)) {
+        return res.body[0];
+    }
+    return res.body;
+}
+//# sourceMappingURL=mcp-http-transport.test.js.map