chainlesschain 0.162.77 → 0.162.79

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;

package/src/lib/dao-governance.js

@@ -437,7 +437,7 @@ export function castVote(db, opts) {
       `Invalid voteType: ${voteType}. Must be one of: ${Object.values(VOTE_TYPE).join(", ")}`,
     );
   }
-  if (typeof voteCount !== "number" || voteCount <= 0) {
+  if (!Number.isFinite(voteCount) || voteCount <= 0) {
     throw new Error("voteCount must be a positive number");
   }
 
@@ -686,7 +686,7 @@ export function allocateFundsV2(db, opts) {
   const { proposalId, recipient, amount, asset = "native", memo } = opts || {};
   if (!proposalId) throw new Error("proposalId is required");
   if (!recipient) throw new Error("recipient is required");
-  if (typeof amount !== "number" || amount <= 0) {
+  if (!Number.isFinite(amount) || amount <= 0) {
     throw new Error("amount must be a positive number");
   }
   if (amount > _configV2.maxSingleAllocation) {
@@ -807,7 +807,7 @@ export function getConfigV2() {
 
 export function depositToTreasuryV2(db, opts) {
   const { amount, asset = "native", memo, depositorDid } = opts || {};
-  if (typeof amount !== "number" || amount <= 0) {
+  if (!Number.isFinite(amount) || amount <= 0) {
     throw new Error("amount must be a positive number");
   }
 

package/src/lib/downloader.js

@@ -24,6 +24,67 @@ const ASSET_PATTERNS = {
   linux: { x64: /chainlesschain.*linux.*x64.*\.zip$/i },
 };
 
+/**
+ * Stream a fetch Response body to `destPath` with two robustness guards for the
+ * download/install path:
+ *   - idle timeout: if no bytes arrive for `idleTimeoutMs`, abort `controller`
+ *     (which cancels the underlying fetch) so a hung server can't freeze the
+ *     download forever. The timer resets on every chunk — a stall detector, not
+ *     a total-time cap — and is unref'd so it never holds the loop open.
+ *   - size verification: if the server advertised a Content-Length and fewer
+ *     bytes arrived, throw. A silently truncated download must not look like a
+ *     successful one (the caller would otherwise extract/install a corrupt file).
+ *
+ * Exported for tests. Returns { downloadedBytes, totalBytes }.
+ */
+export async function streamToFileVerified(
+  response,
+  destPath,
+  {
+    controller = null,
+    idleTimeoutMs = 60000,
+    onProgress = null,
+    createWriteStreamImpl = createWriteStream,
+  } = {},
+) {
+  const totalBytes = parseInt(
+    response.headers.get("content-length") || "0",
+    10,
+  );
+  let downloadedBytes = 0;
+  let idleTimer = null;
+  const armIdle = () => {
+    if (!controller || !(idleTimeoutMs > 0)) return;
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => controller.abort(), idleTimeoutMs);
+    if (idleTimer && typeof idleTimer.unref === "function") idleTimer.unref();
+  };
+  const reader = response.body.getReader();
+  async function* track() {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) return;
+        armIdle();
+        downloadedBytes += value.byteLength;
+        if (onProgress) onProgress(downloadedBytes, totalBytes);
+        yield value;
+      }
+    } finally {
+      if (idleTimer) clearTimeout(idleTimer);
+    }
+  }
+  armIdle();
+  await pipeline(track(), createWriteStreamImpl(destPath));
+  if (idleTimer) clearTimeout(idleTimer);
+  if (totalBytes > 0 && downloadedBytes !== totalBytes) {
+    throw new Error(
+      `Download truncated: received ${downloadedBytes} of ${totalBytes} bytes`,
+    );
+  }
+  return { downloadedBytes, totalBytes };
+}
+
 export async function downloadRelease(version, options = {}) {
   const binDir = ensureDir(getBinDir());
 
@@ -41,9 +102,14 @@ export async function downloadRelease(version, options = {}) {
   const spinner = ora(`Downloading ${assetName}...`).start();
 
   try {
+    // Abort the fetch if the download stalls (no bytes for idleTimeoutMs) so a
+    // hung mirror can't freeze `cc setup` forever; streamToFileVerified also
+    // verifies the full body landed (truncation guard).
+    const controller = new AbortController();
     const response = await fetch(assetUrl, {
       headers: { Accept: "application/octet-stream" },
       redirect: "follow",
+      signal: controller.signal,
     });
 
     if (!response.ok) {
@@ -52,30 +118,16 @@ export async function downloadRelease(version, options = {}) {
       );
     }
 
-    const totalBytes = parseInt(
-      response.headers.get("content-length") || "0",
-      10,
-    );
-    let downloadedBytes = 0;
-
-    // Stream the fetch body to disk via an async generator (stable APIs only —
-    // avoids the experimental stream.Readable.fromWeb); `pipeline` keeps the
-    // backpressure + error handling. Progress is tracked as chunks flow through.
-    const reader = response.body.getReader();
-    async function* trackProgress() {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) return;
-        downloadedBytes += value.byteLength;
-        if (totalBytes > 0) {
-          const pct = ((downloadedBytes / totalBytes) * 100).toFixed(1);
-          spinner.text = `Downloading ${assetName}... ${pct}% (${formatBytes(downloadedBytes)}/${formatBytes(totalBytes)})`;
+    const { downloadedBytes } = await streamToFileVerified(response, destPath, {
+      controller,
+      idleTimeoutMs: options.idleTimeoutMs,
+      onProgress: (downloaded, total) => {
+        if (total > 0) {
+          const pct = ((downloaded / total) * 100).toFixed(1);
+          spinner.text = `Downloading ${assetName}... ${pct}% (${formatBytes(downloaded)}/${formatBytes(total)})`;
         }
-        yield value;
-      }
-    }
-
-    await pipeline(trackProgress(), createWriteStream(destPath));
+      },
+    });
 
     spinner.succeed(
       `Downloaded ${assetName} (${formatBytes(downloadedBytes)})`,
@@ -96,11 +148,16 @@ export async function downloadRelease(version, options = {}) {
 
     return binDir;
   } catch (err) {
-    spinner.fail(`Download failed: ${err.message}`);
+    const stalled =
+      err && (err.name === "AbortError" || err.code === "ABORT_ERR");
+    const msg = stalled
+      ? `Download stalled (no data received): ${assetName}`
+      : `Download failed: ${err.message}`;
+    spinner.fail(msg);
     if (existsSync(destPath)) {
       unlinkSync(destPath);
     }
-    throw err;
+    throw stalled ? new Error(msg) : err;
   }
 }
 

package/src/lib/headless-config-command.js

@@ -0,0 +1,62 @@
+/**
+ * Headless `/config` directive (Claude-Code 2.1.181 parity — "/config key=value
+ * in interactive AND -p modes"). The REPL already handles `/config` for the
+ * interactive half; this is the `-p` / piped-stdin half: when the headless
+ * prompt is a leading `/config …` slash command, treat it as a one-shot config
+ * get / set / show instead of a task for the LLM — no model call, no session,
+ * no bootstrap. (`cc config get|set` covers the same ground for pure scripting;
+ * this gives the symmetric single-interface form Claude Code exposes.)
+ *
+ * Pure detection + execution; config-manager does the disk I/O (injected for
+ * tests). Secrets stay masked on read and write — the same invariant the REPL
+ * `/config` upholds.
+ */
+import {
+  parseConfigCommand,
+  renderConfigGet,
+  renderConfigSet,
+  renderConfigSummary,
+} from "../repl/config-summary.js";
+
+/** Does this headless prompt start with the `/config` slash command? */
+export function isHeadlessConfigCommand(prompt) {
+  return /^\/config(?:\s|$)/.test((prompt || "").trim());
+}
+
+/**
+ * Execute a `/config …` directive. Returns `{ text, isError }`.
+ *
+ * @param {string} prompt  the full prompt (leading `/config …`)
+ * @param {object} deps
+ *   - configManager: { loadConfig, getConfigValue, setConfigValue } (required)
+ *   - getConfigPath?: () => string|null  (shown in the `show` summary)
+ */
+export function runConfigDirective(prompt, deps = {}) {
+  const cm = deps.configManager;
+  if (!cm) return { text: "/config: no config manager", isError: true };
+  const getConfigPath = deps.getConfigPath || (() => null);
+  const argStr = (prompt || "").trim().replace(/^\/config\b/, "");
+  const cmd = parseConfigCommand(argStr);
+
+  if (cmd.action === "error") {
+    return { text: `/config: ${cmd.message}`, isError: true };
+  }
+  if (cmd.action === "get") {
+    return {
+      text: renderConfigGet(cmd.key, cm.getConfigValue(cmd.key)),
+      isError: false,
+    };
+  }
+  if (cmd.action === "set") {
+    cm.setConfigValue(cmd.key, cmd.value);
+    return {
+      text: renderConfigSet(cmd.key, cm.getConfigValue(cmd.key)),
+      isError: false,
+    };
+  }
+  // show
+  return {
+    text: renderConfigSummary(cm.loadConfig(), { path: getConfigPath() }),
+    isError: false,
+  };
+}