@swarmclawai/swarmclaw 1.5.63 → 1.5.65

package/src/lib/server/chats/clear-undo-snapshots.test.ts

@@ -0,0 +1,107 @@
+import assert from 'node:assert/strict'
+import { afterEach, describe, it } from 'node:test'
+
+import type { Message } from '@/types'
+import {
+  CLEAR_UNDO_TTL_MS,
+  __resetClearUndoSnapshotsForTests,
+  consumeClearUndoSnapshot,
+  recordClearUndoSnapshot,
+  type ClearUndoCliIds,
+} from './clear-undo-snapshots'
+
+function makeMsg(text: string): Message {
+  return { role: 'user', text, time: Date.now() }
+}
+
+const emptyCli: ClearUndoCliIds = {
+  claudeSessionId: null,
+  codexThreadId: null,
+  opencodeSessionId: null,
+  opencodeWebSessionId: null,
+  geminiSessionId: null,
+  copilotSessionId: null,
+  droidSessionId: null,
+  cursorSessionId: null,
+  qwenSessionId: null,
+  acpSessionId: null,
+  delegateResumeIds: null,
+}
+
+describe('clear-undo-snapshots', () => {
+  afterEach(() => {
+    __resetClearUndoSnapshotsForTests()
+  })
+
+  it('records and consumes a snapshot within the TTL window', () => {
+    const sessionId = 'sess_test_1'
+    const messages = [makeMsg('hello'), makeMsg('world')]
+    const { token, expiresAt } = recordClearUndoSnapshot({ sessionId, messages, cli: emptyCli })
+    assert.match(token, /^undo_/)
+    assert.ok(expiresAt > Date.now())
+    const snapshot = consumeClearUndoSnapshot({ token, sessionId })
+    assert.ok(snapshot)
+    assert.equal(snapshot.messages.length, 2)
+  })
+
+  it('single-use: a consumed snapshot cannot be consumed again', () => {
+    const sessionId = 'sess_test_2'
+    const { token } = recordClearUndoSnapshot({
+      sessionId,
+      messages: [makeMsg('hi')],
+      cli: emptyCli,
+    })
+    const first = consumeClearUndoSnapshot({ token, sessionId })
+    assert.ok(first)
+    const second = consumeClearUndoSnapshot({ token, sessionId })
+    assert.equal(second, null)
+  })
+
+  it('rejects a consume with a mismatched sessionId', () => {
+    const { token } = recordClearUndoSnapshot({
+      sessionId: 'sess_owner',
+      messages: [makeMsg('hi')],
+      cli: emptyCli,
+    })
+    const hijacked = consumeClearUndoSnapshot({ token, sessionId: 'sess_other' })
+    assert.equal(hijacked, null)
+  })
+
+  it('rejects an expired snapshot and sweeps it from the store', () => {
+    const base = 1_000_000
+    const { token } = recordClearUndoSnapshot({
+      sessionId: 'sess_expire',
+      messages: [makeMsg('stale')],
+      cli: emptyCli,
+      now: base,
+    })
+    const expired = consumeClearUndoSnapshot({
+      token,
+      sessionId: 'sess_expire',
+      now: base + CLEAR_UNDO_TTL_MS + 1,
+    })
+    assert.equal(expired, null)
+    // Same token is now gone from the store entirely
+    const again = consumeClearUndoSnapshot({ token, sessionId: 'sess_expire', now: base })
+    assert.equal(again, null)
+  })
+
+  it('preserves CLI session IDs and delegateResumeIds across record/consume', () => {
+    const cli: ClearUndoCliIds = {
+      ...emptyCli,
+      claudeSessionId: 'cs_abc',
+      codexThreadId: 'cx_def',
+      delegateResumeIds: { claudeCode: 'resume_123', codex: null },
+    }
+    const { token } = recordClearUndoSnapshot({
+      sessionId: 'sess_cli',
+      messages: [],
+      cli,
+    })
+    const snapshot = consumeClearUndoSnapshot({ token, sessionId: 'sess_cli' })
+    assert.ok(snapshot)
+    assert.equal(snapshot.cli.claudeSessionId, 'cs_abc')
+    assert.equal(snapshot.cli.codexThreadId, 'cx_def')
+    assert.equal(snapshot.cli.delegateResumeIds?.claudeCode, 'resume_123')
+  })
+})

package/src/lib/server/chats/clear-undo-snapshots.ts

@@ -0,0 +1,92 @@
+import type { Message } from '@/types'
+import { hmrSingleton } from '@/lib/shared-utils'
+import { genId } from '@/lib/id'
+
+export const CLEAR_UNDO_TTL_MS = 30_000
+const MAX_SNAPSHOTS = 200
+
+export interface ClearUndoCliIds {
+  claudeSessionId: string | null
+  codexThreadId: string | null
+  opencodeSessionId: string | null
+  opencodeWebSessionId: string | null
+  geminiSessionId: string | null
+  copilotSessionId: string | null
+  droidSessionId: string | null
+  cursorSessionId: string | null
+  qwenSessionId: string | null
+  acpSessionId: string | null
+  delegateResumeIds?: Record<string, string | null> | null
+}
+
+export interface ClearUndoSnapshot {
+  sessionId: string
+  messages: Message[]
+  cli: ClearUndoCliIds
+  createdAt: number
+  expiresAt: number
+}
+
+const snapshots = hmrSingleton(
+  'swarmclaw:clearUndoSnapshots',
+  () => new Map<string, ClearUndoSnapshot>(),
+)
+
+function sweepExpired(now: number): void {
+  if (snapshots.size === 0) return
+  for (const [token, snapshot] of snapshots) {
+    if (snapshot.expiresAt <= now) snapshots.delete(token)
+  }
+}
+
+function enforceCap(): void {
+  if (snapshots.size <= MAX_SNAPSHOTS) return
+  const entries = [...snapshots.entries()].sort((a, b) => a[1].createdAt - b[1].createdAt)
+  const excess = snapshots.size - MAX_SNAPSHOTS
+  for (let i = 0; i < excess; i++) snapshots.delete(entries[i][0])
+}
+
+export function recordClearUndoSnapshot(params: {
+  sessionId: string
+  messages: Message[]
+  cli: ClearUndoCliIds
+  now?: number
+}): { token: string; expiresAt: number } {
+  const now = typeof params.now === 'number' ? params.now : Date.now()
+  sweepExpired(now)
+  const token = `undo_${genId(8)}`
+  const expiresAt = now + CLEAR_UNDO_TTL_MS
+  snapshots.set(token, {
+    sessionId: params.sessionId,
+    messages: params.messages,
+    cli: params.cli,
+    createdAt: now,
+    expiresAt,
+  })
+  enforceCap()
+  return { token, expiresAt }
+}
+
+export function consumeClearUndoSnapshot(params: {
+  token: string
+  sessionId: string
+  now?: number
+}): ClearUndoSnapshot | null {
+  const now = typeof params.now === 'number' ? params.now : Date.now()
+  sweepExpired(now)
+  const snapshot = snapshots.get(params.token)
+  if (!snapshot) return null
+  if (snapshot.sessionId !== params.sessionId) {
+    return null
+  }
+  if (snapshot.expiresAt <= now) {
+    snapshots.delete(params.token)
+    return null
+  }
+  snapshots.delete(params.token)
+  return snapshot
+}
+
+export function __resetClearUndoSnapshotsForTests(): void {
+  snapshots.clear()
+}

package/src/lib/server/mcp-connection-pool.test.ts

@@ -0,0 +1,127 @@
+import assert from 'node:assert/strict'
+import { describe, it, beforeEach, after } from 'node:test'
+import type { McpServerConfig } from '@/types'
+import {
+  __setPoolConnector,
+  evictAllMcpClients,
+  evictMcpClient,
+  getOrConnectMcpClient,
+  isConnectionLikeError,
+  isPooled,
+  poolSize,
+} from './mcp-connection-pool'
+
+let connectCalls = 0
+let disconnectCalls = 0
+
+function server(id: string, overrides: Partial<McpServerConfig> = {}): McpServerConfig {
+  return {
+    id,
+    name: `srv-${id}`,
+    transport: 'stdio',
+    command: 'echo',
+    args: [],
+    createdAt: 0,
+    updatedAt: 0,
+    ...overrides,
+  }
+}
+
+describe('mcp-connection-pool', () => {
+  beforeEach(async () => {
+    await evictAllMcpClients()
+    connectCalls = 0
+    disconnectCalls = 0
+    __setPoolConnector({
+      connect: async () => {
+        connectCalls += 1
+        return {
+          client: { seq: connectCalls } as never,
+          transport: { seq: connectCalls } as never,
+        }
+      },
+      disconnect: async () => {
+        disconnectCalls += 1
+      },
+    })
+  })
+
+  after(() => {
+    __setPoolConnector()
+  })
+
+  it('connects once per server and reuses on subsequent calls', async () => {
+    const a = await getOrConnectMcpClient(server('a'))
+    const b = await getOrConnectMcpClient(server('a'))
+    assert.equal(connectCalls, 1)
+    assert.equal(a.client, b.client)
+  })
+
+  it('reconnects when the config fingerprint changes', async () => {
+    await getOrConnectMcpClient(server('a', { args: ['--v1'] }))
+    await getOrConnectMcpClient(server('a', { args: ['--v2'] }))
+    assert.equal(connectCalls, 2)
+    assert.equal(disconnectCalls, 1)
+  })
+
+  it('evictMcpClient disconnects and lets the next call reconnect', async () => {
+    await getOrConnectMcpClient(server('a'))
+    await evictMcpClient('a')
+    assert.equal(disconnectCalls, 1)
+    assert.equal(isPooled('a'), false)
+    await getOrConnectMcpClient(server('a'))
+    assert.equal(connectCalls, 2)
+  })
+
+  it('coalesces concurrent connects', async () => {
+    const [a, b] = await Promise.all([
+      getOrConnectMcpClient(server('dup')),
+      getOrConnectMcpClient(server('dup')),
+    ])
+    assert.equal(connectCalls, 1)
+    assert.equal(a.client, b.client)
+  })
+
+  it('tracks multiple distinct servers independently', async () => {
+    await getOrConnectMcpClient(server('a'))
+    await getOrConnectMcpClient(server('b'))
+    assert.equal(poolSize(), 2)
+    assert.equal(connectCalls, 2)
+  })
+
+  it('evictAll clears everything', async () => {
+    await getOrConnectMcpClient(server('a'))
+    await getOrConnectMcpClient(server('b'))
+    await evictAllMcpClients()
+    assert.equal(disconnectCalls, 2)
+    assert.equal(poolSize(), 0)
+  })
+})
+
+describe('isConnectionLikeError', () => {
+  it('returns true for known transport-level error codes', () => {
+    const err = Object.assign(new Error('epipe'), { code: 'EPIPE' })
+    assert.equal(isConnectionLikeError(err), true)
+    const err2 = Object.assign(new Error('reset'), { code: 'ECONNRESET' })
+    assert.equal(isConnectionLikeError(err2), true)
+  })
+
+  it('returns true on connection-closed messages', () => {
+    assert.equal(isConnectionLikeError(new Error('Connection closed')), true)
+    assert.equal(isConnectionLikeError(new Error('MCP server not connected')), true)
+    assert.equal(isConnectionLikeError(new Error('child process exited')), true)
+    assert.equal(isConnectionLikeError(new Error('socket hang up')), true)
+  })
+
+  it('returns false for ordinary tool-level errors', () => {
+    assert.equal(isConnectionLikeError(new Error('GitHub token is invalid')), false)
+    assert.equal(isConnectionLikeError(new Error('File not found: /nope')), false)
+    assert.equal(isConnectionLikeError(new Error('schema validation failed')), false)
+  })
+
+  it('returns false for non-error inputs', () => {
+    assert.equal(isConnectionLikeError(null), false)
+    assert.equal(isConnectionLikeError(undefined), false)
+    assert.equal(isConnectionLikeError(''), false)
+  })
+})

package/src/lib/server/mcp-connection-pool.ts

@@ -0,0 +1,150 @@
+import type { McpServerConfig } from '@/types'
+import { hmrSingleton } from '@/lib/shared-utils'
+import { connectMcpServer, disconnectMcpServer } from './mcp-client'
+
+/**
+ * Long-lived MCP client pool. Pre-connection took ~100–500 ms per downstream
+ * per turn; that's multiplied by (servers × chat turns) for every agent.
+ * The pool reuses a single Client/transport per server for the whole process
+ * lifetime, re-connecting only when the server's config fingerprint changes
+ * or when an explicit evict is requested (e.g. from the `/test` endpoint).
+ *
+ * State lives on `globalThis` via hmrSingleton so Next.js HMR reloads don't
+ * leak child processes (see CLAUDE.md §"hmrSingleton").
+ */
+
+interface PoolEntry {
+  client: Awaited<ReturnType<typeof connectMcpServer>>['client']
+  transport: Awaited<ReturnType<typeof connectMcpServer>>['transport']
+  configFingerprint: string
+  connectedAt: number
+}
+
+type Connector = (config: McpServerConfig) => Promise<{
+  client: PoolEntry['client']
+  transport: PoolEntry['transport']
+}>
+
+type Disconnector = (client: PoolEntry['client'], transport: PoolEntry['transport']) => Promise<void>
+
+interface PoolState {
+  entries: Map<string, PoolEntry>
+  inflight: Map<string, Promise<PoolEntry>>
+  connector: Connector
+  disconnector: Disconnector
+}
+
+const pool = hmrSingleton<PoolState>('mcpConnectionPool', () => ({
+  entries: new Map<string, PoolEntry>(),
+  inflight: new Map<string, Promise<PoolEntry>>(),
+  connector: connectMcpServer,
+  disconnector: disconnectMcpServer,
+}))
+
+/**
+ * Test-only hook. Swap the connect/disconnect functions with a fake so tests
+ * can exercise pool behavior (caching, fingerprinting, coalescing, eviction)
+ * without spawning child processes. Pass `undefined` to restore defaults.
+ */
+export function __setPoolConnector(opts: {
+  connect?: Connector
+  disconnect?: Disconnector
+} = {}): void {
+  pool.connector = opts.connect ?? connectMcpServer
+  pool.disconnector = opts.disconnect ?? disconnectMcpServer
+}
+
+function configFingerprint(c: McpServerConfig): string {
+  return JSON.stringify({
+    t: c.transport,
+    cmd: c.command,
+    args: c.args,
+    cwd: c.cwd,
+    url: c.url,
+    env: c.env,
+    headers: c.headers,
+  })
+}
+
+export async function getOrConnectMcpClient(
+  config: McpServerConfig,
+): Promise<{ client: PoolEntry['client']; transport: PoolEntry['transport'] }> {
+  const existing = pool.entries.get(config.id)
+  const fp = configFingerprint(config)
+  if (existing && existing.configFingerprint === fp) {
+    return { client: existing.client, transport: existing.transport }
+  }
+  // Config changed (or first connect) — drop any stale entry.
+  if (existing) {
+    await safeDisconnect(existing)
+    pool.entries.delete(config.id)
+  }
+  // Coalesce concurrent connect attempts for the same server id.
+  const inflight = pool.inflight.get(config.id)
+  if (inflight) {
+    const entry = await inflight
+    return { client: entry.client, transport: entry.transport }
+  }
+  const promise = (async () => {
+    const { client, transport } = await pool.connector(config)
+    const entry: PoolEntry = {
+      client,
+      transport,
+      configFingerprint: fp,
+      connectedAt: Date.now(),
+    }
+    pool.entries.set(config.id, entry)
+    return entry
+  })()
+  pool.inflight.set(config.id, promise)
+  try {
+    const entry = await promise
+    return { client: entry.client, transport: entry.transport }
+  } finally {
+    pool.inflight.delete(config.id)
+  }
+}
+
+export async function evictMcpClient(serverId: string): Promise<void> {
+  const entry = pool.entries.get(serverId)
+  if (!entry) return
+  pool.entries.delete(serverId)
+  await safeDisconnect(entry)
+}
+
+export async function evictAllMcpClients(): Promise<void> {
+  const ids = Array.from(pool.entries.keys())
+  await Promise.all(ids.map((id) => evictMcpClient(id)))
+}
+
+export function poolSize(): number {
+  return pool.entries.size
+}
+
+export function isPooled(serverId: string): boolean {
+  return pool.entries.has(serverId)
+}
+
+async function safeDisconnect(entry: PoolEntry): Promise<void> {
+  try {
+    await pool.disconnector(entry.client, entry.transport)
+  } catch {
+    /* ignore — we're tearing down anyway */
+  }
+}
+
+/**
+ * Heuristic: does this error look like the pooled connection is dead (vs. a
+ * normal tool-level error the caller should surface)? Conservative by design —
+ * we only evict on well-known transport-level signatures so a "your API key is
+ * wrong" error from an MCP tool doesn't force a reconnect storm.
+ */
+export function isConnectionLikeError(err: unknown): boolean {
+  if (!err) return false
+  const code = typeof err === 'object' && err && 'code' in err ? String((err as { code: unknown }).code ?? '') : ''
+  if (code && /^(ECONNREFUSED|ECONNRESET|EPIPE|EHOSTUNREACH|ETIMEDOUT|ENOTFOUND|ECONNABORTED)$/i.test(code)) {
+    return true
+  }
+  const msg = err instanceof Error ? err.message : String(err)
+  return /connection closed|transport closed|server has closed|process exited|child exited|mcp server not connected|read ECONN|write EPIPE|socket hang up|stream closed|unexpected end of (?:json|input|stream)/i.test(msg)
+}

package/src/lib/server/mcp-gateway-runtime.test.ts

@@ -0,0 +1,177 @@
+import assert from 'node:assert/strict'
+import { describe, it, beforeEach } from 'node:test'
+import type { McpServerConfig } from '@/types'
+import {
+  getPromoter,
+  clearPromoter,
+  recordDiscoveredTools,
+  searchDiscoveredTools,
+  shouldExposeMcpTool,
+  SessionToolPromoter,
+  type DiscoveredTool,
+} from './mcp-gateway-runtime'
+
+function baseServer(overrides: Partial<McpServerConfig> = {}): McpServerConfig {
+  return {
+    id: 'srv_1',
+    name: 'fs',
+    transport: 'stdio',
+    command: 'npx',
+    args: ['-y', 'thing'],
+    createdAt: 0,
+    updatedAt: 0,
+    ...overrides,
+  }
+}
+
+describe('SessionToolPromoter', () => {
+  it('remembers promoted names', () => {
+    const p = new SessionToolPromoter()
+    assert.equal(p.allow('mcp_fs_read'), false)
+    p.promote('mcp_fs_read')
+    assert.equal(p.allow('mcp_fs_read'), true)
+    assert.deepEqual(p.promoted(), ['mcp_fs_read'])
+  })
+
+  it('clears', () => {
+    const p = new SessionToolPromoter()
+    p.promoteMany(['a', 'b'])
+    p.clear()
+    assert.deepEqual(p.promoted(), [])
+  })
+})
+
+describe('getPromoter', () => {
+  it('returns a stable instance per sessionId', () => {
+    const s1 = 'sess_' + Math.random().toString(36).slice(2)
+    const s2 = 'sess_' + Math.random().toString(36).slice(2)
+    const p1 = getPromoter(s1)
+    const p2 = getPromoter(s2)
+    const p1Again = getPromoter(s1)
+    assert.equal(p1, p1Again)
+    assert.notEqual(p1, p2)
+    clearPromoter(s1)
+    clearPromoter(s2)
+  })
+})
+
+describe('shouldExposeMcpTool', () => {
+  it('binds everything when alwaysExpose is undefined (back-compat)', () => {
+    const server = baseServer()
+    assert.equal(
+      shouldExposeMcpTool({
+        server,
+        toolName: 'read',
+        langChainName: 'mcp_fs_read',
+      }),
+      true,
+    )
+  })
+
+  it('respects alwaysExpose: false unless promoted', () => {
+    const server = baseServer({ alwaysExpose: false })
+    assert.equal(
+      shouldExposeMcpTool({
+        server,
+        toolName: 'read',
+        langChainName: 'mcp_fs_read',
+      }),
+      false,
+    )
+    const promoter = new SessionToolPromoter()
+    promoter.promote('mcp_fs_read')
+    assert.equal(
+      shouldExposeMcpTool({
+        server,
+        toolName: 'read',
+        langChainName: 'mcp_fs_read',
+        promoter,
+      }),
+      true,
+    )
+  })
+
+  it('honors string[] allowlist by bare tool name', () => {
+    const server = baseServer({ alwaysExpose: ['read'] })
+    assert.equal(
+      shouldExposeMcpTool({
+        server,
+        toolName: 'read',
+        langChainName: 'mcp_fs_read',
+      }),
+      true,
+    )
+    assert.equal(
+      shouldExposeMcpTool({
+        server,
+        toolName: 'write',
+        langChainName: 'mcp_fs_write',
+      }),
+      false,
+    )
+  })
+
+  it('per-agent mcpEagerTools overrides server policy', () => {
+    const server = baseServer({ alwaysExpose: false })
+    assert.equal(
+      shouldExposeMcpTool({
+        server,
+        toolName: 'read',
+        langChainName: 'mcp_fs_read',
+        agentEagerTools: ['read'],
+      }),
+      true,
+    )
+  })
+})
+
+describe('searchDiscoveredTools', () => {
+  const discovered: DiscoveredTool[] = [
+    {
+      name: 'read_file',
+      langChainName: 'mcp_fs_read_file',
+      description: 'Read a file from disk',
+      serverId: 's1',
+      serverName: 'fs',
+    },
+    {
+      name: 'list_issues',
+      langChainName: 'mcp_github_list_issues',
+      description: 'List GitHub issues in a repository',
+      serverId: 's2',
+      serverName: 'github',
+    },
+    {
+      name: 'run_sql',
+      langChainName: 'mcp_db_run_sql',
+      description: 'Execute a SQL query against Postgres',
+      serverId: 's3',
+      serverName: 'db',
+    },
+  ]
+
+  beforeEach(() => {
+    for (const t of discovered) {
+      recordDiscoveredTools(t.serverId, [t])
+    }
+  })
+
+  it('matches on bare tool name substring', () => {
+    const matches = searchDiscoveredTools('read_file')
+    assert.equal(matches[0]?.name, 'mcp_fs_read_file')
+  })
+
+  it('matches on description keywords', () => {
+    const matches = searchDiscoveredTools('github issues')
+    assert.equal(matches[0]?.name, 'mcp_github_list_issues')
+  })
+
+  it('returns empty for empty query', () => {
+    assert.deepEqual(searchDiscoveredTools(''), [])
+  })
+
+  it('honors limit', () => {
+    const matches = searchDiscoveredTools('read list run', 2)
+    assert.ok(matches.length <= 2)
+  })
+})