@limno/core 0.1.2 → 0.1.4

package/dist/index.js

@@ -10,8 +10,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;
@@ -53,8 +53,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);
@@ -62,7 +62,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 {
@@ -174,24 +174,451 @@ async function stampTemplate(code, id, relFile, root) {
 
 // src/service.ts
 import { createHash } from "crypto";
-import { existsSync, mkdirSync, readFileSync, renameSync, watch, writeFileSync } from "fs";
-import { createRequire as createRequire2 } from "module";
-import path2 from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync, statSync, watch, writeFileSync as writeFileSync3 } from "fs";
+import { createRequire as createRequire3 } from "module";
+import path4 from "path";
 import { emptyChangeSet, mergeStatuses, renderPrompt } from "@limno/spec";
-var ROUTE = "/__limno";
+
+// src/runner.ts
+import { spawn } from "child_process";
+import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "fs";
+import os from "os";
+import path2 from "path";
+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 = () => path2.join(os.homedir(), ".limno", "trust.json");
+function projectKey(root) {
+  try {
+    return realpathSync(root);
+  } catch {
+    return root;
+  }
+}
+function readTrust() {
+  try {
+    return JSON.parse(readFileSync(trustFile(), "utf8")).projects ?? {};
+  } catch {
+    return {};
+  }
+}
+function writeTrust(projects) {
+  mkdirSync(path2.dirname(trustFile()), { recursive: true });
+  writeFileSync(trustFile(), `${JSON.stringify({ projects }, null, 2)}
+`);
+}
+function run(cmd, args, timeoutMs = 8e3) {
+  return new Promise((resolve) => {
+    let out = "";
+    let child;
+    try {
+      child = 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 = path2.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(readFileSync(sessionsFile, "utf8"));
+    } catch {
+      return {};
+    }
+  };
+  const saveSession = (agent, id) => {
+    mkdirSync(folder, { recursive: true });
+    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 = path2.isAbsolute(p) ? p : path2.join(root, p);
+    return path2.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 = 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
+import { spawn as spawn2 } from "child_process";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import os2 from "os";
+import path3 from "path";
 var require2 = createRequire2(import.meta.url);
+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 (existsSync(path3.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (existsSync(path3.join(dir, "yarn.lock"))) return "yarn";
+    if (existsSync(path3.join(dir, "bun.lockb")) || existsSync(path3.join(dir, "bun.lock"))) return "bun";
+    if (existsSync(path3.join(dir, "package-lock.json"))) return "npm";
+    const up = path3.dirname(dir);
+    if (up === dir) return "npm";
+    dir = up;
+  }
+}
+function listedPackages(root) {
+  try {
+    const pkg = JSON.parse(readFileSync2(path3.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 = () => path3.join(os2.homedir(), ".limno", "update-check.json");
+async function latestVersion() {
+  try {
+    const cached = JSON.parse(readFileSync2(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) {
+      mkdirSync2(path3.dirname(cacheFile()), { recursive: true });
+      writeFileSync2(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 = spawn2(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 {
+            writeFileSync2(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 = createRequire3(import.meta.url);
 var STALE_MS = 3e4;
 function readJson(file) {
   try {
-    return JSON.parse(readFileSync(file, "utf8"));
+    return JSON.parse(readFileSync3(file, "utf8"));
   } catch {
     return null;
   }
 }
 function writeAtomic(file, data) {
-  mkdirSync(path2.dirname(file), { recursive: true });
+  mkdirSync3(path4.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync(tmp, data);
+  writeFileSync3(tmp, data);
   renameSync(tmp, file);
 }
 function body(req) {
@@ -210,12 +637,12 @@ function send(res, status, payload, type = "application/json") {
 }
 var hash = (s) => 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 = path2.join(root, dir);
-  const file = path2.join(folder, "changeset.json");
-  const presenceFile = path2.join(folder, "agent.json");
+  const folder = path4.join(root, dir);
+  const file = path4.join(folder, "changeset.json");
+  const presenceFile = path4.join(folder, "agent.json");
   let lastWrittenHash = "";
   const clients = /* @__PURE__ */ new Set();
   function broadcast(event, data) {
@@ -225,6 +652,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 };
   }
@@ -242,23 +671,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" ? path2.join(root, ".mcp.json") : path2.join(root, ".cursor", "mcp.json");
+    const dest = target === "claude" ? path4.join(root, ".mcp.json") : path4.join(root, ".cursor", "mcp.json");
     let config = {};
-    if (existsSync(dest)) {
+    if (existsSync2(dest)) {
       try {
-        config = JSON.parse(readFileSync(dest, "utf8"));
+        config = JSON.parse(readFileSync3(dest, "utf8"));
       } catch {
-        throw new Error(`${path2.relative(root, dest)} isn't valid JSON; fix or remove it first.`);
+        throw new Error(`${path4.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 path2.isAbsolute(a) ? path2.relative(root, a).split(path2.sep).join("/") : a;
+      return path4.isAbsolute(a) ? path4.relative(root, a).split(path4.sep).join("/") : a;
     });
     config.mcpServers = { ...config.mcpServers ?? {}, limno: { command, args: portable } };
     writeAtomic(dest, JSON.stringify(config, null, 2) + "\n");
-    return path2.relative(root, dest);
+    return path4.relative(root, dest);
   }
   let lastAgent = "";
   function pushAgent() {
@@ -269,27 +698,45 @@ data: ${JSON.stringify(data)}
     broadcast("agent", status);
   }
   function onChangeSetFile() {
-    const raw = existsSync(file) ? readFileSync(file, "utf8") : "";
+    const raw = existsSync2(file) ? readFileSync3(file, "utf8") : "";
     if (!raw || hash(raw) === lastWrittenHash) return;
     const set = readJson(file);
     if (set) broadcast("changeset", set);
   }
-  mkdirSync(folder, { recursive: true });
+  mkdirSync3(folder, { recursive: true });
   let watcher = null;
+  let watchedIno = -1;
   let debounce;
-  try {
-    watcher = 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 = statSync(folder).ino;
+      watcher = 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 = 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");
@@ -298,8 +745,8 @@ data: ${JSON.stringify(data)}
   async function openInEditor(spec) {
     const m = /^(.*?)(?::(\d+))?(?::(\d+))?$/.exec(spec);
     if (!m) return false;
-    const target = path2.resolve(root, m[1]);
-    if (!target.startsWith(root + path2.sep) || !existsSync(target)) return false;
+    const target = path4.resolve(root, m[1]);
+    if (!target.startsWith(root + path4.sep) || !existsSync2(target)) return false;
     const { default: launch } = await import("launch-editor");
     launch(`${target}${m[2] ? `:${m[2]}` : ""}${m[3] ? `:${m[3]}` : ""}`);
     return true;
@@ -309,7 +756,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, readFileSync(overlayFile(), "utf8"), "text/javascript");
+        return send(res, 200, readFileSync3(overlayFile(), "utf8"), "text/javascript");
       }
       if (url === `${ROUTE}/events`) {
         res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-store", Connection: "keep-alive" });
@@ -346,12 +793,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: path2.relative(root, file) });
+        return send(res, 200, { name: "limno", root, file: path4.relative(root, file) });
       }
       send(res, 404, { error: "not found" });
     } catch (err) {
@@ -363,6 +839,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();
@@ -374,12 +851,12 @@ data: ${JSON.stringify(data)}
 // src/server.ts
 import { createHash as createHash2 } from "crypto";
 import http from "http";
-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;
   }
@@ -409,7 +886,7 @@ function startServer(options) {
 async function listen(options) {
   const service = createLimnoService(options);
   const server = http.createServer((req, res) => {
-    if (!LOOPBACK.test(req.headers.host ?? "")) {
+    if (!LOOPBACK2.test(req.headers.host ?? "")) {
       res.statusCode = 403;
       return res.end();
     }
@@ -476,6 +953,7 @@ export {
   SOURCE_FILES,
   TEMPLATE_FILES,
   createLimnoService,
+  isLocalRequest,
   overlayFile,
   shouldStamp,
   stampSource,