privateer-agent 0.15.5 → 0.15.6

package/dist-boot/ext-privateer-recovery.mjs

@@ -0,0 +1,287 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// extensions/privateer-recovery.ts?ext=privateer-recovery
+import fs2 from "node:fs";
+
+// src/config/paths.ts?ext=privateer-recovery
+import { homedir } from "node:os";
+import { join } from "node:path";
+function globalDir() {
+  return process.env.PRIVATEER_HOME ?? join(homedir(), ".privateer");
+}
+__name(globalDir, "globalDir");
+
+// bin/session-recovery.mjs?ext=privateer-recovery
+import fs from "node:fs";
+import path from "node:path";
+var RECOVERY_ENV = "PRIVATEER_RECOVERY";
+var MARKER_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var RESUME_WINDOW_MS = 3 * 60 * 1e3;
+function liveDir(home) {
+  return path.join(home, "run", "live");
+}
+__name(liveDir, "liveDir");
+function markerPath(home, pid) {
+  return path.join(liveDir(home), `${pid}.json`);
+}
+__name(markerPath, "markerPath");
+function writeMarker(home, marker) {
+  const dir = liveDir(home);
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  const file = markerPath(home, marker.pid);
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(marker) + "\n", { mode: 384 });
+  fs.renameSync(tmp, file);
+}
+__name(writeMarker, "writeMarker");
+function removeMarker(home, pid) {
+  try {
+    fs.rmSync(markerPath(home, pid), { force: true });
+  } catch {
+  }
+}
+__name(removeMarker, "removeMarker");
+function safeRead(file) {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+__name(safeRead, "safeRead");
+function parseMarker(text) {
+  if (typeof text !== "string") return null;
+  let m;
+  try {
+    m = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!m || m.v !== 1 || !Number.isInteger(m.pid) || typeof m.sessionFile !== "string" || !m.sessionFile) return null;
+  return {
+    v: 1,
+    pid: m.pid,
+    sessionFile: m.sessionFile,
+    cwd: typeof m.cwd === "string" ? m.cwd : "",
+    startedAt: Number(m.startedAt) || 0,
+    updatedAt: Number(m.updatedAt) || 0,
+    turnOpen: m.turnOpen === true,
+    tool: m.tool && typeof m.tool.name === "string" ? { name: m.tool.name, summary: typeof m.tool.summary === "string" ? m.tool.summary : "", startedAt: Number(m.tool.startedAt) || 0 } : null,
+    hinted: m.hinted === true
+  };
+}
+__name(parseMarker, "parseMarker");
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e?.code === "EPERM";
+  }
+}
+__name(isAlive, "isAlive");
+function listStale(home, { cwd, now = Date.now(), alive = isAlive } = {}) {
+  let names = [];
+  try {
+    names = fs.readdirSync(liveDir(home)).filter((n) => /^\d+\.json$/.test(n));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    const file = path.join(liveDir(home), name);
+    const m = parseMarker(safeRead(file));
+    if (!m) continue;
+    if (alive(m.pid)) continue;
+    if (!m.turnOpen || now - (m.updatedAt || m.startedAt) > MARKER_MAX_AGE_MS || !fs.existsSync(m.sessionFile)) {
+      try {
+        fs.rmSync(file, { force: true });
+      } catch {
+      }
+      continue;
+    }
+    if (cwd && path.resolve(m.cwd) !== path.resolve(cwd)) continue;
+    out.push(m);
+  }
+  return out.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+__name(listStale, "listStale");
+function staleForSession(home, sessionFile, opts = {}) {
+  const want = path.resolve(sessionFile);
+  return listStale(home, opts).find((m) => path.resolve(m.sessionFile) === want) ?? null;
+}
+__name(staleForSession, "staleForSession");
+function summarizeToolCall(name, args) {
+  const flat = /* @__PURE__ */ __name((s) => String(s).replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim(), "flat");
+  const clip = /* @__PURE__ */ __name((s, n = 160) => s.length > n ? s.slice(0, n - 1) + "\u2026" : s, "clip");
+  if (!args || typeof args !== "object") return clip(flat(name));
+  const pick = args.command ?? args.cmd ?? args.path ?? args.file_path ?? args.file ?? args.url ?? args.query;
+  if (typeof pick === "string" && pick.trim()) return clip(flat(pick));
+  return clip(Object.keys(args).slice(0, 6).join(", "));
+}
+__name(summarizeToolCall, "summarizeToolCall");
+var ago = /* @__PURE__ */ __name((ms) => {
+  const m = Math.round(ms / 6e4);
+  if (m < 1) return "moments ago";
+  if (m < 60) return `${m} min ago`;
+  const h = Math.round(m / 60);
+  return h < 48 ? `${h} h ago` : `${Math.round(h / 24)} days ago`;
+}, "ago");
+function recoveryNote(marker, { reason = "stopped unexpectedly" } = {}) {
+  if (!marker?.turnOpen) return null;
+  const during = marker.tool ? `while it was running the \`${marker.tool.name}\` tool${marker.tool.summary ? ` (\`${marker.tool.summary}\`)` : ""}` : "in the middle of a turn, between tool calls";
+  return [
+    `[Privateer] The previous agent process for this session ${reason} ${during}.`,
+    "Its last action may have run fully, partly, or not at all, and anything it started (a server, a build, a migration) may still be running or may have been killed.",
+    "Do not repeat that action blindly. Check the current state first (files, git status, running processes, the remote) and tell the user briefly what you found before carrying on."
+  ].join(" ");
+}
+__name(recoveryNote, "recoveryNote");
+function recoveryNotice(marker, { now = Date.now() } = {}) {
+  const when = ago(now - (marker.updatedAt || marker.startedAt || now));
+  if (!marker.turnOpen) return `Resumed your session \u2014 the previous agent stopped ${when}.`;
+  const what = marker.tool ? ` during ${marker.tool.name}${marker.tool.summary ? `: ${marker.tool.summary}` : ""}` : "";
+  return `Resumed your session \u2014 the previous agent stopped ${when} mid-task${what}. It may have been partly done; the agent will check before continuing.`;
+}
+__name(recoveryNotice, "recoveryNotice");
+function sessionIdFromFile(file) {
+  const m = path.basename(file).match(/_([0-9a-f-]{8,})\.jsonl$/i);
+  return m ? m[1] : null;
+}
+__name(sessionIdFromFile, "sessionIdFromFile");
+function resumeHint(marker, { cmd = "privateer", now = Date.now() } = {}) {
+  const id = sessionIdFromFile(marker.sessionFile);
+  const target = id ?? marker.sessionFile;
+  const what = marker.tool ? ` (during ${marker.tool.name}${marker.tool.summary ? `: ${marker.tool.summary}` : ""})` : "";
+  return `\u2693 Your last session in this folder stopped mid-task ${ago(now - (marker.updatedAt || now))}${what}.
+   Resume it: ${cmd} --session ${target}`;
+}
+__name(resumeHint, "resumeHint");
+function decodeRecovery(value) {
+  if (typeof value !== "string" || !value) return null;
+  try {
+    return parseMarker(Buffer.from(value, "base64").toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+__name(decodeRecovery, "decodeRecovery");
+
+// extensions/privateer-recovery.ts?ext=privateer-recovery
+var HANDOFF = /* @__PURE__ */ Symbol.for("privateer.recovery.handoff");
+function takeHandoff() {
+  const g = globalThis;
+  if (!(HANDOFF in g)) {
+    g[HANDOFF] = process.env[RECOVERY_ENV];
+    delete process.env[RECOVERY_ENV];
+  }
+  const v = g[HANDOFF];
+  g[HANDOFF] = void 0;
+  return v;
+}
+__name(takeHandoff, "takeHandoff");
+var sealingWarned = false;
+function sealingNotice(ctx) {
+  const g = globalThis;
+  const codec = g[/* @__PURE__ */ Symbol.for("privateer.sessionCodec")];
+  const error = g[/* @__PURE__ */ Symbol.for("privateer.sessionCodecError")];
+  if (!codec) {
+    if (sealingWarned || !error) return;
+    sealingWarned = true;
+    ctx?.ui?.notify?.(`Session encryption is off for this run (${error}). This session is being saved unencrypted. Your key file was left untouched \u2014 sessions sealed with it are unreadable until it's fixed.`, "warning");
+    return;
+  }
+  if (codec.failures > 0) {
+    const n = codec.failures;
+    codec.failures = 0;
+    ctx?.ui?.notify?.(`${n} saved line${n === 1 ? "" : "s"} of this session couldn't be decrypted with this machine's session key and ${n === 1 ? "isn't" : "aren't"} shown. The file itself is unchanged.`, "warning");
+  }
+}
+__name(sealingNotice, "sealingNotice");
+function privateerRecovery(pi) {
+  const home = globalDir();
+  const pid = process.pid;
+  let state = null;
+  const save = /* @__PURE__ */ __name(() => {
+    if (!state) return;
+    try {
+      writeMarker(home, { v: 1, pid, ...state, updatedAt: Date.now() });
+    } catch {
+    }
+  }, "save");
+  pi.on("session_start", (_event, ctx) => {
+    if (ctx?.mode !== "tui") return;
+    const sessionFile = ctx?.sessionManager?.getSessionFile?.();
+    if (!sessionFile) {
+      state = null;
+      removeMarker(home, pid);
+      return;
+    }
+    state = { sessionFile, cwd: ctx?.cwd ?? process.cwd(), startedAt: Date.now(), turnOpen: false, tool: null };
+    save();
+    sealingNotice(ctx);
+    try {
+      if (fs2.existsSync(sessionFile)) fs2.chmodSync(sessionFile, 384);
+    } catch {
+    }
+    const handed = decodeRecovery(takeHandoff());
+    const dead = handed && handed.sessionFile === sessionFile ? handed : staleForSession(home, sessionFile);
+    if (!dead || dead.pid === pid) {
+      if (_event?.reason === "startup") hintInterrupted(ctx, sessionFile);
+      return;
+    }
+    removeMarker(home, dead.pid);
+    const note = recoveryNote(dead);
+    if (note) {
+      pi.sendMessage?.(
+        { customType: "privateer-recovery", content: note, display: false },
+        { deliverAs: "nextTurn" }
+      );
+    }
+    ctx?.ui?.notify?.(recoveryNotice(dead), dead.turnOpen ? "warning" : "info");
+  });
+  const hintInterrupted = /* @__PURE__ */ __name((ctx, current) => {
+    const cwd = ctx?.cwd ?? process.cwd();
+    const m = listStale(home, { cwd }).find((x) => x.turnOpen && !x.hinted && x.sessionFile !== current);
+    if (!m) return;
+    ctx?.ui?.notify?.(resumeHint(m, { cmd: process.env.PRIVATEER_CMD || "privateer" }), "info");
+    try {
+      writeMarker(home, { ...m, hinted: true });
+    } catch {
+    }
+  }, "hintInterrupted");
+  pi.on("agent_start", () => {
+    if (!state) return;
+    state.turnOpen = true;
+    save();
+  });
+  pi.on("tool_execution_start", (event) => {
+    if (!state || event?.parentToolCallId) return;
+    state.tool = { name: String(event?.toolName ?? "tool"), summary: summarizeToolCall(event?.toolName, event?.args), startedAt: Date.now() };
+    save();
+  });
+  pi.on("tool_execution_end", (event) => {
+    if (!state || event?.parentToolCallId) return;
+    state.tool = null;
+    save();
+  });
+  pi.on("agent_end", () => {
+    if (!state) return;
+    state.turnOpen = false;
+    state.tool = null;
+    save();
+  });
+  pi.on("session_shutdown", () => {
+    if (!state) return;
+    if (state.turnOpen) save();
+    else removeMarker(home, pid);
+    state = null;
+  });
+}
+__name(privateerRecovery, "privateerRecovery");
+export {
+  privateerRecovery as default
+};