thinkpool-pair 0.7.238 → 0.7.239

package/bridge.mjs

@@ -50,6 +50,7 @@ import { validateProviderSwitch, providerSwitchPlan, BUILTIN_PROVIDER } from './
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk'
 import { z } from 'zod'
 import { readCodexDefaultModel, readCodexModels, codexConfigForMode, codexThreadCanResume } from './codex-session.mjs'
+import { withMcpSessionFactory } from './codex-mcp-http.mjs'
 import { startStructuredSession } from './runtime-session.mjs'
 import { defaultStructuredMode, shouldDeferStructuredRuntime, structuredRuntimeForCommand, structuredRuntimeMetadata, structuredRuntimeSupportsMode } from './runtime-registry.mjs'
 import { probeHermesRuntime } from './hermes-probe.mjs'
@@ -2052,7 +2053,7 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
   // own `id` (excluded) + `entry` (per-turn call counter, reset by the code-turn
   // handler). Auto-allowed by the PreToolUse gate (mcp__thinkpool__ prefix).
   // Spec: docs/specs/2026-06-28-cross-terminal-awareness.md
-  const peekServer = createSdkMcpServer({
+  const createPeekServer = () => createSdkMcpServer({
     name: 'thinkpool',
     version: '1.0.0',
     tools: [
@@ -2420,6 +2421,7 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
       )] : []),
     ],
   })
+  const peekServer = withMcpSessionFactory(createPeekServer)
   // S5 (slice 1b) — the review-lane write-block, wired into the live PreToolUse path.
   // Null for builder lanes (no reviewSliceRoots) → their toolset is UNCHANGED. For a review
   // lane, deny a mutating tool call if it targets ANY reviewed slice's worktree, allowing the

package/codex-mcp-http.mjs

@@ -6,18 +6,47 @@ import http from 'node:http'
 import { randomUUID } from 'node:crypto'
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'
 
+export function withMcpSessionFactory(createSessionServer) {
+  if (typeof createSessionServer !== 'function') throw new TypeError('MCP session factory must be a function')
+  return Object.assign(createSessionServer(), { createSessionServer })
+}
+
 export async function startCodexMcpHttp({ sdkServer, host = '127.0.0.1' } = {}) {
-  const instance = sdkServer?.instance
-  if (!instance?.connect) throw new TypeError('Codex MCP requires an SDK MCP server instance')
+  const createSessionServer = sdkServer?.createSessionServer
+  const initialInstance = sdkServer?.instance
+  if (!initialInstance?.connect || typeof createSessionServer !== 'function') {
+    throw new TypeError('Codex MCP requires an SDK MCP server and createSessionServer factory')
+  }
 
   const secretPath = `/mcp/${randomUUID()}`
-  // Stateful sessions (not stateless): a stateless transport (sessionIdGenerator
-  // undefined) 500s on the `notifications/initialized` POST that every MCP client
-  // sends right after initialize — it has no session to attach the notification to.
-  // Each connecting Codex process gets its own session id; the bridge owns one
-  // server per lane, so the in-memory session map is bounded by the live lanes.
-  const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: () => randomUUID() })
-  await instance.connect(transport)
+  // Stateful sessions are required: this SDK's stateless transport rejects the
+  // `notifications/initialized` POST sent by every MCP client. A transport is
+  // single-initialize, though, while Codex App Server -> exec fallback and Hermes
+  // crash recovery both start a new client against the same lane endpoint.
+  // Keep exactly one active child session per lane. A new initialize atomically
+  // retires the old server+transport before receiving its own isolated instance.
+  let active = null
+
+  const retireActive = async () => {
+    const current = active
+    active = null
+    if (!current) return
+    await Promise.allSettled([
+      current.instance.close(),
+      current.transport.close(),
+    ])
+  }
+
+  const beginSession = async () => {
+    await retireActive()
+    const next = createSessionServer()
+    const instance = next?.instance
+    if (!instance?.connect) throw new TypeError('Codex MCP session factory did not return an SDK MCP server instance')
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: () => randomUUID() })
+    await instance.connect(transport)
+    active = { instance, transport }
+    return active
+  }
 
   const server = http.createServer(async (req, res) => {
     if (req.url !== secretPath) {
@@ -25,7 +54,19 @@ export async function startCodexMcpHttp({ sdkServer, host = '127.0.0.1' } = {})
       return
     }
     try {
-      await transport.handleRequest(req, res)
+      const sessionId = req.headers['mcp-session-id']
+      let target = active
+      if (!sessionId) {
+        if (req.method !== 'POST') {
+          res.writeHead(400).end('missing session')
+          return
+        }
+        target = await beginSession()
+      } else if (!target?.transport?.sessionId || sessionId !== target.transport.sessionId) {
+        res.writeHead(404).end('session not found')
+        return
+      }
+      await target.transport.handleRequest(req, res)
     } catch {
       if (!res.headersSent) res.writeHead(500)
       res.end()
@@ -38,7 +79,7 @@ export async function startCodexMcpHttp({ sdkServer, host = '127.0.0.1' } = {})
       server.listen(0, host, resolve)
     })
   } catch (error) {
-    await transport.close().catch(() => {})
+    await retireActive()
     throw error
   }
   const address = server.address()
@@ -51,7 +92,7 @@ export async function startCodexMcpHttp({ sdkServer, host = '127.0.0.1' } = {})
       if (closed) return
       closed = true
       await Promise.allSettled([
-        transport.close(),
+        retireActive(),
         new Promise((resolve) => server.close(resolve)),
       ])
     },

package/hermes-isolation.mjs

@@ -4,6 +4,7 @@ import path from 'node:path'
 import { randomUUID } from 'node:crypto'
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk'
 import { startHermesSession } from './hermes-session.mjs'
+import { withMcpSessionFactory } from './codex-mcp-http.mjs'
 
 const waitFor = (predicate, timeoutMs = 25_000) => new Promise((resolve, reject) => {
   const started = Date.now()
@@ -36,10 +37,11 @@ export async function verifyHermesMcpIsolation({ rounds = 2, sessionFactory = st
       for (let i = 0; i < 2; i++) {
         const cwd = path.join(root, i === 0 ? 'alpha' : 'beta')
         fs.mkdirSync(cwd)
-        const sdkServer = createSdkMcpServer({
+        const createMarkerServer = () => createSdkMcpServer({
           name: 'thinkpool', version: '1.0.0',
           tools: [tool(markers[i], 'Synthetic ThinkPool lane-isolation marker.', {}, async () => ({ content: [{ type: 'text', text: markers[i] }] }))],
         })
+        const sdkServer = withMcpSessionFactory(createMarkerServer)
         sessions.push(sessionFactory({ cwd, lazy: true, mcpServers: { thinkpool: sdkServer }, onEvent: (event) => events[i].push(event) }))
       }
       sessions.forEach((session) => session.sendTurn('/tools'))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.238",
+  "version": "0.7.239",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {