chainlesschain 0.162.78 → 0.162.79

package/src/commands/zkp.js

@@ -5,6 +5,7 @@
 
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
+import { parseJsonOption } from "../lib/parse-json-option.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
 import {
   ensureZKPTables,
@@ -100,10 +101,8 @@ export function registerZkpCommand(program) {
         const db = ctx.db.getDatabase();
         ensureZKPTables(db);
 
-        const privateInputs = options.private
-          ? JSON.parse(options.private)
-          : {};
-        const publicInputs = options.public ? JSON.parse(options.public) : [];
+        const privateInputs = parseJsonOption(options.private, "--private", {});
+        const publicInputs = parseJsonOption(options.public, "--public", []);
         const proveOpts = options.scheme ? { scheme: options.scheme } : {};
         const proof = generateProof(
           db,
@@ -174,7 +173,7 @@ export function registerZkpCommand(program) {
     .option("--json", "Output as JSON")
     .action(async (options) => {
       try {
-        const claims = options.claims ? JSON.parse(options.claims) : {};
+        const claims = parseJsonOption(options.claims, "--claims", {});
         const disclose = options.disclose
           ? options.disclose.split(",").map((s) => s.trim())
           : [];
@@ -404,7 +403,7 @@ export function registerZkpCommand(program) {
         const db = ctx.db.getDatabase();
         ensureZKPTables(db);
 
-        const claims = options.claims ? JSON.parse(options.claims) : {};
+        const claims = parseJsonOption(options.claims, "--claims", {});
         const cred = registerCredential(db, {
           did: options.did,
           claims,
@@ -622,7 +621,7 @@ export function registerZkpCommand(program) {
         }
         const db = ctx.db.getDatabase();
         ensureZKPTables(db);
-        const def = options.definition ? JSON.parse(options.definition) : {};
+        const def = parseJsonOption(options.definition, "--definition", {});
         const circuit = compileCircuitV2(db, {
           name,
           definition: def,
@@ -675,8 +674,8 @@ export function registerZkpCommand(program) {
         ensureZKPTables(db);
         const proof = generateProofV2(db, {
           circuitId,
-          privateInputs: JSON.parse(options.private),
-          publicInputs: JSON.parse(options.public),
+          privateInputs: parseJsonOption(options.private, "--private"),
+          publicInputs: parseJsonOption(options.public, "--public"),
           scheme: options.scheme,
         });
         logger.success("Proof generated (V2)");

package/src/gateways/ws/ws-agent-handler.js

@@ -16,6 +16,7 @@ import {
   detectTaskType,
   selectModelForTask,
 } from "../../lib/task-model-selector.js";
+import { runnableTaskModel } from "../../lib/runnable-provider.js";
 import { PlanState } from "../../lib/plan-mode.js";
 import { CLISlotFiller } from "../../lib/slot-filler.js";
 import { createAbortError, isAbortError } from "../../lib/abort-utils.js";
@@ -63,7 +64,9 @@ export class WSAgentHandler {
       // Add user message
       session.messages.push({ role: "user", content: userMessage });
 
-      // Auto-select model based on task type
+      // Auto-select model based on task type — runnable-first: never switch
+      // onto a provider with no usable key (you'd just 401). Keep the
+      // configured model in that case.
       let activeModel = session.model;
       const taskDetection = detectTaskType(userMessage);
       if (taskDetection.confidence > 0.3) {
@@ -71,8 +74,14 @@ export class WSAgentHandler {
           session.provider,
           taskDetection.taskType,
         );
-        if (recommended && recommended !== activeModel) {
-          activeModel = recommended;
+        const switchTo = runnableTaskModel({
+          provider: session.provider,
+          currentModel: activeModel,
+          recommended,
+          apiKey: session.apiKey,
+        });
+        if (switchTo) {
+          activeModel = switchTo;
           this.interaction.emit("model-switch", {
             requestId,
             from: session.model,

package/src/gateways/ws/ws-server.js

@@ -855,6 +855,12 @@ export class ChainlessChainWSServer extends EventEmitter {
   }
 
   _startHeartbeat() {
+    // Idempotent: clear any existing timer first so a repeated start() (or a
+    // re-fired "listening" event) can't leak the previous interval — stop()
+    // only clears the most recent handle, so an overwrite would orphan it.
+    if (this._heartbeatTimer) {
+      clearInterval(this._heartbeatTimer);
+    }
     this._heartbeatTimer = setInterval(() => {
       for (const [clientId, client] of this.clients) {
         if (!client.alive) {

package/src/harness/background-task-manager.js

@@ -9,12 +9,7 @@
  */
 
 import { fork } from "node:child_process";
-import {
-  existsSync,
-  mkdirSync,
-  appendFileSync,
-  readFileSync,
-} from "node:fs";
+import { existsSync, mkdirSync, appendFileSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { createHash } from "node:crypto";
 import { EventEmitter } from "node:events";
@@ -38,7 +33,10 @@ export const TaskStatus = {
   TIMEOUT: "timeout",
 };
 
-const RECOVERABLE_TASK_STATUSES = new Set([TaskStatus.PENDING, TaskStatus.RUNNING]);
+const RECOVERABLE_TASK_STATUSES = new Set([
+  TaskStatus.PENDING,
+  TaskStatus.RUNNING,
+]);
 
 export class BackgroundTaskManager extends EventEmitter {
   constructor(options = {}) {
@@ -47,7 +45,9 @@ export class BackgroundTaskManager extends EventEmitter {
     this.heartbeatTimeout = options.heartbeatTimeout || 60000;
     this.historyLimit = options.historyLimit || 50;
     this.nodeId =
-      options.nodeId || process.env.CC_NODE_ID || `${process.pid}@${process.platform}`;
+      options.nodeId ||
+      process.env.CC_NODE_ID ||
+      `${process.pid}@${process.platform}`;
     this.recoveryPolicy = options.recoveryPolicy || "claim-stale";
     this.staleNodeTimeout = options.staleNodeTimeout || 5 * 60 * 1000;
     this.tasks = new Map();
@@ -139,7 +139,12 @@ export class BackgroundTaskManager extends EventEmitter {
     child.on("exit", (code) => {
       if (task.status === TaskStatus.RUNNING) {
         if (code === 0) {
-          this._complete(taskId, TaskStatus.COMPLETED, "Process exited (0)", null);
+          this._complete(
+            taskId,
+            TaskStatus.COMPLETED,
+            "Process exited (0)",
+            null,
+          );
         } else {
           this._complete(
             taskId,
@@ -178,8 +183,12 @@ export class BackgroundTaskManager extends EventEmitter {
 
   getHistory(taskId, options = {}) {
     const history = this.get(taskId)?.history || [];
-    const limit = Number.isFinite(options.limit) ? Math.max(1, options.limit) : null;
-    const offset = Number.isFinite(options.offset) ? Math.max(0, options.offset) : 0;
+    const limit = Number.isFinite(options.limit)
+      ? Math.max(1, options.limit)
+      : null;
+    const offset = Number.isFinite(options.offset)
+      ? Math.max(0, options.offset)
+      : 0;
 
     if (limit === null && offset === 0) {
       return history;
@@ -192,7 +201,8 @@ export class BackgroundTaskManager extends EventEmitter {
       offset,
       limit: limit || history.length,
       hasMore: offset + items.length < history.length,
-      nextOffset: offset + items.length < history.length ? offset + items.length : null,
+      nextOffset:
+        offset + items.length < history.length ? offset + items.length : null,
     };
   }
 
@@ -212,9 +222,16 @@ export class BackgroundTaskManager extends EventEmitter {
     const child = this.processes.get(taskId);
     if (child) {
       child.kill("SIGTERM");
-      setTimeout(() => {
+      // Escalate to SIGKILL only if SIGTERM didn't take. unref() + clear-on-exit
+      // so a prompt exit (or process shutdown right after stop) isn't held open
+      // for the full grace period by this timer.
+      const killTimer = setTimeout(() => {
         if (child.exitCode === null) child.kill("SIGKILL");
       }, 2000);
+      if (killTimer && typeof killTimer.unref === "function") killTimer.unref();
+      if (typeof child.once === "function") {
+        child.once("exit", () => clearTimeout(killTimer));
+      }
     }
     const task = this.tasks.get(taskId);
     if (task) {
@@ -335,7 +352,8 @@ export class BackgroundTaskManager extends EventEmitter {
   }
 
   _normalizePersistedTask(entry) {
-    const task = entry?.kind === "task_snapshot" && entry.task ? entry.task : entry;
+    const task =
+      entry?.kind === "task_snapshot" && entry.task ? entry.task : entry;
 
     if (!task || typeof task !== "object") {
       return null;
@@ -354,7 +372,11 @@ export class BackgroundTaskManager extends EventEmitter {
     if (normalized.history.length === 0) {
       normalized.history.push({
         event: "loaded",
-        timestamp: normalized.completedAt || normalized.startedAt || normalized.createdAt || Date.now(),
+        timestamp:
+          normalized.completedAt ||
+          normalized.startedAt ||
+          normalized.createdAt ||
+          Date.now(),
         status: normalized.status,
       });
     }
@@ -414,8 +436,10 @@ export class BackgroundTaskManager extends EventEmitter {
 
   _decideRecovery(task) {
     const previousOwnerNodeId = task.ownerNodeId || null;
-    const sameNode = previousOwnerNodeId === this.nodeId || !previousOwnerNodeId;
-    const lastSeenAt = task.lastHeartbeat || task.startedAt || task.createdAt || 0;
+    const sameNode =
+      previousOwnerNodeId === this.nodeId || !previousOwnerNodeId;
+    const lastSeenAt =
+      task.lastHeartbeat || task.startedAt || task.createdAt || 0;
     const stale = Date.now() - lastSeenAt > this.staleNodeTimeout;
 
     if (sameNode) {
@@ -440,7 +464,9 @@ export class BackgroundTaskManager extends EventEmitter {
       return {
         shouldRecover: false,
         policy: this.recoveryPolicy,
-        reason: stale ? "foreign-node-stale-observed" : "foreign-node-active-observed",
+        reason: stale
+          ? "foreign-node-stale-observed"
+          : "foreign-node-active-observed",
         previousOwnerNodeId,
       };
     }

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. */