265 lines
12 KiB
JavaScript
265 lines
12 KiB
JavaScript
// The connector gateway: one local HTTP server inside the plugin process. Every
|
|
// remote connector's mcp-client mounts `http://127.0.0.1:<port>/c/<id>` with a
|
|
// random per-process nonce, so no real credential ever reaches the mcp-client
|
|
// config. The gateway adds the credential here and streams the answer back.
|
|
// When a connector's read-only switch is on, tools/list answers are filtered to
|
|
// readOnlyHint tools and write tools/call is refused locally.
|
|
import { createServer } from 'node:http'
|
|
import { randomBytes, timingSafeEqual } from 'node:crypto'
|
|
import { request as httpsRequest } from 'node:https'
|
|
import { request as httpRequest } from 'node:http'
|
|
|
|
const FORWARD_HEADERS = ['mcp-session-id', 'mcp-protocol-version', 'last-event-id', 'accept', 'content-type']
|
|
const RETURN_HEADERS = ['content-type', 'mcp-session-id', 'mcp-protocol-version']
|
|
const RETRYABLE = new Set(['GET', 'POST', 'DELETE'])
|
|
|
|
const nonceMatches = (header, nonce) => {
|
|
const given = /^Bearer\s+(.+)$/i.exec(String(header ?? ''))?.[1] ?? ''
|
|
const a = Buffer.from(given)
|
|
const b = Buffer.from(nonce)
|
|
return a.length === b.length && timingSafeEqual(a, b)
|
|
}
|
|
|
|
const sseMessage = (body) => {
|
|
// Pull the JSON-RPC payload out of an SSE body (one or more event frames).
|
|
const frames = []
|
|
for (const block of String(body).split(/\r?\n\r?\n/)) {
|
|
const data = block.split(/\r?\n/).filter(line => line.startsWith('data:')).map(line => line.slice(5).trimStart()).join('\n')
|
|
if (data !== '') frames.push(data)
|
|
}
|
|
return frames.length === 1 ? frames[0] : null
|
|
}
|
|
|
|
// Upstreams are https; loopback HTTP is allowed for local custom servers.
|
|
const loopbackHttp = url => /^http:\/\/(127\.|localhost|::1)/i.test(String(url))
|
|
const upstreamRequest = (target, init, onResponse) =>
|
|
(target.protocol === 'http:' && loopbackHttp(target) ? httpRequest : httpsRequest)(target, init, onResponse)
|
|
|
|
const readAll = stream => new Promise((resolve, reject) => {
|
|
if (stream.errored) { reject(stream.errored); return }
|
|
const chunks = []
|
|
stream.on('data', chunk => chunks.push(chunk))
|
|
stream.on('end', () => resolve(Buffer.concat(chunks)))
|
|
stream.on('error', reject)
|
|
})
|
|
|
|
export function createGateway({ credential, readOnly, onUnauthorized, log = () => {} }) {
|
|
const nonce = randomBytes(24).toString('base64url')
|
|
let server = null
|
|
let port = 0
|
|
// Tool annotations seen in tools/list answers, per connector, for read-only checks.
|
|
const annotations = new Map()
|
|
|
|
const toolReadOnly = (id, name) => {
|
|
const flags = annotations.get(id)
|
|
return flags?.get(name) === true
|
|
}
|
|
|
|
// Marks annotations from a tools/list result, and filters it when read-only.
|
|
const processList = (id, result, filtered) => {
|
|
const tools = Array.isArray(result?.result?.tools) ? result.result.tools : null
|
|
if (tools === null) return result
|
|
let flags = annotations.get(id)
|
|
if (flags === undefined) annotations.set(id, flags = new Map())
|
|
for (const tool of tools) flags.set(tool.name, tool.annotations?.readOnlyHint === true)
|
|
if (!filtered) return result
|
|
return { ...result, result: { ...result.result, tools: tools.filter(tool => tool.annotations?.readOnlyHint === true) } }
|
|
}
|
|
|
|
const refuseCall = (id, rpc) => ({
|
|
jsonrpc: '2.0',
|
|
id: rpc?.id ?? null,
|
|
error: { code: -32600, message: `The ${id} connector is read-only: this tool can change things, so it is off. Turn off the read-only switch in Settings → Connectors to use it.` },
|
|
})
|
|
|
|
// A 401 that survives the refresh: answer the JSON-RPC request with a reason
|
|
// the Bot can act on, instead of an empty HTTP error.
|
|
const signInAgain = (id, body, upstream, res) => {
|
|
let rpc
|
|
try { rpc = JSON.parse(body?.toString('utf8') ?? '') } catch { return false }
|
|
if (rpc === null || typeof rpc !== 'object' || Array.isArray(rpc) || rpc.id === undefined) return false
|
|
upstream.resume()
|
|
res.writeHead(200, { 'content-type': 'application/json' })
|
|
res.end(JSON.stringify({
|
|
jsonrpc: '2.0', id: rpc.id,
|
|
error: { code: -32001, message: `The ${id} connector needs sign-in again. Call request_connector with id ${id} so the user can sign in, or ask them to sign in under Settings → Connectors.` },
|
|
}))
|
|
return true
|
|
}
|
|
|
|
async function sendUpstream(id, entry, method, path, headers, body) {
|
|
return new Promise((resolve, reject) => {
|
|
const target = new URL(entry.url)
|
|
const suffix = new URL(path, 'http://x')
|
|
if (suffix.pathname !== '/') {
|
|
target.pathname = `${target.pathname.replace(/\/$/, '')}/${suffix.pathname.replace(/^\//, '')}`
|
|
}
|
|
for (const [key, value] of suffix.searchParams) target.searchParams.append(key, value)
|
|
const outgoing = { ...entry.headers }
|
|
for (const name of FORWARD_HEADERS) if (headers[name] !== undefined) outgoing[name] = headers[name]
|
|
if (body !== undefined) outgoing['content-length'] = body.length
|
|
const req = upstreamRequest(target, { method, headers: outgoing }, upstream => {
|
|
// This listener must exist before refresh awaits: the response can fail
|
|
// before the handler starts consuming it.
|
|
upstream.on('error', reject)
|
|
// GET 405 is the normal answer from servers without a standalone stream.
|
|
if (upstream.statusCode >= 400 && !(method === 'GET' && upstream.statusCode === 405)) log('ds-bot: connector %s upstream %s HTTP %s (session: %s)', id, method, upstream.statusCode, headers['mcp-session-id'] !== undefined)
|
|
resolve(upstream)
|
|
})
|
|
req.on('error', reject)
|
|
if (body !== undefined) req.write(body)
|
|
req.end()
|
|
})
|
|
}
|
|
|
|
async function handle(id, req, res) {
|
|
const entry = credential(id)
|
|
if (entry === undefined) {
|
|
res.writeHead(404, { 'content-type': 'application/json' })
|
|
res.end(JSON.stringify({ error: 'connector not connected' }))
|
|
return
|
|
}
|
|
if (!/^https:\/\//i.test(entry.url) && !loopbackHttp(entry.url)) {
|
|
res.writeHead(502, { 'content-type': 'application/json' })
|
|
res.end(JSON.stringify({ error: 'connector address must be https' }))
|
|
return
|
|
}
|
|
const suffix = req.url.slice(`/c/${id}`.length)
|
|
const path = suffix === '' ? '/' : suffix
|
|
const limited = readOnly(id) === true
|
|
const body = req.method === 'GET' || req.method === 'HEAD' ? undefined : await readAll(req)
|
|
// Read-only: a write tools/call never reaches the server.
|
|
if (limited && req.method === 'POST' && body !== undefined) {
|
|
let rpc
|
|
try { rpc = JSON.parse(body.toString('utf8')) } catch { rpc = null }
|
|
if (Array.isArray(rpc)) {
|
|
// A batch could hide a write call, so read-only refuses them outright.
|
|
res.writeHead(200, { 'content-type': 'application/json' })
|
|
res.end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32600, message: `The ${id} connector is read-only: batched calls are refused.` } }))
|
|
return
|
|
}
|
|
if (rpc?.method === 'tools/call' && !toolReadOnly(id, rpc.params?.name)) {
|
|
res.writeHead(200, { 'content-type': 'application/json' })
|
|
res.end(JSON.stringify(refuseCall(id, rpc)))
|
|
return
|
|
}
|
|
if (rpc?.method === 'tools/list') {
|
|
let upstream = await sendUpstream(id, entry, req.method, path, req.headers, body)
|
|
if (upstream.statusCode === 401) {
|
|
const retried = await onUnauthorized(id)
|
|
if (retried === true) {
|
|
upstream.resume()
|
|
upstream = await sendUpstream(id, credential(id) ?? entry, req.method, path, req.headers, body)
|
|
}
|
|
}
|
|
if (upstream.statusCode === 401 && signInAgain(id, body, upstream, res)) return
|
|
const raw = await readAll(upstream)
|
|
const isSse = String(upstream.headers['content-type'] ?? '').includes('text/event-stream')
|
|
const payload = isSse ? sseMessage(raw.toString('utf8')) : raw.toString('utf8')
|
|
let out = raw
|
|
try {
|
|
const parsed = payload === null ? null : JSON.parse(payload)
|
|
if (parsed !== null) {
|
|
const filtered = JSON.stringify(processList(id, parsed, true))
|
|
out = isSse ? Buffer.from(`event: message\ndata: ${filtered}\n\n`) : Buffer.from(filtered)
|
|
}
|
|
} catch { /* pass the answer through unchanged */ }
|
|
const heads = {}
|
|
for (const name of RETURN_HEADERS) if (upstream.headers[name] !== undefined) heads[name] = upstream.headers[name]
|
|
if (!isSse) heads['content-length'] = out.length
|
|
else delete heads['content-length']
|
|
res.writeHead(upstream.statusCode ?? 502, heads)
|
|
res.end(out)
|
|
return
|
|
}
|
|
}
|
|
if (!RETRYABLE.has(req.method)) {
|
|
res.writeHead(405, { 'content-type': 'application/json' })
|
|
res.end(JSON.stringify({ error: 'method not allowed' }))
|
|
return
|
|
}
|
|
let upstream
|
|
try {
|
|
upstream = await sendUpstream(id, entry, req.method, path, req.headers, body)
|
|
// One refresh + retry when the answer is still unsent.
|
|
if (upstream.statusCode === 401) {
|
|
const retried = await onUnauthorized(id)
|
|
if (retried === true) {
|
|
upstream.resume()
|
|
upstream = await sendUpstream(id, credential(id) ?? entry, req.method, path, req.headers, body)
|
|
}
|
|
}
|
|
if (upstream.errored) throw upstream.errored
|
|
} catch (error) {
|
|
log('ds-bot: connector gateway %s: %s', id, error?.message ?? error)
|
|
res.writeHead(502, { 'content-type': 'application/json' })
|
|
res.end(JSON.stringify({ error: 'connector upstream failed' }))
|
|
return
|
|
}
|
|
if (upstream.statusCode === 401 && req.method === 'POST' && signInAgain(id, body, upstream, res)) return
|
|
// tools/list without the read-only filter still feeds the annotation cache.
|
|
const isList = req.method === 'POST' && body !== undefined && (() => { try { return JSON.parse(body.toString('utf8'))?.method === 'tools/list' } catch { return false } })()
|
|
const heads = {}
|
|
for (const name of RETURN_HEADERS) if (upstream.headers[name] !== undefined) heads[name] = upstream.headers[name]
|
|
if (!isList || limited) {
|
|
const close = () => { upstream.destroy() }
|
|
res.on('close', close)
|
|
upstream.on('end', () => res.off('close', close))
|
|
upstream.on('error', () => {
|
|
log('ds-bot: connector %s upstream %s stream failed', id, req.method)
|
|
res.destroy()
|
|
})
|
|
res.writeHead(upstream.statusCode ?? 502, heads)
|
|
upstream.pipe(res)
|
|
return
|
|
}
|
|
// Unfiltered tools/list: buffer to learn annotations, then send as-is.
|
|
const raw = await readAll(upstream)
|
|
try {
|
|
const isSse = String(upstream.headers['content-type'] ?? '').includes('text/event-stream')
|
|
const payload = isSse ? sseMessage(raw.toString('utf8')) : raw.toString('utf8')
|
|
if (payload !== null) processList(id, JSON.parse(payload), false)
|
|
} catch { /* annotations stay as they were */ }
|
|
res.writeHead(upstream.statusCode ?? 502, heads)
|
|
res.end(raw)
|
|
}
|
|
|
|
return {
|
|
get port() { return port },
|
|
get nonce() { return nonce },
|
|
urlFor(id) { return `http://127.0.0.1:${port}/c/${id}` },
|
|
headers() { return { Authorization: `Bearer ${nonce}` } },
|
|
forget(id) { annotations.delete(id) },
|
|
async listen() {
|
|
if (server !== null) return
|
|
server = createServer((req, res) => {
|
|
req.on('error', () => res.destroy())
|
|
res.on('error', () => req.destroy())
|
|
const found = /^\/c\/([A-Za-z0-9_-]{1,32})/.exec(req.url ?? '')
|
|
if (found === null || !nonceMatches(req.headers.authorization, nonce)) {
|
|
res.writeHead(404)
|
|
res.end()
|
|
return
|
|
}
|
|
handle(found[1], req, res).catch((error) => {
|
|
log('ds-bot: connector gateway: %s', error?.message ?? error)
|
|
if (res.headersSent) res.destroy()
|
|
else { res.writeHead(502); res.end() }
|
|
})
|
|
})
|
|
server.on('error', error => log('ds-bot: connector gateway server failed: %s', error?.code ?? 'error'))
|
|
await new Promise((resolve, reject) => {
|
|
server.once('error', reject)
|
|
server.listen(0, '127.0.0.1', resolve)
|
|
})
|
|
port = server.address().port
|
|
},
|
|
async close() {
|
|
const closing = server
|
|
server = null
|
|
if (closing !== null) await new Promise(resolve => closing.close(resolve))
|
|
annotations.clear()
|
|
},
|
|
}
|
|
}
|