codetrellis 0.0.0-stage → 0.3.0

package/src/backend/mcp/connector/files.js

@@ -0,0 +1,121 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var files_exports = {};
+__export(files_exports, {
+  ENDPOINT_FILE: () => ENDPOINT_FILE,
+  TOKEN_FILE: () => TOKEN_FILE,
+  defaultDataDir: () => defaultDataDir,
+  isLoopbackSseUrl: () => isLoopbackSseUrl,
+  readConnectTarget: () => readConnectTarget,
+  readEndpoint: () => readEndpoint,
+  readToken: () => readToken,
+  removeEndpointFile: () => removeEndpointFile,
+  writeEndpointFile: () => writeEndpointFile
+});
+module.exports = __toCommonJS(files_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_confined_fs = require("../../services/confined-fs");
+const TOKEN_FILE = "capability-token";
+const ENDPOINT_FILE = "mcp-endpoint.json";
+function defaultDataDir(env = process.env) {
+  const fromEnv = env.CODETRELLIS_DATA_DIR;
+  if (fromEnv && fromEnv.trim()) return fromEnv;
+  return import_node_path.default.join(import_node_os.default.homedir(), ".codetrellis");
+}
+function isLoopbackSseUrl(raw) {
+  let u;
+  try {
+    u = new URL(raw);
+  } catch {
+    return false;
+  }
+  if (u.protocol !== "http:") return false;
+  if (!["127.0.0.1", "localhost", "[::1]"].includes(u.hostname)) return false;
+  return u.pathname === "/sse" && u.username === "" && u.password === "";
+}
+function writeEndpointFile(dataDir, endpoint) {
+  import_node_fs.default.mkdirSync(dataDir, { recursive: true });
+  (0, import_confined_fs.writeFileWithin)(dataDir, ENDPOINT_FILE, JSON.stringify(endpoint), "MCP endpoint file");
+}
+function removeEndpointFile(dataDir, pid) {
+  const current = readEndpoint(dataDir);
+  if (current && current.pid !== pid) return;
+  try {
+    (0, import_confined_fs.removeWithin)(dataDir, ENDPOINT_FILE);
+  } catch {
+  }
+}
+function readEndpoint(dataDir) {
+  try {
+    const parsed = JSON.parse((0, import_confined_fs.readTextWithin)(dataDir, ENDPOINT_FILE, "MCP endpoint file"));
+    if (typeof parsed.url !== "string" || !isLoopbackSseUrl(parsed.url)) return null;
+    return {
+      url: parsed.url,
+      pid: typeof parsed.pid === "number" ? parsed.pid : 0,
+      startedAt: typeof parsed.startedAt === "number" ? parsed.startedAt : 0
+    };
+  } catch {
+    return null;
+  }
+}
+function readToken(dataDir) {
+  try {
+    const token = (0, import_confined_fs.readTextWithin)(dataDir, TOKEN_FILE, "capability token").trim();
+    return token.length >= 16 ? token : null;
+  } catch {
+    return null;
+  }
+}
+function readConnectTarget(dataDir) {
+  const token = readToken(dataDir);
+  if (!token) return { ok: false, reason: `no capability token in ${dataDir} yet` };
+  const endpoint = readEndpoint(dataDir);
+  if (!endpoint) return { ok: false, reason: "the app has not published its MCP endpoint yet" };
+  try {
+    const tokenAt = import_node_fs.default.lstatSync(import_node_path.default.join(dataDir, TOKEN_FILE)).mtimeMs;
+    const endpointAt = import_node_fs.default.lstatSync(import_node_path.default.join(dataDir, ENDPOINT_FILE)).mtimeMs;
+    if (endpointAt < tokenAt) return { ok: false, reason: "the app is still starting" };
+  } catch {
+    return { ok: false, reason: "the app is still starting" };
+  }
+  return { ok: true, url: endpoint.url, token };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ENDPOINT_FILE,
+  TOKEN_FILE,
+  defaultDataDir,
+  isLoopbackSseUrl,
+  readConnectTarget,
+  readEndpoint,
+  readToken,
+  removeEndpointFile,
+  writeEndpointFile
+});

package/src/backend/mcp/connector/hook.js

@@ -0,0 +1,284 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hook_exports = {};
+__export(hook_exports, {
+  CHECK_EDIT_FLAG: () => CHECK_EDIT_FLAG,
+  CHECK_EDIT_HELD: () => CHECK_EDIT_HELD,
+  GEMINI_HOOK_MATCHER: () => GEMINI_HOOK_MATCHER,
+  HOOK_BREAKPOINT_MARKER: () => HOOK_BREAKPOINT_MARKER,
+  HOOK_FLAG: () => HOOK_FLAG,
+  HOOK_GEMINI_BEFORE_TOOL: () => HOOK_GEMINI_BEFORE_TOOL,
+  HOOK_MARKER: () => HOOK_MARKER,
+  HOOK_MATCHER: () => HOOK_MATCHER,
+  HOOK_PRE_TOOL_USE: () => HOOK_PRE_TOOL_USE,
+  OLD_TEXT_FILE_FLAG: () => OLD_TEXT_FILE_FLAG,
+  breakpointAnswer: () => breakpointAnswer,
+  geminiDeny: () => geminiDeny,
+  hookDeny: () => hookDeny,
+  hookNotice: () => hookNotice,
+  hookOutput: () => hookOutput,
+  parseGeminiHookInput: () => parseGeminiHookInput,
+  parseHookInput: () => parseHookInput,
+  repoOf: () => repoOf,
+  runCheckEdit: () => runCheckEdit,
+  runGeminiBeforeToolHook: () => runGeminiBeforeToolHook,
+  runPreToolUseHook: () => runPreToolUseHook
+});
+module.exports = __toCommonJS(hook_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+const HOOK_FLAG = "--hook";
+const HOOK_PRE_TOOL_USE = "pre-tool-use";
+const HOOK_MATCHER = "Edit|Write|MultiEdit|NotebookEdit";
+const HOOK_MARKER = "\u2500\u2500 CodeTrellis awareness \u2500\u2500";
+const HOOK_BREAKPOINT_MARKER = "\u2500\u2500 CodeTrellis breakpoint \u2500\u2500";
+function parseHookInput(raw) {
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!input || typeof input !== "object") return null;
+  const { cwd, tool_input: toolInput } = input;
+  if (typeof cwd !== "string" || !import_node_path.default.isAbsolute(cwd)) return null;
+  if (!toolInput || typeof toolInput !== "object") return null;
+  const t = toolInput;
+  const filePath = typeof t.file_path === "string" ? t.file_path : typeof t.notebook_path === "string" ? t.notebook_path : null;
+  if (!filePath) return null;
+  const olds = typeof t.old_string === "string" ? [t.old_string] : Array.isArray(t.edits) ? t.edits.map((e) => e && typeof e === "object" ? e.old_string : null) : null;
+  const oldTexts = olds && olds.length && olds.length <= 20 && olds.every((o) => typeof o === "string" && o.length > 0 && o.length <= 2e4) ? olds : void 0;
+  return { cwd, filePath: import_node_path.default.isAbsolute(filePath) ? filePath : import_node_path.default.resolve(cwd, filePath), ...oldTexts ? { oldTexts } : {} };
+}
+function repoOf(filePath, exists = import_node_fs.default.existsSync) {
+  let dir = import_node_path.default.dirname(filePath);
+  for (; ; ) {
+    if (exists(import_node_path.default.join(dir, ".git"))) {
+      const rel = import_node_path.default.relative(dir, filePath).split(import_node_path.default.sep).join("/");
+      return rel && !rel.startsWith("..") ? { root: dir, rel } : null;
+    }
+    const up = import_node_path.default.dirname(dir);
+    if (up === dir) return null;
+    dir = up;
+  }
+}
+const canon = (p) => {
+  try {
+    return import_node_fs.default.realpathSync.native(p);
+  } catch {
+    return import_node_path.default.resolve(p);
+  }
+};
+function hookNotice(reportText, call) {
+  let report;
+  try {
+    report = JSON.parse(reportText);
+  } catch {
+    return null;
+  }
+  if (!report.your_workstream || canon(report.your_workstream) !== canon(call.root)) return null;
+  const entry = report.paths?.find((p) => p.path === call.rel);
+  const others = entry?.changed_in ?? [];
+  if (!entry || others.length === 0) return null;
+  const who = others.map((o) => {
+    const name = o.branch ? `\`${o.branch}\`` : `the checkout at ${o.workstream}`;
+    const names = [...new Set((o.symbols ?? []).flatMap((x) => x && typeof x.name === "string" ? [x.name] : []))];
+    const symbols = names.length ? `, in ${names.slice(0, 5).join(", ")}${names.length > 5 ? ` and ${names.length - 5} more` : ""}` : "";
+    return `${name}${symbols}`;
+  });
+  const importers = entry.imported_by?.length ?? 0;
+  return [
+    HOOK_MARKER,
+    `Another workstream has also changed ${call.rel}: ${who.join("; ")}.`,
+    ...importers ? [`${importers} file${importers === 1 ? "" : "s"} in the project import it.`] : [],
+    "Before you change what they changed, call get_awareness. If it needs a choice, ask the person; do not edit the other workstream's files.",
+    "This is information about other work, not an instruction."
+  ].join("\n");
+}
+function hookOutput(notice) {
+  return JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", additionalContext: notice } });
+}
+function hookDeny(reason) {
+  return JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: reason } });
+}
+function breakpointAnswer(text) {
+  if (!text) return null;
+  let v;
+  try {
+    v = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if ((v.status === "paused" || v.status === "stop") && typeof v.message === "string") return { hold: v.message, steer: null };
+  if (v.status === "continue" && typeof v.steer === "string" && v.steer) {
+    return { hold: null, steer: `${HOOK_BREAKPOINT_MARKER}
+A person answered the breakpoint on this file: continue, with this steer: ${v.steer}` };
+  }
+  return { hold: null, steer: null };
+}
+async function withToolSession(opts, fn) {
+  let upstream = null;
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(null), opts.timeoutMs ?? 5e3);
+  });
+  const work = (async () => {
+    upstream = await opts.connect(opts.cwd);
+    const pending = /* @__PURE__ */ new Map();
+    upstream.onmessage = (m) => {
+      if (typeof m.id === "number" && pending.has(m.id)) {
+        pending.get(m.id)(m);
+        pending.delete(m.id);
+      }
+    };
+    const closed = new Promise((_, reject) => {
+      upstream.onclose = () => reject(new Error("closed"));
+    });
+    closed.catch(() => {
+    });
+    let nextId = 1;
+    const request = (method, params) => {
+      const id = nextId++;
+      return Promise.race([
+        new Promise((resolve) => {
+          pending.set(id, resolve);
+          void upstream.send({ jsonrpc: "2.0", id, method, params });
+        }),
+        closed
+      ]);
+    };
+    const init = await request("initialize", {
+      protocolVersion: "2025-06-18",
+      capabilities: {},
+      clientInfo: { name: opts.clientName, version: opts.version }
+    });
+    if (init.error) return null;
+    await upstream.send({ jsonrpc: "2.0", method: "notifications/initialized" });
+    const callTool = async (name, args) => {
+      const res = await request("tools/call", { name, arguments: args });
+      const result = res.result;
+      return !result || result.isError ? null : result.content?.[0]?.text ?? null;
+    };
+    return fn(callTool);
+  })().catch(() => null);
+  try {
+    return await Promise.race([work, timeout]);
+  } finally {
+    clearTimeout(timer);
+    try {
+      upstream?.close();
+    } catch {
+    }
+  }
+}
+async function runPreToolUseHook(opts) {
+  const call = parseHookInput(opts.stdin);
+  if (!call) return null;
+  const repo = repoOf(call.filePath, opts.exists);
+  if (!repo) return null;
+  return withToolSession({ connect: opts.connect, cwd: call.cwd, version: opts.version, clientName: "claude-code-hook", timeoutMs: opts.timeoutMs }, async (callTool) => {
+    const bpArgs = call.oldTexts ? { path: repo.rel, old_text: call.oldTexts } : { path: repo.rel };
+    const held = breakpointAnswer(await callTool("check_breakpoint", bpArgs));
+    if (held?.hold) return hookDeny(held.hold);
+    const text = await callTool("check_footprint", { paths: [repo.rel] });
+    const notice = text ? hookNotice(text, repo) : null;
+    const context = [held?.steer, notice].filter((x) => !!x).join("\n\n");
+    return context ? hookOutput(context) : null;
+  });
+}
+const CHECK_EDIT_FLAG = "--check-edit";
+const OLD_TEXT_FILE_FLAG = "--old-text-file";
+const CHECK_EDIT_HELD = 2;
+async function runCheckEdit(opts) {
+  const go = { code: 0, stdout: null, stderr: null };
+  const repo = repoOf(import_node_path.default.resolve(opts.cwd, opts.file), opts.exists);
+  if (!repo) return go;
+  const answer = await withToolSession({ connect: opts.connect, cwd: repo.root, version: opts.version, clientName: "codetrellis-check-edit", timeoutMs: opts.timeoutMs }, async (callTool) => {
+    const args = opts.oldText ? { path: repo.rel, old_text: [opts.oldText] } : { path: repo.rel };
+    return breakpointAnswer(await callTool("check_breakpoint", args));
+  });
+  if (answer?.hold) return { code: CHECK_EDIT_HELD, stdout: null, stderr: answer.hold };
+  if (answer?.steer) return { code: 0, stdout: answer.steer, stderr: null };
+  return go;
+}
+const HOOK_GEMINI_BEFORE_TOOL = "gemini-before-tool";
+const GEMINI_HOOK_MATCHER = "^(write_file|replace)$";
+function parseGeminiHookInput(raw) {
+  let v;
+  try {
+    v = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (v.hook_event_name !== "BeforeTool") return null;
+  if (v.tool_name !== "write_file" && v.tool_name !== "replace") return null;
+  const cwd = typeof v.cwd === "string" ? v.cwd : null;
+  const file = v.tool_input?.file_path;
+  if (!cwd || typeof file !== "string" || !file) return null;
+  const old = v.tool_input?.old_string;
+  const oldTexts = v.tool_name === "replace" && typeof old === "string" && old && old.length <= 2e4 ? [old] : void 0;
+  return { cwd, filePath: import_node_path.default.resolve(cwd, file), ...oldTexts ? { oldTexts } : {} };
+}
+function geminiDeny(reason) {
+  return JSON.stringify({ decision: "deny", reason });
+}
+async function runGeminiBeforeToolHook(opts) {
+  const call = parseGeminiHookInput(opts.stdin);
+  if (!call) return null;
+  const repo = repoOf(call.filePath, opts.exists);
+  if (!repo) return null;
+  return withToolSession({ connect: opts.connect, cwd: call.cwd, version: opts.version, clientName: "gemini-cli-hook", timeoutMs: opts.timeoutMs }, async (callTool) => {
+    const args = call.oldTexts ? { path: repo.rel, old_text: call.oldTexts } : { path: repo.rel };
+    const held = breakpointAnswer(await callTool("check_breakpoint", args));
+    return held?.hold ? geminiDeny(held.hold) : null;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CHECK_EDIT_FLAG,
+  CHECK_EDIT_HELD,
+  GEMINI_HOOK_MATCHER,
+  HOOK_BREAKPOINT_MARKER,
+  HOOK_FLAG,
+  HOOK_GEMINI_BEFORE_TOOL,
+  HOOK_MARKER,
+  HOOK_MATCHER,
+  HOOK_PRE_TOOL_USE,
+  OLD_TEXT_FILE_FLAG,
+  breakpointAnswer,
+  geminiDeny,
+  hookDeny,
+  hookNotice,
+  hookOutput,
+  parseGeminiHookInput,
+  parseHookInput,
+  repoOf,
+  runCheckEdit,
+  runGeminiBeforeToolHook,
+  runPreToolUseHook
+});

package/src/backend/mcp/connector/main.js

@@ -0,0 +1,126 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_core = require("./core");
+var import_sse_upstream = require("./sse-upstream");
+var import_files = require("./files");
+var import_node_fs = __toESM(require("node:fs"));
+var import_hook = require("./hook");
+const VERSION = typeof __CONNECTOR_VERSION__ === "string" ? __CONNECTOR_VERSION__ : "dev";
+function argValue(flag) {
+  const i = process.argv.indexOf(flag);
+  return i >= 0 && i + 1 < process.argv.length ? process.argv[i + 1] : null;
+}
+const dataDir = argValue("--data-dir") ?? (0, import_files.defaultDataDir)();
+const log = (line) => process.stderr.write(`[codetrellis-mcp] ${line}
+`);
+const connectFrom = (cwd) => {
+  const target = (0, import_files.readConnectTarget)(dataDir);
+  if (!target.ok) throw new Error(target.reason);
+  return (0, import_sse_upstream.connectSseUpstream)({
+    url: target.url,
+    token: target.token,
+    binding: { cwd, hostTerminal: process.env.CODETRELLIS_HOST_TERMINAL ?? null }
+  });
+};
+if (argValue(import_hook.HOOK_FLAG) === import_hook.HOOK_PRE_TOOL_USE || argValue(import_hook.HOOK_FLAG) === import_hook.HOOK_GEMINI_BEFORE_TOOL) {
+  const run = argValue(import_hook.HOOK_FLAG) === import_hook.HOOK_GEMINI_BEFORE_TOOL ? import_hook.runGeminiBeforeToolHook : import_hook.runPreToolUseHook;
+  let input = "";
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => {
+    input += chunk;
+  });
+  process.stdin.on("end", () => {
+    void run({ stdin: input, connect: async (cwd) => connectFrom(cwd), version: VERSION }).catch(() => null).then((out) => {
+      if (out) process.stdout.write(`${out}
+`, () => process.exit(0));
+      else process.exit(0);
+    });
+  });
+} else if (argValue(import_hook.CHECK_EDIT_FLAG) !== null) {
+  const file = argValue(import_hook.CHECK_EDIT_FLAG);
+  const oldTextFile = argValue(import_hook.OLD_TEXT_FILE_FLAG);
+  let oldText = null;
+  try {
+    oldText = oldTextFile ? import_node_fs.default.readFileSync(oldTextFile, "utf8").slice(0, 2e4) : null;
+  } catch {
+    oldText = null;
+  }
+  void (0, import_hook.runCheckEdit)({ file, cwd: process.cwd(), oldText, connect: async (cwd) => connectFrom(cwd), version: VERSION }).catch(() => ({ code: 0, stdout: null, stderr: null })).then((r) => {
+    const out = () => r.stdout ? process.stdout.write(`${r.stdout}
+`, () => process.exit(r.code)) : process.exit(r.code);
+    if (r.stderr) process.stderr.write(`${r.stderr}
+`, out);
+    else out();
+  });
+} else {
+  runConnector();
+}
+function runConnector() {
+  const core = new import_core.ConnectorCore({
+    version: VERSION,
+    log,
+    send: (msg) => {
+      process.stdout.write(`${JSON.stringify(msg)}
+`);
+    },
+    // Read both files on EVERY connect. This is the entire point: the token
+    // rotates on each launch, and the port moves when a second instance runs.
+    // The agent launched us in its working directory; a CodeTrellis terminal
+    // also names itself. The server binds the session to a workstream from
+    // these, re-derived on every connect (Phase 32 A1.1).
+    connect: async () => connectFrom(process.cwd())
+  });
+  let buffer = "";
+  let queue = Promise.resolve();
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => {
+    buffer += chunk;
+    let newline;
+    while ((newline = buffer.indexOf("\n")) >= 0) {
+      const line = buffer.slice(0, newline).trim();
+      buffer = buffer.slice(newline + 1);
+      if (!line) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        log("Ignored a line that was not JSON.");
+        continue;
+      }
+      queue = queue.then(() => core.handleClientMessage(msg)).catch((err) => {
+        log(`Error handling a message: ${err instanceof Error ? err.message : String(err)}`);
+      });
+    }
+  });
+  const shutdown = () => {
+    core.stop();
+    process.exit(0);
+  };
+  process.stdin.on("end", shutdown);
+  process.stdin.on("close", shutdown);
+  process.stdout.on("error", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+  log(`Starting (data dir ${dataDir}).`);
+  core.start();
+}

package/src/backend/mcp/connector/sse-upstream.js

@@ -0,0 +1,152 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sse_upstream_exports = {};
+__export(sse_upstream_exports, {
+  TOKEN_HEADER: () => TOKEN_HEADER,
+  UpstreamRefused: () => UpstreamRefused,
+  connectSseUpstream: () => connectSseUpstream
+});
+module.exports = __toCommonJS(sse_upstream_exports);
+var import_binding_headers = require("../binding-headers");
+const TOKEN_HEADER = "x-codetrellis-token";
+class UpstreamRefused extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "UpstreamRefused";
+  }
+  status;
+}
+async function connectSseUpstream(opts) {
+  const doFetch = opts.fetchImpl ?? fetch;
+  const abort = new AbortController();
+  const headers = { [TOKEN_HEADER]: opts.token };
+  let res;
+  try {
+    res = await doFetch(opts.url, {
+      headers: { ...headers, ...(0, import_binding_headers.bindingHeaders)(opts.binding ?? {}), Accept: "text/event-stream" },
+      signal: abort.signal
+    });
+  } catch (err) {
+    abort.abort();
+    throw new Error(`not reachable at ${opts.url}${err instanceof Error && err.message ? ` (${err.message})` : ""}`);
+  }
+  if (!res.ok || !res.body) {
+    abort.abort();
+    throw new UpstreamRefused(
+      res.status,
+      res.status === 401 ? "the capability token was refused \u2014 the app may be mid-restart" : `the server answered HTTP ${res.status}`
+    );
+  }
+  let closed = false;
+  let postUrl = null;
+  let resolveEndpoint = () => {
+  };
+  const endpointSeen = new Promise((resolve) => {
+    resolveEndpoint = resolve;
+  });
+  const upstream = {
+    async send(msg) {
+      if (closed || !postUrl) throw new Error("connection closed");
+      const r = await doFetch(postUrl, {
+        method: "POST",
+        headers: { ...headers, "Content-Type": "application/json" },
+        body: JSON.stringify(msg)
+      });
+      await r.text().catch(() => "");
+      if (!r.ok) throw new UpstreamRefused(r.status, `message refused with HTTP ${r.status}`);
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      abort.abort();
+      upstream.onclose?.();
+    }
+  };
+  const onEvent = (event, data) => {
+    if (event === "endpoint") {
+      const target = new URL(data, opts.url);
+      if (target.origin !== new URL(opts.url).origin) {
+        upstream.close();
+        return;
+      }
+      postUrl = target.toString();
+      resolveEndpoint(postUrl);
+      return;
+    }
+    if (event === "message") {
+      let parsed;
+      try {
+        parsed = JSON.parse(data);
+      } catch {
+        return;
+      }
+      upstream.onmessage?.(parsed);
+    }
+  };
+  void (async () => {
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true }).replace(/\r\n?/g, "\n");
+        let boundary;
+        while ((boundary = buffer.indexOf("\n\n")) >= 0) {
+          const block = buffer.slice(0, boundary);
+          buffer = buffer.slice(boundary + 2);
+          let event = "message";
+          const data = [];
+          for (const line of block.split("\n")) {
+            if (line.startsWith(":")) continue;
+            const colon = line.indexOf(":");
+            const field = colon === -1 ? line : line.slice(0, colon);
+            const value2 = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+            if (field === "event") event = value2;
+            else if (field === "data") data.push(value2);
+          }
+          if (data.length > 0) onEvent(event, data.join("\n"));
+        }
+      }
+    } catch {
+    }
+    upstream.close();
+  })();
+  const timeout = opts.handshakeTimeoutMs ?? 5e3;
+  let timer;
+  const winner = await Promise.race([
+    endpointSeen,
+    new Promise((resolve) => {
+      timer = setTimeout(() => resolve(null), timeout);
+    })
+  ]);
+  clearTimeout(timer);
+  if (!winner || closed) {
+    upstream.close();
+    throw new Error("the server did not complete the SSE handshake");
+  }
+  return upstream;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TOKEN_HEADER,
+  UpstreamRefused,
+  connectSseUpstream
+});