Skip to content

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

TypeScript

fix(web-search): recover malformed comments and inert closes

Alfredo Lopez547d66ea46d9
diff --git a/mcp-servers/web-search/README.md b/mcp-servers/web-search/README.md
index f9e749986..e3aea01d6 100644
--- a/mcp-servers/web-search/README.md
+++ b/mcp-servers/web-search/README.md
@@ -56,12 +56,17 @@ Additional calls fail immediately. `maxChars` remains the output display limit;
it is not the download limit. Redirect and error bodies are destroyed without
reading them. Encodings supported: identity, gzip, deflate and br.
-Errors expose a stable code without upstream details. Private destinations and
-oversized documents previously accepted are intentionally rejected. Text extraction
-ignores comments and non-page prose in script, style, textarea and similar
-containers. It is a bounded lightweight scan, not a browser DOM; HTML entities
-remain verbatim. Self-closing raw-text elements are recognized when the final
-response declares XML/XHTML; in HTML syntax, a trailing slash does not close them.
+Errors expose only a stable code, never upstream details: `invalid_url`,
+`invalid_max_chars`, `destination_blocked`, `redirect_limit`,
+`deadline_exceeded`, `response_too_large`, `unsupported_encoding`,
+`upstream_failure`, `busy`, `cancelled` or `internal_error`. Consumers must
+not parse the older `Error fetching page:` prefix; it no longer exists.
+Private destinations and oversized documents previously accepted are
+intentionally rejected. Text extraction ignores comments and non-page prose in
+script, style, textarea and similar containers. It is a bounded lightweight
+scan, not a browser DOM; HTML entities remain verbatim. Self-closing raw-text
+elements are recognized when the final response declares XML/XHTML; in HTML
+syntax, a trailing slash does not close them.
### Regression tests
diff --git a/mcp-servers/web-search/package-lock.json b/mcp-servers/web-search/package-lock.json
index e5020b22a..fd96b951e 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.17",
+ "version": "1.0.18",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "@clerum/web-search-mcp",
- "version": "1.0.17",
+ "version": "1.0.18",
"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 398476ed8..f15260913 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.17",
+ "version": "1.0.18",
"type": "module",
"main": "dist/index.js",
"scripts": {
diff --git a/mcp-servers/web-search/src/fetchPage.ts b/mcp-servers/web-search/src/fetchPage.ts
index ebc8211a3..d89bd228a 100644
--- a/mcp-servers/web-search/src/fetchPage.ts
+++ b/mcp-servers/web-search/src/fetchPage.ts
@@ -46,7 +46,8 @@ function closingTag(html: string, lower: string, name: string, from: number) {
while (start !== -1) {
if (/[\s>]/.test(lower[start + prefix.length] ?? '')) {
const end = tagEnd(html, start)
- return end < 0 ? undefined : { start, end }
+ // A malformed candidate is not a close; a later well-formed tag is.
+ if (end >= 0) return { start, end }
}
start = lower.indexOf(prefix, start + prefix.length)
}
@@ -70,6 +71,17 @@ function scanPage(html: string, xmlSyntax = false): { title: string; content: st
}
pieces.push(html.slice(offset, start))
if (lower.startsWith('<!--', start)) {
+ // HTML recovers <!--> and <!---> as abrupt-closing empty comments.
+ const abrupt = lower.startsWith('<!--->', start)
+ ? 6
+ : lower.startsWith('<!-->', start)
+ ? 5
+ : 0
+ if (abrupt) {
+ pieces.push(' ')
+ offset = start + abrupt
+ continue
+ }
const end = lower.indexOf('-->', start + 4)
if (end === -1) break
pieces.push(' ')
diff --git a/mcp-servers/web-search/src/fetchPageDestination.ts b/mcp-servers/web-search/src/fetchPageDestination.ts
index bd3e87f0f..b2bedc9ed 100644
--- a/mcp-servers/web-search/src/fetchPageDestination.ts
+++ b/mcp-servers/web-search/src/fetchPageDestination.ts
@@ -90,6 +90,9 @@ export async function resolvePageAddress(url: URL, signal: AbortSignal): Promise
if (!isPublicAddress(hostname)) throw new FetchPageError('destination_blocked')
return hostname
}
+ // c-ares clamps per-query timeouts below 15s on some platforms (commonly
+ // ~5s). The caller's fetch-wide absolute deadline remains the authoritative
+ // bound, so a clamped DNS failure still surfaces promptly and safely.
const resolver = new Resolver({ timeout: 15000, tries: 1 })
const cancel = () => resolver.cancel()
signal.addEventListener('abort', cancel, { once: true })
diff --git a/mcp-servers/web-search/src/fetchPageError.ts b/mcp-servers/web-search/src/fetchPageError.ts
index 1b92e215b..d028fec30 100644
--- a/mcp-servers/web-search/src/fetchPageError.ts
+++ b/mcp-servers/web-search/src/fetchPageError.ts
@@ -9,6 +9,7 @@ export type FetchPageErrorCode =
| 'upstream_failure'
| 'busy'
| 'cancelled'
+ | 'internal_error'
/** Public errors contain no upstream URL, address, response body or native error. */
export class FetchPageError extends Error {
diff --git a/mcp-servers/web-search/src/index.ts b/mcp-servers/web-search/src/index.ts
index b9f988715..eded3c05c 100644
--- a/mcp-servers/web-search/src/index.ts
+++ b/mcp-servers/web-search/src/index.ts
@@ -198,7 +198,7 @@ function createMcpServer(): McpServer {
async ({ url, maxChars }: { url: string; maxChars: number }, extra) => {
try {
const httpSignal = requestSignals.getStore()
- if (!httpSignal) throw new FetchPageError('cancelled')
+ if (!httpSignal) throw new FetchPageError('internal_error')
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) {
diff --git a/mcp-servers/web-search/test/dns-fixture.mjs b/mcp-servers/web-search/test/dns-fixture.mjs
index 801a7733a..56939bc2e 100644
--- a/mcp-servers/web-search/test/dns-fixture.mjs
+++ b/mcp-servers/web-search/test/dns-fixture.mjs
@@ -29,8 +29,9 @@ export async function startDnsFixture() {
if (type === 28 && name === 'mixed.test')
data = Buffer.from('00000000000000000000000000000001', 'hex')
}
+ const servfail = name === 'servfail.test'
const header = Buffer.from(packet.subarray(0, 12))
- header.writeUInt16BE(0x8180, 2)
+ header.writeUInt16BE(servfail ? 0x8182 : 0x8180, 2)
header.writeUInt16BE(1, 4)
header.writeUInt16BE(data ? 1 : 0, 6)
header.writeUInt32BE(0, 8)
diff --git a/mcp-servers/web-search/test/fetchPage.test.mjs b/mcp-servers/web-search/test/fetchPage.test.mjs
index 41401d6f4..52354a915 100644
--- a/mcp-servers/web-search/test/fetchPage.test.mjs
+++ b/mcp-servers/web-search/test/fetchPage.test.mjs
@@ -78,7 +78,7 @@ test('maxChars is not the byte ceiling; exact ceiling succeeds and +1 fails', as
})
test('unsupported encoding returns only a stable error', async t => {
upstream(t, [{ headers: { 'content-encoding': 'gzip, br' } }])
- await assert.rejects(fetchPage('http://8.8.8.8', 100), { message: 'unsupported_encoding' })
+ await assert.rejects(fetchPage('http://8.8.8.8', 100), { code: 'unsupported_encoding' })
})
test('linear stripping preserves malformed and ordinary text', () => {
assert.equal(pageText('a <b> c </b> d'), 'a c d')
@@ -86,6 +86,85 @@ test('linear stripping preserves malformed and ordinary text', () => {
assert.equal(pageText(input), input)
})
+test('abrupt-closing empty comments do not discard following content', () => {
+ assert.equal(pageText('<!-->KEEP-VISIBLE'), 'KEEP-VISIBLE')
+ assert.equal(pageText('<!--->KEEP-VISIBLE'), 'KEEP-VISIBLE')
+ assert.equal(pageText('<!---->KEEP-VISIBLE'), 'KEEP-VISIBLE')
+})
+
+test('a malformed inert close does not hide a later well-formed close', () => {
+ assert.equal(pageText('<script>a</script foo="bar>b</script>REAL-CONTENT'), 'REAL-CONTENT')
+ // The malformed fragment stays inside the title raw-text region, but the
+ // rest of the document is no longer discarded.
+ assert.equal(pageText('<title>t</title x</title>BODY'), 't</title x BODY')
+})
+
+test('redirect and error bodies are destroyed without reading them', async t => {
+ const responses = []
+ t.mock.method(http, 'request', (_opts, callback) => {
+ const req = new EventEmitter()
+ req.end = () =>
+ queueMicrotask(() => {
+ const response = new PassThrough()
+ const first = responses.length === 0
+ response.statusCode = first ? 302 : 500
+ response.headers = first ? { location: '/next' } : {}
+ t.mock.method(response, 'resume')
+ responses.push(response)
+ callback(response)
+ response.end('must-not-be-read')
+ })
+ return req
+ })
+ await assert.rejects(fetchPage('http://8.8.8.8', 100), { code: 'upstream_failure' })
+ assert.equal(responses.length, 2)
+ assert.deepEqual(
+ responses.map(response => ({
+ destroyed: response.destroyed,
+ resumed: response.resume.mock.callCount(),
+ })),
+ [
+ { destroyed: true, resumed: 0 },
+ { destroyed: true, resumed: 0 },
+ ]
+ )
+})
+
+test('the deadline is absolute across the redirect chain', async t => {
+ t.mock.timers.enable({ apis: ['setTimeout'] })
+ const headersDelivered = [Promise.withResolvers(), Promise.withResolvers()]
+ let connects = 0
+ t.mock.method(http, 'request', (_opts, callback) => {
+ const req = new EventEmitter()
+ const index = connects++
+ req.end = () =>
+ queueMicrotask(() => {
+ const response = new PassThrough()
+ if (index < 2) {
+ response.statusCode = 302
+ response.headers = { location: `/hop-${index}` }
+ callback(response)
+ response.end()
+ headersDelivered[index].resolve()
+ } else {
+ response.statusCode = 200
+ response.headers = {}
+ callback(response)
+ response.write('partial')
+ }
+ })
+ return req
+ })
+ const pending = fetchPage('http://8.8.8.8', 100)
+ const rejected = assert.rejects(pending, { code: 'deadline_exceeded' })
+ await headersDelivered[0].promise
+ t.mock.timers.tick(FETCH_PAGE_LIMITS.timeoutMs - 1000)
+ await headersDelivered[1].promise
+ t.mock.timers.tick(1000)
+ await rejected
+ assert.equal(connects, 3)
+})
+
test('deadline remains active after headers and destroys the body', async t => {
t.mock.timers.enable({ apis: ['setTimeout'] })
const headers = Promise.withResolvers()
diff --git a/mcp-servers/web-search/test/mcp.network.mjs b/mcp-servers/web-search/test/mcp.network.mjs
index 33ec6b7eb..75faa9270 100644
--- a/mcp-servers/web-search/test/mcp.network.mjs
+++ b/mcp-servers/web-search/test/mcp.network.mjs
@@ -133,6 +133,10 @@ test('real DNS pins a single answer and rejects mixed public/private records', a
assert.equal(dns.queries.get('rebind.test:1'), 1)
assert.equal(errorCode(await call('http://mixed.test:8080/')), 'destination_blocked')
})
+
+test('a real DNS SERVFAIL is an upstream failure', async () => {
+ assert.equal(errorCode(await call('http://servfail.test:8080/')), 'upstream_failure')
+})
test('TLS validates original host and SNI, and blocks downgrade', async () => {
assert.notEqual((await call('https://fixture.test:8443/')).isError, true)
assert.equal(lastSni, 'fixture.test')