frizz-server 0.15.10 → 0.15.11

package/dist/claude-agent-broker.js

@@ -2,12 +2,13 @@ import { createRequire as __frizzCreateRequire } from "node:module"; const requi
 
 // packages/server/src/backend/claude-agent-broker.ts
 import net from "node:net";
-import { readFileSync as readFileSync5, realpathSync as realpathSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { readFileSync as readFileSync6, realpathSync as realpathSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join8 } from "node:path";
 import { randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
 
 // packages/server/src/backend/claude-agent-sdk.ts
-import { accessSync, constants as fsConstants } from "node:fs";
+import { accessSync, constants as fsConstants, rmSync as rmSync3 } from "node:fs";
 import { delimiter, isAbsolute as isAbsolute3 } from "node:path";
 
 // node_modules/.pnpm/@anthropic-ai+claude-agent-sdk@0.3.289_@anthropic-ai+sdk@0.111.0_zod@4.4.3__@modelconte_76f969b8ddf7678546f3feaaa7329174/node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
@@ -26533,6 +26534,7 @@ function startClaudeQuery(executablePath, options) {
   } : void 0;
   const claudeEffort = resolveClaudeEffort(options.effort);
   const launchModel = resolveClaudeLaunchModel(options.model);
+  const mcpConfigFile = options.mcpServers && Object.keys(options.mcpServers).length > 0 ? writeMcpConfigFile(sessionId, options.mcpServers) : void 0;
   const raw = nKe({
     prompt: input,
     options: {
@@ -26567,7 +26569,7 @@ function startClaudeQuery(executablePath, options) {
       // SDK renders that one as inline `--mcp-config <json>` on the CLI's argv, and the config carries the
       // operator's credentials — so every worker published its bearer tokens to `ps` (writeMcpConfigFile).
       ...options.pluginDir ? { plugins: [{ type: "local", path: options.pluginDir }] } : {},
-      ...options.mcpServers && Object.keys(options.mcpServers).length > 0 ? { extraArgs: { "mcp-config": writeMcpConfigFile(sessionId, options.mcpServers) } } : {},
+      ...mcpConfigFile ? { extraArgs: { "mcp-config": mcpConfigFile } } : {},
       ...options.strictMcpConfig ? { strictMcpConfig: true } : {},
       ...options.allowedTools?.length ? { allowedTools: options.allowedTools } : {},
       ...options.disallowedTools?.length ? { disallowedTools: [...options.disallowedTools] } : {},
@@ -26603,7 +26605,17 @@ function startClaudeQuery(executablePath, options) {
       }
     }
   });
-  return new RealClaudeQueryHandle(raw, input, sessionId, lifecycleAbort, redact, diagnostic);
+  const handle = new RealClaudeQueryHandle(raw, input, sessionId, lifecycleAbort, redact, diagnostic);
+  if (mcpConfigFile) {
+    const drop = () => {
+      try {
+        rmSync3(mcpConfigFile, { force: true });
+      } catch {
+      }
+    };
+    void handle.ready().then(drop, drop);
+  }
+  return handle;
 }
 function mapPermissionRequest(toolName, rawInput, context) {
   return {
@@ -27521,6 +27533,391 @@ function workerMcpServers(project, frizz) {
   return { ...project ?? {}, ...frizz ?? {} };
 }
 
+// packages/server/src/backend/lazy-mcp-host.ts
+import { spawn } from "node:child_process";
+import { createHash as createHash2, randomBytes } from "node:crypto";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import http from "node:http";
+import { join as join6 } from "node:path";
+var CACHED_METHODS = /* @__PURE__ */ new Set(["tools/list", "prompts/list", "resources/list", "resources/templates/list", "server/discover"]);
+var METHOD_NOT_FOUND = -32601;
+var CACHE_VERSION = 2;
+var LIST_CHANGED = {
+  "tools/list": "notifications/tools/list_changed",
+  "prompts/list": "notifications/prompts/list_changed",
+  "resources/list": "notifications/resources/list_changed",
+  "resources/templates/list": "notifications/resources/list_changed"
+};
+var FALLBACK_PROTOCOL_VERSION = "2025-06-18";
+var STDERR_TAIL_BYTES = 2048;
+var MAX_BODY_BYTES = 64 * 1024 * 1024;
+function cacheable(response) {
+  if (response.result !== void 0) return { result: response.result };
+  if (response.error?.code === METHOD_NOT_FOUND) return { error: response.error };
+  return void 0;
+}
+function lazyMcpEnabled(env = process.env) {
+  return env.FRIZZ_LAZY_MCP_OFF !== "1";
+}
+function lazyMcpCacheKey(server, cwd) {
+  const identity = JSON.stringify({ command: server.command, args: server.args ?? [], env: server.env ?? {}, cwd });
+  return createHash2("sha256").update(identity).digest("hex").slice(0, 32);
+}
+function listKey(method, params) {
+  if (params === null || typeof params !== "object" || Array.isArray(params)) return method;
+  const { _meta: _ignored, ...rest } = params;
+  return Object.keys(rest).length === 0 ? method : `${method} ${JSON.stringify(rest)}`;
+}
+function isRequest(message) {
+  return typeof message.method === "string" && message.id !== void 0 && message.id !== null;
+}
+function isResponse(message) {
+  return message.method === void 0 && message.id !== void 0 && ("result" in message || "error" in message);
+}
+var LazyServer = class {
+  constructor(name, server, context, cachePath, log) {
+    this.name = name;
+    this.server = server;
+    this.context = context;
+    this.cachePath = cachePath;
+    this.log = log;
+    this.cache = this.readCache();
+  }
+  child;
+  ready;
+  initResult;
+  clientInitParams;
+  nextInternalId = 0;
+  /** Requests the HOST sent the child (its own handshake and refreshes), by id. */
+  internal = /* @__PURE__ */ new Map();
+  /** Client requests forwarded to the child, by id, waiting for the child's answer. */
+  forwarded = /* @__PURE__ */ new Map();
+  stream;
+  outbox = [];
+  stderrTail = "";
+  cache;
+  get isRunning() {
+    return this.child !== void 0;
+  }
+  readCache() {
+    try {
+      const parsed = JSON.parse(readFileSync4(this.cachePath, "utf8"));
+      if (parsed?.version === CACHE_VERSION && parsed.answers && typeof parsed.answers === "object") return parsed;
+    } catch {
+    }
+    return { version: CACHE_VERSION, answers: {} };
+  }
+  writeCache() {
+    try {
+      const temp = `${this.cachePath}.${process.pid}.tmp`;
+      writeFileSync3(temp, JSON.stringify(this.cache), { mode: 384 });
+      renameSync2(temp, this.cachePath);
+    } catch (error) {
+      this.log(`${this.name}: cache write failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  // ---- the client side -------------------------------------------------------------------------
+  async handleRequest(message) {
+    const id2 = message.id;
+    try {
+      const method = message.method;
+      if (method === "initialize") {
+        this.clientInitParams = message.params ?? {};
+        if (this.initResult !== void 0) return { jsonrpc: "2.0", id: id2, result: this.initResult };
+        if (this.cache.initialize !== void 0) return { jsonrpc: "2.0", id: id2, result: this.cache.initialize };
+        await this.start(method);
+        return { jsonrpc: "2.0", id: id2, result: this.initResult };
+      }
+      if (method === "ping" && !this.child) return { jsonrpc: "2.0", id: id2, result: {} };
+      if (CACHED_METHODS.has(method) && !this.child) {
+        const cached2 = this.cache.answers[listKey(method, message.params)];
+        if (cached2 !== void 0) return { jsonrpc: "2.0", id: id2, ...cached2 };
+      }
+      await this.start(method);
+      const response = await this.forward(message);
+      const answer = CACHED_METHODS.has(method) ? cacheable(response) : void 0;
+      if (answer) {
+        this.cache.answers[listKey(method, message.params)] = answer;
+        this.writeCache();
+      }
+      return response;
+    } catch (error) {
+      return { jsonrpc: "2.0", id: id2, error: { code: -32603, message: error instanceof Error ? error.message : String(error) } };
+    }
+  }
+  /** A client notification or a client's answer to a server request. Never starts the server. */
+  handleOther(message) {
+    if (message.method === "notifications/initialized") return;
+    if (this.child && this.initResult !== void 0) this.send(message);
+  }
+  openStream(response) {
+    this.stream?.end();
+    this.stream = response;
+    response.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
+    response.flushHeaders();
+    response.on("close", () => {
+      if (this.stream === response) this.stream = void 0;
+    });
+    for (const message of this.outbox.splice(0)) this.toClient(message);
+  }
+  toClient(message) {
+    if (!this.stream) {
+      this.outbox.push(message);
+      return;
+    }
+    this.stream.write(`event: message
+data: ${JSON.stringify(message)}
+
+`);
+  }
+  // ---- the server side -------------------------------------------------------------------------
+  /** `reason` is the client method that needed the real server — the line that says why it ran. */
+  start(reason) {
+    this.ready ??= this.spawnAndInitialize(reason).catch((error) => {
+      this.ready = void 0;
+      throw error;
+    });
+    return this.ready;
+  }
+  async spawnAndInitialize(reason) {
+    this.log(`${this.name}: starting ${this.server.command} for ${reason}`);
+    const child = spawn(this.server.command, this.server.args ?? [], {
+      cwd: this.context.cwd,
+      env: { ...this.context.env, ...this.server.env ?? {} },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child = child;
+    this.stderrTail = "";
+    let buffered = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      buffered += chunk;
+      let newline;
+      while ((newline = buffered.indexOf("\n")) >= 0) {
+        const line = buffered.slice(0, newline).trim();
+        buffered = buffered.slice(newline + 1);
+        if (!line) continue;
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        this.fromChild(parsed);
+      }
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      this.stderrTail = (this.stderrTail + chunk).slice(-STDERR_TAIL_BYTES);
+    });
+    child.stdin.on("error", () => {
+    });
+    const exited = new Promise((_resolve, reject) => {
+      const fail = (detail) => {
+        if (this.child === child) this.reset(detail);
+        reject(new Error(detail));
+      };
+      child.once("error", (error) => fail(`MCP server "${this.name}" could not start: ${error.message}`));
+      child.once("exit", (code, signal) => fail(`MCP server "${this.name}" exited (${signal ?? `code ${code}`})${this.stderrTail ? `: ${this.stderrTail.trim()}` : ""}`));
+    });
+    exited.catch(() => {
+    });
+    const params = {
+      protocolVersion: this.clientInitParams?.protocolVersion ?? FALLBACK_PROTOCOL_VERSION,
+      capabilities: this.clientInitParams?.capabilities ?? {},
+      clientInfo: this.clientInitParams?.clientInfo ?? { name: "frizz-lazy-mcp", version: "1" }
+    };
+    const response = await Promise.race([this.internalRequest("initialize", params), exited]);
+    if (response.error) throw new Error(`MCP server "${this.name}" refused initialize: ${response.error.message}`);
+    this.initResult = response.result;
+    this.send({ jsonrpc: "2.0", method: "notifications/initialized" });
+    this.cache.initialize = response.result;
+    this.writeCache();
+    void this.refreshLists();
+  }
+  /** Re-read every cached list from the live server; a difference updates the cache and tells the client. */
+  async refreshLists() {
+    const changed = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(this.cache.answers)) {
+      const space = key.indexOf(" ");
+      const method = space < 0 ? key : key.slice(0, space);
+      const params = space < 0 ? void 0 : JSON.parse(key.slice(space + 1));
+      const response = await this.internalRequest(method, params).catch(() => void 0);
+      const answer = response && cacheable(response);
+      if (!answer) continue;
+      if (JSON.stringify(answer) !== JSON.stringify(this.cache.answers[key])) {
+        this.cache.answers[key] = answer;
+        changed.add(LIST_CHANGED[method] ?? "");
+      }
+    }
+    if (changed.size === 0) return;
+    this.writeCache();
+    for (const notification of changed) if (notification) this.toClient({ jsonrpc: "2.0", method: notification });
+    this.log(`${this.name}: cached lists were stale; sent ${[...changed].join(", ")}`);
+  }
+  internalRequest(method, params) {
+    const id2 = `frizz-lazy-${++this.nextInternalId}`;
+    return new Promise((resolve3) => {
+      this.internal.set(id2, resolve3);
+      this.send({ jsonrpc: "2.0", id: id2, method, ...params === void 0 ? {} : { params } });
+    });
+  }
+  forward(message) {
+    return new Promise((resolve3) => {
+      this.forwarded.set(JSON.stringify(message.id), resolve3);
+      this.send(message);
+    });
+  }
+  send(message) {
+    this.child?.stdin?.write(`${JSON.stringify(message)}
+`);
+  }
+  fromChild(message) {
+    if (isResponse(message)) {
+      const key = typeof message.id === "string" && message.id.startsWith("frizz-lazy-") ? message.id : void 0;
+      const waiter = key !== void 0 ? this.internal.get(key) : this.forwarded.get(JSON.stringify(message.id));
+      if (key !== void 0) this.internal.delete(key);
+      else this.forwarded.delete(JSON.stringify(message.id));
+      waiter?.(message);
+      return;
+    }
+    this.toClient(message);
+  }
+  /** The child is gone: fail everything waiting on it, and let the next request start a fresh one. */
+  reset(detail) {
+    this.log(detail);
+    this.child = void 0;
+    this.ready = void 0;
+    this.initResult = void 0;
+    const error = { code: -32e3, message: detail };
+    for (const [id2, waiter] of this.forwarded) waiter({ jsonrpc: "2.0", id: JSON.parse(id2), error });
+    for (const [id2, waiter] of this.internal) waiter({ jsonrpc: "2.0", id: id2, error });
+    this.forwarded.clear();
+    this.internal.clear();
+  }
+  async close() {
+    this.stream?.end();
+    const child = this.child;
+    if (!child) return;
+    this.child = void 0;
+    await new Promise((resolve3) => {
+      const timer = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        ;
+        resolve3();
+      }, 2e3);
+      child.once("exit", () => {
+        clearTimeout(timer);
+        resolve3();
+      });
+      try {
+        child.stdin?.end();
+      } catch {
+      }
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    });
+  }
+};
+function readBody(request) {
+  return new Promise((resolve3, reject) => {
+    let size = 0;
+    const chunks = [];
+    request.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES) {
+        reject(new Error("body too large"));
+        request.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    request.on("end", () => resolve3(Buffer.concat(chunks).toString("utf8")));
+    request.on("error", reject);
+  });
+}
+function startLazyMcpHost(options) {
+  const log = options.log ?? (() => {
+  });
+  const token = randomBytes(32).toString("hex");
+  const servers = /* @__PURE__ */ new Map();
+  let mounted = 0;
+  const httpServer = http.createServer((request, response) => {
+    const route = /^\/mcp\/([A-Za-z0-9]+)$/.exec((request.url ?? "").split("?")[0] ?? "");
+    const server = route ? servers.get(route[1]) : void 0;
+    if (!server) {
+      response.writeHead(404).end();
+      return;
+    }
+    if (request.headers.authorization !== `Bearer ${token}`) {
+      response.writeHead(403).end();
+      return;
+    }
+    if (request.method === "GET") {
+      server.openStream(response);
+      return;
+    }
+    if (request.method !== "POST") {
+      response.writeHead(405, { allow: "GET, POST" }).end();
+      return;
+    }
+    void (async () => {
+      let parsed;
+      try {
+        parsed = JSON.parse(await readBody(request));
+      } catch {
+        response.writeHead(400, { "content-type": "application/json" });
+        response.end(JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } }));
+        return;
+      }
+      const messages = Array.isArray(parsed) ? parsed : [parsed];
+      const requests = messages.filter(isRequest);
+      for (const message of messages) if (!isRequest(message)) server.handleOther(message);
+      if (requests.length === 0) {
+        response.writeHead(202).end();
+        return;
+      }
+      const answers = await Promise.all(requests.map((message) => server.handleRequest(message)));
+      response.writeHead(200, { "content-type": "application/json" });
+      response.end(JSON.stringify(Array.isArray(parsed) ? answers : answers[0]));
+    })();
+  });
+  httpServer.requestTimeout = 0;
+  return new Promise((resolve3, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(0, "127.0.0.1", () => {
+      httpServer.off("error", reject);
+      const address = httpServer.address();
+      const port = typeof address === "object" && address ? address.port : 0;
+      resolve3({
+        port,
+        mount(stdio, context) {
+          mkdirSync4(options.cacheDir, { recursive: true, mode: 448 });
+          const out = {};
+          for (const [name, definition] of Object.entries(stdio)) {
+            const slot = String(++mounted);
+            const cachePath = join6(options.cacheDir, `${lazyMcpCacheKey(definition, context.cwd)}.json`);
+            servers.set(slot, new LazyServer(name, definition, context, cachePath, context.log ?? log));
+            out[name] = { type: "http", url: `http://127.0.0.1:${port}/mcp/${slot}`, headers: { Authorization: `Bearer ${token}` } };
+          }
+          return out;
+        },
+        running: () => [...servers.values()].filter((server) => server.isRunning).map((server) => server.name),
+        async close() {
+          await Promise.all([...servers.values()].map((server) => server.close()));
+          httpServer.closeAllConnections();
+          await new Promise((done) => httpServer.close(() => done()));
+        }
+      });
+    });
+  });
+}
+
 // packages/server/src/backend/types.ts
 var CLAUDE_WORKER_ENV = {
   CLAUDE_CODE_TOTAL_TOKENS_REMINDER: "infinite",
@@ -27557,14 +27954,14 @@ function socketPathOwnership(socketPath) {
 }
 
 // packages/server/src/backend/claude-broker-diagnostics.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync2, statSync as statSync3 } from "node:fs";
-import { join as join6 } from "node:path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync3, statSync as statSync3 } from "node:fs";
+import { join as join7 } from "node:path";
 var MAX_BYTES = 4 * 1024 * 1024;
 function appendRecord(path, record) {
   try {
-    mkdirSync4(join6(path, ".."), { recursive: true });
+    mkdirSync5(join7(path, ".."), { recursive: true });
     try {
-      if (statSync3(path).size > MAX_BYTES) renameSync2(path, `${path}.1`);
+      if (statSync3(path).size > MAX_BYTES) renameSync3(path, `${path}.1`);
     } catch {
     }
     appendFileSync2(path, `${JSON.stringify(record)}
@@ -27595,7 +27992,15 @@ var IDLE_EXIT_MS = 6 * 60 * 60 * 1e3;
 var REACHABILITY_CHECK_MS = 3e4;
 var REACHABILITY_STRIKES = 2;
 var EVENT_ERROR_TOLERANCE = 5;
-function runClaudeBroker(config) {
+function mountLazily(project, frizz, host, context) {
+  if (!host) return project;
+  const stdio = {};
+  for (const [name, server] of Object.entries(project)) {
+    if ((server.type === void 0 || server.type === "stdio") && !(frizz && name in frizz)) stdio[name] = server;
+  }
+  return { ...project, ...host.mount(stdio, context) };
+}
+function runClaudeBroker(config, options = {}) {
   const generation = config.generation ?? randomUUID();
   let client = null;
   const MAX_BACKLOG_FRAMES = 2e4;
@@ -27641,7 +28046,18 @@ function runClaudeBroker(config) {
     // approved `.mcp.json` (and the operator's remote user-scope servers) under the frizz mount, which
     // wins a name collision. Read at every fork, not once per project, so a `.mcp.json` edit reaches the
     // next dispatch the way it reaches the next plain `claude`. project-mcp-servers.ts has the reasons.
-    mcpServers: workerMcpServers(projectMcpServers(config.cwd, { env }), config.mcpServers),
+    // Stdio servers are not started here: the lazy host stands in for each one and starts the real
+    // command on the first tool call (lazy-mcp-host.ts has the measurement that motivated it).
+    mcpServers: workerMcpServers(
+      mountLazily(projectMcpServers(config.cwd, { env }), config.mcpServers, options.lazyMcpHost, {
+        cwd: config.cwd,
+        // What the CLI itself would have spawned the server with: the env the factory hands it, after
+        // the same sanitizing (no inherited NODE_OPTIONS, no nub shim on PATH).
+        env: sanitizeProviderChildEnvironment(env),
+        log: (message) => writeDiagnostic?.({ kind: "stderr", message: `[lazy-mcp] ${message}`, truncated: false })
+      }),
+      config.mcpServers
+    ),
     strictMcpConfig: true,
     allowedTools: config.allowedTools,
     // NO `disallowedTools` here, and the asymmetry with the argv path (WORKER_DISALLOWED_TOOLS →
@@ -27809,7 +28225,7 @@ function runClaudeBroker(config) {
   const recordOwner = () => {
     if (!config.recordPath) return null;
     try {
-      return JSON.parse(readFileSync5(config.recordPath, "utf8")).daemonPid;
+      return JSON.parse(readFileSync6(config.recordPath, "utf8")).daemonPid;
     } catch {
       return null;
     }
@@ -27857,6 +28273,8 @@ function runClaudeBroker(config) {
     }
     await handle.close().catch(() => {
     });
+    await options.lazyMcpHost?.close().catch(() => {
+    });
     if (config.recordPath) process.exit(code);
   }
   const reach = setInterval(() => {
@@ -27888,7 +28306,7 @@ function runClaudeBroker(config) {
     if (config.recordPath) {
       const record = { daemonPid: process.pid, socketPath: config.socketPath, sessionId: config.sessionId, generation, createdAt: (/* @__PURE__ */ new Date()).toISOString(), capabilities: BROKER_CAPABILITIES, compactionWindow: claudeCompactionWindowOf(config.workerEnv) };
       try {
-        writeFileSync3(config.recordPath, JSON.stringify(record), { mode: 384 });
+        writeFileSync4(config.recordPath, JSON.stringify(record), { mode: 384 });
       } catch {
       }
     }
@@ -27933,7 +28351,10 @@ ${error.stack ?? ""}`.slice(0, 2e3) : String(error));
 ${reason.stack ?? ""}`.slice(0, 2e3) : String(reason));
     process.exit(1);
   });
-  running = runClaudeBroker(config);
+  const lazyMcpHost = lazyMcpEnabled() ? startLazyMcpHost({ cacheDir: join8(frizzRoots().data, "mcp-cache") }) : Promise.resolve(void 0);
+  void lazyMcpHost.catch(() => void 0).then((host) => {
+    running = runClaudeBroker(config, { lazyMcpHost: host });
+  });
 } else if (startedAsProcessEntry()) {
   throw new Error("claude session broker started without FRIZZ_CLAUDE_BROKER");
 }