Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript

fix(web-search): cancel upstream work on HTTP disconnect

Alfredo Lopezaa4998afb784
diff --git a/.github/workflows/ci-public.yml b/.github/workflows/ci-public.yml
index e11973d89..50c46cf80 100644
--- a/.github/workflows/ci-public.yml
+++ b/.github/workflows/ci-public.yml
@@ -127,6 +127,15 @@ jobs:
working-directory: ${{ matrix.service }}
run: npm test
+ - name: Test web-search image with isolated DNS TLS and MCP
+ if: matrix.service == 'mcp-servers/web-search'
+ working-directory: mcp-servers/web-search
+ timeout-minutes: 10
+ run: |
+ docker build -t issue198-ci-image:test .
+ web_search_image_id="$(docker image inspect issue198-ci-image:test --format '{{.Id}}')"
+ node test/run-network.mjs --image "$web_search_image_id"
+
# Typecheck against the base tsconfig (covers src + test dirs).
# This catches errors in test files that tsconfig.build.json may exclude.
#
diff --git a/mcp-servers/web-search/package-lock.json b/mcp-servers/web-search/package-lock.json
index 8c2718aca..18101764f 100644
--- a/mcp-servers/web-search/package-lock.json
+++ b/mcp-servers/web-search/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "@clerum/web-search-mcp",
- "version": "1.0.9",
+ "version": "1.0.10",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "@clerum/web-search-mcp",
- "version": "1.0.9",
+ "version": "1.0.10",
"dependencies": {
"@modelcontextprotocol/sdk": "^1.12.1",
"express": "^4.21.2"
diff --git a/mcp-servers/web-search/package.json b/mcp-servers/web-search/package.json
index a8bb32f06..a835167ac 100644
--- a/mcp-servers/web-search/package.json
+++ b/mcp-servers/web-search/package.json
@@ -1,6 +1,6 @@
{
"name": "@clerum/web-search-mcp",
- "version": "1.0.9",
+ "version": "1.0.10",
"type": "module",
"main": "dist/index.js",
"scripts": {
diff --git a/mcp-servers/web-search/src/index.ts b/mcp-servers/web-search/src/index.ts
index af15475d9..b9f988715 100644
--- a/mcp-servers/web-search/src/index.ts
+++ b/mcp-servers/web-search/src/index.ts
@@ -15,10 +15,13 @@ import express, { Request, Response } from 'express'
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'
import { randomUUID } from 'crypto'
+import { AsyncLocalStorage } from 'node:async_hooks'
import { z } from 'zod'
import { fetchPage } from './fetchPage.js'
import { FetchPageError } from './fetchPageError.js'
+const requestSignals = new AsyncLocalStorage<AbortSignal>()
+
const PORT = parseInt(process.env.PORT || '3000', 10)
const SEARCH_API_KEY = process.env.SEARCH_API_KEY || ''
@@ -194,7 +197,9 @@ function createMcpServer(): McpServer {
},
async ({ url, maxChars }: { url: string; maxChars: number }, extra) => {
try {
- const result = await fetchPage(url, maxChars, extra.signal)
+ const httpSignal = requestSignals.getStore()
+ if (!httpSignal) throw new FetchPageError('cancelled')
+ const result = await fetchPage(url, maxChars, AbortSignal.any([extra.signal, httpSignal]))
return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
} catch (error) {
const code = error instanceof FetchPageError ? error.code : 'upstream_failure'
@@ -267,6 +272,17 @@ function createMcpServer(): McpServer {
// ---------------------------------------------------------------------------
const app = express()
+// The SDK's SSE cancellation drops the response stream but does not cancel the
+// handler. Bind each HTTP request to its own signal, including shared sessions.
+app.use('/mcp', (_req, res, next) => {
+ const controller = new AbortController()
+ const onClose = () => {
+ if (!res.writableFinished) controller.abort()
+ }
+ res.once('close', onClose)
+ res.once('finish', () => res.removeListener('close', onClose))
+ requestSignals.run(controller.signal, next)
+})
const transports = new Map<string, StreamableHTTPServerTransport>()
diff --git a/mcp-servers/web-search/test/mcp.network.mjs b/mcp-servers/web-search/test/mcp.network.mjs
index 91890125b..db850a9e0 100644
--- a/mcp-servers/web-search/test/mcp.network.mjs
+++ b/mcp-servers/web-search/test/mcp.network.mjs
@@ -13,6 +13,8 @@ import { StreamableHTTPClientTransport } from '/app/node_modules/@modelcontextpr
const content = '<title>Network fixture</title><p>issue198-real-result</p>'
let trapHits = 0
let slowClosed = 0
+let slowActive = 0
+let onSlowStarted = () => {}
const sockets = new Set()
const dns = await startDnsFixture()
let lastSni
@@ -53,22 +55,27 @@ const upstream = http.createServer((req, res) => {
}
if (req.url === '/slow') {
res.writeHead(200)
+ slowActive++
res.write('first')
+ onSlowStarted()
// Intentionally active hostile upstream, not a test readiness sleep.
const interval = setInterval(() => res.write('x'), 50)
res.on('close', () => {
clearInterval(interval)
slowClosed++
+ slowActive--
})
return
}
res.end(content)
})
+const ipv6 = http.createServer((_req, res) => res.end(content))
+await new Promise(r => ipv6.listen(8080, '2606:4700::198', r))
const trap = http.createServer((_req, res) => {
trapHits++
res.end('must-not-be-read')
})
-for (const server of [upstream, trap, tlsServer])
+for (const server of [upstream, trap, tlsServer, ipv6])
server.on('connection', socket => {
sockets.add(socket)
socket.on('close', () => sockets.delete(socket))
@@ -85,6 +92,7 @@ after(async () => {
for (const socket of sockets) socket.destroy()
upstream.close()
trap.close()
+ ipv6.close()
tlsServer.close()
dns.close()
})
@@ -101,7 +109,8 @@ await new Promise((resolve, reject) => {
}
})
})
-await client.connect(new StreamableHTTPClientTransport(new URL('http://127.0.0.1:3000/mcp')))
+const transport = new StreamableHTTPClientTransport(new URL('http://127.0.0.1:3000/mcp'))
+await client.connect(transport)
const call = url =>
client.callTool({ name: 'fetch_page', arguments: { url } }, undefined, { timeout: 25000 })
const errorCode = result => {
@@ -174,3 +183,108 @@ test(
assert.equal(errorCode(result), 'upstream_failure')
}
)
+
+test(
+ 'HTTP disconnect cancels upstream without an MCP cancellation notification',
+ { timeout: 4000 },
+ async () => {
+ const started = Promise.withResolvers()
+ onSlowStarted = () => started.resolve()
+ const prior = slowClosed
+ const controller = new AbortController()
+ const response = await fetch('http://127.0.0.1:3000/mcp', {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ Accept: 'application/json, text/event-stream',
+ 'mcp-session-id': transport.sessionId,
+ },
+ body: JSON.stringify({
+ jsonrpc: '2.0',
+ id: 'disconnect',
+ method: 'tools/call',
+ params: { name: 'fetch_page', arguments: { url: 'http://11.198.0.2:8080/slow' } },
+ }),
+ signal: controller.signal,
+ })
+ assert.equal(response.status, 200)
+ await started.promise
+ controller.abort()
+ await new Promise((resolve, reject) => {
+ const limit = setTimeout(() => {
+ clearInterval(poll)
+ reject(new Error('upstream retained after disconnect'))
+ }, 1000)
+ const poll = setInterval(() => {
+ if (slowClosed > prior) {
+ clearInterval(poll)
+ clearTimeout(limit)
+ resolve()
+ }
+ }, 10)
+ })
+ onSlowStarted = () => {}
+ }
+)
+
+test('a public IPv6 literal reaches the real isolated server', async () => {
+ assert.notEqual((await call('http://[2606:4700::198]:8080/')).isError, true)
+})
+
+test(
+ 'concurrency spans sessions and cancellation affects only its own request',
+ { timeout: 6000 },
+ async () => {
+ const peer = new Client({ name: 'issue198-peer', version: '1.0' })
+ await peer.connect(new StreamableHTTPClientTransport(new URL('http://127.0.0.1:3000/mcp')))
+ const started = Promise.withResolvers()
+ onSlowStarted = () => {
+ if (slowActive === 4) started.resolve()
+ }
+ const controllers = Array.from({ length: 4 }, () => new AbortController())
+ const pending = controllers.map(controller =>
+ client
+ .callTool(
+ { name: 'fetch_page', arguments: { url: 'http://11.198.0.2:8080/slow' } },
+ undefined,
+ { signal: controller.signal, timeout: 5000 }
+ )
+ .catch(error => error)
+ )
+ try {
+ await started.promise
+ assert.equal(
+ errorCode(
+ await peer.callTool({ name: 'fetch_page', arguments: { url: 'http://11.198.0.2:8080/' } })
+ ),
+ 'busy'
+ )
+ controllers[0].abort()
+ await pending[0]
+ await new Promise((resolve, reject) => {
+ const limit = setTimeout(() => {
+ clearInterval(poll)
+ reject(new Error('cancelled request retained a slot'))
+ }, 1000)
+ const poll = setInterval(() => {
+ if (slowActive === 3) {
+ clearInterval(poll)
+ clearTimeout(limit)
+ resolve()
+ }
+ }, 10)
+ })
+ assert.notEqual(
+ (await peer.callTool({ name: 'fetch_page', arguments: { url: 'http://11.198.0.2:8080/' } }))
+ .isError,
+ true
+ )
+ assert.equal(slowActive, 3)
+ } finally {
+ onSlowStarted = () => {}
+ for (const controller of controllers) controller.abort()
+ await Promise.all(pending)
+ await peer.close()
+ }
+ }
+)
diff --git a/mcp-servers/web-search/test/run-network.mjs b/mcp-servers/web-search/test/run-network.mjs
index c031301a3..2114ec99b 100644
--- a/mcp-servers/web-search/test/run-network.mjs
+++ b/mcp-servers/web-search/test/run-network.mjs
@@ -24,97 +24,100 @@ if (
)
throw new Error('A local Docker endpoint is required')
const config = mkdtempSync(path.join(tmpdir(), 'issue198-docker-'))
-// Synthetic, one-day certificate generated locally, never committed.
-execFileSync(
- 'openssl',
- [
- 'req',
- '-x509',
- '-newkey',
- 'rsa:2048',
- '-nodes',
- '-keyout',
- path.join(config, 'fixture-key.pem'),
- '-out',
- path.join(config, 'fixture-cert.pem'),
- '-days',
- '1',
- '-subj',
- '/CN=fixture.test',
- '-addext',
- 'subjectAltName=DNS:fixture.test,DNS:rebind.test,IP:11.198.0.2',
- ],
- { stdio: 'ignore', timeout: 10000 }
-)
-const name = 'issue198-network-' + randomUUID()
-const docker = ['--host', endpoint, '--config', config]
-const args = [
- ...docker,
- 'run',
- '--rm',
- '--pull=never',
- '--name',
- name,
- '--network=none',
- '--cap-drop=ALL',
- '--cap-add=NET_ADMIN',
- '--memory=256m',
- '--cpus=1',
- '--label',
- 'evenfire.test=issue198-network',
- '--mount',
- `type=bind,src=${config},dst=/fixture-tls,readonly`,
- '-e',
- 'NODE_EXTRA_CA_CERTS=/fixture-tls/fixture-cert.pem',
-]
-for (const part of image ? ['test'] : ['dist', 'node_modules', 'test'])
- args.push(
+try {
+ // Synthetic, one-day certificate generated locally, never committed.
+ execFileSync(
+ 'openssl',
+ [
+ 'req',
+ '-x509',
+ '-newkey',
+ 'rsa:2048',
+ '-nodes',
+ '-keyout',
+ path.join(config, 'fixture-key.pem'),
+ '-out',
+ path.join(config, 'fixture-cert.pem'),
+ '-days',
+ '1',
+ '-subj',
+ '/CN=fixture.test',
+ '-addext',
+ 'subjectAltName=DNS:fixture.test,DNS:rebind.test,IP:11.198.0.2',
+ ],
+ { stdio: 'ignore', timeout: 10000 }
+ )
+ const name = 'issue198-network-' + randomUUID()
+ const docker = ['--host', endpoint, '--config', config]
+ const args = [
+ ...docker,
+ 'run',
+ '--rm',
+ '--pull=never',
+ '--name',
+ name,
+ '--network=none',
+ '--cap-drop=ALL',
+ '--cap-add=NET_ADMIN',
+ '--memory=256m',
+ '--cpus=1',
+ '--label',
+ 'evenfire.test=issue198-network',
'--mount',
- `type=bind,src=${realpathSync(path.join(root, part))},dst=/app/${part},readonly`
+ `type=bind,src=${config},dst=/fixture-tls,readonly`,
+ '-e',
+ 'NODE_EXTRA_CA_CERTS=/fixture-tls/fixture-cert.pem',
+ ]
+ for (const part of image ? ['test'] : ['dist', 'node_modules', 'test'])
+ args.push(
+ '--mount',
+ `type=bind,src=${realpathSync(path.join(root, part))},dst=/app/${part},readonly`
+ )
+ args.push(
+ image ?? 'node:24-alpine',
+ 'sh',
+ '-ec',
+ 'ip addr add 11.198.0.2/32 dev lo; ip -6 addr add 2606:4700::198/128 dev lo; test -z "$(ip -6 route show default)"; test -z "$(ip route show default)"; printf "nameserver 127.0.0.1\\n" > /etc/resolv.conf; node --test /app/test/mcp.network.mjs'
)
-args.push(
- image ?? 'node:24-alpine',
- 'sh',
- '-ec',
- 'ip addr add 11.198.0.2/32 dev lo; test -z "$(ip route show default)"; printf "nameserver 127.0.0.1\\n" > /etc/resolv.conf; node --test /app/test/mcp.network.mjs'
-)
-let child
-let timeout
-let interrupted = false
-const stop = () => {
- interrupted = true
- child?.kill('SIGTERM')
-}
-process.once('SIGINT', stop)
-process.once('SIGTERM', stop)
-try {
- child = spawn('docker', args, { stdio: 'inherit' })
- timeout = setTimeout(stop, 60000)
- const status = await new Promise((resolve, reject) => {
- child.once('error', reject)
- child.once('exit', resolve)
- })
- process.exitCode = interrupted || status !== 0 ? 1 : 0
-} finally {
- clearTimeout(timeout)
- process.removeListener('SIGINT', stop)
- process.removeListener('SIGTERM', stop)
- // Random name belongs exclusively to this invocation, including on timeout.
+ let child
+ let timeout
+ let interrupted = false
+ const stop = () => {
+ interrupted = true
+ child?.kill('SIGTERM')
+ }
+ process.once('SIGINT', stop)
+ process.once('SIGTERM', stop)
try {
- execFileSync('docker', [...docker, 'rm', '-f', name], { stdio: 'ignore', timeout: 10000 })
- } catch {
- // --rm may already have removed it. Prove absence; a Docker failure is not cleanup.
+ child = spawn('docker', args, { stdio: 'inherit' })
+ timeout = setTimeout(stop, 60000)
+ const status = await new Promise((resolve, reject) => {
+ child.once('error', reject)
+ child.once('exit', resolve)
+ })
+ process.exitCode = interrupted || status !== 0 ? 1 : 0
+ } finally {
+ clearTimeout(timeout)
+ process.removeListener('SIGINT', stop)
+ process.removeListener('SIGTERM', stop)
+ // Random name belongs exclusively to this invocation, including on timeout.
try {
- const remaining = execFileSync(
- 'docker',
- [...docker, 'ps', '-aq', '--filter', `name=^/${name}$`],
- { encoding: 'utf8', timeout: 10000 }
- ).trim()
- if (remaining) throw new Error('The test container remains after cleanup')
+ execFileSync('docker', [...docker, 'rm', '-f', name], { stdio: 'ignore', timeout: 10000 })
} catch {
- process.exitCode = 1
- console.error('Could not verify removal of the isolated test container')
+ // --rm may already have removed it. Prove absence; a Docker failure is not cleanup.
+ try {
+ const remaining = execFileSync(
+ 'docker',
+ [...docker, 'ps', '-aq', '--filter', `name=^/${name}$`],
+ { encoding: 'utf8', timeout: 10000 }
+ ).trim()
+ if (remaining) throw new Error('The test container remains after cleanup')
+ } catch {
+ process.exitCode = 1
+ console.error('Could not verify removal of the isolated test container')
+ }
}
}
+} finally {
rmSync(config, { recursive: true, force: true })
}