thincoder 0.7.8 → 0.8.0

package/src/mcp/transport-http.mjs

@@ -0,0 +1,176 @@
+/**
+ * mcp/transport-http.mjs — MCP HTTP + SSE transport (Streamable HTTP)
+ */
+import { rpcId, CALL_TIMEOUT_MS, ENDPOINT_WAIT_MS, withTimeout } from "./helpers.mjs"
+
+export function httpTransport(baseURL, extraHeaders = {}) {
+  const url = baseURL.replace(/\/+$/, "")
+  let sessionId = null
+  let closed = false
+  let eventSource = null
+  let abortController = null
+  let postUrl = url
+  let legacySSE = false
+
+  const headers = () => {
+    const h = { "Content-Type": "application/json", Accept: "text/event-stream, application/json", ...extraHeaders }
+    if (sessionId) h["Mcp-Session-Id"] = sessionId
+    return h
+  }
+
+  const pending = new Map()
+
+  async function* parseSSE(response) {
+    const reader = response.body.getReader()
+    const decoder = new TextDecoder()
+    let buf = ""
+    let current = { data: "", event: "message" }
+    try {
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        buf += decoder.decode(value, { stream: true })
+        const lines = buf.split("\n")
+        buf = lines.pop() ?? ""
+        for (const raw of lines) {
+          const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw
+          if (line === "") {
+            if (current.data) {
+              yield { event: current.event, data: current.data.trimEnd() }
+              current = { data: "", event: "message" }
+            }
+          } else if (line.startsWith("data:")) {
+            current.data += (current.data ? "\n" : "") + line.slice(5).replace(/^ /, "")
+          } else if (line.startsWith("event:")) {
+            current.event = line.slice(6).trim()
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock()
+    }
+  }
+
+  async function openSSE() {
+    if (closed) return
+    abortController?.abort()
+    abortController = new AbortController()
+    const resp = await fetch(url, {
+      method: "GET",
+      headers: { Accept: "text/event-stream", ...extraHeaders },
+      signal: abortController.signal,
+    })
+    if (!resp.ok) throw new Error(`SSE connect failed: HTTP ${resp.status}`)
+    eventSource = parseSSE(resp)
+    let endpointReady
+    const gotEndpoint = new Promise((resolve) => { endpointReady = resolve })
+
+    ;(async () => {
+      try {
+        for await (const { event, data } of eventSource) {
+          if (closed) break
+          if (event === "endpoint") {
+            postUrl = new URL(data.trim(), url).href
+            legacySSE = true
+            endpointReady()
+            continue
+          }
+          try {
+            const msg = JSON.parse(data)
+            const resolver = pending.get(msg.id)
+            if (resolver) {
+              pending.delete(msg.id)
+              resolver(msg)
+            }
+          } catch { /* 非 JSON，忽略 */ }
+        }
+      } catch (error) {
+        if (!closed) {
+          for (const [, resolve] of pending) resolve({ id: null, error: { code: -32000, message: `SSE error: ${error.message}` } })
+          pending.clear()
+        }
+      }
+    })()
+
+    const wait = new Promise((resolve) => {
+      const t = setTimeout(resolve, ENDPOINT_WAIT_MS)
+      t.unref?.()
+    })
+    await Promise.race([gotEndpoint, wait])
+  }
+
+  async function postRequest(method, params) {
+    const id = rpcId()
+    const body = JSON.stringify({ jsonrpc: "2.0", id, method, params })
+
+    if (legacySSE) {
+      return new Promise((resolve) => {
+        pending.set(id, resolve)
+        fetch(postUrl, { method: "POST", headers: headers(), body, signal: AbortSignal.timeout(CALL_TIMEOUT_MS) })
+          .then((resp) => {
+            if (!resp.ok) {
+              pending.delete(id)
+              resolve({ id, error: { code: -32000, message: `POST failed: HTTP ${resp.status}` } })
+            }
+          })
+          .catch((e) => {
+            pending.delete(id)
+            resolve({ id, error: { code: -32000, message: `POST failed: ${e.message}` } })
+          })
+      }).finally(() => pending.delete(id))
+    }
+
+    const resp = await fetch(postUrl, {
+      method: "POST",
+      headers: headers(),
+      body,
+      signal: AbortSignal.timeout(CALL_TIMEOUT_MS),
+    })
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`)
+
+    const ct = resp.headers.get("content-type") ?? ""
+    const newSessionId = resp.headers.get("Mcp-Session-Id")
+    if (newSessionId) sessionId = newSessionId
+
+    if (ct.includes("text/event-stream")) {
+      const sse = parseSSE(resp)
+      for await (const { data } of sse) {
+        try {
+          const msg = JSON.parse(data)
+          if (msg.id === id) return msg
+        } catch { /* skip */ }
+      }
+      return { id, error: { code: -32000, message: "No JSON-RPC response in SSE stream" } }
+    }
+
+    return resp.json()
+  }
+
+  const send = async (method, params) => withTimeout(postRequest(method, params), CALL_TIMEOUT_MS)
+
+  const notify = (method, params) => {
+    fetch(postUrl, {
+      method: "POST",
+      headers: headers(),
+      body: JSON.stringify({ jsonrpc: "2.0", method, params }),
+      signal: AbortSignal.timeout(10_000),
+    }).catch(() => {})
+  }
+
+  const close = () => {
+    closed = true
+    abortController?.abort()
+    if (sessionId) {
+      fetch(postUrl, {
+        method: "DELETE",
+        headers: { "Mcp-Session-Id": sessionId, ...extraHeaders },
+        signal: AbortSignal.timeout(5_000),
+      }).catch(() => {})
+      sessionId = null
+    }
+    for (const [, resolve] of pending) resolve({ id: null, error: { code: -32000, message: "Connection closed" } })
+    pending.clear()
+  }
+
+  return { send, notify, close, openSSE, url, headers: extraHeaders }
+}

package/src/mcp/transport-stdio.mjs

@@ -0,0 +1,84 @@
+/**
+ * mcp/transport-stdio.mjs — MCP stdio transport
+ */
+import { spawn } from "node:child_process"
+import { rpcId, CALL_TIMEOUT_MS, withTimeout, quoteArg } from "./helpers.mjs"
+
+export function stdioTransport(command, args) {
+  const spawnOptions = { stdio: ["pipe", "pipe", "pipe"], windowsHide: true, env: { ...process.env } }
+  const child =
+    process.platform === "win32" && !/\.exe$/i.test(command)
+      ? spawn("cmd.exe", ["/d", "/s", "/c", [command, ...(args ?? [])].map(quoteArg).join(" ")], {
+          ...spawnOptions,
+          windowsVerbatimArguments: true,
+        })
+      : spawn(command, args ?? [], spawnOptions)
+
+  const pending = new Map()
+  const decoder = new TextDecoder()
+  let buffer = ""
+  let stderrTail = ""
+  let spawnError = null
+  let closed = false
+
+  const failAll = (message) => {
+    for (const [, resolve] of pending) resolve({ id: null, error: { code: -32000, message } })
+    pending.clear()
+  }
+
+  child.stdout.on("data", (chunk) => {
+    buffer += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true })
+    const lines = buffer.split("\n")
+    buffer = lines.pop() ?? ""
+    for (const line of lines) {
+      if (!line.trim()) continue
+      try {
+        const msg = JSON.parse(line)
+        const resolver = pending.get(msg.id)
+        if (resolver) {
+          pending.delete(msg.id)
+          resolver(msg)
+        }
+      } catch { /* 非 JSON 行忽略 */ }
+    }
+  })
+
+  child.stderr.on("data", (chunk) => {
+    stderrTail = (stderrTail + chunk.toString()).slice(-2000)
+  })
+
+  child.stdin.on("error", () => {})
+  child.on("error", (error) => {
+    spawnError = error
+    closed = true
+    failAll(`spawn failed: ${error.message}`)
+  })
+  child.on("close", () => {
+    closed = true
+    const lastLine = stderrTail.trim().split("\n").pop()
+    failAll(`Connection closed${lastLine ? ` | stderr: ${lastLine}` : ""}`)
+  })
+
+  const send = (method, params) => {
+    if (spawnError) return Promise.resolve({ id: null, error: { code: -32000, message: `spawn failed: ${spawnError.message}` } })
+    if (closed) return Promise.reject(new Error("MCP connection closed"))
+    const id = rpcId()
+    const promise = new Promise((resolve) => pending.set(id, resolve))
+    try {
+      child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n")
+    } catch (error) {
+      pending.delete(id)
+      return Promise.resolve({ id: null, error: { code: -32000, message: `stdin write failed: ${error.message}` } })
+    }
+    return withTimeout(promise, CALL_TIMEOUT_MS).finally(() => pending.delete(id))
+  }
+
+  const notify = (method, params) => {
+    if (closed) return
+    try {
+      child.stdin.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n")
+    } catch { /* 忽略 */ }
+  }
+
+  return { send, notify, close: () => { if (!closed) child.kill() } }
+}

package/src/mcp/transport-ws.mjs

@@ -0,0 +1,87 @@
+/**
+ * mcp/transport-ws.mjs — MCP WebSocket transport
+ */
+import { rpcId, INIT_TIMEOUT_MS, CALL_TIMEOUT_MS, withTimeout, withAuthToken } from "./helpers.mjs"
+
+export function wsTransport(wsUrl, extraHeaders = {}) {
+  const pending = new Map()
+  let closed = false
+  let ws = null
+
+  const failAll = (message) => {
+    for (const [, resolve] of pending) resolve({ id: null, error: { code: -32000, message } })
+    pending.clear()
+  }
+
+  const connect = () => {
+    if (closed) throw new Error("MCP WebSocket connection closed")
+    ws = new WebSocket(withAuthToken(wsUrl, extraHeaders.Authorization))
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        ws.close()
+        reject(new Error(`WebSocket connect timeout: ${wsUrl}`))
+      }, INIT_TIMEOUT_MS)
+
+      ws.addEventListener("open", () => {
+        clearTimeout(timeout)
+        resolve()
+      })
+
+      ws.addEventListener("message", (event) => {
+        try {
+          const msg = JSON.parse(event.data.toString())
+          const resolver = pending.get(msg.id)
+          if (resolver) {
+            pending.delete(msg.id)
+            resolver(msg)
+          }
+        } catch { /* 非 JSON，忽略 */ }
+      })
+
+      ws.addEventListener("error", (event) => {
+        clearTimeout(timeout)
+        closed = true
+        const errMsg = event.message || "WebSocket error"
+        if (pending.size > 0) {
+          failAll(errMsg)
+        } else {
+          reject(new Error(errMsg))
+        }
+      })
+
+      ws.addEventListener("close", () => {
+        clearTimeout(timeout)
+        closed = true
+        failAll("WebSocket closed")
+      })
+    })
+  }
+
+  const send = (method, params) => {
+    if (closed) return Promise.reject(new Error("MCP WebSocket connection closed"))
+    const id = rpcId()
+    const promise = new Promise((resolve) => pending.set(id, resolve))
+    try {
+      ws.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }))
+    } catch (error) {
+      pending.delete(id)
+      return Promise.resolve({ id: null, error: { code: -32000, message: `ws send failed: ${error.message}` } })
+    }
+    return withTimeout(promise, CALL_TIMEOUT_MS).finally(() => pending.delete(id))
+  }
+
+  const notify = (method, params) => {
+    if (!closed && ws?.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ jsonrpc: "2.0", method, params }))
+    }
+  }
+
+  const close = () => {
+    closed = true
+    failAll("Connection closed")
+    try { ws?.close() } catch { /* 忽略 */ }
+  }
+
+  return { send, notify, close, connect }
+}