@maycombhq/atticus 2.0.0-beta.22 → 2.0.0-beta.24

package/dist/chunk-G3ZFEHCX.js

@@ -0,0 +1,925 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  keptFilesMayHaveChanged
+} from "./chunk-CTJHEG6A.js";
+
+// packages/core/dist/fs.js
+import { randomBytes } from "node:crypto";
+import { link, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { hostname } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+async function writeFileAtomic(path, data) {
+  await mkdir(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+  try {
+    await writeFile(tmp, data, typeof data === "string" ? "utf8" : void 0);
+    await renameRetrying(tmp, path);
+  } catch (e) {
+    await rm(tmp, { force: true });
+    throw e;
+  } finally {
+    keptFilesMayHaveChanged(path);
+  }
+}
+var FileChangedError = class extends Error {
+  path;
+  constructor(path) {
+    super(`${path} changed since it was read (another edit, or a person's): nothing was written. Read it again and redo the change.`);
+    this.path = path;
+  }
+};
+var writing = /* @__PURE__ */ new Map();
+function writeFileIfUnchanged(path, before, data) {
+  const key = resolve(path);
+  const prev = writing.get(key) ?? Promise.resolve();
+  const work = async () => {
+    const now = await readFile(path, "utf8").catch(() => void 0);
+    if (now !== before)
+      throw new FileChangedError(path);
+    await writeFileAtomic(path, data);
+  };
+  const next = prev.then(work, work);
+  const tail = next.catch(() => void 0);
+  writing.set(key, tail);
+  void tail.then(() => {
+    if (writing.get(key) === tail)
+      writing.delete(key);
+  });
+  return next;
+}
+var BUSY = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
+async function renameRetrying(from, to, tries = 9) {
+  for (let i = 0; ; i++) {
+    try {
+      await rename(from, to);
+      return;
+    } catch (e) {
+      const code = e.code ?? "";
+      if (!BUSY.has(code) || i >= tries - 1)
+        throw e;
+      await new Promise((r) => setTimeout(r, 20 * 2 ** i));
+    }
+  }
+}
+var LockHeldError = class extends Error {
+  held;
+  file;
+  constructor(held, file) {
+    super(`Another ${held.what} is running (process ${held.pid} on ${held.host}, since ${held.startedAt}). Wait for it to finish${file ? `; if nothing is running, delete ${file}` : ""}.`);
+    this.held = held;
+    this.file = file;
+    this.name = "LockHeldError";
+  }
+};
+var heldHere = /* @__PURE__ */ new Set();
+var lockFileOf = (root, name) => join(root, ".atticus", "locks", `${name}.json`);
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+async function readLock(root, name, o = {}) {
+  try {
+    const file = lockFileOf(root, name);
+    const info = JSON.parse(await readFile(file, "utf8"));
+    const here = info.host === hostname();
+    const age = (o.now ?? (() => /* @__PURE__ */ new Date()))().getTime() - Date.parse(info.startedAt);
+    const stale = here && (!alive(info.pid) || info.pid === process.pid && !heldHere.has(file)) || o.maxAgeMs !== void 0 && Number.isFinite(age) && age > o.maxAgeMs;
+    return { ...info, stale };
+  } catch {
+    return void 0;
+  }
+}
+async function acquireLock(root, name, what, now = () => /* @__PURE__ */ new Date(), o = {}) {
+  const file = lockFileOf(root, name);
+  await ensureLocalIgnore(root);
+  await mkdir(dirname(file), { recursive: true });
+  const info = {
+    pid: process.pid,
+    host: hostname(),
+    startedAt: now().toISOString(),
+    what
+  };
+  let interrupted;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      await writeFile(file, JSON.stringify(info), { encoding: "utf8", flag: "wx" });
+      heldHere.add(file);
+      const release = async () => {
+        const cur = await readLock(root, name);
+        if (cur && cur.pid === info.pid && cur.startedAt === info.startedAt)
+          await rm(file, { force: true });
+        heldHere.delete(file);
+      };
+      return interrupted ? { release, interrupted } : { release };
+    } catch (e) {
+      if (e.code !== "EEXIST")
+        throw e;
+      const held = await readLock(root, name, { ...o, now });
+      if (held && !held.stale)
+        throw new LockHeldError(held, file);
+      if (held) {
+        const { stale: _s, ...rest } = held;
+        interrupted = rest;
+      }
+      await rm(file, { force: true });
+    }
+  }
+  throw new Error(`Couldn't take the ${name} lock at ${file}.`);
+}
+var sharedLockFileOf = (path) => `${path}.lock`;
+var sharing = /* @__PURE__ */ new Map();
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var QUICK_WRITE_LOCK = { maxAgeMs: 12e4 };
+function withSharedFileLock(path, work, o = {}) {
+  const key = resolve(path);
+  const prev = sharing.get(key) ?? Promise.resolve();
+  const run = async () => {
+    const release = await takeSharedLock(key, o);
+    try {
+      return await work();
+    } finally {
+      await release();
+    }
+  };
+  const next = prev.then(run, run);
+  const tail = next.catch(() => void 0);
+  sharing.set(key, tail);
+  void tail.then(() => {
+    if (sharing.get(key) === tail)
+      sharing.delete(key);
+  });
+  return next;
+}
+async function takeSharedLock(path, o) {
+  const file = sharedLockFileOf(path);
+  const staleMs = o.staleMs ?? 1e4;
+  const waitMs = o.waitMs ?? 15e3;
+  const info = {
+    pid: process.pid,
+    host: hostname(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    what: o.what ?? `write of ${basename(path)}`,
+    token: randomBytes(8).toString("hex")
+  };
+  await mkdir(dirname(file), { recursive: true });
+  const start = Date.now();
+  let delay = 5;
+  for (; ; ) {
+    let code;
+    try {
+      await writeFile(file, JSON.stringify(info), { encoding: "utf8", flag: "wx" });
+      return () => releaseShared(file, info.token);
+    } catch (e) {
+      code = e.code ?? "";
+      if (code !== "EEXIST" && !BUSY.has(code))
+        throw e;
+    }
+    let held;
+    if (code === "EEXIST") {
+      const seen = await readFile(file, "utf8").catch(() => void 0);
+      if (seen === void 0)
+        continue;
+      held = parseLockInfo(seen);
+      if (await isStaleShared(file, held, staleMs, o.maxAgeMs)) {
+        await takeOver(file, seen, info.token);
+        continue;
+      }
+    }
+    if (Date.now() - start > waitMs)
+      throw new LockHeldError(held ?? { pid: 0, host: "?", startedAt: "?", what: `write of ${basename(path)}` }, file);
+    await sleep(delay + Math.floor(Math.random() * delay));
+    delay = Math.min(delay * 2, 100);
+  }
+}
+function parseLockInfo(text) {
+  try {
+    const j = JSON.parse(text);
+    return typeof j.pid === "number" && typeof j.startedAt === "string" ? {
+      pid: j.pid,
+      host: String(j.host ?? ""),
+      startedAt: j.startedAt,
+      what: String(j.what ?? "")
+    } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function isStaleShared(file, held, staleMs, maxAgeMs) {
+  if (held && maxAgeMs !== void 0) {
+    const since2 = Date.parse(held.startedAt);
+    if (Number.isFinite(since2) && Date.now() - since2 > maxAgeMs)
+      return true;
+  }
+  if (held && held.host === hostname() && held.pid !== process.pid)
+    return !alive(held.pid);
+  const since = held ? Date.parse(held.startedAt) : await stat(file).then((s) => s.mtimeMs, () => NaN);
+  return Number.isFinite(since) && Date.now() - since > staleMs;
+}
+async function takeOver(file, seen, token) {
+  const aside = `${file}.${token}.stale`;
+  try {
+    await rename(file, aside);
+  } catch {
+    return;
+  }
+  const moved = await readFile(aside, "utf8").catch(() => void 0);
+  if (moved !== void 0 && moved !== seen)
+    await link(aside, file).catch(() => void 0);
+  await rmRetrying(aside);
+}
+async function releaseShared(file, token) {
+  const now = await readFile(file, "utf8").catch(() => void 0);
+  if (now === void 0)
+    return;
+  try {
+    if (JSON.parse(now).token !== token)
+      return;
+  } catch {
+    return;
+  }
+  await rmRetrying(file);
+}
+async function rmRetrying(file, tries = 9) {
+  for (let i = 0; ; i++) {
+    try {
+      await rm(file, { force: true });
+      return;
+    } catch (e) {
+      const code = e.code ?? "";
+      if (!BUSY.has(code) || i >= tries - 1)
+        throw e;
+      await sleep(20 * 2 ** i);
+    }
+  }
+}
+var LOCAL_ONLY = [
+  "me.yaml",
+  "logs/",
+  "locks/",
+  "backups/",
+  "history/",
+  "probe/",
+  "cache/",
+  // ADR 0161: where `atticus map --all` is in the estate, so running it again resumes.
+  "map-all/"
+];
+async function ensureLocalIgnore(root) {
+  const file = join(root, ".atticus", ".gitignore");
+  const text = await readFile(file, "utf8").catch(() => "");
+  const have = new Set(text.split(/\r?\n/).map((l) => l.trim()));
+  const missing = LOCAL_ONLY.filter((l) => !have.has(l));
+  if (!missing.length)
+    return;
+  const prefix = text && !text.endsWith("\n") ? `${text}
+` : text;
+  await writeFileAtomic(file, `${prefix}${prefix ? "" : "# This machine's own files: never committed.\n"}${missing.join("\n")}
+`);
+}
+
+// packages/core/dist/log.js
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir, userInfo } from "node:os";
+import { join as join2 } from "node:path";
+var ORDER = { debug: 10, info: 20, warn: 30, error: 40, off: 100 };
+var LOG_MAX_BYTES = 5 * 1024 * 1024;
+var LOG_KEEP = 3;
+var logFileOf = (root) => join2(root, ".atticus", "logs", "atticus.log");
+var SECRET_KEY = /(token|password|passwd|pwd|secret|api[-_]?key|private[-_]?key|credential|authorization|cookie|session)/i;
+function redactText(s, o = {}) {
+  let out = s.replace(/([a-z][a-z0-9+.-]*:\/\/)[^/@\s:]+:[^/@\s]+@/gi, "$1***@").replace(/\b(bearer|basic)\s+[A-Za-z0-9._~+/=-]{8,}/gi, "$1 ***").replace(new RegExp(`(${SECRET_KEY.source})(["']?\\s*[:=]\\s*["']?)([^\\s"',;&]+)`, "gi"), "$1$3***").replace(/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,}/g, "***").replace(/\b(?=[A-Za-z0-9+_-]*\d)(?=[A-Za-z0-9+_-]*[A-Z])(?=[A-Za-z0-9+_-]*[a-z])[A-Za-z0-9+_-]{32,}={0,2}/g, "***");
+  const home = o.home ?? safeHome();
+  if (home && home.length > 3)
+    out = out.split(home).join("~");
+  const user = o.user ?? safeUser();
+  if (user && user.length > 2)
+    out = out.replace(new RegExp(`([\\\\/])${escapeRe(user)}(?=[\\\\/])`, "g"), "$1<user>");
+  return out;
+}
+function redact(v, o = {}) {
+  if (typeof v === "string")
+    return redactText(v, o);
+  if (Array.isArray(v))
+    return v.map((x) => redact(x, o));
+  if (v && typeof v === "object") {
+    const out = {};
+    for (const [k, x] of Object.entries(v))
+      out[k] = SECRET_KEY.test(k) ? "***" : redact(x, o);
+    return out;
+  }
+  return v;
+}
+var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function safeHome() {
+  try {
+    return homedir();
+  } catch {
+    return void 0;
+  }
+}
+function safeUser() {
+  try {
+    return userInfo().username;
+  } catch {
+    return void 0;
+  }
+}
+function rotate(file, max, keep) {
+  try {
+    if (statSync(file).size < max)
+      return;
+  } catch {
+    return;
+  }
+  rmSync(`${file}.${keep}`, { force: true });
+  for (let i = keep - 1; i >= 1; i--) {
+    try {
+      renameSync(`${file}.${i}`, `${file}.${i + 1}`);
+    } catch {
+    }
+  }
+  try {
+    renameSync(file, `${file}.1`);
+  } catch {
+  }
+}
+function logLevelFrom(env = process.env) {
+  const v = (env.ATTICUS_LOG ?? "").toLowerCase();
+  return v in ORDER ? v : "info";
+}
+function createLog(root, o = {}) {
+  const file = logFileOf(root);
+  const level = o.level ?? logLevelFrom();
+  const now = o.now ?? (() => /* @__PURE__ */ new Date());
+  const write = (lvl, event, fields) => {
+    if (ORDER[lvl] < ORDER[level])
+      return;
+    try {
+      mkdirSync(join2(file, ".."), { recursive: true });
+      ignoreLocalSync(root);
+      rotate(file, o.maxBytes ?? LOG_MAX_BYTES, o.keep ?? LOG_KEEP);
+      const entry = redact({ at: now().toISOString(), level: lvl, event, ...fields });
+      appendFileSync(file, `${JSON.stringify(entry)}
+`, "utf8");
+    } catch {
+    }
+  };
+  return {
+    file,
+    debug: (e, f = {}) => write("debug", e, f),
+    info: (e, f = {}) => write("info", e, f),
+    warn: (e, f = {}) => write("warn", e, f),
+    error: (e, err, f = {}) => write("error", e, {
+      ...f,
+      error: err instanceof Error ? { name: err.name, message: err.message, stack: err.stack?.split("\n").slice(0, 25) } : { message: String(err) }
+    })
+  };
+}
+function ignoreLocalSync(root) {
+  const f = join2(root, ".atticus", ".gitignore");
+  const text = existsSync(f) ? readFileSync(f, "utf8") : "";
+  const have = new Set(text.split(/\r?\n/).map((l) => l.trim()));
+  const missing = LOCAL_ONLY.filter((l) => !have.has(l));
+  if (!missing.length)
+    return;
+  const prefix = text && !text.endsWith("\n") ? `${text}
+` : text;
+  const head = prefix ? "" : "# This machine's own files: never committed.\n";
+  writeFileSync(f, `${prefix}${head}${missing.join("\n")}
+`, "utf8");
+}
+var NO_LOG = {
+  file: "",
+  debug: () => void 0,
+  info: () => void 0,
+  warn: () => void 0,
+  error: () => void 0
+};
+
+// packages/core/dist/run-log.js
+import { createHash, randomBytes as randomBytes2 } from "node:crypto";
+import { appendFileSync as appendFileSync2, closeSync, mkdirSync as mkdirSync2, openSync, readdirSync, readFileSync as readFileSync2, readSync, renameSync as renameSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { hostname as hostname2 } from "node:os";
+import { join as join3 } from "node:path";
+var RUN_LOG_KEEP = 50;
+var RUN_LOG_MAX_BYTES = 2 * 1024 * 1024;
+var RUN_LOG_LINE_MAX = 4e3;
+var RUN_LOG_READ_MAX = 5e3;
+var RUN_HEARTBEAT_MS = 3e4;
+var RUN_SILENT_MS = 5 * 60 * 1e3;
+var TERMINAL_RUN_ID = /^\d{8}-\d{6}-\d{1,10}-[0-9a-f]{4}$/;
+var runLogsDirOf = (root) => join3(root, ".atticus", "logs", "runs");
+var runningDirOf = (root) => join3(root, ".atticus", "logs", "running");
+var RECORDED = {
+  map: true,
+  scan: true,
+  verify: true,
+  upgrade: true,
+  reconcile: true,
+  "run-ready": true,
+  workspace: /* @__PURE__ */ new Set(["sync", "bring-in", "open"]),
+  task: /* @__PURE__ */ new Set(["run", "run-ready"]),
+  knowledge: /* @__PURE__ */ new Set(["scan"]),
+  handoff: /* @__PURE__ */ new Set(["done"]),
+  index: /* @__PURE__ */ new Set(["rebuild", "embed"])
+};
+var NOT_RECORDED_FLAGS = /* @__PURE__ */ new Set(["help", "version", "check", "dry-run"]);
+var QUICK = /* @__PURE__ */ new Set(["map render", "verify audit", "scan review"]);
+function recordedCommand(positionals, flags) {
+  const [group, command] = positionals;
+  if (!group || flags.some((f) => NOT_RECORDED_FLAGS.has(f)))
+    return false;
+  if (command && QUICK.has(`${group} ${command}`))
+    return false;
+  const rule = RECORDED[group];
+  if (rule === true)
+    return true;
+  return !!rule && !!command && rule.has(command);
+}
+var ID_WORD = /^[A-Za-z0-9][A-Za-z0-9._/-]{0,99}$/;
+var MAX_WORDS = 8;
+var safeWord = (w) => ID_WORD.test(w) && !w.includes("//") && redactText(w, { home: "", user: "" }) === w ? w : "\u2026";
+function runTitle(positionals, flags) {
+  const command = positionals.slice(0, MAX_WORDS).map(safeWord);
+  const names = flags.filter((f) => /^[a-z][a-z0-9-]{0,40}$/.test(f)).map((f) => `--${f}`);
+  return { command, title: ["atticus", ...command, ...names].join(" ") };
+}
+function startedByOf(env = process.env) {
+  if (env.ATTICUS_ACP_SESSION)
+    return "copilot";
+  const said = env.ATTICUS_STARTED_BY;
+  if (said === "vscode" || said === "intellij" || said === "terminal")
+    return said;
+  if (env.TERM_PROGRAM === "vscode")
+    return "vscode";
+  if ((env.TERMINAL_EMULATOR ?? "").startsWith("JetBrains"))
+    return "intellij";
+  return "terminal";
+}
+var hostHash = () => {
+  try {
+    return createHash("sha256").update(hostname2()).digest("hex").slice(0, 12);
+  } catch {
+    return "unknown";
+  }
+};
+function procStartOf(pid) {
+  if (process.platform !== "linux")
+    return void 0;
+  try {
+    const stat2 = readFileSync2(`/proc/${pid}/stat`, "utf8");
+    const v = stat2.slice(stat2.lastIndexOf(")") + 2).split(" ")[19];
+    return v && /^\d+$/.test(v) ? v : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var pad = (n, w = 2) => String(n).padStart(w, "0");
+var idAt = (d, pid) => `${d.getUTCFullYear()}${pad(d.getUTCMonth() + 1)}${pad(d.getUTCDate())}-${pad(d.getUTCHours())}${pad(d.getUTCMinutes())}${pad(d.getUTCSeconds())}-${pid}-${randomBytes2(2).toString("hex")}`;
+var ANSI = /\u001b\[[0-9;?]*[ -/]*[@-~]|\u001b\][^\u0007]*\u0007/g;
+function runLogLines(text, o = {}) {
+  return text.replace(ANSI, "").split(/\r?\n|\r/).map((l) => {
+    const r = redactText(l, o);
+    return r.length > RUN_LOG_LINE_MAX ? `${r.slice(0, RUN_LOG_LINE_MAX)}\u2026` : r;
+  });
+}
+var writeJson = (file, v) => {
+  const text = `${JSON.stringify(v, null, 2)}
+`;
+  const tmp = `${file}.${process.pid}.tmp`;
+  try {
+    writeFileSync2(tmp, text, "utf8");
+    renameSync2(tmp, file);
+  } catch {
+    rmSync2(tmp, { force: true });
+    writeFileSync2(file, text, "utf8");
+  }
+};
+function prune(root, keep, live) {
+  let names;
+  try {
+    names = readdirSync(runningDirOf(root)).filter((n) => n.endsWith(".json") && TERMINAL_RUN_ID.test(n.slice(0, -5))).sort();
+  } catch {
+    return;
+  }
+  const removed = /* @__PURE__ */ new Set();
+  let over = names.length - keep;
+  for (const n of names) {
+    if (over <= 0)
+      break;
+    const id = n.slice(0, -5);
+    if (live(id))
+      continue;
+    rmSync2(join3(runningDirOf(root), n), { force: true });
+    rmSync2(join3(runLogsDirOf(root), `${id}.log`), { force: true });
+    removed.add(id);
+    over--;
+  }
+  try {
+    const kept = new Set(names.map((n) => n.slice(0, -5)).filter((id) => !removed.has(id)));
+    for (const n of readdirSync(runLogsDirOf(root)))
+      if (n.endsWith(".log") && TERMINAL_RUN_ID.test(n.slice(0, -4)) && !kept.has(n.slice(0, -4)))
+        rmSync2(join3(runLogsDirOf(root), n), { force: true });
+  } catch {
+  }
+}
+function startTerminalRun(root, o) {
+  const now = o.now ?? (() => /* @__PURE__ */ new Date());
+  const pid = o.pid ?? process.pid;
+  const keep = Math.max(o.keep ?? RUN_LOG_KEEP, 1);
+  const maxBytes = Math.max(o.maxBytes ?? RUN_LOG_MAX_BYTES, 256);
+  const started = now();
+  const runId = idAt(started, pid);
+  const heartbeatMs = o.heartbeatMs ?? (o.hookProcess ? RUN_HEARTBEAT_MS : void 0);
+  const procStart = o.procStart ? o.procStart() : pid === process.pid ? procStartOf(pid) : void 0;
+  const { command, title } = runTitle(o.positionals, o.flags);
+  const rec = {
+    schemaVersion: 1,
+    runId,
+    pid,
+    host: hostHash(),
+    title,
+    command,
+    flags: o.flags.filter((f) => /^[a-z][a-z0-9-]{0,40}$/.test(f)),
+    startedBy: startedByOf(o.env),
+    startedAt: started.toISOString(),
+    state: "running",
+    lines: 0,
+    dropped: 0,
+    ...procStart ? { procStart } : {},
+    ...heartbeatMs ? { beatAt: started.toISOString() } : {}
+  };
+  const jsonFile = join3(runningDirOf(root), `${runId}.json`);
+  const logFile = join3(runLogsDirOf(root), `${runId}.log`);
+  try {
+    mkdirSync2(runningDirOf(root), { recursive: true });
+    mkdirSync2(runLogsDirOf(root), { recursive: true });
+    ignoreLocalSync(root);
+    const alive2 = o.alive ?? pidAlive;
+    prune(root, keep - 1, (id) => {
+      const r = readRecord(root, id);
+      return !!r && r.state === "running" && !goneRun(r, rec.host, alive2, now().getTime(), root);
+    });
+    writeFileSync2(logFile, "", "utf8");
+    writeJson(jsonFile, rec);
+  } catch {
+    return void 0;
+  }
+  let bytes = 0;
+  let inFile = 0;
+  let ended = false;
+  let broken = false;
+  const save = () => {
+    try {
+      if (heartbeatMs && !ended)
+        rec.beatAt = now().toISOString();
+      writeJson(jsonFile, { ...rec, lines: rec.dropped + inFile });
+    } catch {
+    }
+  };
+  const trim = () => {
+    const all = readFileSync2(logFile, "utf8").split("\n");
+    if (all.at(-1) === "")
+      all.pop();
+    let size = 0;
+    let at = all.length;
+    while (at > 0 && size + Buffer.byteLength(all[at - 1]) + 1 <= maxBytes / 2) {
+      size += Buffer.byteLength(all[at - 1]) + 1;
+      at--;
+    }
+    const kept = all.slice(at);
+    const tmp = `${logFile}.${process.pid}.tmp`;
+    const text = kept.length ? `${kept.join("\n")}
+` : "";
+    try {
+      writeFileSync2(tmp, text, "utf8");
+      renameSync2(tmp, logFile);
+    } catch {
+      rmSync2(tmp, { force: true });
+      writeFileSync2(logFile, text, "utf8");
+    }
+    rec.dropped += at;
+    inFile = kept.length;
+    bytes = size;
+    save();
+  };
+  const unhook = [];
+  if (heartbeatMs) {
+    const beat = setInterval(() => {
+      if (!ended)
+        save();
+    }, heartbeatMs);
+    beat.unref?.();
+    unhook.push(() => clearInterval(beat));
+  }
+  const recorder = {
+    runId,
+    line(text) {
+      if (ended || broken)
+        return;
+      try {
+        for (const l of runLogLines(text, o.redact)) {
+          const s = `${l}
+`;
+          const n = Buffer.byteLength(s);
+          if (bytes + n > maxBytes)
+            trim();
+          appendFileSync2(logFile, s, "utf8");
+          bytes += n;
+          inFile++;
+        }
+      } catch {
+        broken = true;
+      }
+    },
+    end(code, how) {
+      if (ended)
+        return;
+      ended = true;
+      for (const u of unhook)
+        u();
+      rec.state = how === "crash" ? "failed" : code === 0 ? "done" : code === 130 || code === 143 ? "cancelled" : "failed";
+      rec.exitCode = code;
+      rec.finishedAt = now().toISOString();
+      save();
+    }
+  };
+  if (o.hookProcess) {
+    const onExit = (code) => recorder.end(typeof code === "number" ? code : 1);
+    process.once("exit", onExit);
+    unhook.push(() => process.off("exit", onExit));
+    for (const [sig, code] of [
+      ["SIGINT", 130],
+      ["SIGTERM", 143]
+    ]) {
+      const on = () => {
+        if (process.listenerCount(sig) > 1)
+          return;
+        recorder.end(code);
+        process.exit(code);
+      };
+      process.on(sig, on);
+      unhook.push(() => process.off(sig, on));
+    }
+  }
+  return recorder;
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+var DAY = 24 * 60 * 60 * 1e3;
+var mtimeOf = (file) => {
+  try {
+    return statSync2(file).mtimeMs;
+  } catch {
+    return 0;
+  }
+};
+function goneRun(r, here, alive2, now, root, startOf = procStartOf) {
+  const age = now - Date.parse(r.startedAt);
+  if (r.host !== here)
+    return age > 2 * DAY;
+  if (!alive2(r.pid) || age > 7 * DAY)
+    return true;
+  const started = r.procStart ? startOf(r.pid) : void 0;
+  if (started !== void 0)
+    return started !== r.procStart;
+  if (r.beatAt) {
+    const last = Math.max(Date.parse(r.beatAt) || 0, mtimeOf(join3(runLogsDirOf(root), `${r.runId}.log`)));
+    return now - last > RUN_SILENT_MS;
+  }
+  return false;
+}
+function readRecord(root, runId) {
+  if (!TERMINAL_RUN_ID.test(runId))
+    return void 0;
+  try {
+    const r = JSON.parse(readFileSync2(join3(runningDirOf(root), `${runId}.json`), "utf8"));
+    if (r.schemaVersion !== 1 || r.runId !== runId || typeof r.title !== "string" || typeof r.startedAt !== "string" || typeof r.pid !== "number" || !["running", "done", "failed", "cancelled"].includes(r.state))
+      return void 0;
+    return {
+      ...r,
+      command: Array.isArray(r.command) ? r.command.map(String) : [],
+      flags: Array.isArray(r.flags) ? r.flags.map(String) : [],
+      lines: Number(r.lines) || 0,
+      dropped: Number(r.dropped) || 0,
+      ...typeof r.procStart === "string" ? { procStart: r.procStart } : {},
+      ...typeof r.beatAt === "string" ? { beatAt: r.beatAt } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function readTerminalRuns(root, o = {}) {
+  let names;
+  try {
+    names = readdirSync(runningDirOf(root));
+  } catch {
+    return [];
+  }
+  const here = hostHash();
+  const alive2 = o.alive ?? pidAlive;
+  const now = (o.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
+  const out = [];
+  for (const n of names.sort().reverse()) {
+    if (!n.endsWith(".json"))
+      continue;
+    const r = readRecord(root, n.slice(0, -5));
+    if (!r)
+      continue;
+    if (r.state === "running") {
+      if (goneRun(r, here, alive2, now, root, o.startOf)) {
+        out.push({ ...r, stale: true });
+        continue;
+      }
+    }
+    out.push(r);
+  }
+  return out;
+}
+var readTerminalRun = (root, runId, o = {}) => TERMINAL_RUN_ID.test(runId) ? readTerminalRuns(root, o).find((r) => r.runId === runId) : void 0;
+function readTerminalRunLines(root, runId, from, max = RUN_LOG_READ_MAX) {
+  const r = readRecord(root, runId);
+  if (!r)
+    return void 0;
+  let text;
+  try {
+    text = readFileSync2(join3(runLogsDirOf(root), `${runId}.log`), "utf8");
+  } catch {
+    text = "";
+  }
+  const all = text.split("\n");
+  all.pop();
+  const total = r.dropped + all.length;
+  const start = from === void 0 ? Math.max(total - max, r.dropped) : Math.max(Math.min(from, total), r.dropped);
+  const lines = all.slice(start - r.dropped, start - r.dropped + max);
+  return { from: start, lines, total };
+}
+function linesIn(buf, skip, max) {
+  const lines = [];
+  let at = 0;
+  let n = 0;
+  while (at < buf.length) {
+    const nl = buf.indexOf(10, at);
+    if (nl < 0)
+      break;
+    if (n >= skip) {
+      if (lines.length >= max)
+        return { lines, end: at, more: true };
+      lines.push(buf.toString("utf8", at, nl));
+    }
+    n++;
+    at = nl + 1;
+  }
+  return { lines, end: at, more: false };
+}
+function readFrom(file, from, size) {
+  const buf = Buffer.alloc(Math.max(size - from, 0));
+  if (!buf.length)
+    return buf;
+  const fd = openSync(file, "r");
+  try {
+    let got = 0;
+    while (got < buf.length) {
+      const n = readSync(fd, buf, got, buf.length - got, from + got);
+      if (n <= 0)
+        break;
+      got += n;
+    }
+    return got < buf.length ? buf.subarray(0, got) : buf;
+  } finally {
+    closeSync(fd);
+  }
+}
+function tailTerminalRunLines(root, runId, at, max = RUN_LOG_READ_MAX) {
+  const file = join3(runLogsDirOf(root), `${runId}.log`);
+  for (let tries = 0; ; tries++) {
+    const r = readRecord(root, runId);
+    if (!r)
+      return void 0;
+    let size = 0;
+    let ino = 0;
+    try {
+      const st = statSync2(file);
+      size = st.size;
+      ino = st.ino;
+    } catch {
+    }
+    if (at && at.dropped === r.dropped && at.ino === ino && size >= at.bytes) {
+      let buf2;
+      try {
+        buf2 = readFrom(file, at.bytes, size);
+      } catch {
+        buf2 = Buffer.alloc(0);
+      }
+      const got2 = linesIn(buf2, 0, max);
+      return {
+        from: at.line,
+        lines: got2.lines,
+        at: {
+          line: at.line + got2.lines.length,
+          bytes: at.bytes + got2.end,
+          dropped: r.dropped,
+          ino
+        },
+        more: got2.more
+      };
+    }
+    let buf;
+    try {
+      buf = readFileSync2(file);
+    } catch {
+      buf = Buffer.alloc(0);
+    }
+    const again = readRecord(root, runId);
+    if (again && again.dropped !== r.dropped && tries < 1)
+      continue;
+    let count = 0;
+    for (let i = buf.indexOf(10); i >= 0; i = buf.indexOf(10, i + 1))
+      count++;
+    const total = r.dropped + count;
+    const start = at === void 0 ? Math.max(total - max, r.dropped) : Math.max(Math.min(at.line, total), r.dropped);
+    const got = linesIn(buf, start - r.dropped, max);
+    return {
+      from: start,
+      lines: got.lines,
+      at: { line: start + got.lines.length, bytes: got.end, dropped: r.dropped, ino },
+      more: got.more
+    };
+  }
+}
+
+// packages/core/dist/printer.js
+import { AsyncLocalStorage } from "node:async_hooks";
+var printer = new AsyncLocalStorage();
+function withPrinter(print, work) {
+  return printer.run(print, work);
+}
+function printToCurrent(line) {
+  const p = printer.getStore();
+  if (!p)
+    return;
+  try {
+    p(line);
+  } catch {
+  }
+}
+
+export {
+  writeFileAtomic,
+  FileChangedError,
+  writeFileIfUnchanged,
+  renameRetrying,
+  LockHeldError,
+  lockFileOf,
+  readLock,
+  acquireLock,
+  sharedLockFileOf,
+  QUICK_WRITE_LOCK,
+  withSharedFileLock,
+  LOCAL_ONLY,
+  ensureLocalIgnore,
+  LOG_MAX_BYTES,
+  LOG_KEEP,
+  logFileOf,
+  redactText,
+  redact,
+  logLevelFrom,
+  createLog,
+  ignoreLocalSync,
+  NO_LOG,
+  RUN_LOG_KEEP,
+  RUN_LOG_MAX_BYTES,
+  RUN_LOG_LINE_MAX,
+  RUN_LOG_READ_MAX,
+  RUN_HEARTBEAT_MS,
+  RUN_SILENT_MS,
+  TERMINAL_RUN_ID,
+  runLogsDirOf,
+  runningDirOf,
+  recordedCommand,
+  runTitle,
+  startedByOf,
+  procStartOf,
+  runLogLines,
+  startTerminalRun,
+  pidAlive,
+  readTerminalRuns,
+  readTerminalRun,
+  readTerminalRunLines,
+  tailTerminalRunLines,
+  withPrinter,
+  printToCurrent
+};