@limno/core 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -34,6 +34,7 @@ __export(index_exports, {
   SOURCE_FILES: () => SOURCE_FILES,
   TEMPLATE_FILES: () => TEMPLATE_FILES,
   createLimnoService: () => createLimnoService,
+  isLocalRequest: () => isLocalRequest,
   overlayFile: () => overlayFile,
   shouldStamp: () => shouldStamp,
   stampSource: () => stampSource,
@@ -58,8 +59,8 @@ function jsxName(name) {
   return `${jsxName(name.object)}.${name.property.name}`;
 }
 var isCapitalized = (s) => /^[A-Z]/.test(s);
-function componentName(path3, fileBase) {
-  let p = path3.getFunctionParent();
+function componentName(path5, fileBase) {
+  let p = path5.getFunctionParent();
   while (p) {
     const node = p.node;
     let name;
@@ -101,8 +102,8 @@ function stampSource(code, id, relFile) {
   const fileBase = relFile.split("/").pop().replace(/\.[jt]sx?$/, "").replace(/^./, (c) => c.toUpperCase());
   let touched = false;
   traverse(ast, {
-    JSXOpeningElement(path3) {
-      const node = path3.node;
+    JSXOpeningElement(path5) {
+      const node = path5.node;
       const loc = node.loc;
       if (!loc || node.name.end == null) return;
       const name = jsxName(node.name);
@@ -110,7 +111,7 @@ function stampSource(code, id, relFile) {
       const host = node.name.type === "JSXIdentifier" && !isCapitalized(name);
       if (host) {
         if (hasAttr(node, "data-limno-src")) return;
-        const comp = componentName(path3, fileBase);
+        const comp = componentName(path5, fileBase);
         s.appendLeft(node.name.end, ` data-limno-src="${escapeAttr(where)}"${comp ? ` data-limno-comp="${escapeAttr(comp)}"` : ""}`);
         touched = true;
       } else {
@@ -222,25 +223,452 @@ async function stampTemplate(code, id, relFile, root) {
 
 // src/service.ts
 var import_node_crypto = require("crypto");
+var import_node_fs3 = require("fs");
+var import_node_module3 = require("module");
+var import_node_path4 = __toESM(require("path"), 1);
+var import_spec = require("@limno/spec");
+
+// src/runner.ts
+var import_node_child_process = require("child_process");
 var import_node_fs = require("fs");
-var import_node_module2 = require("module");
+var import_node_os = __toESM(require("os"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
-var import_spec = require("@limno/spec");
-var ROUTE = "/__limno";
+var NAMES = { claude: "Claude Code", codex: "Codex" };
+var SIGN_IN = { claude: "claude auth login", codex: "codex login" };
+var PROMPT = [
+  "You were started by Limno, a visual editor, because the designer clicked Send.",
+  "Call limno_get_changes to read the visual changes and comments waiting for you, then implement them in this project's source by following the rules it gives you.",
+  "Report progress with limno_update_status, and answer comments with limno_reply.",
+  "Only read and edit files inside this project. Don't run shell commands; Limno checks the result on the page itself.",
+  "Finish with one short sentence summarising what you changed."
+].join(" ");
+var trustFile = () => import_node_path2.default.join(import_node_os.default.homedir(), ".limno", "trust.json");
+function projectKey(root) {
+  try {
+    return (0, import_node_fs.realpathSync)(root);
+  } catch {
+    return root;
+  }
+}
+function readTrust() {
+  try {
+    return JSON.parse((0, import_node_fs.readFileSync)(trustFile(), "utf8")).projects ?? {};
+  } catch {
+    return {};
+  }
+}
+function writeTrust(projects) {
+  (0, import_node_fs.mkdirSync)(import_node_path2.default.dirname(trustFile()), { recursive: true });
+  (0, import_node_fs.writeFileSync)(trustFile(), `${JSON.stringify({ projects }, null, 2)}
+`);
+}
+function run(cmd, args, timeoutMs = 8e3) {
+  return new Promise((resolve) => {
+    let out = "";
+    let child;
+    try {
+      child = (0, import_node_child_process.spawn)(cmd, args, { env: agentEnv(), stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
+    } catch {
+      return resolve({ code: null, out: "" });
+    }
+    const timer = setTimeout(() => child.kill(), timeoutMs);
+    child.stdout?.on("data", (d) => out += d);
+    child.stderr?.on("data", (d) => out += d);
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolve({ code: null, out });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ code, out });
+    });
+  });
+}
+function agentEnv() {
+  const env = { ...process.env };
+  delete env.CLAUDECODE;
+  return env;
+}
+async function detectAgent(id) {
+  const base = { id, name: NAMES[id], signIn: SIGN_IN[id] };
+  const version = await run(id, ["--version"]);
+  if (version.code !== 0) return { ...base, installed: false, signedIn: false };
+  const status = id === "claude" ? await run("claude", ["auth", "status"]) : await run("codex", ["login", "status"]);
+  return { ...base, installed: true, signedIn: status.code === 0 };
+}
+var detected = null;
+async function detectAgents(force = false) {
+  if (!force && detected && Date.now() - detected.at < 2e4) return detected.agents;
+  const agents = await Promise.all(["claude", "codex"].map(detectAgent));
+  detected = { at: Date.now(), agents };
+  return agents;
+}
+var LOOPBACK = /^(localhost|127(?:\.\d+){3}|\[?::1\]?|[a-z0-9-]+\.localhost)$/i;
+function isLocalRequest(req) {
+  const remote = req.socket.remoteAddress ?? "";
+  if (!/^(127\.|::1$|::ffff:127\.)/.test(remote)) return false;
+  const host = (req.headers.host ?? "").replace(/:\d+$/, "");
+  if (!LOOPBACK.test(host)) return false;
+  const origin = req.headers.origin;
+  if (origin) {
+    try {
+      if (!LOOPBACK.test(new URL(origin).hostname)) return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function createRunner(root, folder, onState) {
+  const sessionsFile = import_node_path2.default.join(folder, "runner.json");
+  let child = null;
+  let again = false;
+  let state = { status: "idle", agent: null, startedAt: null, endedAt: null, log: [], files: [] };
+  const sessions = () => {
+    try {
+      return JSON.parse((0, import_node_fs.readFileSync)(sessionsFile, "utf8"));
+    } catch {
+      return {};
+    }
+  };
+  const saveSession = (agent, id) => {
+    (0, import_node_fs.mkdirSync)(folder, { recursive: true });
+    (0, import_node_fs.writeFileSync)(sessionsFile, `${JSON.stringify({ ...sessions(), [agent]: id }, null, 2)}
+`);
+  };
+  let emitTimer;
+  const emit = (now = false) => {
+    clearTimeout(emitTimer);
+    if (now) onState(state);
+    else emitTimer = setTimeout(() => onState(state), 120);
+  };
+  const log = (entry) => {
+    const last = state.log[state.log.length - 1];
+    if (last && last.text === entry.text) return;
+    state.log = [...state.log.slice(-60), { at: Date.now(), ...entry }];
+    if (entry.kind === "edit" && entry.file && !state.files.includes(entry.file)) state.files = [...state.files, entry.file];
+    emit();
+  };
+  const rel = (p) => {
+    if (!p) return "";
+    const abs = import_node_path2.default.isAbsolute(p) ? p : import_node_path2.default.join(root, p);
+    return import_node_path2.default.relative(root, abs) || p;
+  };
+  const key = projectKey(root);
+  const allowed = () => readTrust()[key]?.agent ?? null;
+  function limnoLine(tool, input = {}) {
+    if (tool.endsWith("get_changes")) return "Reading your changes";
+    if (tool.endsWith("update_status")) {
+      const n = Array.isArray(input.ids) ? input.ids.length : 0;
+      const status = String(input.status ?? "");
+      return status === "implemented" ? `Marked ${n || ""} ${n === 1 ? "change" : "changes"} done`.replace("  ", " ") : status === "failed" ? "Reported a change it couldn\u2019t make" : "Working on your changes";
+    }
+    if (tool.endsWith("reply")) return "Replied to your comment";
+    return "Checking Limno";
+  }
+  function onClaudeEvent(e) {
+    if (e.session_id) saveSession("claude", e.session_id);
+    if (e.type === "system" && e.subtype === "init") {
+      const limno = (e.mcp_servers ?? []).find((s) => s.name === "limno");
+      if (limno && limno.status !== "connected") log({ kind: "error", text: "Limno\u2019s tools didn\u2019t start for the agent" });
+      return;
+    }
+    if (e.type === "assistant") {
+      for (const block of e.message?.content ?? []) {
+        if (block.type === "tool_use") {
+          const name = String(block.name);
+          const input = block.input ?? {};
+          if (name.startsWith("mcp__limno__")) log({ kind: "limno", text: limnoLine(name, input) });
+          else if (name === "Read") log({ kind: "read", text: `Reading ${rel(input.file_path)}`, file: rel(input.file_path) });
+          else if (name === "Edit" || name === "MultiEdit" || name === "Write") log({ kind: "edit", text: `Editing ${rel(input.file_path)}`, file: rel(input.file_path) });
+          else if (name === "Glob" || name === "Grep") log({ kind: "search", text: "Searching the project" });
+        } else if (block.type === "text" && String(block.text).trim()) {
+          log({ kind: "message", text: String(block.text).trim().split("\n")[0].slice(0, 220) });
+        }
+      }
+      return;
+    }
+    if (e.type === "result") {
+      if (e.is_error) state.error = String(e.result ?? e.subtype ?? "The agent stopped with an error").slice(0, 300);
+    }
+  }
+  function onCodexEvent(e) {
+    if (e.type === "thread.started" && e.thread_id) return saveSession("codex", e.thread_id);
+    if (e.type === "error" || e.type === "turn.failed") {
+      state.error = String(e.message ?? e.error?.message ?? "The agent stopped with an error").slice(0, 300);
+      return;
+    }
+    if (e.type !== "item.started" && e.type !== "item.completed") return;
+    const item = e.item ?? {};
+    if (item.type === "mcp_tool_call" && e.type === "item.started") log({ kind: "limno", text: limnoLine(String(item.tool ?? ""), item.arguments ?? {}) });
+    else if (item.type === "file_change" && e.type === "item.completed") {
+      for (const c of item.changes ?? []) log({ kind: "edit", text: `Editing ${rel(c.path)}`, file: rel(c.path) });
+    } else if (item.type === "agent_message" && e.type === "item.completed" && item.text) {
+      log({ kind: "message", text: String(item.text).trim().split("\n")[0].slice(0, 220) });
+    } else if (item.type === "command_execution" && e.type === "item.started") {
+      log({ kind: "search", text: "Looking through the project" });
+    }
+  }
+  function args(agent, resume) {
+    const server = { command: "npx", args: ["-y", "@limno/mcp", "--root", root] };
+    if (agent === "claude") {
+      return [
+        "-p",
+        PROMPT,
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--mcp-config",
+        JSON.stringify({ mcpServers: { limno: server } }),
+        "--strict-mcp-config",
+        // Anything not listed is refused without a prompt: no shell, no web.
+        "--permission-mode",
+        "dontAsk",
+        "--allowedTools",
+        "Read",
+        "Edit",
+        "MultiEdit",
+        "Write",
+        "Glob",
+        "Grep",
+        "mcp__limno__limno_get_changes",
+        "mcp__limno__limno_update_status",
+        "mcp__limno__limno_reply",
+        "mcp__limno__limno_get_status",
+        ...resume ? ["--resume", resume] : []
+      ];
+    }
+    const opts = [
+      "--json",
+      "--sandbox",
+      "workspace-write",
+      "--skip-git-repo-check",
+      "-c",
+      `mcp_servers.limno.command=${JSON.stringify(server.command)}`,
+      "-c",
+      `mcp_servers.limno.args=${JSON.stringify(server.args)}`
+    ];
+    return resume ? ["exec", ...opts, "resume", resume, PROMPT] : ["exec", ...opts, PROMPT];
+  }
+  function launch(agent, resume) {
+    const proc = (0, import_node_child_process.spawn)(agent, args(agent, resume), { cwd: root, env: agentEnv(), stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
+    child = proc;
+    let buf = "";
+    let stderr = "";
+    let sawEvent = false;
+    proc.stdout?.on("data", (d) => {
+      buf += d;
+      const lines = buf.split("\n");
+      buf = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const e = JSON.parse(line);
+          sawEvent = true;
+          if (state.status === "starting") state.status = "running";
+          if (agent === "claude") onClaudeEvent(e);
+          else onCodexEvent(e);
+          emit();
+        } catch {
+        }
+      }
+    });
+    proc.stderr?.on("data", (d) => stderr = (stderr + d).slice(-2e3));
+    proc.on("error", (err) => {
+      state = { ...state, status: "failed", endedAt: Date.now(), error: `Couldn\u2019t start ${NAMES[agent]}: ${err.message}` };
+      child = null;
+      emit(true);
+    });
+    proc.on("close", (code, signal) => {
+      if (child !== proc) return;
+      child = null;
+      if (resume && code !== 0 && !sawEvent) {
+        launch(agent);
+        return;
+      }
+      if (state.status === "stopped") return emit(true);
+      const failed = code !== 0 || !!state.error;
+      const tail = stderr.trim().split("\n").filter(Boolean).slice(-2).join(" ").slice(0, 300);
+      state = {
+        ...state,
+        status: failed ? "failed" : "done",
+        endedAt: Date.now(),
+        error: failed ? state.error ?? (tail || `${NAMES[agent]} exited${signal ? ` (${signal})` : ` with code ${code}`}`) : void 0
+      };
+      emit(true);
+      if (again && !failed) {
+        again = false;
+        void start();
+      }
+      again = false;
+    });
+  }
+  async function start() {
+    if (child) {
+      again = true;
+      return { ok: true, queued: true };
+    }
+    const agent = allowed();
+    if (!agent) return { ok: false, error: "not-allowed" };
+    const info = (await detectAgents(true)).find((a) => a.id === agent);
+    if (!info?.installed) return { ok: false, error: `${NAMES[agent]} isn\u2019t installed on this computer.` };
+    if (!info.signedIn) return { ok: false, error: `${NAMES[agent]} isn\u2019t signed in. Run \u201C${SIGN_IN[agent]}\u201D in a terminal, then send again.` };
+    state = { status: "starting", agent, startedAt: Date.now(), endedAt: null, log: [], files: [] };
+    emit(true);
+    launch(agent, sessions()[agent]);
+    return { ok: true };
+  }
+  return {
+    async info(force) {
+      return { agents: await detectAgents(force), allowed: allowed(), state };
+    },
+    allow(agent) {
+      writeTrust({ ...readTrust(), [key]: { agent, at: Date.now() } });
+    },
+    forget() {
+      const t = readTrust();
+      delete t[key];
+      writeTrust(t);
+    },
+    start,
+    stop() {
+      if (!child) return;
+      again = false;
+      state = { ...state, status: "stopped", endedAt: Date.now() };
+      child.kill("SIGINT");
+      const c = child;
+      setTimeout(() => c.exitCode === null && c.kill("SIGTERM"), 3e3).unref();
+      emit(true);
+    },
+    close() {
+      child?.kill("SIGTERM");
+    }
+  };
+}
+
+// src/update.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs2 = require("fs");
+var import_node_module2 = require("module");
+var import_node_os2 = __toESM(require("os"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 var require2 = (0, import_node_module2.createRequire)(importMetaUrl);
+var DAY = 24 * 60 * 60 * 1e3;
+function currentVersion() {
+  try {
+    return require2("../package.json").version;
+  } catch {
+    return "0.0.0";
+  }
+}
+var newer = (a, b) => {
+  const pa = a.split(/[.-]/).map((n) => parseInt(n, 10) || 0);
+  const pb = b.split(/[.-]/).map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) > (pb[i] ?? 0);
+  return false;
+};
+function packageManager(root) {
+  let dir = root;
+  for (; ; ) {
+    if ((0, import_node_fs2.existsSync)(import_node_path3.default.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if ((0, import_node_fs2.existsSync)(import_node_path3.default.join(dir, "yarn.lock"))) return "yarn";
+    if ((0, import_node_fs2.existsSync)(import_node_path3.default.join(dir, "bun.lockb")) || (0, import_node_fs2.existsSync)(import_node_path3.default.join(dir, "bun.lock"))) return "bun";
+    if ((0, import_node_fs2.existsSync)(import_node_path3.default.join(dir, "package-lock.json"))) return "npm";
+    const up = import_node_path3.default.dirname(dir);
+    if (up === dir) return "npm";
+    dir = up;
+  }
+}
+function listedPackages(root) {
+  try {
+    const pkg = JSON.parse((0, import_node_fs2.readFileSync)(import_node_path3.default.join(root, "package.json"), "utf8"));
+    return Object.keys({ ...pkg.dependencies, ...pkg.devDependencies }).filter((n) => n.startsWith("@limno/") && n !== "@limno/cli");
+  } catch {
+    return [];
+  }
+}
+function installArgs(pm, pkgs) {
+  const at = pkgs.map((p) => `${p}@latest`);
+  if (pm === "pnpm") return ["pnpm", ["add", "-D", ...at]];
+  if (pm === "yarn") return ["yarn", ["add", "-D", ...at]];
+  if (pm === "bun") return ["bun", ["add", "-d", ...at]];
+  return ["npm", ["install", "-D", ...at]];
+}
+var cacheFile = () => import_node_path3.default.join(import_node_os2.default.homedir(), ".limno", "update-check.json");
+async function latestVersion() {
+  try {
+    const cached = JSON.parse((0, import_node_fs2.readFileSync)(cacheFile(), "utf8"));
+    if (Date.now() - cached.at < DAY) return cached.latest;
+  } catch {
+  }
+  try {
+    const res = await fetch("https://registry.npmjs.org/-/package/@limno/core/dist-tags", { signal: AbortSignal.timeout(4e3) });
+    if (!res.ok) return null;
+    const latest = (await res.json()).latest ?? null;
+    if (latest) {
+      (0, import_node_fs2.mkdirSync)(import_node_path3.default.dirname(cacheFile()), { recursive: true });
+      (0, import_node_fs2.writeFileSync)(cacheFile(), JSON.stringify({ at: Date.now(), latest }));
+    }
+    return latest;
+  } catch {
+    return null;
+  }
+}
+function createUpdater(root) {
+  let installing = null;
+  async function info() {
+    const current = currentVersion();
+    if (process.env.LIMNO_NO_UPDATE_CHECK) return { current, latest: null, available: false, command: null };
+    const latest = await latestVersion();
+    const pkgs = listedPackages(root);
+    const [cmd, args] = installArgs(packageManager(root), pkgs);
+    const available = !!latest && newer(latest, current) && pkgs.length > 0;
+    return { current, latest, available, command: available ? `${cmd} ${args.join(" ")}` : null };
+  }
+  function install() {
+    if (installing) return installing;
+    const pkgs = listedPackages(root);
+    if (!pkgs.length) return Promise.resolve({ ok: false, output: "No @limno packages found in package.json." });
+    const [cmd, args] = installArgs(packageManager(root), pkgs);
+    installing = new Promise((resolve) => {
+      let output = "";
+      const child = (0, import_node_child_process2.spawn)(cmd, args, { cwd: root, env: process.env, shell: process.platform === "win32" });
+      child.stdout?.on("data", (d) => output += d);
+      child.stderr?.on("data", (d) => output += d);
+      child.on("error", (e) => resolve({ ok: false, output: String(e) }));
+      child.on("close", (code) => {
+        if (code === 0) {
+          try {
+            (0, import_node_fs2.writeFileSync)(cacheFile(), JSON.stringify({ at: 0, latest: "" }));
+          } catch {
+          }
+        }
+        resolve({ ok: code === 0, output: output.trim().split("\n").slice(-12).join("\n") });
+      });
+    }).finally(() => {
+      installing = null;
+    });
+    return installing;
+  }
+  return { info, install };
+}
+
+// src/service.ts
+var ROUTE = "/__limno";
+var require3 = (0, import_node_module3.createRequire)(importMetaUrl);
 var STALE_MS = 3e4;
 function readJson(file) {
   try {
-    return JSON.parse((0, import_node_fs.readFileSync)(file, "utf8"));
+    return JSON.parse((0, import_node_fs3.readFileSync)(file, "utf8"));
   } catch {
     return null;
   }
 }
 function writeAtomic(file, data) {
-  (0, import_node_fs.mkdirSync)(import_node_path2.default.dirname(file), { recursive: true });
+  (0, import_node_fs3.mkdirSync)(import_node_path4.default.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  (0, import_node_fs.writeFileSync)(tmp, data);
-  (0, import_node_fs.renameSync)(tmp, file);
+  (0, import_node_fs3.writeFileSync)(tmp, data);
+  (0, import_node_fs3.renameSync)(tmp, file);
 }
 function body(req) {
   return new Promise((resolve, reject) => {
@@ -258,12 +686,12 @@ function send(res, status, payload, type = "application/json") {
 }
 var hash = (s) => (0, import_node_crypto.createHash)("sha1").update(s).digest("hex");
 function overlayFile() {
-  return require2.resolve("@limno/overlay/dist/overlay.js");
+  return require3.resolve("@limno/overlay/dist/overlay.js");
 }
 function createLimnoService({ root, dir = ".limno" }) {
-  const folder = import_node_path2.default.join(root, dir);
-  const file = import_node_path2.default.join(folder, "changeset.json");
-  const presenceFile = import_node_path2.default.join(folder, "agent.json");
+  const folder = import_node_path4.default.join(root, dir);
+  const file = import_node_path4.default.join(folder, "changeset.json");
+  const presenceFile = import_node_path4.default.join(folder, "agent.json");
   let lastWrittenHash = "";
   const clients = /* @__PURE__ */ new Set();
   function broadcast(event, data) {
@@ -273,6 +701,8 @@ data: ${JSON.stringify(data)}
 `;
     for (const c of clients) c.write(msg);
   }
+  const runner = createRunner(root, folder, (state) => broadcast("runner", state));
+  const updater = createUpdater(root);
   function setupInfo() {
     return { command: "npx", args: ["-y", "@limno/mcp", "--root", root], root };
   }
@@ -290,23 +720,23 @@ data: ${JSON.stringify(data)}
     return { connected, client: connected ? presence?.client ?? null : null, lastSeen: presence?.lastSeen ?? null, setup: setupInfo() };
   }
   function installConfig(target) {
-    const dest = target === "claude" ? import_node_path2.default.join(root, ".mcp.json") : import_node_path2.default.join(root, ".cursor", "mcp.json");
+    const dest = target === "claude" ? import_node_path4.default.join(root, ".mcp.json") : import_node_path4.default.join(root, ".cursor", "mcp.json");
     let config = {};
-    if ((0, import_node_fs.existsSync)(dest)) {
+    if ((0, import_node_fs3.existsSync)(dest)) {
       try {
-        config = JSON.parse((0, import_node_fs.readFileSync)(dest, "utf8"));
+        config = JSON.parse((0, import_node_fs3.readFileSync)(dest, "utf8"));
       } catch {
-        throw new Error(`${import_node_path2.default.relative(root, dest)} isn't valid JSON; fix or remove it first.`);
+        throw new Error(`${import_node_path4.default.relative(root, dest)} isn't valid JSON; fix or remove it first.`);
       }
     }
     const { command, args } = setupInfo();
     const portable = args.map((a, i) => {
       if (args[i - 1] === "--root") return ".";
-      return import_node_path2.default.isAbsolute(a) ? import_node_path2.default.relative(root, a).split(import_node_path2.default.sep).join("/") : a;
+      return import_node_path4.default.isAbsolute(a) ? import_node_path4.default.relative(root, a).split(import_node_path4.default.sep).join("/") : a;
     });
     config.mcpServers = { ...config.mcpServers ?? {}, limno: { command, args: portable } };
     writeAtomic(dest, JSON.stringify(config, null, 2) + "\n");
-    return import_node_path2.default.relative(root, dest);
+    return import_node_path4.default.relative(root, dest);
   }
   let lastAgent = "";
   function pushAgent() {
@@ -317,27 +747,45 @@ data: ${JSON.stringify(data)}
     broadcast("agent", status);
   }
   function onChangeSetFile() {
-    const raw = (0, import_node_fs.existsSync)(file) ? (0, import_node_fs.readFileSync)(file, "utf8") : "";
+    const raw = (0, import_node_fs3.existsSync)(file) ? (0, import_node_fs3.readFileSync)(file, "utf8") : "";
     if (!raw || hash(raw) === lastWrittenHash) return;
     const set = readJson(file);
     if (set) broadcast("changeset", set);
   }
-  (0, import_node_fs.mkdirSync)(folder, { recursive: true });
+  (0, import_node_fs3.mkdirSync)(folder, { recursive: true });
   let watcher = null;
+  let watchedIno = -1;
   let debounce;
-  try {
-    watcher = (0, import_node_fs.watch)(folder, (_event, name) => {
-      if (!name || name.endsWith(".tmp")) return;
-      clearTimeout(debounce);
-      debounce = setTimeout(() => {
-        if (name === "changeset.json") onChangeSetFile();
-        if (name === "agent.json") pushAgent();
-      }, 40);
-    });
-    watcher.unref?.();
-  } catch {
+  function startWatching() {
+    watcher?.close();
+    watcher = null;
+    try {
+      watchedIno = (0, import_node_fs3.statSync)(folder).ino;
+      watcher = (0, import_node_fs3.watch)(folder, (_event, name) => {
+        if (!name || name.endsWith(".tmp")) return;
+        clearTimeout(debounce);
+        debounce = setTimeout(() => {
+          if (name === "changeset.json") onChangeSetFile();
+          if (name === "agent.json") pushAgent();
+        }, 40);
+      });
+      watcher.unref?.();
+    } catch {
+    }
   }
-  const presenceTimer = setInterval(pushAgent, 1e4);
+  startWatching();
+  const presenceTimer = setInterval(() => {
+    let ino = -1;
+    try {
+      ino = (0, import_node_fs3.statSync)(folder).ino;
+    } catch {
+    }
+    if (ino !== -1 && ino !== watchedIno) {
+      startWatching();
+      onChangeSetFile();
+    }
+    pushAgent();
+  }, 1e4);
   presenceTimer.unref();
   const keepAlive = setInterval(() => {
     for (const c of clients) c.write(": ping\n\n");
@@ -346,8 +794,8 @@ data: ${JSON.stringify(data)}
   async function openInEditor(spec) {
     const m = /^(.*?)(?::(\d+))?(?::(\d+))?$/.exec(spec);
     if (!m) return false;
-    const target = import_node_path2.default.resolve(root, m[1]);
-    if (!target.startsWith(root + import_node_path2.default.sep) || !(0, import_node_fs.existsSync)(target)) return false;
+    const target = import_node_path4.default.resolve(root, m[1]);
+    if (!target.startsWith(root + import_node_path4.default.sep) || !(0, import_node_fs3.existsSync)(target)) return false;
     const { default: launch } = await import("launch-editor");
     launch(`${target}${m[2] ? `:${m[2]}` : ""}${m[3] ? `:${m[3]}` : ""}`);
     return true;
@@ -357,7 +805,7 @@ data: ${JSON.stringify(data)}
     if (!url.startsWith(ROUTE)) return next ? next() : send(res, 404, { error: "not found" });
     try {
       if (url === `${ROUTE}/overlay.js`) {
-        return send(res, 200, (0, import_node_fs.readFileSync)(overlayFile(), "utf8"), "text/javascript");
+        return send(res, 200, (0, import_node_fs3.readFileSync)(overlayFile(), "utf8"), "text/javascript");
       }
       if (url === `${ROUTE}/events`) {
         res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-store", Connection: "keep-alive" });
@@ -394,12 +842,41 @@ data: ${JSON.stringify(data)}
           return send(res, 409, { error: e instanceof Error ? e.message : String(e) });
         }
       }
+      if (url === `${ROUTE}/update` && req.method === "GET") {
+        return send(res, 200, await updater.info());
+      }
+      if (url === `${ROUTE}/update` && req.method === "POST") {
+        if (!isLocalRequest(req)) return send(res, 403, { error: "Only available from this computer" });
+        return send(res, 200, await updater.install());
+      }
+      if (url === `${ROUTE}/runner` && req.method === "GET") {
+        return send(res, 200, await runner.info(new URLSearchParams(query).has("refresh")));
+      }
+      if (url.startsWith(`${ROUTE}/runner/`) && req.method === "POST") {
+        if (!isLocalRequest(req)) return send(res, 403, { error: "Only available from this computer" });
+        const action = url.slice(`${ROUTE}/runner/`.length);
+        if (action === "allow") {
+          const { agent } = JSON.parse(await body(req));
+          if (agent !== "claude" && agent !== "codex") return send(res, 400, { error: "unknown agent" });
+          runner.allow(agent);
+          return send(res, 200, await runner.info());
+        }
+        if (action === "forget") {
+          runner.forget();
+          return send(res, 200, await runner.info());
+        }
+        if (action === "run") return send(res, 200, await runner.start());
+        if (action === "stop") {
+          runner.stop();
+          return send(res, 200, { ok: true });
+        }
+      }
       if (url === `${ROUTE}/open`) {
         const spec = new URLSearchParams(query).get("file") ?? "";
         return send(res, await openInEditor(spec) ? 200 : 404, { ok: true });
       }
       if (url === `${ROUTE}/info`) {
-        return send(res, 200, { name: "limno", root, file: import_node_path2.default.relative(root, file) });
+        return send(res, 200, { name: "limno", root, file: import_node_path4.default.relative(root, file) });
       }
       send(res, 404, { error: "not found" });
     } catch (err) {
@@ -411,6 +888,7 @@ data: ${JSON.stringify(data)}
     handle: (req, res, next) => void handle(req, res, next),
     close() {
       watcher?.close();
+      runner.close();
       clearInterval(presenceTimer);
       clearInterval(keepAlive);
       for (const c of clients) c.end();
@@ -422,12 +900,12 @@ data: ${JSON.stringify(data)}
 // src/server.ts
 var import_node_crypto2 = require("crypto");
 var import_node_http = __toESM(require("http"), 1);
-var LOOPBACK = /^(localhost|127\.0\.0\.1|\[::1\]|[\w-]+\.localhost)(:\d+)?$/i;
+var LOOPBACK2 = /^(localhost|127\.0\.0\.1|\[::1\]|[\w-]+\.localhost)(:\d+)?$/i;
 function allowedOrigin(origin) {
   if (!origin) return null;
   try {
     const u = new URL(origin);
-    return (u.protocol === "http:" || u.protocol === "https:") && LOOPBACK.test(u.host) ? origin : null;
+    return (u.protocol === "http:" || u.protocol === "https:") && LOOPBACK2.test(u.host) ? origin : null;
   } catch {
     return null;
   }
@@ -457,7 +935,7 @@ function startServer(options) {
 async function listen(options) {
   const service = createLimnoService(options);
   const server = import_node_http.default.createServer((req, res) => {
-    if (!LOOPBACK.test(req.headers.host ?? "")) {
+    if (!LOOPBACK2.test(req.headers.host ?? "")) {
       res.statusCode = 403;
       return res.end();
     }
@@ -525,6 +1003,7 @@ function shouldStamp(file, include = SOURCE_FILES) {
   SOURCE_FILES,
   TEMPLATE_FILES,
   createLimnoService,
+  isLocalRequest,
   overlayFile,
   shouldStamp,
   stampSource,