@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.1

package/src/remote-workers/worker.js

@@ -0,0 +1,304 @@
+import { resolveRunPermissions } from "../run-permissions.js";
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { execFile } from "node:child_process";
+import { lstat, mkdir, open, readFile, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { getAdapter } from "../adapters/index.js";
+import { validateAgentContainer } from "../agent-container.js";
+import { ensureCodeflowExcludes, git, resolveCommit } from "../git.js";
+import { redactExport } from "../privacy.js";
+import { verificationIntegrity } from "../verification-integrity.js";
+import { registerPrivateEnvNames } from "../env.js";
+import { assertTransferTree, boundedBundle, disabledCheckoutFilters, gitChecked, sha256, writeContext } from "./bundles.js";
+import { CAPABILITY, MAX_EVENTS_BYTES, REQUEST_ID, RemoteWorkerError, validateWorkerRequest } from "./protocol.js";
+import { durableWorkerDirectory } from "./durability.js";
+const object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const hashCapability = (value) => createHash("sha256").update(value).digest();
+async function loadWorkerConfig(path) {
+  registerPrivateEnvNames(["CODEFLOW_WORKER_CONFIG_FILE", "CODEFLOW_REMOTE_WORKERS_FILE", "CODEFLOW_REMOTE_WORKERS_JSON"]);
+  if (!isAbsolute(path)) throw new RemoteWorkerError("Worker configuration path must be absolute");
+  const info = await lstat(path);
+  if (!info.isFile() || info.isSymbolicLink() || info.size > 128 * 1024) throw new RemoteWorkerError("Worker configuration must be a regular file under 128 KiB");
+  const raw = JSON.parse(await readFile(path, "utf8"));
+  if (!object(raw) || raw.version !== 1 || typeof raw.root !== "string" || !isAbsolute(raw.root) || !object(raw.repos) || Object.keys(raw.repos).length > 20 || !Array.isArray(raw.providers) || !raw.providers.length || raw.providers.some((id) => !["claude", "codex", "agy"].includes(id))) throw new RemoteWorkerError("Invalid explicitly provisioned worker configuration");
+  const repos = /* @__PURE__ */ Object.create(null);
+  for (const [id, path2] of Object.entries(raw.repos)) {
+    if (!/^[a-z][a-z0-9-]{0,63}$/.test(id) || typeof path2 !== "string" || !isAbsolute(path2) || !(await lstat(path2)).isDirectory()) throw new RemoteWorkerError("Worker repository mappings need regular, existing absolute Git directories");
+    repos[id] = await realpath(path2);
+    await resolveCommit(repos[id]);
+  }
+  const allowedTrust = raw.allowedTrust ?? ["safe", "standard"];
+  if (!Array.isArray(allowedTrust) || !allowedTrust.length || allowedTrust.some((value) => !["safe", "standard", "trusted", "full"].includes(value))) throw new RemoteWorkerError("Invalid worker permission policy");
+  if (raw.containers !== void 0 && (!object(raw.containers) || Object.keys(raw.containers).length > 20)) throw new RemoteWorkerError("Worker containers must be at most 20 explicit named profiles");
+  const containers = /* @__PURE__ */ Object.create(null);
+  for (const [id, value] of Object.entries(raw.containers ?? {})) {
+    if (!/^[a-z][a-z0-9-]{0,63}$/.test(id)) throw new RemoteWorkerError("Invalid worker container profile ID");
+    containers[id] = validateAgentContainer(value);
+  }
+  await durableWorkerDirectory(raw.root);
+  if (!(await lstat(raw.root)).isDirectory()) throw new RemoteWorkerError("Worker root must be a regular directory");
+  return { version: 1, root: await realpath(raw.root), repos, providers: [...new Set(raw.providers)], allowedTrust, containers };
+}
+class ProvisionedWorker {
+  constructor(config) {
+    this.config = config;
+  }
+  controllers = /* @__PURE__ */ new Map();
+  async providerAvailable(id, profile) {
+    if (!profile) return getAdapter(id).available();
+    if (!Object.hasOwn(this.config.containers, profile)) throw new RemoteWorkerError("Choose an explicit worker-local container profile");
+    const container = this.config.containers[profile], name = `codeflow-probe-${randomBytes(8).toString("hex")}`;
+    const invoke = (args, timeout) => new Promise((done) => execFile("docker", args, { timeout, killSignal: "SIGKILL", maxBuffer: 64 * 1024 }, (error) => done(!error)));
+    try {
+      return await invoke(["run", "--rm", "--pull=never", "--name", name, "--network=none", "--read-only", "--cap-drop=ALL", "--security-opt=no-new-privileges", "--entrypoint", getAdapter(id).binary, container.image, "--version"], 1e4);
+    } finally {
+      await invoke(["rm", "-f", name], 5e3);
+    }
+  }
+  async capabilities(containerProfile, discoverModels = false) {
+    if (containerProfile !== void 0 && (!/^[a-z][a-z0-9-]{0,63}$/.test(containerProfile) || !Object.hasOwn(this.config.containers, containerProfile))) throw new RemoteWorkerError("Choose an explicit worker-local container profile");
+    return { protocol: 1, providers: await Promise.all(this.config.providers.map(async (id) => ({ id, available: await this.providerAvailable(id, containerProfile), modelCatalog: discoverModels ? await getAdapter(id).discoverModels?.({ cwd: this.config.root, agentContainer: containerProfile ? this.config.containers[containerProfile] : void 0 }).catch(() => void 0) : void 0 }))), repoMappings: Object.keys(this.config.repos), containerProfiles: Object.keys(this.config.containers), resumeSessions: false, liveTeamTools: false, interactiveApprovals: false, stagedContext: true, maximumBundleBytes: 64 * 1024 * 1024, maximumContextBytes: 16 * 1024 * 1024 };
+  }
+  repo(id) {
+    const path = Object.hasOwn(this.config.repos, id) ? this.config.repos[id] : void 0;
+    if (!path) throw new RemoteWorkerError("Choose an explicitly provisioned worker repository mapping");
+    return path;
+  }
+  directory(id) {
+    if (!REQUEST_ID.test(id)) throw new RemoteWorkerError("Invalid worker request identity");
+    return join(this.config.root, "requests", id);
+  }
+  async save(receipt) {
+    const folder = this.directory(receipt.requestId), temp = join(folder, `receipt-${randomBytes(8).toString("hex")}.tmp`);
+    const handle = await open(temp, "wx", 384);
+    try {
+      await handle.writeFile(JSON.stringify(receipt));
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    try {
+      await rename(temp, join(folder, "receipt.json"));
+      await this.syncDirectory(folder);
+    } finally {
+      await rm(temp, { force: true });
+    }
+  }
+  async syncDirectory(path) {
+    const handle = await open(path, "r");
+    try {
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+  }
+  async acquireSlot(id) {
+    const root = join(this.config.root, "slots");
+    await mkdir(root, { recursive: true, mode: 448 });
+    for (let slot = 0; slot < 4; slot++) {
+      const file = join(root, String(slot));
+      let handle;
+      try {
+        handle = await open(file, "wx", 384);
+        await handle.writeFile(JSON.stringify({ id, pid: process.pid }));
+        await handle.sync();
+        return async () => {
+          await rm(file, { force: true });
+        };
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+      } finally {
+        await handle?.close();
+      }
+    }
+    throw new RemoteWorkerError("Worker has four active or unresolved execution slots. Inspect stale worker processes before removing their slot files.");
+  }
+  publicReceipt(receipt) {
+    const { capabilityHash: _hash, pid: _pid, ...value } = receipt;
+    return redactExport(value);
+  }
+  async receipt(id, capability) {
+    if (!CAPABILITY.test(capability)) throw new RemoteWorkerError("Invalid worker request capability");
+    const file = join(this.directory(id), "receipt.json"), info = await lstat(file).catch(() => void 0);
+    if (!info) return { version: 1, requestId: id, state: "unknown", reason: "No durable receipt is available. Do not automatically repeat this execution." };
+    if (!info.isFile() || info.isSymbolicLink() || info.size > 2 * 1024 * 1024) throw new RemoteWorkerError("Worker receipt is damaged");
+    const saved = JSON.parse(await readFile(file, "utf8"));
+    if (saved.version !== 1 || saved.requestId !== id || !/^[a-f0-9]{64}$/.test(saved.capabilityHash) || !timingSafeEqual(Buffer.from(saved.capabilityHash, "hex"), hashCapability(capability))) throw new RemoteWorkerError("This capability does not own the worker receipt");
+    const value = this.publicReceipt(saved);
+    if (["accepted", "running"].includes(value.state) && Date.now() - (value.heartbeatAt ?? value.updatedAt ?? 0) > 15e3) {
+      value.state = "unknown";
+      value.reason = "Worker heartbeat expired; the execution outcome is ambiguous. Inspect or cancel it before explicitly retrying.";
+    }
+    return value;
+  }
+  async cancel(id, capability) {
+    const receipt = await this.receipt(id, capability);
+    if (["completed", "failed", "cancelled"].includes(receipt.state)) return receipt;
+    if (!receipt.createdAt) return { ...receipt, reason: "No execution receipt was found; nothing was cancelled. Do not automatically repeat an ambiguous request." };
+    await writeFile(join(this.directory(id), "cancel"), "cancel\n", { flag: "w", mode: 384 });
+    this.controllers.get(id)?.abort();
+    return receipt;
+  }
+  async capacity() {
+    const root = join(this.config.root, "requests");
+    await durableWorkerDirectory(root);
+    const entries = await readdir(root);
+    if (entries.length >= 100) throw new RemoteWorkerError("Worker keeps at most 100 request receipts. Archive inspected terminal request directories before accepting more work.");
+  }
+  /** The exclusive receipt lock is acquired before any provider launches and is never reused. */
+  async execute(raw, source, context, emit, heartbeat, signal) {
+    const request = validateWorkerRequest(raw), repo = this.repo(request.repoMapping);
+    const fingerprint = sha256(JSON.stringify({ ...request, capability: void 0, source: void 0 }));
+    if (!this.config.providers.includes(request.agent) || !await this.providerAvailable(request.agent, request.containerProfile)) throw new RemoteWorkerError("The selected official CLI is unavailable in this worker execution profile");
+    if (!this.config.allowedTrust.includes(request.trust)) throw new RemoteWorkerError("The requested permission level is outside this worker's explicit policy");
+    if (request.containerProfile && !Object.hasOwn(this.config.containers, request.containerProfile)) throw new RemoteWorkerError("Choose an explicit worker-local container profile; host credential volumes are never forwarded");
+    await this.capacity();
+    const folder = this.directory(request.id);
+    await mkdir(folder, { recursive: true, mode: 448 });
+    let lock;
+    try {
+      lock = await open(join(folder, "execution.lock"), "wx", 384);
+      await lock.writeFile(request.id);
+      await lock.sync();
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const receipt = await this.receipt(request.id, request.capability);
+      if (receipt.fingerprint && receipt.fingerprint !== fingerprint) throw new RemoteWorkerError("This request identity belongs to a different scoped execution");
+      return { receipt, result: receipt.result ?? { ok: false, finalText: "", error: "This request was already accepted; inspect its receipt instead of duplicating it", errorKind: "other" } };
+    } finally {
+      await lock?.close();
+    }
+    const saved = { version: 1, requestId: request.id, state: "accepted", fingerprint, capabilityHash: hashCapability(request.capability).toString("hex"), createdAt: Date.now(), updatedAt: Date.now(), heartbeatAt: Date.now(), pid: process.pid };
+    await this.syncDirectory(folder);
+    await this.syncDirectory(join(this.config.root, "requests"));
+    await this.save(saved);
+    heartbeat(this.publicReceipt(saved));
+    const controller = new AbortController();
+    this.controllers.set(request.id, controller);
+    const abort = () => controller.abort();
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+    const timeout = setTimeout(abort, request.timeoutMs);
+    timeout.unref();
+    let ticking = false, eventsBytes = 0, artifact;
+    const tick = setInterval(() => {
+      if (ticking) return;
+      ticking = true;
+      void (async () => {
+        if (await lstat(join(folder, "cancel")).then(() => true, () => false)) controller.abort();
+        saved.heartbeatAt = Date.now();
+        saved.updatedAt = Date.now();
+        await this.save(saved);
+        heartbeat(this.publicReceipt(saved));
+      })().catch(abort).finally(() => {
+        ticking = false;
+      });
+    }, 2e3);
+    tick.unref();
+    const checkout = join(folder, "checkout"), importRef = `refs/codeflow/imports/${request.id}`;
+    let imported = false, attached = false;
+    let releaseSlot;
+    let result = { ok: false, finalText: "", error: "Remote execution did not complete", errorKind: "other" };
+    try {
+      releaseSlot = await this.acquireSlot(request.id);
+      if (request.source) {
+        if (!source || source.length !== request.source.size || sha256(source) !== request.source.sha256) throw new RemoteWorkerError("Uploaded source bundle failed its manifest");
+        const file = join(folder, "source.bundle");
+        await writeFile(file, source, { flag: "wx", mode: 384 });
+        if (await gitChecked(repo, ["bundle", "list-heads", file]) !== `${request.baseCommit} ${request.source.ref}`) throw new RemoteWorkerError("Source bundle has unexpected references");
+        await gitChecked(repo, ["bundle", "verify", file]);
+        if (!(await git(["show-ref", "--verify", "--quiet", importRef], repo)).code) throw new RemoteWorkerError("Worker import identity is already claimed");
+        await gitChecked(repo, ["fetch", "--no-write-fetch-head", "--no-tags", "--no-recurse-submodules", file, `${request.source.ref}:${importRef}`]);
+        imported = true;
+      }
+      if (await resolveCommit(repo, request.baseCommit) !== request.baseCommit) throw new RemoteWorkerError("The provisioned mapping lacks the exact requested commit");
+      await assertTransferTree(repo, request.baseCommit);
+      const filters = await disabledCheckoutFilters(repo);
+      await ensureCodeflowExcludes(repo);
+      await gitChecked(repo, [...filters, "worktree", "add", "--detach", checkout, request.baseCommit]);
+      attached = true;
+      for (const file of request.context) {
+        const data = context.get(file.path);
+        if (!data || data.length !== file.size || sha256(data) !== file.sha256) throw new RemoteWorkerError("Uploaded context failed its manifest");
+        await writeContext(checkout, file.path, data);
+      }
+      const integrity = await verificationIntegrity(checkout, controller.signal);
+      saved.state = "running";
+      saved.updatedAt = Date.now();
+      await this.save(saved);
+      heartbeat(this.publicReceipt(saved));
+      if (controller.signal.aborted || await lstat(join(folder, "cancel")).then(() => true, () => false)) {
+        controller.abort();
+        throw new RemoteWorkerError("Remote execution was cancelled before invoking its provider");
+      }
+      const permissions = request.managedPermissions ? resolveRunPermissions({ policy: request.managedPermissions, provider: request.agent, mode: request.mode, currentTrust: request.trust, currentTools: request.managedPermissions.toolApprovals, unattended: true, container: !!request.containerProfile }) : void 0;
+      result = await getAdapter(request.agent).run({ permissions, cwd: checkout, prompt: request.prompt, mode: request.mode, model: request.model, effort: request.effort, trust: permissions?.trust ?? request.trust, interactiveApprovals: permissions?.toolApprovals ?? false, timeoutMs: request.timeoutMs, idleTimeoutMs: request.idleTimeoutMs, signal: controller.signal, jsonSchema: request.jsonSchema, questionProtocol: request.questionProtocol, ...request.containerProfile ? { agentContainer: this.config.containers[request.containerProfile] } : {} }, (event) => {
+        if (event.kind === "session") return;
+        const data = redactExport(event), bytes = Buffer.byteLength(JSON.stringify(data));
+        eventsBytes += bytes;
+        if (bytes > 256 * 1024 || eventsBytes > MAX_EVENTS_BYTES) {
+          controller.abort();
+          return;
+        }
+        emit(data);
+      });
+      result = redactExport({ ...result, sessionId: void 0, finalText: result.finalText.slice(0, 512 * 1024) });
+      if (JSON.stringify(result).length > 1024 * 1024) result = { ok: false, finalText: "", error: "Worker result exceeded its bounded response", errorKind: "other" };
+      if (request.mode === "read") {
+        await integrity.assert("read-only agent turn");
+        if ((await git(["status", "--porcelain", "--untracked-files=all"], checkout)).stdout.trim()) throw new RemoteWorkerError("The read-only worker turn modified its checkout; its changes were discarded");
+      } else {
+        if (await resolveCommit(checkout) !== request.baseCommit) throw new RemoteWorkerError("The agent changed checkout history instead of returning work for its scoped commit");
+        await gitChecked(checkout, [...await disabledCheckoutFilters(checkout), "add", "--all", "--", "."]);
+        const changed = await git(["diff", "--cached", "--quiet", "--exit-code"], checkout);
+        if (changed.code > 1) throw new RemoteWorkerError("Cannot inspect remote staged changes");
+        if (changed.code === 1) {
+          await assertTransferTree(checkout, await gitChecked(checkout, ["write-tree"]));
+          await gitChecked(checkout, [...await disabledCheckoutFilters(checkout), "-c", "user.name=code-flow worker", "-c", "user.email=worker@code-flow.invalid", "commit", "-m", `Remote request ${request.id}`]);
+          const head = await resolveCommit(checkout);
+          await assertTransferTree(checkout, head);
+          const ref = `refs/codeflow/results/${request.id}`, file = join(folder, "result.bundle");
+          await gitChecked(checkout, ["update-ref", ref, head, "0".repeat(head.length)]);
+          let data;
+          try {
+            data = await boundedBundle(checkout, file, [ref, `^${request.baseCommit}`]);
+          } finally {
+            await gitChecked(checkout, ["update-ref", "-d", ref, head]);
+          }
+          artifact = { requestId: request.id, baseCommit: request.baseCommit, head, size: data.length, sha256: sha256(data), ref, file };
+        }
+      }
+      if (controller.signal.aborted) result = { ok: false, finalText: result.finalText, error: "Remote execution was cancelled or exceeded its deadline", errorKind: "cancelled" };
+    } catch (error) {
+      result = { ok: false, finalText: result.finalText, error: redactExport(error.message).slice(0, 2e3), errorKind: controller.signal.aborted ? "cancelled" : "other" };
+    } finally {
+      clearTimeout(timeout);
+      clearInterval(tick);
+      signal?.removeEventListener("abort", abort);
+      this.controllers.delete(request.id);
+      while (ticking) await new Promise((resolve) => setTimeout(resolve, 10));
+      if (attached) await gitChecked(repo, ["worktree", "remove", "--force", checkout]).catch(() => void 0);
+      if (imported) await gitChecked(repo, ["update-ref", "-d", importRef, request.baseCommit]).catch(() => void 0);
+      await rm(checkout, { recursive: true, force: true });
+      await releaseSlot?.();
+    }
+    if (controller.signal.aborted) {
+      artifact = void 0;
+      await rm(join(folder, "result.bundle"), { force: true });
+    }
+    saved.state = controller.signal.aborted ? "cancelled" : result.ok ? "completed" : "failed";
+    saved.result = result;
+    saved.updatedAt = Date.now();
+    saved.heartbeatAt = Date.now();
+    if (artifact) {
+      const { file: _file, ...manifest } = artifact;
+      saved.artifact = manifest;
+    }
+    await this.save(saved);
+    return { receipt: this.publicReceipt(saved), result, artifact };
+  }
+}
+export {
+  ProvisionedWorker,
+  loadWorkerConfig
+};

package/src/remote.js

@@ -0,0 +1,204 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { networkInterfaces } from "node:os";
+import { dirname, join } from "node:path";
+import { cantRunMessage } from "./checks.js";
+import { CODEFLOW_HOME } from "./config.js";
+import { logError } from "./log.js";
+import { projectOf } from "./projects.js";
+const FILE = join(CODEFLOW_HOME, "remote.json");
+const validToken = (t) => typeof t === "string" && /^[0-9a-f]{32,}$/.test(t);
+const fresh = () => ({ enabled: false, token: newToken(), controlToken: newToken(), lan: false, control: false });
+async function loadRemote(file = FILE) {
+  unreadable.delete(file);
+  let text;
+  try {
+    text = await readFile(file, "utf8");
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      logError(`Couldn't read ${file}; phone access is off until it can be read`, err);
+      unreadable.set(file, err.message);
+    }
+    return fresh();
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    raw = void 0;
+  }
+  if (!raw || typeof raw !== "object" || !validToken(raw.token)) {
+    const aside = `${file}.corrupt-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+    await rename(file, aside).then(
+      () => logError(`${file} couldn't be read: moved it to ${aside}; phone access is off`),
+      (err) => logError(`${file} couldn't be read, nor moved aside; phone access is off`, err)
+    );
+    return fresh();
+  }
+  const settings = {
+    enabled: raw.enabled === true,
+    token: raw.token,
+    // Saved before full control had a secret of its own: phones sign in again, once.
+    controlToken: validToken(raw.controlToken) && raw.controlToken !== raw.token ? raw.controlToken : newToken(),
+    // Unknown transports must not silently become a listener on every LAN interface.
+    lan: raw.lan === true && (raw.transport === void 0 || raw.transport === "lan" || raw.transport === "tailscale"),
+    transport: raw.transport === "tailscale" ? "tailscale" : "lan",
+    control: raw.control === true,
+    ...Number.isSafeInteger(raw.pairingUntil) && raw.pairingUntil > 0 ? { pairingUntil: raw.pairingUntil } : {}
+  };
+  if (settings.controlToken !== raw.controlToken) {
+    await saveRemote(settings, file).catch((err) => logError(`Couldn't save ${file}; the full-control link changes at the next start`, err));
+  }
+  return settings;
+}
+const unreadable = /* @__PURE__ */ new Map();
+async function saveRemote(settings, file = FILE) {
+  const why = unreadable.get(file);
+  if (why) throw new Error(`Phone settings can't be changed: ${file} couldn't be read when code-flow started (${why}). Fix its permissions, then restart code-flow.`);
+  await mkdir(dirname(file), { recursive: true });
+  const tmp = `${file}.tmp`;
+  await writeFile(tmp, JSON.stringify(settings, null, 2), { mode: 384 });
+  await rename(tmp, file);
+}
+function changeRemote(before, patch) {
+  const next = { ...before };
+  if (typeof patch.enabled === "boolean") next.enabled = patch.enabled;
+  if (typeof patch.lan === "boolean") next.lan = patch.lan;
+  if (patch.transport === "lan" || patch.transport === "tailscale") next.transport = patch.transport;
+  if (typeof patch.control === "boolean") next.control = patch.control;
+  const turnedOff = (key) => before[key] && !next[key];
+  const changedTransport = (before.transport ?? "lan") !== (next.transport ?? "lan");
+  if (patch.rotate || turnedOff("enabled") || turnedOff("lan") || changedTransport) {
+    next.token = newToken();
+    next.controlToken = newToken();
+  } else if (turnedOff("control")) {
+    next.controlToken = newToken();
+  }
+  const wasControl = before.enabled && before.lan && before.control;
+  const isControl = next.enabled && next.lan && next.control;
+  if (isControl && (patch.rotate || changedTransport || !wasControl)) next.pairingUntil = Date.now() + 10 * 6e4;
+  else if (!isControl) delete next.pairingUntil;
+  return next;
+}
+function newToken() {
+  return randomBytes(24).toString("hex");
+}
+function tokenMatches(given, token) {
+  const a = Buffer.from(given);
+  const b = Buffer.from(token);
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+function lanAddresses() {
+  return Object.values(networkInterfaces()).flat().filter((i) => i && i.family === "IPv4" && !i.internal).map((i) => i.address);
+}
+function isOwnAddress(address) {
+  if (!address) return true;
+  const plain = address.replace(/^::ffff:/i, "").replace(/%.*$/, "").toLowerCase();
+  if (plain === "::1" || plain === "::" || plain === "0.0.0.0" || plain.startsWith("127.")) return true;
+  return Object.values(networkInterfaces()).flat().some((i) => !!i && i.address.replace(/%.*$/, "").toLowerCase() === plain);
+}
+const esc = (s) => String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+const STATUS = {
+  running: "Running",
+  done: "Done",
+  failed: "Failed",
+  cancelled: "Cancelled",
+  stopped: "Stopped at limit",
+  interrupted: "Interrupted"
+};
+function badge(run) {
+  if (run.awaiting || run.status === "running" && run.team?.awaitingRequestId) return `<span class="b warn">Waiting for you</span>`;
+  if (run.team?.status === "blocked") return `<span class="b warn">Team needs attention</span>`;
+  if (run.triage?.state === "pending") return `<span class="b warn">In your inbox</span>`;
+  const watch = Object.values(run.watches ?? {}).find((w) => w.state === "needs-you");
+  if (watch) return `<span class="b warn">PR needs you</span>`;
+  const failing = run.status === "done" && run.verdict === "failing";
+  if (run.status === "done" && !failing && run.checkCantRun) return `<span class="b warn">Done \xB7 check can't run</span>`;
+  const cls = run.status === "running" ? "run" : run.status === "done" && !failing ? "ok" : "bad";
+  return `<span class="b ${cls}">${esc(failing ? "Done \xB7 check failing" : STATUS[run.status] ?? run.status)}</span>`;
+}
+const ago = (ts) => {
+  const s = Math.round((Date.now() - ts) / 1e3);
+  return s < 60 ? "just now" : s < 3600 ? `${Math.floor(s / 60)}m ago` : s < 86400 ? `${Math.floor(s / 3600)}h ago` : `${Math.floor(s / 86400)}d ago`;
+};
+function page(title, body, refresh = true) {
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+${refresh ? '<meta http-equiv="refresh" content="15">' : ""}<meta name="referrer" content="no-referrer"><meta name="robots" content="noindex">
+<title>${esc(title)}</title><style>
+:root{--bg:#f8f7f3;--raised:#fdfcf9;--sunken:#f0efe9;--text:#292a26;--muted:#65675e;--border:#e4e2da;--border-strong:#d4d2c7;--link:#2d6a4b;--mint:#36b98a;--ok:#2d6a4b;--ok-soft:#e5f4ea;--warn:#87662e;--warn-soft:#f6efdd;--bad:#a44a36;--bad-soft:#f7e9e4;--shadow:0 1px 2px rgba(34,35,24,.05);color-scheme:light}
+@media (prefers-color-scheme:dark){:root{--bg:#161713;--raised:#1e1f1a;--sunken:#121310;--text:#ecebe4;--muted:#9c9d92;--border:#2e3029;--border-strong:#3d4036;--link:#8fe3c4;--mint:#4fd0a0;--ok:#8fe3c4;--ok-soft:#19362a;--warn:#eac77f;--warn-soft:#3a2f18;--bad:#f0a08d;--bad-soft:#3d201a;--shadow:0 1px 2px rgba(0,0,0,.3);color-scheme:dark}}
+body{margin:0;background:var(--bg);color:var(--text);font:14px/1.55 Inter,-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;-webkit-font-smoothing:antialiased}
+main{max-width:720px;margin:0 auto;padding:16px 16px calc(32px + env(safe-area-inset-bottom))}
+h1{font:400 23px/1.2 Georgia,"Times New Roman",serif;letter-spacing:-.5px;margin:8px 0 12px;overflow-wrap:anywhere}h2,h3{font-size:12px;font-weight:500;color:var(--muted);margin:24px 0 8px}
+h2.project{font:400 20px/1.25 Georgia,"Times New Roman",serif;letter-spacing:-.3px;color:var(--text);margin:32px 0 0;padding-top:20px;border-top:1px solid var(--border)}
+section:first-of-type h2.project{margin-top:20px;padding-top:0;border-top:0}h2.project+h3{margin-top:12px}
+a{color:var(--link);text-decoration:none;font-weight:500}a:hover{text-decoration:underline}
+.card{display:block;background:var(--raised);border:1px solid var(--border);border-radius:12px;padding:12px 16px;margin:8px 0;color:var(--text);font-weight:400;box-shadow:var(--shadow)}
+.card:hover{border-color:var(--border-strong);text-decoration:none}
+.t{font-weight:500;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.m{font-size:12px;color:var(--muted)}.card .m{margin-top:4px}
+.b{display:inline-flex;align-items:center;gap:5px;height:20px;padding:0 8px;border-radius:999px;font-size:12px;font-weight:500;line-height:1;vertical-align:1px;background:var(--sunken);color:var(--text)}
+.b.ok,.b.run{background:var(--ok-soft);color:var(--ok)}.b.warn{background:var(--warn-soft);color:var(--warn)}.b.bad{background:var(--bad-soft);color:var(--bad)}
+.b.run:before{content:"";width:6px;height:6px;border-radius:50%;background:var(--mint)}
+pre{white-space:pre-wrap;word-break:break-word;font:12px/1.5 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;background:var(--sunken);border:1px solid var(--border);border-radius:8px;padding:10px 12px;margin:8px 0}
+ul,ol{padding-left:20px}li{margin:6px 0}li b{font-weight:600}.foot{font-size:12px;color:var(--muted);margin-top:32px}
+@media (min-width:640px){h1{font-size:26px}}
+</style></head><body><main>${body}<p class="foot">Read-only view of code-flow \xB7 refreshes every 15 s</p></main></body></html>`;
+}
+function renderRemote(manager, projects, base, path) {
+  if (path === "" || path === "/") {
+    const runs = manager.list().filter((r) => !r.archived);
+    const needs = runs.filter((r) => r.awaiting || r.status === "running" && r.team?.awaitingRequestId || r.team?.status === "blocked" || r.triage?.state === "pending" || Object.values(r.watches ?? {}).some((w) => w.state === "needs-you") || r.status !== "running" && !r.seen);
+    const running = runs.filter((r) => r.status === "running" && !needs.includes(r));
+    const recent = runs.filter((r) => !needs.includes(r) && !running.includes(r)).slice(0, 15);
+    const card = (r) => `<a class="card" href="${base}/run/${esc(r.id)}"><div class="t">${esc(r.task.split("\n")[0])}</div><div class="m">${badge(r)} \xB7 ${esc(r.pattern)} \xB7 ${esc(r.repo.split("/").pop())}${r.trigger ? ` \xB7 \u23F1 ${esc(r.trigger.name)}` : ""} \xB7 ${ago(r.createdAt)}</div></a>`;
+    const group = (tag, title, list) => list.length ? `<${tag}>${title} (${list.length})</${tag}>${list.map(card).join("")}` : "";
+    const groups = (tag, keep = () => true) => group(tag, "Needs you", needs.filter(keep)) + group(tag, "Running", running.filter(keep)) + group(tag, "Recent", recent.filter(keep));
+    const ids = [...new Set([...needs, ...running, ...recent].map((r) => projectOf(r, projects)))].sort((a, b) => Number(a === void 0) - Number(b === void 0));
+    const name = (id) => projects.find((p) => p.id === id)?.name ?? "No project";
+    const body = ids.length === 1 && ids[0] === void 0 ? groups("h2") : ids.map((id) => `<section><h2 class="project">${esc(name(id))}</h2>${groups("h3", (r) => projectOf(r, projects) === id)}</section>`).join("");
+    return page("code-flow", `<h1>code-flow</h1>${body}${runs.length ? "" : '<p class="m">No runs yet.</p>'}`);
+  }
+  const match = path.match(/^\/run\/([\w-]+)$/);
+  const run = match ? manager.get(match[1]) : void 0;
+  if (!run) return null;
+  return page(run.task.split("\n")[0].slice(0, 60), renderRun(run, base, projects.find((p) => p.id === projectOf(run, projects))), run.status === "running");
+}
+function renderRun(run, base, project) {
+  const steps = run.steps.map((s) => `<li>${s.status === "done" ? "\u2713" : s.status === "running" ? "\u2026" : s.status === "failed" ? "\u2715" : "\u25A0"} ${esc(s.title)} <span class="m">${esc(s.agent ?? s.kind)}${s.endedAt ? ` \xB7 ${Math.round((s.endedAt - s.startedAt) / 1e3)}s` : ""}</span></li>`).join("");
+  const review = run.review ? `<h2>Review</h2><p>${esc(run.review.verdict === "approve" ? "Approve" : "Changes requested")}${run.review.summary ? ` \u2014 ${esc(run.review.summary)}` : ""}</p><ol>${run.review.findings.map((f) => `<li><b>${esc(f.severity)}</b> ${esc(f.file)} \u2014 ${esc(f.problem)} <span class="m">(${esc(f.raisedBy.join(", "))})</span></li>`).join("")}</ol>` : "";
+  const watches = Object.values(run.watches ?? {}).map((w) => `<li>${esc(w.pr)} \u2014 <b>${esc(w.state)}</b>: ${esc(w.detail)}</li>`).join("");
+  const artifacts = run.artifacts.map((a) => `<li><b>${esc(a.label)}</b> <span class="m">${esc(a.branch)}</span>${a.stat ? `<pre>${esc(a.stat)}</pre>` : ""}</li>`).join("");
+  const team = run.team;
+  const memberName = (id) => id === "user" ? "You" : team?.members.find((member) => member.id === id)?.name ?? id;
+  const teamView = team ? [
+    `<h2>Team and workflow</h2><p>${esc(team.status)} \xB7 revision ${team.revision} \xB7 ${team.metrics.invocations} lifetime calls (${team.metrics.coordinatorInvocations} coordinating)</p>`,
+    `<ul>${team.tasks.map((task) => `<li><b>${esc(task.title)}</b> \xB7 ${esc(memberName(task.owner))} \xB7 ${esc(task.status ?? "planned")}${task.dependsOn.length ? `<br><span class="m">Needs ${task.dependsOn.map((id) => esc(team.tasks.find((item) => item.id === id)?.title ?? id)).join(", ")}</span>` : ""}</li>`).join("")}</ul>`,
+    team.messages.some((message) => message.kind === "question" && message.status === "open") ? `<h2>Open questions</h2><ul>${team.messages.filter((message) => message.kind === "question" && message.status === "open").map((message) => `<li><b>${esc(memberName(message.sender))} \u2192 ${esc(memberName(message.recipient))}</b>: ${esc(message.body)}${message.recipient === "user" ? `<br><span class="m">Open the full-control app or code-flow on your computer to answer.</span>` : ""}${message.deadlineAt ? `<br><span class="m">Deadline ${esc(new Date(message.deadlineAt).toLocaleString())}</span>` : ""}</li>`).join("")}</ul>` : "",
+    team.gaps.length ? `<h2>Unresolved work</h2><ul>${team.gaps.map((gap) => `<li>${esc(gap)}</li>`).join("")}</ul>` : "",
+    team.verification ? `<p class="m">Verification: ${esc(team.verification.check)} \xB7 independent review ${team.verification.reviewed ? team.verification.approved ? "approved" : "changes requested" : "pending"} \xB7 ${esc(team.verification.head.slice(0, 12))}</p>` : ""
+  ].join("") : "";
+  return [
+    `<p><a href="${base}/">\u2190 All runs</a></p>`,
+    `<h1>${esc(run.task.split("\n")[0])}</h1>`,
+    `<p class="m">${badge(run)} \xB7 ${esc(run.pattern)} \xB7 ${project && project.name !== run.repo.split("/").pop() ? `${esc(project.name)} \xB7 ` : ""}${esc(run.repo.split("/").pop())} \xB7 started ${ago(run.createdAt)}${run.trigger ? ` \xB7 by ${run.trigger.via === "sweep" ? "sweep" : "automation"} \u201C${esc(run.trigger.name)}\u201D` : ""}</p>`,
+    run.awaiting ? `<h2>Waiting for you</h2><p>${esc(run.awaiting.title)} \u2014 open code-flow on your computer to answer.</p><pre>${esc(run.awaiting.content.slice(0, 4e3))}</pre>` : "",
+    run.triage?.state === "pending" ? "<h2>In your inbox</h2><p>Approve, revise or reject it in code-flow on your computer.</p>" : "",
+    run.error ? `<h2>Error</h2><pre>${esc(run.error)}</pre>` : "",
+    run.checkCantRun ? `<h2>Check</h2><p>${esc(cantRunMessage(run.checkCantRun.reason))}.</p>` : "",
+    teamView,
+    review || (run.summary ? `<h2>Summary</h2><pre>${esc(run.summary.slice(0, 8e3))}</pre>` : ""),
+    artifacts ? `<h2>Results</h2><ul>${artifacts}</ul>` : "",
+    watches ? `<h2>Pull requests</h2><ul>${watches}</ul>` : "",
+    steps ? `<h2>Steps</h2><ul>${steps}</ul>` : ""
+  ].join("");
+}
+export {
+  changeRemote,
+  isOwnAddress,
+  lanAddresses,
+  loadRemote,
+  newToken,
+  renderRemote,
+  saveRemote,
+  tokenMatches
+};