AI-native design editor. Open-source Figma alternative.
fix(mcp): release cancelled requests and preserve HTTP method semantics (#1278)
Paolo Musolino4ee5c39ae0fc
diff --git a/changes/1278/fixed.md b/changes/1278/fixed.mdnew file mode 100644index 000000000..d50707748--- /dev/null+++ b/changes/1278/fixed.md@@ -0,0 +1 @@+- The MCP HTTP server no longer runs out of sessions after failed initializations, session-less GET requests, or cancelled tool calls, and closes sessions idle for 15 minutes (`OPENPENCIL_MCP_SESSION_IDLE_TIMEOUT_MS`).diff --git a/package.json b/package.jsonindex 94942187e..9bc749fd2 100644--- a/package.json+++ b/package.json@@ -63,8 +63,8 @@"benchmark:navigation": "bun tools/dev/navigation-benchmark/src/cli.ts run","test:native": "bun run build:native-test && wdio run wdio.conf.ts","lint": "bun run lint:structure && oxlint -c oxlint.json --type-aware --type-check src/ packages/scene-graph/src/ packages/core/src/ packages/vue/src/ packages/cli/src/ packages/mcp/src/ packages/harness/src/ packages/feedback/src/ packages/cloud/src/ packages/dom-css/src/ packages/pen/src/ packages/design-jsx/src/ packages/emit/src/ packages/kiwi/src/ packages/fig/src/ packages/docs/.vitepress/theme/landing/",- "lint:structure": "oxlint -c oxlint.json commitlint.config.ts vite.config.ts vite/ .storybook/ src/ packages/scene-graph/src/ packages/scene-graph/scripts/ packages/core/src/ packages/vue/src/ packages/cli/src/ packages/mcp/src/ packages/harness/src/ packages/harness/tests/ packages/feedback/src/ packages/feedback/tests/ packages/cloud/src/ packages/cloud/tests/ packages/cloud/deploy/ packages/dom-css/src/ packages/dom-css/tests/ packages/dom-css/scripts/ packages/pen/src/ packages/pen/scripts/ packages/design-jsx/src/ packages/design-jsx/tests/ packages/design-jsx/scripts/ packages/emit/src/ packages/emit/tests/ packages/emit/scripts/ packages/kiwi/src/ packages/kiwi/tests/ packages/kiwi/scripts/ packages/fig/src/ packages/fig/tests/ packages/fig/scripts/ packages/core/tests/ packages/cli/tests/ packages/scene-graph/tests/ packages/vue/tests/ tests/ scripts/ tools/ packages/docs/.vitepress/theme/landing/",- "format": "oxfmt --write .oxfmtrc.json commitlint.config.ts vite.config.ts vite/ .storybook/ src/ packages/scene-graph/src/ packages/scene-graph/scripts/ packages/core/src/ packages/cli/src/ packages/mcp/src/ packages/harness/src/ packages/harness/tests/ packages/feedback/src/ packages/feedback/tests/ packages/cloud/src/ packages/cloud/tests/ packages/cloud/deploy/ packages/cloud/tsdown.config.ts packages/cloud/tsdown.standalone.config.ts packages/vue/src/ packages/dom-css/src/ packages/dom-css/tests/ packages/dom-css/scripts/ packages/pen/src/ packages/pen/scripts/ packages/design-jsx/src/ packages/design-jsx/tests/ packages/design-jsx/scripts/ packages/emit/src/ packages/emit/tests/ packages/emit/scripts/ packages/kiwi/src/ packages/kiwi/tests/ packages/kiwi/scripts/ packages/fig/src/ packages/fig/tests/ packages/fig/scripts/ tests scripts/ tools/ packages/docs/.vitepress/theme/landing/",+ "lint:structure": "oxlint -c oxlint.json commitlint.config.ts vite.config.ts vite/ .storybook/ src/ packages/scene-graph/src/ packages/scene-graph/scripts/ packages/core/src/ packages/vue/src/ packages/cli/src/ packages/mcp/src/ packages/mcp/tests/ packages/harness/src/ packages/harness/tests/ packages/feedback/src/ packages/feedback/tests/ packages/cloud/src/ packages/cloud/tests/ packages/cloud/deploy/ packages/dom-css/src/ packages/dom-css/tests/ packages/dom-css/scripts/ packages/pen/src/ packages/pen/scripts/ packages/design-jsx/src/ packages/design-jsx/tests/ packages/design-jsx/scripts/ packages/emit/src/ packages/emit/tests/ packages/emit/scripts/ packages/kiwi/src/ packages/kiwi/tests/ packages/kiwi/scripts/ packages/fig/src/ packages/fig/tests/ packages/fig/scripts/ packages/core/tests/ packages/cli/tests/ packages/scene-graph/tests/ packages/vue/tests/ tests/ scripts/ tools/ packages/docs/.vitepress/theme/landing/",+ "format": "oxfmt --write .oxfmtrc.json commitlint.config.ts vite.config.ts vite/ .storybook/ src/ packages/scene-graph/src/ packages/scene-graph/scripts/ packages/core/src/ packages/cli/src/ packages/mcp/src/ packages/mcp/tests/ packages/harness/src/ packages/harness/tests/ packages/feedback/src/ packages/feedback/tests/ packages/cloud/src/ packages/cloud/tests/ packages/cloud/deploy/ packages/cloud/tsdown.config.ts packages/cloud/tsdown.standalone.config.ts packages/vue/src/ packages/dom-css/src/ packages/dom-css/tests/ packages/dom-css/scripts/ packages/pen/src/ packages/pen/scripts/ packages/design-jsx/src/ packages/design-jsx/tests/ packages/design-jsx/scripts/ packages/emit/src/ packages/emit/tests/ packages/emit/scripts/ packages/kiwi/src/ packages/kiwi/tests/ packages/kiwi/scripts/ packages/fig/src/ packages/fig/tests/ packages/fig/scripts/ tests scripts/ tools/ packages/docs/.vitepress/theme/landing/","format:check": "bun run format && status=$(git status --porcelain -uall) && test -z \"$status\" || (echo \"$status\" && exit 1)","check": "bun run check:icons && bun run build:packages && bun run lint && tsgo --noEmit && bun run check:vue && bun run check:native-test && bun run check:i18n && bun run check:docs && bun run check:changelog && bun run check:packages && bun run check:deps && bun run check:audit && bun run check:secrets && bun run check:monorepo && bun run check:arch && bun run check:test-homes && bun run check:cloud-off && bun run check:test-types && bun run test:type-shapes && bun run check:tools && bun run test:tools && bun run test:dupes","check:commits": "commitlint",diff --git a/packages/mcp/README.md b/packages/mcp/README.mdindex ae77889f3..d8dd41ef9 100644--- a/packages/mcp/README.md+++ b/packages/mcp/README.md@@ -10,6 +10,8 @@ openpencil-mcp-http # Streamable HTTP transport for browser extensions and scrOn macOS and Linux, local clients prefer a private Unix domain socket; Windows and unavailable sockets fall back to localhost TCP. File access is limited to the effective MCP root.+Streamable HTTP clients initialize with a POST, then open GET/SSE with the returned `Mcp-Session-Id`; DELETE ends the session. The server keeps at most 10 sessions and closes those idle for 15 minutes (`OPENPENCIL_MCP_SESSION_IDLE_TIMEOUT_MS`, `0` disables). Running requests keep a session alive, an open SSE stream alone does not, and an expired session ID returns 404.+- Setup and client configuration: https://openpencil.dev/programmable/mcp-server- Source and issues: https://github.com/open-pencil/open-pencildiff --git a/packages/mcp/src/index.ts b/packages/mcp/src/index.tsindex cd265c05f..91699fd96 100644--- a/packages/mcp/src/index.ts+++ b/packages/mcp/src/index.ts@@ -27,6 +27,9 @@ if (process.argv.includes('--help') || process.argv.includes('-h')) {` OPENPENCIL_MCP_AUTH_TOKEN Bearer token for MCP and RPC auth\n` +` OPENPENCIL_MCP_ROOT Allowed directory for file-scoped tools (default: home directory on Windows, current working directory elsewhere)\n` +` OPENPENCIL_MCP_EVAL Set to 1 to enable the eval tool\n` ++ ` OPENPENCIL_MCP_SESSION_IDLE_TIMEOUT_MS\n` ++ ` Close sessions idle this long, in ms (default: 900000;\n` ++ ` 0 disables). An open GET/SSE stream is not activity.\n` +` OPENPENCIL_MCP_DISABLED_TOOLS Comma-separated tool names to omit\n` +` OPENPENCIL_MCP_SCOPE "selection" to let clients read only the selected layers\n` +` (default: "document")\n` +@@ -60,25 +63,25 @@ const port = rawPort// the PORT value alone determines whether TCP is enabled (PORT=0 is the kill switch).const withTcp = port > 0-const MAX_APP_TIMEOUT_MS = 2_147_483_647-const rawAppTimeoutText = process.env.OPENPENCIL_MCP_APP_TIMEOUT_MS?.trim()-let appAttachTimeoutMs: number | undefined-if (rawAppTimeoutText) {- if (!/^\d+$/.test(rawAppTimeoutText)) {- process.stderr.write(- `Error: OPENPENCIL_MCP_APP_TIMEOUT_MS must be a non-negative integer, got "${rawAppTimeoutText}"\n`- )- process.exit(1)- }- appAttachTimeoutMs = Number.parseInt(rawAppTimeoutText, 10)- if (!Number.isSafeInteger(appAttachTimeoutMs) || appAttachTimeoutMs > MAX_APP_TIMEOUT_MS) {+const MAX_TIMEOUT_MS = 2_147_483_647++/** Read a millisecond timeout from the environment, exiting on an invalid value. */+function readTimeoutEnv(name: string): number | undefined {+ const text = process.env[name]?.trim()+ if (!text) return undefined+ const timeoutMs = Number(text)+ if (!/^\d+$/.test(text) || timeoutMs > MAX_TIMEOUT_MS) {process.stderr.write(- `Error: OPENPENCIL_MCP_APP_TIMEOUT_MS must be an integer in 0–${MAX_APP_TIMEOUT_MS}, got "${rawAppTimeoutText}"\n`+ `Error: ${name} must be an integer in 0–${MAX_TIMEOUT_MS}, got "${text}"\n`)process.exit(1)}+ return timeoutMs}+const appAttachTimeoutMs = readTimeoutEnv('OPENPENCIL_MCP_APP_TIMEOUT_MS')+const sessionIdleTimeoutMs = readTimeoutEnv('OPENPENCIL_MCP_SESSION_IDLE_TIMEOUT_MS')+const toolPolicy = readToolPolicyFromEnv()const handle = await startServer({@@ -107,7 +110,8 @@ const handle = await startServer({return trimmed})(),corsOrigin: resolveCORSOrigins(process.env.OPENPENCIL_MCP_CORS_ORIGIN),- appAttachTimeoutMs+ appAttachTimeoutMs,+ sessionIdleTimeoutMs})const readyMarker = process.env.OPENPENCIL_MCP_READY_MARKERdiff --git a/packages/mcp/src/server.ts b/packages/mcp/src/server.tsindex 56ebee88b..4253c334a 100644--- a/packages/mcp/src/server.ts+++ b/packages/mcp/src/server.ts@@ -41,6 +41,7 @@ import {export const MCP_VERSION: string = packageJSON.versionconst HEARTBEAT_INTERVAL_MS = 5_000+const MCP_METHODS: readonly string[] = ['GET', 'POST', 'DELETE']let installCommandPromise: Promise<string> | null = null@@ -105,6 +106,12 @@ export interface ServerOptions {* app opts in when it spawns the server.*/appAttachTimeoutMs?: number+ /**+ * How long an MCP session may sit without requests before it is closed.+ * Defaults to 15 minutes; 0 disables expiration. An open GET/SSE stream+ * does not count as activity.+ */+ sessionIdleTimeoutMs?: number/*** How long a tool call waits for the app to register before it fails with* APP_NOT_CONNECTED. Defaults to 10 s so a stdio bridge started slightly@@ -200,18 +207,16 @@ function createHonoApp(options: {return c.json({ error: 'Unauthorized' }, 401)}}- const sessionId = c.req.header('mcp-session-id') ?? undefined- // Reject anonymous DELETE requests before they allocate a session.- // Without this guard, a DELETE without a session ID would call- // resolveTransport(undefined), which creates a fresh session just- // to no-op on deleteSession(undefined) — burning a session slot.- if (c.req.method === 'DELETE' && !sessionId) {- return c.json({ error: 'Missing MCP session id' }, 400)+ if (!MCP_METHODS.includes(c.req.method)) {+ return c.json(+ { error: 'Method not allowed' },+ { status: 405, headers: { Allow: MCP_METHODS.join(', ') } }+ )}- // For DELETE, look up the existing session without creating a new one.- // resolveTransport() would allocate a fresh session for an unknown ID,- // only to immediately delete it — wasting a session slot.- if (c.req.method === 'DELETE' && sessionId) {+ const sessionId = c.req.header('mcp-session-id') ?? undefined+ if (sessionId) {+ // Never allocate a session for an unknown ID: DELETE or a stale client+ // would burn a slot it can never use.const existing = mcpSessions.getExistingTransport(sessionId)if ('error' in existing) {if (existing.error === 'closed') {@@ -219,22 +224,16 @@ function createHonoApp(options: {}return c.json({ error: 'MCP session not found' }, 404)}+ if (c.req.method !== 'DELETE') return existing.handleRequest(c.req.raw)try {return await existing.handleRequest(c.req.raw)} finally {- mcpSessions.deleteSession(sessionId)+ await mcpSessions.deleteSession(sessionId)}}- if (sessionId) {- const existing = mcpSessions.getExistingTransport(sessionId)- if ('error' in existing) {- if (existing.error === 'closed') {- return c.json({ error: 'MCP server is shutting down' }, 503)- }- return c.json({ error: 'MCP session not found' }, 404)- }- mcpSessions.touch(sessionId, existing)- return existing.handleRequest(c.req.raw)+ // Only an initializing POST may start a session.+ if (c.req.method !== 'POST') {+ return c.json({ error: 'Missing MCP session id' }, 400)}const transport = await mcpSessions.resolveTransport(undefined,@@ -249,7 +248,6 @@ function createHonoApp(options: {{ status: 503, headers: { 'Retry-After': '5' } })}- mcpSessions.touch(undefined, transport)return transport.handleRequest(c.req.raw)})@@ -338,12 +336,14 @@ function buildServerContext(options: ServerOptions) {const mcpSessions = createMCPSessionManager({serverVersion: MCP_VERSION,- registerTools: (mcpServer: McpServer, agentSession: MCPAgentSession) =>+ sessionIdleTimeoutMs: options.sessionIdleTimeoutMs,+ registerTools: (mcpServer: McpServer, agentSession: MCPAgentSession, onToolSettled) =>registerTools(mcpServer, {policy: toolPolicy,mcpRoot,sendRPC: sendToBrowser,- agentSession+ agentSession,+ onToolSettled}),onSessionClosed: (sessionId) => {// Best-effort: the app may be gone already, and then it shows no agents anyway.@@ -476,6 +476,7 @@ function buildHandle(export async function startServer(options: ServerOptions = {}): Promise<ServerHandle> {validateTimeoutOption('appAttachTimeoutMs', options.appAttachTimeoutMs)validateTimeoutOption('appWaitTimeoutMs', options.appWaitTimeoutMs)+ validateTimeoutOption('sessionIdleTimeoutMs', options.sessionIdleTimeoutMs)const ctx = buildServerContext(options)// Wire shared connection handling BEFORE starting listeners so thatdiff --git a/packages/mcp/src/server/pending-requests.ts b/packages/mcp/src/server/pending-requests.tsnew file mode 100644index 000000000..b4ce742f3--- /dev/null+++ b/packages/mcp/src/server/pending-requests.ts@@ -0,0 +1,62 @@+import type {+ ServerContext,+ WebStandardStreamableHTTPServerTransport+} from '@modelcontextprotocol/server'++const REQUEST_CANCELLED = -32800++/**+ * In JSON response mode the SDK never settles the HTTP response of a request+ * that was cancelled or that was still running when the transport closed.+ * This tracks each POST so both cases can be answered.+ */+export function createPendingRequests(transport: WebStandardStreamableHTTPServerTransport) {+ const waiting = new Map<Request, (response: Response) => void>()+ let closed = false++ function settled(request: Request): Promise<Response> {+ if (closed) return Promise.resolve(sessionNotFound())+ return new Promise((resolve) => {+ waiting.set(request, resolve)+ })+ }++ async function handle(request: Request): Promise<Response> {+ const handling = transport.handleRequest(request)+ if (request.method !== 'POST') return handling+ try {+ return await Promise.race([handling, settled(request)])+ } finally {+ waiting.delete(request)+ }+ }++ /** End a cancelled tool call's HTTP request without a JSON-RPC result. */+ async function releaseCancelled(context: ServerContext): Promise<void> {+ const request = context.http?.req+ const respond = request && waiting.get(request)+ if (!respond || !context.mcpReq.signal.aborted) return+ respond(new Response(null, { status: 202 }))+ // The SDK drops the cancelled result, so its stream bookkeeping waits for+ // a response that never comes. Send one to release it.+ await transport+ .send({+ jsonrpc: '2.0',+ id: context.mcpReq.id,+ error: { code: REQUEST_CANCELLED, message: 'Request cancelled' }+ })+ .catch(() => undefined)+ }++ function close() {+ closed = true+ for (const respond of waiting.values()) respond(sessionNotFound())+ waiting.clear()+ }++ return { close, handle, releaseCancelled }+}++function sessionNotFound() {+ return Response.json({ error: 'MCP session not found' }, { status: 404 })+}diff --git a/packages/mcp/src/server/sessions.ts b/packages/mcp/src/server/sessions.tsindex 6e5b741dc..f725dfd94 100644--- a/packages/mcp/src/server/sessions.ts+++ b/packages/mcp/src/server/sessions.ts@@ -1,8 +1,14 @@import { randomUUID } from 'node:crypto'-import { McpServer, WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/server'+import {+ isJSONRPCResultResponse,+ McpServer,+ WebStandardStreamableHTTPServerTransport+} from '@modelcontextprotocol/server'+import { withTimeout } from 'es-toolkit/promise'-import type { MCPAgentKind, MCPAgentSession } from '#mcp/tool/registration'+import { createPendingRequests } from '#mcp/server/pending-requests'+import type { MCPAgentKind, MCPAgentSession, MCPToolSettled } from '#mcp/tool/registration'export type MCPTransport = {handleRequest: (request: Request) => Promise<Response>@@ -12,69 +18,81 @@ export type MCPTransport = {type MCPSession = {transport: MCPTransportserver: McpServer+ requests: ReturnType<typeof createPendingRequests>lastSeen: number+ activeRequests: number+ initialized: boolean}type MCPSessionManagerOptions = {serverVersion: string- registerTools: (server: McpServer, session: MCPAgentSession) => void+ registerTools: (+ server: McpServer,+ session: MCPAgentSession,+ onToolSettled: MCPToolSettled+ ) => void/** Told when a session ends, so the app stops showing its agent. */onSessionClosed?: (sessionId: string) => void+ /** Idle lifetime in ms; 0 disables expiration. Defaults to 15 minutes. */+ sessionIdleTimeoutMs?: number}const MAX_MCP_SESSIONS = 10-const MCP_SESSION_TTL_MS = 15 * 60_000+const MCP_SESSION_IDLE_TIMEOUT_MS = 15 * 60_000+const MAX_SWEEP_INTERVAL_MS = 60_000+// The MCP SDK's close() does not enforce a timeout internally.const SESSION_CLOSE_TIMEOUT_MS = 5_000function describeError(e: unknown): string {return e instanceof Error ? e.message : String(e)}-/**- * Wraps a promise with a timeout. Resolves with undefined if the timeout- * elapses before the promise settles. Used to prevent `transport.close()`- * from hanging indefinitely — the MCP SDK's close() does not enforce a- * timeout internally.- */-function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T | undefined> {- let timer: ReturnType<typeof setTimeout> | undefined- return Promise.race([- promise.finally(() => {- if (timer) clearTimeout(timer)- }),- new Promise<T | undefined>((resolve) => {- timer = setTimeout(() => resolve(undefined), ms)- })- ])-}--async function closeSession(session: MCPSession): Promise<void> {+async function closeSession(session: Pick<MCPSession, 'transport' | 'server'>): Promise<void> {try {- await withTimeout(session.transport.close(), SESSION_CLOSE_TIMEOUT_MS)+ await withTimeout(() => session.transport.close(), SESSION_CLOSE_TIMEOUT_MS)} catch (e) {// Best-effort: the transport may already be closed or in a bad stateprocess.stderr.write(` MCP session: transport close warning (${describeError(e)})\n`)}try {- await withTimeout(session.server.close(), SESSION_CLOSE_TIMEOUT_MS)+ await withTimeout(() => session.server.close(), SESSION_CLOSE_TIMEOUT_MS)} catch (e) {// Best-effortprocess.stderr.write(` MCP session: server close warning (${describeError(e)})\n`)}}+/**+ * The SDK assigns the session ID before it validates the InitializeRequest,+ * so a 200 carrying the session header can still be a JSON-RPC error.+ */+async function isInitializeResult(response: Response, id: string): Promise<boolean> {+ if (!response.ok || response.headers.get('mcp-session-id') !== id) return false+ const message: unknown = await response+ .clone()+ .json()+ .catch(() => undefined)+ return isJSONRPCResultResponse(message)+}+export function createMCPSessionManager({serverVersion,registerTools,- onSessionClosed+ onSessionClosed,+ sessionIdleTimeoutMs = MCP_SESSION_IDLE_TIMEOUT_MS}: MCPSessionManagerOptions) {const sessions = new Map<string, MCPSession>()- const closing = new Set<Promise<void>>()+ const closing = new Map<string, Promise<void>>()- function scheduleClose(session: MCPSession, id?: string): Promise<void> {- if (id) onSessionClosed?.(id)- const task = closeSession(session).finally(() => closing.delete(task))- closing.add(task)+ function scheduleClose(session: MCPSession, id: string): Promise<void> {+ try {+ if (session.initialized) onSessionClosed?.(id)+ } catch (e) {+ // Application notification must not prevent resource cleanup.+ process.stderr.write(` MCP session: close notification warning (${describeError(e)})\n`)+ }+ const task = closeSession(session).finally(() => closing.delete(id))+ closing.set(id, task)return task}@@ -89,15 +107,21 @@ export function createMCPSessionManager({}function cleanupExpired() {+ if (sessionIdleTimeoutMs === 0) returnconst now = Date.now()for (const [id, session] of sessions) {- if (now - session.lastSeen > MCP_SESSION_TTL_MS) {+ if (session.activeRequests === 0 && now - session.lastSeen >= sessionIdleTimeoutMs) {sessions.delete(id)void scheduleClose(session, id)}}}+ const sweep =+ sessionIdleTimeoutMs > 0+ ? setInterval(cleanupExpired, Math.min(sessionIdleTimeoutMs, MAX_SWEEP_INTERVAL_MS)).unref()+ : undefined+const creating = new Map<string, Promise<MCPTransport>>()let closed = false@@ -108,22 +132,20 @@ export function createMCPSessionManager({const promise = (async () => {const server = new McpServer({ name: 'open-pencil', version: serverVersion })- registerTools(server, { id, kind })const transport = new WebStandardStreamableHTTPServerTransport({sessionIdGenerator: () => id,enableJsonResponse: true})- // Await the MCP handshake before storing/returning the transport so- // handleRequest cannot race the SDK's initialization on a fresh- // session. Without this, the /mcp route calls resolveTransport() and- // immediately awaits handleRequest(), which can fail if connect() has- // not completed yet.+ const requests = createPendingRequests(transport)+ // Connect the SDK before exposing its transport. The client's HTTP+ // InitializeRequest is processed later by handleRequest; connect() alone+ // does not establish a valid MCP session.try {+ registerTools(server, { id, kind }, requests.releaseCancelled)await server.connect(transport)} catch (e) {- await transport.close().catch(() => undefined)- await server.close().catch(() => undefined)+ await closeSession({ transport, server })throw e}// `closed` is mutated by clear() which can run concurrently — TypeScript's@@ -131,12 +153,34 @@ export function createMCPSessionManager({// oxlint-disable-next-line no-unnecessary-conditionif (closed) {// Manager was closed while we were connecting — clean up immediately.- await transport.close().catch(() => undefined)- await server.close().catch(() => undefined)+ await closeSession({ transport, server })throw new Error('Session manager closed during session creation')}- sessions.set(id, { transport, server, lastSeen: Date.now() })- return transport+ const session: MCPSession = {+ server,+ requests,+ lastSeen: Date.now(),+ activeRequests: 0,+ initialized: false,+ transport: {+ close: () => transport.close(),+ handleRequest: (request) => handleSessionRequest(id, session, request)+ }+ }+ // Closing a GET/SSE stream does not close the transport, so only a full+ // close ends the session. Keep the SDK's own protocol cleanup.+ const onclose = transport.onclose+ transport.onclose = () => {+ requests.close()+ try {+ onclose?.()+ } finally {+ void deleteSession(id)+ }+ }+ sessions.set(id, session)+ creating.delete(id)+ return session.transport})()creating.set(id, promise)@@ -147,6 +191,29 @@ export function createMCPSessionManager({}}+ async function handleSessionRequest(+ id: string,+ session: MCPSession,+ request: Request+ ): Promise<Response> {+ session.activeRequests+++ session.lastSeen = Date.now()+ try {+ const response = await session.requests.handle(request)+ if (!session.initialized) {+ session.initialized = await isInitializeResult(response, id)+ if (!session.initialized) await deleteSession(id)+ }+ return response+ } catch (error) {+ if (!session.initialized) await deleteSession(id)+ throw error+ } finally {+ session.activeRequests--+ session.lastSeen = Date.now()+ }+ }+function resolveTransport(sessionId: string | undefined,kind: MCPAgentKind = 'mcp'@@ -178,14 +245,6 @@ export function createMCPSessionManager({})}- function touch(sessionId: string | undefined, transport: MCPTransport) {- const resolvedSessionId =- sessionId ?? [...sessions.entries()].find(([, entry]) => entry.transport === transport)?.[0]- if (!resolvedSessionId) return- const session = sessions.get(resolvedSessionId)- if (session) session.lastSeen = Date.now()- }-/*** Look up an existing session's transport without creating a new session.* Used for DELETE requests where creating a session just to delete it@@ -195,23 +254,25 @@ export function createMCPSessionManager({sessionId: string | undefined): MCPTransport | { error: 'not_found' | 'closed' } {if (closed) return { error: 'closed' }+ cleanupExpired()if (!sessionId) return { error: 'not_found' }const existing = sessions.get(sessionId)if (existing) return existing.transportreturn { error: 'not_found' }}- function deleteSession(sessionId: string | undefined) {+ async function deleteSession(sessionId: string | undefined): Promise<void> {if (closed) returnif (!sessionId) returnconst session = sessions.get(sessionId)- if (!session) return+ if (!session) return closing.get(sessionId)sessions.delete(sessionId)- void scheduleClose(session, sessionId)+ await scheduleClose(session, sessionId)}async function clear() {closed = true+ clearInterval(sweep)// Collect sessions before awaiting in-flight creations so new sessions// can't be added during shutdown.const all = [...sessions]@@ -224,10 +285,10 @@ export function createMCPSessionManager({// Await both previously-scheduled closes (from cleanupExpired/deleteSession)// and closes for sessions still alive at clear() time.await Promise.allSettled([- ...closing,+ ...closing.values(),...all.map(([id, session]) => scheduleClose(session, id))])}- return { clear, deleteSession, getExistingTransport, notifyToolsChanged, resolveTransport, touch }+ return { clear, deleteSession, getExistingTransport, notifyToolsChanged, resolveTransport }}diff --git a/packages/mcp/src/tool/registration.ts b/packages/mcp/src/tool/registration.tsindex 469df4c34..0148a9828 100644--- a/packages/mcp/src/tool/registration.ts+++ b/packages/mcp/src/tool/registration.ts@@ -1,7 +1,12 @@import { Buffer } from 'node:buffer'import { resolve } from 'node:path'-import type { McpServer, ToolCallback, ToolAnnotations } from '@modelcontextprotocol/server'+import type {+ McpServer,+ ToolCallback,+ ToolAnnotations,+ ServerContext+} from '@modelcontextprotocol/server'// eslint-disable-next-line open-pencil/no-mixed-case-acronym-identifiers -- Upstream export spelling.import { toStandardJsonSchema as toStandardJSONSchema } from '@valibot/to-json-schema'import * as v from 'valibot'@@ -17,6 +22,7 @@ import { isToolEnabled } from '#mcp/tool/policy'import { SELECTION_SCOPE_FILE_OUTPUT_ERROR } from '#mcp/tool/scope'export type RPCSender = (body: Record<string, unknown>) => Promise<unknown>+export type MCPToolSettled = (context: ServerContext) => Promise<void>const automationTargetSchema = {document_id: v.optional(@@ -74,6 +80,8 @@ export interface RegisterToolsOptions {mcpRoot?: string | nullsendRPC: RPCSenderagentSession?: MCPAgentSession+ /** Transport lifecycle cleanup after tool execution, including cancellation. */+ onToolSettled?: MCPToolSettled}function toolAnnotations(effect: ToolEffect): ToolAnnotations {@@ -116,7 +124,13 @@ export function registerTools(mcpServer: McpServer, options: RegisterToolsOptionannotations: toolAnnotations(descriptor.effect),_meta: { 'openpencil/capabilities': descriptor.capabilities }},- handler+ async (args, context) => {+ try {+ return await handler(args, context)+ } finally {+ await options.onToolSettled?.(context)+ }+ })}diff --git a/packages/mcp/tests/server/sessions.test.ts b/packages/mcp/tests/server/sessions.test.tsnew file mode 100644index 000000000..7aa65283e--- /dev/null+++ b/packages/mcp/tests/server/sessions.test.ts@@ -0,0 +1,438 @@+import { afterEach, describe, expect, spyOn, test } from 'bun:test'++import { McpServer } from '@modelcontextprotocol/server'++import { createMCPSessionManager, type MCPTransport } from '#mcp/server/sessions'+import { registerTools } from '#mcp/tool/registration'++const managers: ReturnType<typeof createMCPSessionManager>[] = []+afterEach(async () => {+ await Promise.all(managers.splice(0).map((manager) => manager.clear()))+})++function manager(options: Partial<Parameters<typeof createMCPSessionManager>[0]> = {}) {+ const instance = createMCPSessionManager({+ serverVersion: '0.0.0',+ registerTools: () => undefined,+ ...options+ })+ managers.push(instance)+ return instance+}++function request(body: unknown, sessionId?: string) {+ return new Request('http://localhost/mcp', {+ method: 'POST',+ headers: {+ accept: 'application/json, text/event-stream',+ 'content-type': 'application/json',+ ...(sessionId ? { 'mcp-session-id': sessionId } : {})+ },+ body: JSON.stringify(body)+ })+}++const initialize = {+ jsonrpc: '2.0',+ id: 1,+ method: 'initialize',+ params: {+ protocolVersion: '2025-06-18',+ capabilities: {},+ clientInfo: { name: 'test', version: '1' }+ }+}++async function transport(instance: ReturnType<typeof manager>): Promise<MCPTransport> {+ const result = await instance.resolveTransport(undefined)+ if ('error' in result) throw new Error(result.error)+ return result+}++async function initialized(instance: ReturnType<typeof manager>) {+ const connection = await transport(instance)+ const response = await connection.handleRequest(request(initialize))+ expect(response.status).toBe(200)+ const id = response.headers.get('mcp-session-id')+ if (!id) throw new Error('Missing session id')+ return { connection, id }+}++describe('MCP session lifecycle', () => {+ test('registration and SDK connection failures release reservations and close resources', async () => {+ const close = spyOn(McpServer.prototype, 'close')+ const connect = spyOn(McpServer.prototype, 'connect')+ try {+ const broken = manager({+ registerTools: () => {+ throw new Error('registration failed')+ }+ })+ for (let i = 0; i < 12; i++) {+ const result = await broken.resolveTransport(undefined).catch((error: unknown) => error)+ expect(result).toEqual(new Error('registration failed'))+ }+ expect(close).toHaveBeenCalledTimes(12)+ const instance = manager()+ connect.mockRejectedValueOnce(new Error('connect failed'))+ const result = await instance.resolveTransport(undefined).catch((error: unknown) => error)+ expect(result).toEqual(new Error('connect failed'))+ expect(close).toHaveBeenCalledTimes(13)+ await initialized(instance)+ } finally {+ connect.mockRestore()+ close.mockRestore()+ }+ })++ test('shutdown during SDK connection closes the allocation without publishing a session', async () => {+ const release = deferred<undefined>()+ const connect = spyOn(McpServer.prototype, 'connect').mockImplementationOnce(async () => {+ await release.promise+ })+ try {+ const instance = manager()+ const creating = instance.resolveTransport(undefined)+ const closing = instance.clear()+ release.resolve(undefined)+ expect(await creating).toEqual({ error: 'closed' })+ await closing+ expect(await instance.resolveTransport(undefined)).toEqual({ error: 'closed' })+ } finally {+ release.resolve(undefined)+ connect.mockRestore()+ }+ })+ test('rejected requests do not consume session slots', async () => {+ const instance = manager()+ for (let i = 0; i < 12; i++) {+ const connection = await transport(instance)+ const response = await connection.handleRequest(+ new Request('http://localhost/mcp', {+ headers: { accept: 'text/event-stream' }+ })+ )+ expect(response.status).toBe(400)+ }+ await initialized(instance)+ })++ test('JSON-RPC initialization errors release their allocated session', async () => {+ const ended: string[] = []+ const instance = manager({+ onSessionClosed: (id) => {+ ended.push(id)+ }+ })+ for (let i = 0; i < 12; i++) {+ const connection = await transport(instance)+ await connection.handleRequest(request({ ...initialize, params: { protocolVersion: 42 } }))+ }+ expect(ended).toHaveLength(0)+ await initialized(instance)+ })++ test('concurrent initializations respect capacity and DELETE permits repeated reconnects', async () => {+ const instance = manager()+ const results = await Promise.all(+ Array.from({ length: 12 }, () => instance.resolveTransport(undefined))+ )+ const connections = results.filter((result): result is MCPTransport => !('error' in result))+ expect(connections).toHaveLength(10)+ expect(results.filter((result) => 'error' in result)).toHaveLength(2)+ for (const connection of connections) {+ const response = await connection.handleRequest(request(initialize))+ const id = response.headers.get('mcp-session-id')+ if (!id) throw new Error('Missing session id')+ await instance.deleteSession(id)+ }+ for (let i = 0; i < 12; i++) {+ const { id } = await initialized(instance)+ await instance.deleteSession(id)+ expect(instance.getExistingTransport(id)).toEqual({ error: 'not_found' })+ }+ })++ test('counts resources still closing until cleanup completes', async () => {+ const instance = manager()+ const connections = await Promise.all(Array.from({ length: 10 }, () => initialized(instance)))+ const first = connections[0]+ if (!first) throw new Error('Missing session')+ const release = deferred<undefined>()+ const originalClose = first.connection.close+ const close = spyOn(first.connection, 'close').mockImplementationOnce(async () => {+ await release.promise+ await originalClose()+ })+ try {+ const closing = instance.deleteSession(first.id)+ expect(await instance.resolveTransport(undefined)).toEqual({ error: 'too_many' })+ release.resolve(undefined)+ await closing+ await initialized(instance)+ } finally {+ release.resolve(undefined)+ close.mockRestore()+ }+ })+})++function deferred<T>() {+ let resolve: (value: T) => void = () => undefined+ const promise = new Promise<T>((done) => {+ resolve = done+ })+ return { promise, resolve }+}++describe('MCP idle expiration', () => {+ test('completed cancelled tools do not pin sessions or send a JSON-RPC response', async () => {+ const started = deferred<undefined>()+ const finish = deferred<undefined>()+ const instance = manager({+ sessionIdleTimeoutMs: 1000,+ registerTools: (server, agentSession, onToolSettled) =>+ registerTools(server, {+ policy: { allowEval: false, disabledTools: [], scope: 'document' },+ agentSession,+ onToolSettled,+ sendRPC: async () => {+ started.resolve(undefined)+ await finish.promise+ return { ok: true, result: { id: 'page', name: 'Page' } }+ }+ })+ })+ const { connection, id } = await initialized(instance)+ const pending = connection.handleRequest(+ request(+ {+ jsonrpc: '2.0',+ id: 2,+ method: 'tools/call',+ params: { name: 'get_current_page', arguments: {} }+ },+ id+ )+ )+ await started.promise+ try {+ const cancelled = await connection.handleRequest(+ request(+ {+ jsonrpc: '2.0',+ method: 'notifications/cancelled',+ params: { requestId: 2 }+ },+ id+ )+ )+ expect(cancelled.status).toBe(202)+ const clockWhileRunning = spyOn(Date, 'now').mockReturnValue(Date.now() + 10_000)+ try {+ expect(instance.getExistingTransport(id)).toBe(connection)+ } finally {+ clockWhileRunning.mockRestore()+ }+ finish.resolve(undefined)+ const response = await pending+ expect(response.status).toBe(202)+ expect(await response.text()).toBe('')+ const ping = await connection.handleRequest(+ request({ jsonrpc: '2.0', id: 3, method: 'ping' }, id)+ )+ expect(ping.status).toBe(200)+ const clock = spyOn(Date, 'now').mockReturnValue(Date.now() + 1001)+ try {+ expect(instance.getExistingTransport(id)).toEqual({ error: 'not_found' })+ } finally {+ clock.mockRestore()+ }+ } finally {+ finish.resolve(undefined)+ await instance.clear()+ await pending+ }+ })++ test.each(['DELETE', 'shutdown'])(+ '%s closes pending HTTP requests and aborts SDK handlers',+ async (action) => {+ const started = deferred<AbortSignal>()+ const finish = deferred<undefined>()+ const instance = manager({+ registerTools: (server) => {+ server.registerTool('wait', {}, async (context) => {+ started.resolve(context.mcpReq.signal)+ await finish.promise+ return { content: [] }+ })+ }+ })+ const { connection, id } = await initialized(instance)+ const pending = connection.handleRequest(+ request(+ {+ jsonrpc: '2.0',+ id: 2,+ method: 'tools/call',+ params: { name: 'wait', arguments: {} }+ },+ id+ )+ )+ const signal = await started.promise+ try {+ if (action === 'DELETE') {+ const response = await connection.handleRequest(+ new Request('http://localhost/mcp', {+ method: 'DELETE',+ headers: { 'mcp-session-id': id }+ })+ )+ expect(response.status).toBe(200)+ await instance.deleteSession(id)+ } else {+ await instance.clear()+ }+ expect(signal.aborted).toBe(true)+ expect((await pending).status).toBe(404)+ } finally {+ finish.resolve(undefined)+ }+ }+ )++ test('reclaims abandoned sessions in the background without another allocation', async () => {+ const ended = deferred<string>()+ const instance = manager({ sessionIdleTimeoutMs: 20, onSessionClosed: ended.resolve })+ const { id } = await initialized(instance)+ const clock = spyOn(Date, 'now').mockReturnValue(Date.now() + 100)+ try {+ expect(await ended.promise).toBe(id)+ expect(instance.getExistingTransport(id)).toEqual({ error: 'not_found' })+ await initialized(instance)+ } finally {+ clock.mockRestore()+ }+ })++ test('expires an existing ID before touching it, and permits disabling expiration', async () => {+ const instance = manager({ sessionIdleTimeoutMs: 20 })+ const persistent = manager({ sessionIdleTimeoutMs: 0 })+ const expired = await initialized(instance)+ const retained = await initialized(persistent)+ const clock = spyOn(Date, 'now').mockReturnValue(Date.now() + 1_000_000)+ try {+ expect(instance.getExistingTransport(expired.id)).toEqual({ error: 'not_found' })+ expect(persistent.getExistingTransport(retained.id)).toBe(retained.connection)+ } finally {+ clock.mockRestore()+ }+ })++ test('protects a pending tool call and starts its idle lifetime at completion', async () => {+ const started = deferred<undefined>()+ const finish = deferred<undefined>()+ const instance = manager({+ sessionIdleTimeoutMs: 1000,+ registerTools: (server) => {+ server.registerTool('wait', {}, async () => {+ started.resolve(undefined)+ await finish.promise+ return { content: [] }+ })+ }+ })+ const { connection, id } = await initialized(instance)+ const disconnect = new AbortController()+ const response = connection.handleRequest(+ new Request(+ request(+ {+ jsonrpc: '2.0',+ id: 2,+ method: 'tools/call',+ params: { name: 'wait', arguments: {} }+ },+ id+ ),+ { signal: disconnect.signal }+ )+ )+ await started.promise+ disconnect.abort()+ const future = Date.now() + 10_000+ const clock = spyOn(Date, 'now').mockReturnValue(future)+ try {+ expect(instance.getExistingTransport(id)).toBe(connection)+ finish.resolve(undefined)+ expect((await response).status).toBe(200)+ clock.mockReturnValue(future + 999)+ expect(instance.getExistingTransport(id)).toBe(connection)+ clock.mockReturnValue(future + 1000)+ expect(instance.getExistingTransport(id)).toEqual({ error: 'not_found' })+ } finally {+ finish.resolve(undefined)+ clock.mockRestore()+ }+ })++ test('SSE disconnection preserves the session, while idle expiration closes its stream', async () => {+ const instance = manager({ sessionIdleTimeoutMs: 1000 })+ const { connection, id } = await initialized(instance)+ const get = () =>+ connection.handleRequest(+ new Request('http://localhost/mcp', {+ headers: { accept: 'text/event-stream', 'mcp-session-id': id }+ })+ )+ const first = await get()+ await first.body?.cancel()+ expect(instance.getExistingTransport(id)).toBe(connection)+ const ping = await connection.handleRequest(+ request({ jsonrpc: '2.0', id: 2, method: 'ping' }, id)+ )+ expect(ping.status).toBe(200)+ const second = await get()+ const reader = second.body?.getReader()+ if (!reader) throw new Error('Missing SSE stream')+ const clock = spyOn(Date, 'now').mockReturnValue(Date.now() + 1000)+ try {+ expect(instance.getExistingTransport(id)).toEqual({ error: 'not_found' })+ expect((await reader.read()).done).toBe(true)+ } finally {+ clock.mockRestore()+ await reader.cancel()+ }+ })++ test('DELETE closes SSE and notifies once before capacity is reused', async () => {+ const closed: string[] = []+ const instance = manager({+ onSessionClosed: (id) => {+ closed.push(id)+ }+ })+ const { connection, id } = await initialized(instance)+ const sse = await connection.handleRequest(+ new Request('http://localhost/mcp', {+ headers: { accept: 'text/event-stream', 'mcp-session-id': id }+ })+ )+ const response = await connection.handleRequest(+ new Request('http://localhost/mcp', {+ method: 'DELETE',+ headers: { 'mcp-session-id': id }+ })+ )+ await instance.deleteSession(id)+ expect(response.status).toBe(200)+ expect(closed).toEqual([id])+ expect(instance.getExistingTransport(id)).toEqual({ error: 'not_found' })+ expect((await sse.body?.getReader().read())?.done).toBe(true)+ await initialized(instance)+ await instance.clear()+ expect(closed.filter((value) => value === id)).toHaveLength(1)+ })+})diff --git a/tests/engine/mcp/server/index.test.ts b/tests/engine/mcp/server/index.test.tsindex 5c9fab48a..a85fc2c15 100644--- a/tests/engine/mcp/server/index.test.ts+++ b/tests/engine/mcp/server/index.test.ts@@ -144,6 +144,12 @@ describe('startServer option validation', () => {'appWaitTimeoutMs must be a safe integer')})++ test('rejects an invalid session idle timeout', async () => {+ for (const sessionIdleTimeoutMs of [-1, Number.NaN, Infinity, 1.5, 2_147_483_648]) {+ await expect(startServer({ sessionIdleTimeoutMs })).rejects.toThrow(RangeError)+ }+ })})describe('MCP server', () => {diff --git a/tests/engine/mcp/server/transport.test.ts b/tests/engine/mcp/server/transport.test.tsindex f4ed0b55f..fafee0499 100644--- a/tests/engine/mcp/server/transport.test.ts+++ b/tests/engine/mcp/server/transport.test.ts@@ -158,6 +158,83 @@ describe('MCP server unified transport', () => {// ---------------------------------------------------------------------------describe('MCP Streamable HTTP transport', () => {+ test('failed requests cannot exhaust sessions, while valid concurrent sessions retain the cap', async () => {+ const handle = await startServer({+ httpPort: 0,+ withTcp: true,+ socketPath: testSocketPath(),+ authToken: TEST_AUTH_TOKEN,+ mcpRoot: null+ })+ const url = `http://127.0.0.1:${handle.httpPort}/mcp`+ const headers = {+ Authorization: `Bearer ${TEST_AUTH_TOKEN}`,+ accept: 'application/json, text/event-stream',+ 'content-type': 'application/json'+ }+ const init = {+ jsonrpc: '2.0',+ id: 1,+ method: 'initialize',+ params: {+ protocolVersion: '2025-06-18',+ capabilities: {},+ clientInfo: { name: 'session-regression', version: '1' }+ }+ }+ try {+ for (let i = 0; i < 12; i++) {+ for (const method of ['PUT', 'PATCH', 'HEAD']) {+ const response = await fetch(url, { method, headers })+ expect(response.status).toBe(405)+ expect(response.headers.get('allow')).toBe('GET, POST, DELETE')+ await response.text()+ }+ expect((await fetch(url, { headers })).status).toBe(400)+ for (const body of [+ '{invalid',+ JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'ping' }),+ JSON.stringify({ ...init, params: { protocolVersion: 42 } })+ ]) {+ const response = await fetch(url, { method: 'POST', headers, body })+ expect([200, 400]).toContain(response.status)+ await response.text()+ }+ }+ const responses = await Promise.all(+ Array.from({ length: 12 }, () =>+ fetch(url, {+ method: 'POST',+ headers,+ body: JSON.stringify(init)+ })+ )+ )+ expect(responses.filter((response) => response.status === 200)).toHaveLength(10)+ const rejected = responses.filter((response) => response.status === 503)+ expect(rejected).toHaveLength(2)+ expect(rejected[0]?.headers.get('retry-after')).toBe('5')+ // A probe without an ID still cannot allocate, even at capacity.+ expect((await fetch(url, { headers })).status).toBe(400)+ expect((await fetch(url, { method: 'PUT', headers })).status).toBe(405)+ for (const response of responses) {+ const sessionId = response.headers.get('mcp-session-id')+ await response.text()+ if (!sessionId) continue+ const deleted = await fetch(url, {+ method: 'DELETE',+ headers: { ...headers, 'Mcp-Session-Id': sessionId }+ })+ expect(deleted.status).toBe(200)+ }+ const reconnected = await fetch(url, { method: 'POST', headers, body: JSON.stringify(init) })+ expect(reconnected.status).toBe(200)+ await reconnected.text()+ } finally {+ await handle.close()+ }+ })+test('returns JSON responses for request/response calls', async () => {if (isUnix) await mkdir(SOCKET_DIR, { recursive: true })const handle = await startServer({diff --git a/tools/checks/architecture/src/steiger-rules/support.ts b/tools/checks/architecture/src/steiger-rules/support.tsindex 2435d0afa..84c4adf6e 100644--- a/tools/checks/architecture/src/steiger-rules/support.ts+++ b/tools/checks/architecture/src/steiger-rules/support.ts@@ -66,7 +66,7 @@ export const PACKAGE_ALIAS_OWNERS: Record<string, string> = {'#dom-css-tests/': 'packages/dom-css/tests/','#vue/': 'packages/vue/','#cli/': 'packages/cli/',- '#mcp/': 'packages/mcp/src/',+ '#mcp/': 'packages/mcp/','#feedback/': 'packages/feedback/','#feedback-tests/': 'packages/feedback/tests/','#cloud/': 'packages/cloud/',