frizz-server 0.14.6 → 0.15.0

package/dist/acp-daemon.js

@@ -0,0 +1,407 @@
+import { createRequire as __frizzCreateRequire } from "node:module"; const require = __frizzCreateRequire(import.meta.url);
+
+// packages/server/src/backend/acp-daemon.ts
+import { spawn } from "node:child_process";
+import { createServer } from "node:net";
+import { existsSync, readFileSync, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+
+// packages/server/src/backend/stale-socket-sweep.ts
+import { execFile } from "node:child_process";
+import { readdirSync, unlinkSync } from "node:fs";
+import { connect as connectSocket } from "node:net";
+import { join } from "node:path";
+function parseLsofSocketNames(stdout) {
+  const referenced = /* @__PURE__ */ new Set();
+  for (const line of stdout.split("\n")) {
+    if (!line.startsWith("n/")) continue;
+    const raw = line.slice(1);
+    referenced.add(raw);
+    const meta = raw.indexOf(" type=");
+    if (meta > 0) referenced.add(raw.slice(0, meta));
+  }
+  return referenced;
+}
+var defaultListReferenced = (prefix, done) => {
+  execFile("lsof", ["-U", "-F", "n"], { timeout: 3e4, maxBuffer: 16 * 1024 * 1024 }, (error, stdout) => {
+    if (!stdout) return done(null);
+    if (error && !stdout.includes(prefix)) return done(null);
+    done(parseLsofSocketNames(stdout));
+  }).unref?.();
+};
+var defaultProbe = (path, verdict) => {
+  const probe = connectSocket(path);
+  probe.unref?.();
+  probe.on("connect", () => {
+    probe.destroy();
+    verdict(false);
+  });
+  probe.on("error", (error) => {
+    probe.destroy();
+    verdict(error.code === "ECONNREFUSED" || error.code === "ENOENT");
+  });
+};
+function sweepStaleSockets(options, deps = {}) {
+  if (process.platform === "win32") return;
+  const keep = new Set(options.keep ?? []);
+  let candidates;
+  try {
+    candidates = (deps.readdir ?? readdirSync)(options.dir).filter((name) => name.startsWith(options.prefix) && name.endsWith(".sock")).map((name) => join(options.dir, name)).filter((path) => !keep.has(path));
+  } catch {
+    return;
+  }
+  if (candidates.length === 0) return;
+  const probe = deps.probe ?? defaultProbe;
+  const unlink = deps.unlink ?? ((path) => {
+    try {
+      unlinkSync(path);
+    } catch {
+    }
+  });
+  (deps.listReferenced ?? defaultListReferenced)(options.prefix, (referenced) => {
+    if (!referenced) return;
+    for (const path of candidates) {
+      if (referenced.has(path)) continue;
+      probe(path, (dead) => {
+        if (dead) unlink(path);
+      });
+    }
+  });
+}
+
+// packages/server/src/backend/acp-daemon.ts
+var MAX_QUEUED_LINES = 2e4;
+var MAX_QUEUED_BYTES = 64 * 1024 * 1024;
+var MAX_LINE_BYTES = 8 * 1024 * 1024;
+var IDLE_EXIT_MS = 6 * 60 * 60 * 1e3;
+var REACHABILITY_CHECK_MS = 3e4;
+var REACHABILITY_STRIKES = 2;
+function readConfig() {
+  const raw = process.env.FRIZZ_ACP_DAEMON;
+  if (!raw) throw new Error("acp daemon started without FRIZZ_ACP_DAEMON");
+  const config = JSON.parse(raw);
+  if (!config.socketPath || !config.recordPath || !config.command || !config.generation || !config.sessionId) {
+    throw new Error("acp daemon config is incomplete");
+  }
+  return config;
+}
+function lineReader(onLine, onOverflow) {
+  const decoder = new StringDecoder("utf8");
+  let buffer = "";
+  let overflowed = false;
+  return (chunk) => {
+    buffer += decoder.write(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    for (; ; ) {
+      const index = buffer.indexOf("\n");
+      if (index < 0) break;
+      const line = buffer.slice(0, index);
+      buffer = buffer.slice(index + 1);
+      if (overflowed) {
+        overflowed = false;
+        continue;
+      }
+      if (Buffer.byteLength(line) > MAX_LINE_BYTES) {
+        onOverflow();
+        continue;
+      }
+      const trimmed = line.trim();
+      if (trimmed) onLine(trimmed);
+    }
+    if (Buffer.byteLength(buffer) > MAX_LINE_BYTES) {
+      buffer = "";
+      if (!overflowed) onOverflow();
+      overflowed = true;
+    }
+  };
+}
+function main() {
+  const config = readConfig();
+  const child = spawn(config.command, config.args, {
+    cwd: config.cwd,
+    env: config.env,
+    stdio: ["pipe", "pipe", "pipe"],
+    // This daemon is forked `detached`, which on Windows is DETACHED_PROCESS: it owns NO console, and a
+    // console-subsystem agent started without CREATE_NO_WINDOW would get a fresh visible one.
+    windowsHide: true
+  });
+  let client = null;
+  let queuedLines = [];
+  let queuedBytes = 0;
+  let dropped = 0;
+  let idleTimer = null;
+  let published = false;
+  const recordOwner = () => {
+    try {
+      const value = JSON.parse(readFileSync(config.recordPath, "utf8"));
+      return typeof value.daemonPid === "number" ? value.daemonPid : null;
+    } catch {
+      return null;
+    }
+  };
+  const cleanup = () => {
+    try {
+      client?.destroy();
+    } catch {
+    }
+    const owner = recordOwner();
+    if (owner === process.pid) {
+      try {
+        unlinkSync2(config.recordPath);
+      } catch {
+      }
+    }
+    if (published && owner !== null && owner !== process.pid) return;
+    if (published && process.platform !== "win32") {
+      try {
+        unlinkSync2(config.socketPath);
+      } catch {
+      }
+    }
+  };
+  const writeExitBreadcrumb = (reason) => {
+    try {
+      writeFileSync(`${config.recordPath}.exit`, JSON.stringify({
+        threadSlug: config.threadSlug,
+        sessionId: config.sessionId,
+        generation: config.generation,
+        daemonPid: process.pid,
+        childPid: child.pid ?? null,
+        reason,
+        at: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+    } catch {
+    }
+  };
+  const die = (code, reason) => {
+    writeExitBreadcrumb(reason);
+    cleanup();
+    process.exit(code);
+  };
+  const armIdleExit = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      ;
+      die(0, "idle-timeout");
+    }, config.idleExitMs ?? IDLE_EXIT_MS);
+    idleTimer.unref?.();
+  };
+  let unreachableStrikes = 0;
+  const checkReachable = () => {
+    if (client) {
+      unreachableStrikes = 0;
+      return;
+    }
+    if (recordOwner() === process.pid) {
+      unreachableStrikes = 0;
+      return;
+    }
+    if (++unreachableStrikes < REACHABILITY_STRIKES) return;
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+    die(0, "self-collected-record-reassigned");
+  };
+  const toClient = (line) => {
+    if (client) {
+      try {
+        client.write(`${line}
+`);
+        return;
+      } catch {
+      }
+    }
+    if (queuedLines.length >= MAX_QUEUED_LINES || queuedBytes >= MAX_QUEUED_BYTES) {
+      dropped++;
+      return;
+    }
+    queuedLines.push(line);
+    queuedBytes += Buffer.byteLength(line) + 1;
+  };
+  const control = (payload) => JSON.stringify({ frizz: 1, ...payload });
+  const pendingFromClient = /* @__PURE__ */ new Map();
+  let nextDaemonId = 1e6;
+  let initializeResult = null;
+  let initializeDaemonId = null;
+  let acpSessionId = null;
+  const toChild = (message) => {
+    try {
+      child.stdin.write(`${JSON.stringify(message)}
+`);
+    } catch {
+    }
+  };
+  const readChildLine = (line) => {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      toClient(line);
+      return;
+    }
+    if (message.id !== void 0 && message.method === void 0 && typeof message.id === "number") {
+      const owner = pendingFromClient.get(message.id);
+      if (owner !== void 0) {
+        pendingFromClient.delete(message.id);
+        if (message.id === initializeDaemonId && message.error === void 0) initializeResult = message.result ?? null;
+        if (owner.method === "session/new" && message.error === void 0) {
+          const result = message.result;
+          if (typeof result?.sessionId === "string") acpSessionId = result.sessionId;
+        }
+        if (owner.method === "session/load" && message.error === void 0) {
+          const params = owner.params;
+          if (typeof params?.sessionId === "string") acpSessionId = params.sessionId;
+        }
+        toClient(JSON.stringify({ ...message, id: owner.clientId }));
+        return;
+      }
+    }
+    if (message.id !== void 0 && message.method !== void 0) {
+      pendingFromChild.set(String(message.id), { line, queued: client === null });
+    }
+    toClient(line);
+  };
+  const pendingFromChild = /* @__PURE__ */ new Map();
+  const readClientLine = (line) => {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (message.frizz === 1) {
+      const adopt = message.adopt;
+      if (adopt && typeof adopt.daemonId === "number" && (typeof adopt.clientId === "number" || typeof adopt.clientId === "string")) {
+        const owner = pendingFromClient.get(adopt.daemonId);
+        if (owner) owner.clientId = adopt.clientId;
+      }
+      return;
+    }
+    if (message.method === "initialize" && initializeResult !== null) {
+      if (message.id !== void 0) toClient(JSON.stringify({ jsonrpc: "2.0", id: message.id, result: initializeResult }));
+      return;
+    }
+    if (message.id !== void 0 && message.method !== void 0) {
+      const daemonId = nextDaemonId++;
+      pendingFromClient.set(daemonId, { clientId: message.id, method: String(message.method), params: message.params });
+      if (message.method === "initialize" && initializeDaemonId === null) initializeDaemonId = daemonId;
+      toChild({ ...message, id: daemonId });
+      return;
+    }
+    if (message.id !== void 0 && message.method === void 0) pendingFromChild.delete(String(message.id));
+    toChild(message);
+  };
+  const writeRecord = () => {
+    writeFileSync(config.recordPath, JSON.stringify({
+      threadSlug: config.threadSlug,
+      sessionId: config.sessionId,
+      generation: config.generation,
+      daemonPid: process.pid,
+      childPid: child.pid,
+      socketPath: config.socketPath,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  };
+  const server = createServer((sock) => {
+    if (client) {
+      try {
+        client.destroy();
+      } catch {
+      }
+    }
+    client = sock;
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+    sock.setNoDelay(true);
+    try {
+      sock.write(`${control({
+        hello: 1,
+        generation: config.generation,
+        childPid: child.pid,
+        droppedWhileDetached: dropped,
+        initialize: initializeResult,
+        acpSessionId,
+        outstanding: [...pendingFromClient].map(([daemonId, owner]) => ({ daemonId, method: owner.method }))
+      })}
+`);
+      for (const line of queuedLines) sock.write(`${line}
+`);
+      for (const entry of pendingFromChild.values()) {
+        if (!entry.queued) sock.write(`${entry.line}
+`);
+        entry.queued = false;
+      }
+    } catch {
+    }
+    queuedLines = [];
+    queuedBytes = 0;
+    dropped = 0;
+    sock.on("data", lineReader((line) => {
+      if (!sock.destroyed) readClientLine(line);
+    }, () => sock.destroy()));
+    const drop = () => {
+      if (client !== sock) return;
+      client = null;
+      armIdleExit();
+    };
+    sock.on("close", drop);
+    sock.on("error", drop);
+  });
+  const sweepOwnFamily = () => sweepStaleSockets({ dir: dirname(config.socketPath), prefix: "frizz-acp-", keep: [config.socketPath] });
+  const startListening = () => {
+    if (process.platform !== "win32" && existsSync(config.socketPath)) {
+      try {
+        unlinkSync2(config.socketPath);
+      } catch {
+      }
+    }
+    server.on("error", () => die(6, "socket-listen-error"));
+    server.listen(config.socketPath, () => {
+      published = true;
+      writeRecord();
+      armIdleExit();
+      const reachability = setInterval(checkReachable, config.reachabilityCheckMs ?? REACHABILITY_CHECK_MS);
+      reachability.unref?.();
+      setTimeout(sweepOwnFamily, 5e3).unref?.();
+    });
+  };
+  child.stdout.on("data", lineReader(readChildLine, () => {
+    dropped++;
+    const lostClient = client;
+    client = null;
+    lostClient?.destroy();
+    armIdleExit();
+  }));
+  child.stderr.on("data", (chunk) => {
+    if (!client) return;
+    for (const line of String(chunk).split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        client.write(`${control({ stderr: line.slice(0, 2e3) })}
+`);
+      } catch {
+      }
+    }
+  });
+  child.on("exit", (code, signal) => die(0, signal ? `agent-killed-${signal}` : `agent-exited-code-${code ?? "null"}`));
+  child.on("error", () => die(4, "agent-spawn-error"));
+  startListening();
+  for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) {
+    process.on(signal, () => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      ;
+      die(0, `signal-${signal}`);
+    });
+  }
+}
+main();

package/dist/claude-agent-broker.js

@@ -24388,6 +24388,17 @@ function startClaudeQuery(executablePath, options) {
       // an additional highest-precedence settings source, layered over `settingSources` above.
       ...claudeEffort.effort ? { effort: claudeEffort.effort } : {},
       ...claudeEffort.ultracode ? { settings: claudeUltracodeSettings() } : {},
+      // AN INTERRUPT MUST NOT KILL THE WORKER'S SUB-AGENTS. The CLI fails closed here: unless the
+      // consumer declares that it renders a per-task stop control wired to `stop_task`, every
+      // interrupt (the ⌘-Enter "interrupt and send", the queued bubble's push-now, a "pause now")
+      // aborts the turn AND kills every background agent under it — because a consumer with no way
+      // to stop a runaway child must not be left with one it cannot end. Frizz HAS that control (the
+      // sub-agent row's stop → `Query.stopTask`, see router.ts / board.ts), so it declares it, and an
+      // interrupt then aborts only the turn: the children keep running and their notifications land
+      // as usual. Measured 2026-09-24 (_live_broker_interrupt_subagent.mts), one variable: the flag
+      // absent → the child was reported `stopped` 7ms after the interrupt; present → it ran
+      // to `completed` after the parent's turn had already been aborted.
+      perTaskStopAffordance: true,
       stderr(data) {
         const redacted = redact(data);
         diagnostic?.({ kind: "stderr", ...redacted });