@zooid/context-mcp 0.12.0 → 0.14.0

package/src/daemon-socket.ts

@@ -1,15 +1,23 @@
 import { createServer, createConnection, type Server, type Socket } from 'node:net'
 import { unlink } from 'node:fs/promises'
 import type { SpawnRegistry } from './spawn-registry.js'
+import type { CompleteTaskInput, StartTasksInput } from '@zooid/core'
+import { agentSocketPath } from './socket-paths.js'
 
-interface DaemonRequest {
-  spawnId: string
+export interface DaemonRequest {
+  spawnId?: string
+  acpSessionId?: string
   method:
     | 'getRoomHistory'
     | 'getRecentThreads'
     | 'getThreadHistory'
     | 'getChannelMembers'
-    | 'getChannelInfo'
+    | 'getRoomInfo'
+    | 'getRooms'
+    | 'sendMessage'
+    | 'startTasks'
+    | 'completeTask'
+    | 'describeRole'
   params: Record<string, unknown>
 }
 
@@ -27,12 +35,33 @@ export interface DaemonSocketHandle {
   close(): Promise<void>
 }
 
+export interface AgentSocketsHandle {
+  /** Agent → host socket path. A missing path means its listener failed. */
+  paths: Record<string, string | undefined>
+  close(): Promise<void>
+}
+
+/** Same wire error for absent and foreign bindings, so sockets are not an ID oracle. */
+const NOT_OWNED = 'binding not owned by caller'
+
 export async function startDaemonSocketServer(opts: {
   sockPath: string
   registry: SpawnRegistry
+  /** The only agent whose bindings this listener may serve. */
+  agentName: string
 }): Promise<DaemonSocketHandle> {
   await unlink(opts.sockPath).catch(() => {})
+  // net.Server.close() waits for every open connection and — unlike
+  // http.Server since Node 19 — never destroys idle ones, and there is no
+  // closeAllConnections() for it. The clients here are context-mcp servers
+  // spawned beside each agent, which outlive AcpClient.stop() (it SIGTERMs
+  // the agent without waiting, and these are its grandchildren). So without
+  // tracking them, close() hangs until they happen to die — which is what
+  // made `zooid dev` take ages to stop.
+  const open = new Set<Socket>()
   const server: Server = createServer((socket: Socket) => {
+    open.add(socket)
+    socket.on('close', () => open.delete(socket))
     let buf = ''
     socket.setEncoding('utf8')
     socket.on('data', async (chunk) => {
@@ -42,7 +71,7 @@ export async function startDaemonSocketServer(opts: {
         const line = buf.slice(0, idx)
         buf = buf.slice(idx + 1)
         if (!line) continue
-        await handleLine(line, socket, opts.registry)
+        await handleLine(line, socket, opts.registry, opts.agentName)
       }
     })
     socket.on('error', () => {})
@@ -58,33 +87,61 @@ export async function startDaemonSocketServer(opts: {
     close: () =>
       new Promise<void>((resolve) => {
         server.close(() => resolve())
+        // Shutdown is already tearing the agents down, so there is no
+        // in-flight request worth waiting for. Drop the connections that
+        // would otherwise keep close() pending forever.
+        for (const socket of open) socket.destroy()
+        open.clear()
       }),
   }
 }
 
-async function handleLine(line: string, socket: Socket, registry: SpawnRegistry) {
+async function handleLine(
+  line: string,
+  socket: Socket,
+  registry: SpawnRegistry,
+  callerAgent: string,
+) {
   let req: DaemonRequest
   try {
     req = JSON.parse(line) as DaemonRequest
   } catch {
-    socket.write(JSON.stringify({ ok: false, error: 'invalid json' } satisfies DaemonError) + '\n')
+    socket.write(
+      JSON.stringify({
+        ok: false,
+        error: 'invalid json',
+      } satisfies DaemonError) + '\n',
+    )
     return
   }
-  const binding = registry.get(req.spawnId)
+  const binding = req.spawnId
+    ? registry.get(req.spawnId)
+    : req.acpSessionId
+      ? registry.getByAcpSession(req.acpSessionId)
+      : undefined
   if (!binding) {
+    const address = req.acpSessionId ? `session: ${req.acpSessionId}` : `spawn-id: ${req.spawnId ?? ''}`
     process.stderr.write(
-      `[context-mcp] daemon: unknown spawn-id ${req.spawnId} for method=${req.method}\n`,
+      `[context-mcp] daemon: unknown ${address} for method=${req.method}\n`,
     )
     socket.write(
       JSON.stringify({
         ok: false,
-        error: `unknown spawn-id: ${req.spawnId}`,
+        error: NOT_OWNED,
       } satisfies DaemonError) + '\n',
     )
     return
   }
+  if (binding.agentName !== callerAgent) {
+    process.stderr.write(
+      `[context-mcp] daemon: refused ${req.method} — binding owned by ${binding.agentName}, ` +
+        `caller is ${callerAgent}\n`,
+    )
+    socket.write(JSON.stringify({ ok: false, error: NOT_OWNED } satisfies DaemonError) + '\n')
+    return
+  }
   process.stderr.write(
-    `[context-mcp] daemon: ${req.method} spawn=${req.spawnId.slice(0, 8)} agent=${binding.agentName}\n`,
+    `[context-mcp] daemon: ${req.method} spawn=${binding.spawnId.slice(0, 8)} agent=${binding.agentName}\n`,
   )
   try {
     let result: unknown
@@ -98,8 +155,41 @@ async function handleLine(line: string, socket: Socket, registry: SpawnRegistry)
       result = await binding.provider.getThreadHistory(channelId, threadId, req.params)
     } else if (req.method === 'getChannelMembers') {
       result = await binding.provider.getChannelMembers(channelId)
-    } else if (req.method === 'getChannelInfo') {
-      result = await binding.provider.getChannelInfo(channelId)
+    } else if (req.method === 'getRoomInfo') {
+      result = await binding.provider.getRoomInfo(channelId)
+    } else if (req.method === 'getRooms') {
+      result = await binding.provider.getRooms()
+    } else if (req.method === 'sendMessage') {
+      result = await binding.provider.sendMessage(
+        req.params as unknown as Parameters<typeof binding.provider.sendMessage>[0],
+      )
+    } else if (
+      req.method === 'startTasks' ||
+      req.method === 'completeTask' ||
+      req.method === 'describeRole'
+    ) {
+      const actions = registry.taskActions
+      if (!actions) {
+        socket.write(
+          JSON.stringify({
+            ok: false,
+            error: 'task actions unavailable',
+          } satisfies DaemonError) + '\n',
+        )
+        return
+      }
+      const caller = {
+        agentName: binding.agentName,
+        channelId,
+        threadRoot: binding.threadRef.threadId,
+        sessionKey: binding.sessionKey ?? binding.threadRef.threadId,
+      }
+      result =
+        req.method === 'startTasks'
+          ? await actions.startTasks(caller, req.params as unknown as StartTasksInput)
+          : req.method === 'completeTask'
+            ? await actions.completeTask(caller, req.params as unknown as CompleteTaskInput)
+            : await actions.describeRole(caller)
     } else {
       socket.write(
         JSON.stringify({
@@ -120,6 +210,43 @@ async function handleLine(line: string, socket: Socket, registry: SpawnRegistry)
   }
 }
 
+/** Start independent context listeners; a bind failure disables only that agent. */
+export async function startAgentSocketServers(opts: {
+  runDir: string
+  registry: SpawnRegistry
+  agentNames: string[]
+  listen?: (sockPath: string, agentName: string) => Promise<DaemonSocketHandle>
+}): Promise<AgentSocketsHandle> {
+  const listen =
+    opts.listen ??
+    ((sockPath: string, agentName: string) =>
+      startDaemonSocketServer({ sockPath, registry: opts.registry, agentName }))
+  const derived = opts.agentNames.map((agentName) => ({
+    agentName,
+    sockPath: agentSocketPath({ runDir: opts.runDir, agentName }),
+  }))
+  const paths: Record<string, string | undefined> = {}
+  const handles: Array<{ handle: DaemonSocketHandle; path: string }> = []
+  for (const { agentName, sockPath } of derived) {
+    try {
+      const handle = await listen(sockPath, agentName)
+      paths[agentName] = sockPath
+      handles.push({ handle, path: sockPath })
+    } catch (err) {
+      console.warn(`[context] socket bind failed for agent=${agentName}; context disabled for it:`, err)
+    }
+  }
+  return {
+    paths,
+    close: async () => {
+      for (const { handle, path } of handles) {
+        await handle.close()
+        await unlink(path).catch(() => {})
+      }
+    },
+  }
+}
+
 export async function callDaemon(sockPath: string, req: DaemonRequest): Promise<unknown> {
   return new Promise((resolve, reject) => {
     const socket = createConnection(sockPath)

package/src/factory.test.ts

@@ -82,6 +82,16 @@ describe('contextContainerMounts', () => {
     ])
   })
 
+  it('uses each agent host socket at the same container target', () => {
+    const alice = contextContainerMounts({ sockPath: '/data/run/context-alice.sock' })
+    const bob = contextContainerMounts({ sockPath: '/data/run/context-bob.sock' })
+    const aliceSocket = alice.find((mount) => mount.target === CONTEXT_CONTAINER_SOCK)!
+    const bobSocket = bob.find((mount) => mount.target === CONTEXT_CONTAINER_SOCK)!
+    expect(aliceSocket.path).not.toBe(bobSocket.path)
+    expect(aliceSocket).toMatchObject({ target: CONTEXT_CONTAINER_SOCK, mode: 'rw' })
+    expect(bobSocket.target).toBe(CONTEXT_CONTAINER_SOCK)
+  })
+
   it('defaults the bin dir to the resolved package dist on disk', () => {
     const mounts = contextContainerMounts({ sockPath: '/tmp/x.sock' })
     const binMount = mounts.find((m) => m.target === CONTEXT_CONTAINER_BIN_DIR)!

package/src/index.ts

@@ -1,6 +1,7 @@
 export { SpawnRegistry } from './spawn-registry.js'
-export { startDaemonSocketServer, callDaemon } from './daemon-socket.js'
-export type { DaemonSocketHandle } from './daemon-socket.js'
+export { startDaemonSocketServer, startAgentSocketServers, callDaemon } from './daemon-socket.js'
+export type { DaemonRequest, DaemonSocketHandle, AgentSocketsHandle } from './daemon-socket.js'
+export { agentSocketPath, SUN_PATH_MAX } from './socket-paths.js'
 export { buildContextMcpServer } from './mcp-server.js'
 export {
   buildContextServerSpec,

package/src/integration.test.ts

@@ -3,11 +3,12 @@ import { fileURLToPath } from 'node:url'
 import { dirname, join } from 'node:path'
 import { tmpdir } from 'node:os'
 import { randomUUID } from 'node:crypto'
-import { existsSync } from 'node:fs'
+import { existsSync, mkdtempSync } from 'node:fs'
 import { Client } from '@modelcontextprotocol/sdk/client/index.js'
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
 import { SpawnRegistry } from './spawn-registry.js'
-import { startDaemonSocketServer } from './daemon-socket.js'
+import { callDaemon, startAgentSocketServers, startDaemonSocketServer } from './daemon-socket.js'
+import { agentSocketPath } from './socket-paths.js'
 import type { TransportContextProvider } from '@zooid/core'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
@@ -25,7 +26,7 @@ function fakeProvider(over: Partial<TransportContextProvider> = {}): TransportCo
     getRecentThreads: async () => ({ threads: [], has_more: false }),
     getThreadHistory: async () => ({ messages: [], has_more: false }),
     getChannelMembers: async () => [],
-    getChannelInfo: async () => ({ id: 'r', name: 'r', transport: 'matrix' }),
+    getRoomInfo: async () => ({ id: 'r', name: 'r', transport: 'matrix' }),
     ...over,
   }
 }
@@ -35,7 +36,13 @@ describe.skipIf(!existsSync(BIN))('zooid-context MCP server (out-of-process)', (
     const provider = fakeProvider({
       getRoomHistory: async () => ({
         messages: [
-          { id: 'e1', sender: 'alice', text: 'hi', timestamp: 'T', is_agent: false },
+          {
+            id: 'e1',
+            sender: 'alice',
+            text: 'hi',
+            timestamp: 'T',
+            is_agent: false,
+          },
         ],
         has_more: false,
       }),
@@ -47,7 +54,7 @@ describe.skipIf(!existsSync(BIN))('zooid-context MCP server (out-of-process)', (
       provider,
     })
     const sockPath = join(tmpdir(), `zooid-it-${randomUUID()}.sock`)
-    const server = await startDaemonSocketServer({ sockPath, registry })
+    const server = await startDaemonSocketServer({ sockPath, registry, agentName: 'architect' })
     cleanup.push(() => server.close())
 
     const transport = new StdioClientTransport({
@@ -61,16 +68,24 @@ describe.skipIf(!existsSync(BIN))('zooid-context MCP server (out-of-process)', (
       await client.close()
     })
 
+    // No taskActions registered on this registry, so the daemon-side
+    // describeRole query fails, bin.ts's role stays undefined, and neither
+    // task tool registers ([[ZOD084]] role-conditional registration).
     const list = await client.listTools()
     expect(list.tools.map((t) => t.name).sort()).toEqual([
-      'zooid_get_channel_info',
       'zooid_get_history',
       'zooid_get_members',
       'zooid_get_recent_threads',
+      'zooid_get_room_info',
+      'zooid_get_rooms',
       'zooid_get_thread_history',
+      'zooid_send_message',
     ])
 
-    const result = await client.callTool({ name: 'zooid_get_history', arguments: {} })
+    const result = await client.callTool({
+      name: 'zooid_get_history',
+      arguments: {},
+    })
     const payload = JSON.parse((result.content as Array<{ text: string }>)[0].text)
     expect(payload.messages[0].id).toBe('e1')
   })
@@ -78,17 +93,41 @@ describe.skipIf(!existsSync(BIN))('zooid-context MCP server (out-of-process)', (
   it('two MCP server subprocesses sharing one socket route to their own bindings', async () => {
     const providerA = fakeProvider({
       getRoomHistory: async () => ({
-        messages: [{ id: 'A1', sender: 'alice', text: 'from A', timestamp: 'T', is_agent: false }],
+        messages: [
+          {
+            id: 'A1',
+            sender: 'alice',
+            text: 'from A',
+            timestamp: 'T',
+            is_agent: false,
+          },
+        ],
         has_more: false,
       }),
-      getChannelInfo: async () => ({ id: '!a:hs', name: 'room-A', transport: 'matrix' }),
+      getRoomInfo: async () => ({
+        id: '!a:hs',
+        name: 'room-A',
+        transport: 'matrix',
+      }),
     })
     const providerB = fakeProvider({
       getRoomHistory: async () => ({
-        messages: [{ id: 'B1', sender: 'bob', text: 'from B', timestamp: 'T', is_agent: false }],
+        messages: [
+          {
+            id: 'B1',
+            sender: 'bob',
+            text: 'from B',
+            timestamp: 'T',
+            is_agent: false,
+          },
+        ],
         has_more: false,
       }),
-      getChannelInfo: async () => ({ id: '!b:hs', name: 'room-B', transport: 'matrix' }),
+      getRoomInfo: async () => ({
+        id: '!b:hs',
+        name: 'room-B',
+        transport: 'matrix',
+      }),
     })
     const registry = new SpawnRegistry()
     const spawnA = registry.register({
@@ -97,12 +136,12 @@ describe.skipIf(!existsSync(BIN))('zooid-context MCP server (out-of-process)', (
       provider: providerA,
     })
     const spawnB = registry.register({
-      agentName: 'product-owner',
+      agentName: 'architect',
       threadRef: { channelId: '!b:hs', threadId: '!b:hs' },
       provider: providerB,
     })
     const sockPath = join(tmpdir(), `zooid-it-${randomUUID()}.sock`)
-    const server = await startDaemonSocketServer({ sockPath, registry })
+    const server = await startDaemonSocketServer({ sockPath, registry, agentName: 'architect' })
     cleanup.push(() => server.close())
 
     async function startClient(spawnId: string) {
@@ -130,9 +169,54 @@ describe.skipIf(!existsSync(BIN))('zooid-context MCP server (out-of-process)', (
     expect(payloadA.messages[0].id).toBe('A1')
     expect(payloadB.messages[0].id).toBe('B1')
 
-    const infoA = await clientA.callTool({ name: 'zooid_get_channel_info', arguments: {} })
-    const infoB = await clientB.callTool({ name: 'zooid_get_channel_info', arguments: {} })
+    const infoA = await clientA.callTool({
+      name: 'zooid_get_room_info',
+      arguments: {},
+    })
+    const infoB = await clientB.callTool({
+      name: 'zooid_get_room_info',
+      arguments: {},
+    })
     expect(JSON.parse((infoA.content as Array<{ text: string }>)[0].text).id).toBe('!a:hs')
     expect(JSON.parse((infoB.content as Array<{ text: string }>)[0].text).id).toBe('!b:hs')
   })
 })
+
+describe('per-agent sockets (integration)', () => {
+  it('isolates two agents sharing a registry', async () => {
+    const registry = new SpawnRegistry()
+    const aliceSpawn = registry.register({
+      agentName: 'alice',
+      threadRef: { channelId: '!alice:hs', threadId: 'a' },
+      provider: fakeProvider({ getRoomInfo: async () => ({ id: '!alice:hs', name: 'alice', transport: 'matrix' }) }),
+    })
+    const bobSpawn = registry.register({
+      agentName: 'bob',
+      threadRef: { channelId: '!bob:hs', threadId: 'b' },
+      provider: fakeProvider({ getRoomInfo: async () => ({ id: '!bob:hs', name: 'bob', transport: 'matrix' }) }),
+    })
+    const runDir = mkdtempSync(join(tmpdir(), 'zooid-run-'))
+    const sockets = await startAgentSocketServers({ runDir, registry, agentNames: ['alice', 'bob'] })
+    cleanup.push(() => sockets.close())
+    expect(sockets.paths.alice).toBe(agentSocketPath({ runDir, agentName: 'alice' }))
+    await expect(callDaemon(sockets.paths.alice!, { spawnId: aliceSpawn, method: 'getRoomInfo', params: {} })).resolves.toMatchObject({ id: '!alice:hs' })
+    await expect(callDaemon(sockets.paths.bob!, { spawnId: aliceSpawn, method: 'getRoomInfo', params: {} })).rejects.toThrow(/binding not owned by caller/)
+    await expect(callDaemon(sockets.paths.bob!, { spawnId: bobSpawn, method: 'getRoomInfo', params: {} })).resolves.toMatchObject({ id: '!bob:hs' })
+  })
+
+  it('keeps other listeners serving when one bind fails', async () => {
+    const registry = new SpawnRegistry()
+    const sockets = await startAgentSocketServers({
+      runDir: mkdtempSync(join(tmpdir(), 'zooid-run-')),
+      registry,
+      agentNames: ['alice', 'bob'],
+      listen: async (path, name) => {
+        if (name === 'bob') throw new Error('EADDRINUSE')
+        return startDaemonSocketServer({ sockPath: path, registry, agentName: name })
+      },
+    })
+    cleanup.push(() => sockets.close())
+    expect(sockets.paths.alice).toBeDefined()
+    expect(sockets.paths.bob).toBeUndefined()
+  })
+})