chainlesschain 0.162.78 → 0.162.80

package/src/harness/mcp-client.js

@@ -33,6 +33,14 @@ export const ServerState = {
 /** Transport kinds that carry a URL (no stdio process). */
 const URL_TRANSPORTS = new Set(["http", "https", "sse", "ws", "wss"]);
 
+/**
+ * Default per-call timeout for HTTP MCP requests, mirroring the 30s stdio
+ * timeout so a hung/dead HTTP server can't block a request forever. Servers
+ * flagged `longRunning` (e.g. the IDE bridge, whose openDiff blocks on human
+ * review) are exempt; override per server with `config.requestTimeoutMs`.
+ */
+const HTTP_REQUEST_TIMEOUT_MS = 30000;
+
 /**
  * Infer the transport kind for a server config. Falls back to "stdio".
  * Prefers an explicit `transport` field; otherwise derives from URL scheme
@@ -218,13 +226,32 @@ export class MCPClient extends EventEmitter {
           this.emit("server-error", { name, error: data.toString("utf8") });
         });
 
+        // If the server process dies with requests in flight, reject them
+        // immediately with a clear error instead of letting each hang until its
+        // 30s timeout (fail-fast on a crashed/exited MCP server).
+        const failPending = (errMsg) => {
+          for (const [, pending] of entry._pending) {
+            if (pending.timeout) clearTimeout(pending.timeout);
+            try {
+              pending.reject(new Error(errMsg));
+            } catch {
+              // already settled — ignore
+            }
+          }
+          entry._pending.clear();
+        };
+
         proc.on("close", (code) => {
           entry.state = ServerState.DISCONNECTED;
+          failPending(
+            `MCP server "${name}" process exited (code ${code}) before responding`,
+          );
           this.emit("server-disconnected", { name, code });
         });
 
         proc.on("error", (err) => {
           entry.state = ServerState.ERROR;
+          failPending(`MCP server "${name}" process error: ${err.message}`);
           this.emit("server-error", { name, error: err.message });
         });
       } else {
@@ -247,12 +274,24 @@ export class MCPClient extends EventEmitter {
       entry.serverInfo = initResult?.serverInfo || {};
       entry.capabilities = initResult?.capabilities || {};
 
-      // Fetch available tools
+      // Fetch available tools. Per MCP a server advertises a `tools` capability
+      // in its initialize response; if it does and tools/list then fails, that
+      // is a genuine fetch failure we must surface (Claude-Code 2.1.181 — show
+      // "Connected · tools fetch failed" rather than a misleading "Tools: 0").
+      // A server that did not advertise tools simply has none, so a failure
+      // there is expected and stays quiet.
+      entry.tools = [];
+      entry.toolsError = null;
+      const advertisesTools =
+        entry.capabilities && entry.capabilities.tools !== undefined;
       try {
         const toolsResult = await this._sendRequest(name, "tools/list", {});
         entry.tools = toolsResult?.tools || [];
-      } catch {
-        // Server may not support tools
+      } catch (err) {
+        if (advertisesTools) {
+          entry.toolsError = err?.message || String(err);
+        }
+        // else: server did not advertise tools — legitimately none.
       }
 
       // Fetch available resources
@@ -275,11 +314,16 @@ export class MCPClient extends EventEmitter {
         // Server may not support prompts
       }
 
-      this.emit("server-connected", { name, tools: entry.tools.length });
+      this.emit("server-connected", {
+        name,
+        tools: entry.tools.length,
+        toolsError: entry.toolsError,
+      });
       return {
         name,
         state: entry.state,
         tools: entry.tools,
+        toolsError: entry.toolsError,
         resources: entry.resources,
         prompts: entry.prompts,
         serverInfo: entry.serverInfo,
@@ -338,6 +382,7 @@ export class MCPClient extends EventEmitter {
         name,
         state: entry.state,
         tools: entry.tools.length,
+        toolsError: entry.toolsError || null,
         resources: entry.resources.length,
         prompts: (entry.prompts || []).length,
         serverInfo: entry.serverInfo || {},
@@ -599,53 +644,87 @@ export class MCPClient extends EventEmitter {
       headers["Mcp-Session-Id"] = entry.httpSessionId;
     }
 
-    const response = await _deps.fetch(entry.httpUrl, {
-      method: "POST",
-      headers,
-      body,
-    });
-
-    // Capture session id (server may emit on initialize response only)
-    const sessionId =
-      (response.headers && typeof response.headers.get === "function"
-        ? response.headers.get("mcp-session-id") ||
-          response.headers.get("Mcp-Session-Id")
-        : null) || null;
-    if (sessionId && !entry.httpSessionId) {
-      entry.httpSessionId = sessionId;
-    }
-
-    if (!response.ok) {
-      const text =
-        typeof response.text === "function" ? await response.text() : "";
-      throw new Error(
-        `HTTP ${response.status}${text ? `: ${text.slice(0, 200)}` : ""}`,
-      );
+    // Per-call timeout (parity with the 30s stdio timeout) so a hung or dead
+    // HTTP MCP server can't block the request forever. Servers flagged
+    // longRunning — e.g. the IDE bridge, whose openDiff blocks on human review
+    // (see ideServerToMcpConfig) — are exempt. Override per server with
+    // config.requestTimeoutMs (0 disables).
+    const longRunning = Boolean(entry.config && entry.config.longRunning);
+    const timeoutMs = Number.isFinite(entry.config?.requestTimeoutMs)
+      ? entry.config.requestTimeoutMs
+      : HTTP_REQUEST_TIMEOUT_MS;
+    let controller = null;
+    let timer = null;
+    if (
+      !longRunning &&
+      timeoutMs > 0 &&
+      typeof AbortController === "function"
+    ) {
+      controller = new AbortController();
+      timer = setTimeout(() => controller.abort(), timeoutMs);
     }
 
-    const contentType = response.headers?.get
-      ? String(response.headers.get("content-type") || "").toLowerCase()
-      : "";
+    try {
+      const response = await _deps.fetch(entry.httpUrl, {
+        method: "POST",
+        headers,
+        body,
+        ...(controller ? { signal: controller.signal } : {}),
+      });
 
-    let envelope;
-    if (contentType.includes("text/event-stream")) {
-      envelope = await _extractSseResponse(response, id);
-    } else {
-      envelope =
-        typeof response.json === "function"
-          ? await response.json()
-          : JSON.parse(
-              typeof response.text === "function" ? await response.text() : "",
-            );
-    }
+      // Capture session id (server may emit on initialize response only)
+      const sessionId =
+        (response.headers && typeof response.headers.get === "function"
+          ? response.headers.get("mcp-session-id") ||
+            response.headers.get("Mcp-Session-Id")
+          : null) || null;
+      if (sessionId && !entry.httpSessionId) {
+        entry.httpSessionId = sessionId;
+      }
 
-    if (!envelope || typeof envelope !== "object") {
-      throw new Error("Empty or invalid JSON-RPC response");
-    }
-    if (envelope.error) {
-      throw new Error(envelope.error.message || "Unknown error");
+      if (!response.ok) {
+        const text =
+          typeof response.text === "function" ? await response.text() : "";
+        throw new Error(
+          `HTTP ${response.status}${text ? `: ${text.slice(0, 200)}` : ""}`,
+        );
+      }
+
+      const contentType = response.headers?.get
+        ? String(response.headers.get("content-type") || "").toLowerCase()
+        : "";
+
+      let envelope;
+      if (contentType.includes("text/event-stream")) {
+        envelope = await _extractSseResponse(response, id);
+      } else {
+        envelope =
+          typeof response.json === "function"
+            ? await response.json()
+            : JSON.parse(
+                typeof response.text === "function"
+                  ? await response.text()
+                  : "",
+              );
+      }
+
+      if (!envelope || typeof envelope !== "object") {
+        throw new Error("Empty or invalid JSON-RPC response");
+      }
+      if (envelope.error) {
+        throw new Error(envelope.error.message || "Unknown error");
+      }
+      return envelope.result;
+    } catch (err) {
+      if (controller && controller.signal.aborted) {
+        throw new Error(
+          `Request timeout: ${method} (HTTP, no response in ${timeoutMs}ms)`,
+        );
+      }
+      throw err;
+    } finally {
+      if (timer) clearTimeout(timer);
     }
-    return envelope.result;
   }
 
   /** Fire-and-forget JSON-RPC notification over HTTP. Errors swallowed. */

package/src/lib/chat-core.js

@@ -12,23 +12,65 @@
 import { BUILT_IN_PROVIDERS } from "./llm-providers.js";
 import { appendTokenUsage } from "../harness/jsonl-session-store.js";
 
+// A streaming chat call must not hang forever if the API accepts the connection
+// but then goes silent (TCP up, no bytes). Abort the request if no data arrives
+// for STREAM_STALL_MS — reset on every chunk, so it's a stall detector, not a
+// total-time cap (long but healthy responses are unaffected). The default is
+// generous (and env-overridable) so a slow local model's first token isn't cut
+// off; raise CC_CHAT_STALL_MS if you run very large local models.
+export const STREAM_STALL_MS = Number(process.env.CC_CHAT_STALL_MS) || 180000;
+
+function makeStallGuard(stallMs = STREAM_STALL_MS) {
+  const controller = new AbortController();
+  let timer = null;
+  const bump = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => controller.abort(), stallMs);
+    if (timer && typeof timer.unref === "function") timer.unref();
+  };
+  const stop = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+  };
+  return {
+    signal: controller.signal,
+    bump,
+    stop,
+    stalled: () => controller.signal.aborted,
+  };
+}
+
 /**
  * Stream a response from Ollama.
  * If `onUsage` is provided, it's called with `{inputTokens, outputTokens}`
  * derived from Ollama's terminal `prompt_eval_count` / `eval_count` fields.
  */
 export async function streamOllama(messages, model, baseUrl, onToken, onUsage) {
-  const response = await fetch(`${baseUrl}/api/chat`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      model,
-      messages,
-      stream: true,
-    }),
-  });
+  const guard = makeStallGuard();
+  guard.bump();
+  let response;
+  try {
+    response = await fetch(`${baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model,
+        messages,
+        stream: true,
+      }),
+      signal: guard.signal,
+    });
+  } catch (e) {
+    guard.stop();
+    throw guard.stalled()
+      ? new Error(
+          `Ollama request stalled (no response in ${STREAM_STALL_MS / 1000}s)`,
+        )
+      : e;
+  }
 
   if (!response.ok) {
+    guard.stop();
     throw new Error(`Ollama error: ${response.status} ${response.statusText}`);
   }
 
@@ -36,31 +78,42 @@ export async function streamOllama(messages, model, baseUrl, onToken, onUsage) {
   const decoder = new TextDecoder();
   let fullResponse = "";
 
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      guard.bump();
 
-    const text = decoder.decode(value, { stream: true });
-    const lines = text.split("\n").filter(Boolean);
+      const text = decoder.decode(value, { stream: true });
+      const lines = text.split("\n").filter(Boolean);
 
-    for (const line of lines) {
-      try {
-        const json = JSON.parse(line);
-        if (json.message?.content) {
-          fullResponse += json.message.content;
-          onToken(json.message.content);
-        }
-        if (json.done && onUsage) {
-          const inputTokens = Number(json.prompt_eval_count) || 0;
-          const outputTokens = Number(json.eval_count) || 0;
-          if (inputTokens || outputTokens) {
-            onUsage({ inputTokens, outputTokens });
+      for (const line of lines) {
+        try {
+          const json = JSON.parse(line);
+          if (json.message?.content) {
+            fullResponse += json.message.content;
+            onToken(json.message.content);
           }
+          if (json.done && onUsage) {
+            const inputTokens = Number(json.prompt_eval_count) || 0;
+            const outputTokens = Number(json.eval_count) || 0;
+            if (inputTokens || outputTokens) {
+              onUsage({ inputTokens, outputTokens });
+            }
+          }
+        } catch {
+          // Partial JSON, skip
         }
-      } catch {
-        // Partial JSON, skip
       }
     }
+  } catch (e) {
+    throw guard.stalled()
+      ? new Error(
+          `Ollama stream stalled (no data in ${STREAM_STALL_MS / 1000}s)`,
+        )
+      : e;
+  } finally {
+    guard.stop();
   }
 
   return fullResponse;
@@ -77,23 +130,37 @@ export async function streamOpenAI(
   onToken,
   onUsage,
 ) {
-  const response = await fetch(`${baseUrl}/chat/completions`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`,
-    },
-    body: JSON.stringify({
-      model,
-      messages,
-      stream: true,
-      // Opt-in token usage in the terminal chunk (OpenAI-compatible).
-      // Servers that don't understand it simply ignore it.
-      stream_options: { include_usage: true },
-    }),
-  });
+  const guard = makeStallGuard();
+  guard.bump();
+  let response;
+  try {
+    response = await fetch(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        model,
+        messages,
+        stream: true,
+        // Opt-in token usage in the terminal chunk (OpenAI-compatible).
+        // Servers that don't understand it simply ignore it.
+        stream_options: { include_usage: true },
+      }),
+      signal: guard.signal,
+    });
+  } catch (e) {
+    guard.stop();
+    throw guard.stalled()
+      ? new Error(
+          `API request stalled (no response in ${STREAM_STALL_MS / 1000}s)`,
+        )
+      : e;
+  }
 
   if (!response.ok) {
+    guard.stop();
     throw new Error(`API error: ${response.status} ${response.statusText}`);
   }
 
@@ -101,36 +168,45 @@ export async function streamOpenAI(
   const decoder = new TextDecoder();
   let fullResponse = "";
 
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      guard.bump();
 
-    const text = decoder.decode(value, { stream: true });
-    const lines = text.split("\n").filter(Boolean);
+      const text = decoder.decode(value, { stream: true });
+      const lines = text.split("\n").filter(Boolean);
 
-    for (const line of lines) {
-      if (line.startsWith("data: ")) {
-        const data = line.slice(6);
-        if (data === "[DONE]") continue;
-        try {
-          const json = JSON.parse(data);
-          const content = json.choices?.[0]?.delta?.content;
-          if (content) {
-            fullResponse += content;
-            onToken(content);
-          }
-          if (json.usage && onUsage) {
-            const inputTokens = Number(json.usage.prompt_tokens) || 0;
-            const outputTokens = Number(json.usage.completion_tokens) || 0;
-            if (inputTokens || outputTokens) {
-              onUsage({ inputTokens, outputTokens });
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6);
+          if (data === "[DONE]") continue;
+          try {
+            const json = JSON.parse(data);
+            const content = json.choices?.[0]?.delta?.content;
+            if (content) {
+              fullResponse += content;
+              onToken(content);
+            }
+            if (json.usage && onUsage) {
+              const inputTokens = Number(json.usage.prompt_tokens) || 0;
+              const outputTokens = Number(json.usage.completion_tokens) || 0;
+              if (inputTokens || outputTokens) {
+                onUsage({ inputTokens, outputTokens });
+              }
             }
+          } catch {
+            // Partial data
           }
-        } catch {
-          // Partial data
         }
       }
     }
+  } catch (e) {
+    throw guard.stalled()
+      ? new Error(`API stream stalled (no data in ${STREAM_STALL_MS / 1000}s)`)
+      : e;
+  } finally {
+    guard.stop();
   }
 
   return fullResponse;
@@ -161,23 +237,37 @@ export async function streamAnthropic(
     }
   }
 
-  const response = await fetch(`${baseUrl}/messages`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "x-api-key": apiKey,
-      "anthropic-version": "2023-06-01",
-    },
-    body: JSON.stringify({
-      model,
-      max_tokens: 4096,
-      stream: true,
-      ...(system ? { system } : {}),
-      messages: convo,
-    }),
-  });
+  const guard = makeStallGuard();
+  guard.bump();
+  let response;
+  try {
+    response = await fetch(`${baseUrl}/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: 4096,
+        stream: true,
+        ...(system ? { system } : {}),
+        messages: convo,
+      }),
+      signal: guard.signal,
+    });
+  } catch (e) {
+    guard.stop();
+    throw guard.stalled()
+      ? new Error(
+          `Anthropic request stalled (no response in ${STREAM_STALL_MS / 1000}s)`,
+        )
+      : e;
+  }
 
   if (!response.ok) {
+    guard.stop();
     throw new Error(
       `Anthropic error: ${response.status} ${response.statusText}`,
     );
@@ -190,36 +280,48 @@ export async function streamAnthropic(
   let inputTokens = 0;
   let outputTokens = 0;
 
-  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.trim();
-      if (!line || !line.startsWith("data:")) continue;
-      const payload = line.slice(5).trim();
-      if (!payload) continue;
-      try {
-        const obj = JSON.parse(payload);
-        if (obj.type === "content_block_delta") {
-          const delta = obj.delta?.text;
-          if (delta) {
-            fullResponse += delta;
-            onToken(delta);
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      guard.bump();
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split("\n");
+      buf = lines.pop() || "";
+      for (const raw of lines) {
+        const line = raw.trim();
+        if (!line || !line.startsWith("data:")) continue;
+        const payload = line.slice(5).trim();
+        if (!payload) continue;
+        try {
+          const obj = JSON.parse(payload);
+          if (obj.type === "content_block_delta") {
+            const delta = obj.delta?.text;
+            if (delta) {
+              fullResponse += delta;
+              onToken(delta);
+            }
+          } else if (obj.type === "message_start") {
+            inputTokens =
+              Number(obj.message?.usage?.input_tokens) || inputTokens;
+            outputTokens =
+              Number(obj.message?.usage?.output_tokens) || outputTokens;
+          } else if (obj.type === "message_delta") {
+            outputTokens = Number(obj.usage?.output_tokens) || outputTokens;
           }
-        } else if (obj.type === "message_start") {
-          inputTokens = Number(obj.message?.usage?.input_tokens) || inputTokens;
-          outputTokens =
-            Number(obj.message?.usage?.output_tokens) || outputTokens;
-        } else if (obj.type === "message_delta") {
-          outputTokens = Number(obj.usage?.output_tokens) || outputTokens;
+        } catch {
+          /* skip malformed */
         }
-      } catch {
-        /* skip malformed */
       }
     }
+  } catch (e) {
+    throw guard.stalled()
+      ? new Error(
+          `Anthropic stream stalled (no data in ${STREAM_STALL_MS / 1000}s)`,
+        )
+      : e;
+  } finally {
+    guard.stop();
   }
 
   if (onUsage && (inputTokens || outputTokens)) {

package/src/lib/claude-code-bridge.js

@@ -97,6 +97,7 @@ export class ClaudeCodeAgent extends EventEmitter {
       timeout = 300_000,
       context = "",
       allowedTools = null,
+      killGraceMs = 3000,
     } = options;
 
     const fullPrompt = context
@@ -128,10 +129,19 @@ export class ClaudeCodeAgent extends EventEmitter {
       });
       this._proc = proc;
 
+      // SIGKILL-escalation timer is hoisted so the close/error handlers can
+      // clear it — otherwise, when the process dies promptly from SIGTERM, this
+      // inner timer still fires a redundant SIGKILL on a dead pid AND holds the
+      // event loop open for the full grace period. unref() is a second guard so
+      // it never keeps the process alive on its own.
+      let killTimer = null;
       const timer = setTimeout(() => {
         timedOut = true;
         proc.kill("SIGTERM");
-        setTimeout(() => proc.kill("SIGKILL"), 3000);
+        killTimer = setTimeout(() => proc.kill("SIGKILL"), killGraceMs);
+        if (killTimer && typeof killTimer.unref === "function") {
+          killTimer.unref();
+        }
       }, timeout);
 
       proc.stdout.on("data", (data) => {
@@ -146,6 +156,7 @@ export class ClaudeCodeAgent extends EventEmitter {
 
       proc.on("close", (code) => {
         clearTimeout(timer);
+        if (killTimer) clearTimeout(killTimer);
         this._proc = null;
         const duration = Date.now() - startTime;
         const rawOutput = outputChunks.join("");
@@ -178,6 +189,7 @@ export class ClaudeCodeAgent extends EventEmitter {
 
       proc.on("error", (err) => {
         clearTimeout(timer);
+        if (killTimer) clearTimeout(killTimer);
         this._proc = null;
         this.status = AGENT_STATUS.FAILED;
         this.currentTask = null;