@saadnvd1/agent-os 0.3.639 → 0.3.644

package/lib/worktree-sweep/findOrphans.ts

@@ -0,0 +1,139 @@
+/**
+ * Folders in the worktrees root that no session owns. Old ones go, after the
+ * same checks as a settled worktree; the throwaway repos tests once left
+ * there (they hold nothing of anyone's) go without them.
+ */
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { db } from "../db";
+import { mainCheckoutOf } from "../worktrees";
+import { resolveSweepDays } from "./settings";
+import { inFolder } from "./panes";
+import type { Candidate, SweepSkipped } from "./types";
+
+const DAY_MS = 24 * 3600_000;
+
+// What a test's quick-change worktree is called (lib/orchestrator/quick.test.ts).
+const TEST_LEAK = /^(aos-quick-repo-|repo-quick-)/;
+// Kept in a folder AgentOS made that holds no work: placed or rebuilt files.
+const DISPOSABLE = new Set([
+  "node_modules",
+  ".next",
+  ".turbo",
+  "dist",
+  "build",
+  ".git",
+  ".dev-tmux",
+  ".agent-os",
+]);
+
+const real = (p: string) => {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return path.resolve(p);
+  }
+};
+
+// Every folder a session row names, on any machine's row: never an orphan.
+function owned(): Set<string> {
+  const rows = db
+    .prepare(
+      `SELECT worktree_path AS a, working_directory AS b FROM session_rows`
+    )
+    .all() as Array<{ a: string | null; b: string | null }>;
+  const out = new Set<string>();
+  for (const r of rows) for (const p of [r.a, r.b]) if (p) out.add(real(p));
+  return out;
+}
+
+// Where a worktree's .git file points; null when it has none.
+function gitdirOf(dir: string): string | null {
+  try {
+    const m = /^gitdir:\s*(.+)$/m.exec(
+      fs.readFileSync(path.join(dir, ".git"), "utf8")
+    );
+    return m ? m[1].trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+const inTemp = (p: string) =>
+  [os.tmpdir(), real(os.tmpdir())].some((t) => inFolder(p, t));
+
+// Nothing in it but what AgentOS placed or rebuilds: no work to lose.
+export const holdsNothing = (dir: string) =>
+  fs
+    .readdirSync(dir)
+    .filter((f) => !DISPOSABLE.has(f))
+    .every((f) => f.startsWith(".env"));
+
+const newestMs = (dir: string) => {
+  let t = 0;
+  for (const p of [dir, path.join(dir, ".git")])
+    try {
+      t = Math.max(t, fs.statSync(p).mtimeMs);
+    } catch {
+      // not there
+    }
+  return t;
+};
+
+export interface OrphanDeps {
+  now: number;
+  root: string;
+  panes: string[];
+}
+
+export async function findOrphans(deps: OrphanDeps): Promise<{
+  candidates: Candidate[];
+  skipped: SweepSkipped[];
+}> {
+  const { days } = resolveSweepDays(null);
+  const candidates: Candidate[] = [];
+  const skipped: SweepSkipped[] = [];
+  if (days === 0 || !fs.existsSync(deps.root)) return { candidates, skipped };
+  const mine = owned();
+  for (const entry of fs.readdirSync(deps.root, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const dir = path.join(deps.root, entry.name);
+    if (mine.has(real(dir))) continue;
+    const skip = (reason: string) =>
+      skipped.push({ path: dir, kind: "orphan", reason });
+    if (deps.now - newestMs(dir) < days * DAY_MS) {
+      skip(`touched less than ${days} day${days === 1 ? "" : "s"} ago`);
+      continue;
+    }
+    if (deps.panes.some((p) => inFolder(p, real(dir)) || inFolder(p, dir))) {
+      skip("a terminal is open in it");
+      continue;
+    }
+    const gitdir = gitdirOf(dir);
+    const registered = !!gitdir && fs.existsSync(gitdir);
+    const leak =
+      TEST_LEAK.test(entry.name) &&
+      !!gitdir &&
+      inTemp(real(path.dirname(gitdir)));
+    if (leak) {
+      candidates.push({
+        path: dir,
+        kind: "test-leak",
+        repo: registered ? path.resolve(gitdir!, "../../..") : undefined,
+      });
+      continue;
+    }
+    if (registered) {
+      const repo = await mainCheckoutOf(dir);
+      if (!repo) skip("its repository can't be found");
+      else candidates.push({ path: dir, kind: "orphan", repo });
+      continue;
+    }
+    // Not a git worktree any more: git can't say what's in it.
+    if (holdsNothing(dir)) candidates.push({ path: dir, kind: "orphan" });
+    else skip("it isn't a git worktree and holds files git can't check");
+  }
+  return { candidates, skipped };
+}

package/lib/worktree-sweep/findSettled.ts

@@ -0,0 +1,112 @@
+/**
+ * The sessions whose worktree the sweep may consider: settled, quiet, not
+ * waiting on anyone, no open PR, and old enough for their project's setting.
+ * Everything else is skipped with the reason.
+ */
+
+import fs from "fs";
+import { db, type Session } from "../db";
+import { fromSqliteTime } from "../session-meta";
+import { statusOf } from "../orchestrator/facts";
+import { isAgentOSWorktree } from "../worktrees";
+import { restoring } from "../resurrect/index";
+import { inFolder } from "./panes";
+import { resolveSweepDays } from "./settings";
+import type { Candidate, SweepSkipped } from "./types";
+
+const DAY_MS = 24 * 3600_000;
+const SETTLED_TASKS = new Set(["merged", "dropped", "done"]);
+
+export interface SettledDeps {
+  now: number;
+  panes: string[];
+  status: (s: Session) => ReturnType<typeof statusOf>;
+  isRestoring: (id: string) => boolean;
+}
+
+const ms = (t: string | null | undefined) =>
+  t ? fromSqliteTime(t).getTime() : 0;
+
+// When it settled: the earliest of the marks it carries, else its last update;
+// anything it did afterwards starts the wait again.
+export function settledSinceMs(s: Session): number {
+  const marks = [s.merged_at, s.task_ended_at, s.settled_at, s.archived_at]
+    .map(ms)
+    .filter((t) => t > 0);
+  const settled = marks.length ? Math.min(...marks) : ms(s.updated_at);
+  return Math.max(settled, ms(s.active_at));
+}
+
+export const isSettled = (s: Session) =>
+  s.task_status
+    ? SETTLED_TASKS.has(s.task_status)
+    : !!(s.archived_at || s.settled_at);
+
+function openAsks(): Set<string> {
+  const rows = db
+    .prepare(`SELECT subject FROM orchestrator_asks WHERE status = 'open'`)
+    .all() as Array<{ subject: string }>;
+  return new Set(rows.map((r) => r.subject));
+}
+
+export async function findSettled(
+  deps: SettledDeps
+): Promise<{ candidates: Candidate[]; skipped: SweepSkipped[] }> {
+  const rows = db
+    .prepare(
+      `SELECT * FROM session_rows
+       WHERE worktree_path IS NOT NULL AND worktree_path != ''
+         AND (host_id IS NULL OR host_id = 'local') AND peer_mirror = 0`
+    )
+    .all() as Session[];
+  const asks = openAsks();
+  const candidates: Candidate[] = [];
+  const skipped: SweepSkipped[] = [];
+  for (const s of rows) {
+    const dir = s.worktree_path!;
+    if (!isSettled(s) || !isAgentOSWorktree(dir) || !fs.existsSync(dir))
+      continue;
+    const skip = async (): Promise<string | null> => {
+      if (s.role) return "an orchestrator's";
+      if (s.pinned) return "pinned";
+      if (s.moved_to)
+        return "its task moved to another machine and may come back";
+      if (s.pr_status === "open") return "its PR is open";
+      const { days } = resolveSweepDays(s.project_id);
+      if (days === 0) return "clean-up is off for its project";
+      if (deps.now - settledSinceMs(s) < days * DAY_MS)
+        return `settled less than ${days} day${days === 1 ? "" : "s"} ago`;
+      if (deps.isRestoring(s.id)) return "it is being restored";
+      if (asks.has(`task:${s.id}`)) return "an ask about it is waiting on you";
+      const real = fs.realpathSync(dir);
+      if (deps.panes.some((p) => inFolder(p, real) || inFolder(p, dir)))
+        return "a terminal is open in it";
+      const { status, needsInput } = await deps.status(s);
+      if (needsInput) return "it is waiting on input";
+      if (status !== "idle" && status !== "dead") return `it is ${status}`;
+      return null;
+    };
+    const reason = await skip();
+    if (reason)
+      skipped.push({ path: dir, kind: "settled", reason, sessionId: s.id });
+    else
+      candidates.push({
+        path: dir,
+        kind: "settled",
+        sessionId: s.id,
+        prNumber: s.pr_number,
+        branch: s.branch_name,
+      });
+  }
+  return { candidates, skipped };
+}
+
+export const defaultSettledDeps = (
+  now = Date.now(),
+  panes: string[] = []
+): SettledDeps => ({
+  now,
+  panes,
+  status: statusOf,
+  isRestoring: restoring,
+});

package/lib/worktree-sweep/index.ts

@@ -0,0 +1,10 @@
+export { sweep, describeRun } from "./runSweep";
+export {
+  sweepNow,
+  startWorktreeSweep,
+  sweepEnabled,
+  ownsWorktrees,
+} from "./start";
+export * from "./settings";
+export { recentRuns, sweptAt } from "./store";
+export type * from "./types";

package/lib/worktree-sweep/judge.ts

@@ -0,0 +1,31 @@
+import { describeChanges, unsavedChanges } from "../worktree-placed";
+import { unpushedCommits } from "./commits";
+
+export type Verdict = { remove: true } | { remove: false; reason: string };
+
+/**
+ * Whether removing the worktree would lose anything: uncommitted changes
+ * (except what AgentOS placed and nobody touched), or commits that no remote
+ * branch, merged PR or upstream patch holds. Anything that can't be read
+ * keeps it.
+ */
+export async function judgeWorktree(
+  path: string,
+  repo: string,
+  opts: { prHead?: string | null; branch?: string | null } = {}
+): Promise<Verdict> {
+  const unsaved = await unsavedChanges(path).catch(() => null);
+  if (!unsaved)
+    return { remove: false, reason: "its changes can't be checked" };
+  const stray = await unpushedCommits(path, repo, opts).catch(() => null);
+  if (!stray) return { remove: false, reason: "its commits can't be checked" };
+  const why = [
+    unsaved.length ? `uncommitted changes (${describeChanges(unsaved)})` : null,
+    stray.length
+      ? `${stray.length} commit${stray.length === 1 ? "" : "s"} no remote branch or merged PR has`
+      : null,
+  ].filter((w) => w !== null);
+  return why.length
+    ? { remove: false, reason: why.join(", and ") }
+    : { remove: true };
+}

package/lib/worktree-sweep/panes.ts

@@ -0,0 +1,18 @@
+import { execFile } from "child_process";
+
+// The folders open in tmux panes, so a worktree someone has a terminal in is
+// left alone. Empty when tmux isn't running or can't be read.
+export function openPaneFolders(timeoutMs = 3000): Promise<string[]> {
+  return new Promise((resolve) => {
+    execFile(
+      "tmux",
+      ["list-panes", "-a", "-F", "#{pane_current_path}"],
+      { timeout: timeoutMs },
+      (error, stdout) =>
+        resolve(error ? [] : String(stdout).split("\n").filter(Boolean))
+    );
+  });
+}
+
+export const inFolder = (folder: string, root: string) =>
+  folder === root || folder.startsWith(root + "/");

package/lib/worktree-sweep/runSweep.ts

@@ -0,0 +1,243 @@
+/**
+ * One clean-up run: settled sessions' worktrees and orphan folders, each
+ * judged, removed when nothing would be lost, skipped with a reason when not.
+ * The branch and the conversation stay; a restore rebuilds the worktree.
+ */
+
+import fs from "fs";
+import path from "path";
+import { execFile } from "child_process";
+import { db, type Session } from "../db";
+import { git as runGit } from "../git-exec";
+import { run as runCmd } from "../tasks/gh";
+import { deleteWorktree, WORKTREES_DIR } from "../worktrees";
+import { keepSessionFiles } from "../session-artifacts/collect";
+import { currentLevel } from "../load/monitor";
+import {
+  findSettled,
+  defaultSettledDeps,
+  type SettledDeps,
+} from "./findSettled";
+import { findOrphans, holdsNothing } from "./findOrphans";
+import { judgeWorktree } from "./judge";
+import { openPaneFolders } from "./panes";
+import { finishRun, recordSwept, startRun } from "./store";
+import type { Candidate, SweepSummary } from "./types";
+
+export interface SweepDeps {
+  now: number;
+  root: string;
+  panes: () => Promise<string[]>;
+  settled: Omit<SettledDeps, "now" | "panes">;
+  size: (dir: string) => Promise<number>;
+  prHead: (repo: string, number: number) => Promise<string | null>;
+  // Stop early when the machine is busy.
+  busy: () => boolean;
+}
+
+const git = (cwd: string, ...args: string[]) =>
+  runGit(cwd, args, { timeout: 30_000 }).then((o) => o.trim());
+
+function duBytes(dir: string): Promise<number> {
+  return new Promise((resolve) =>
+    execFile("du", ["-sk", dir], { timeout: 120_000 }, (error, stdout) =>
+      resolve(error ? 0 : (parseInt(String(stdout), 10) || 0) * 1024)
+    )
+  );
+}
+
+async function prHeadOf(repo: string, number: number): Promise<string | null> {
+  try {
+    const out = await runCmd(
+      "gh",
+      [
+        "pr",
+        "view",
+        String(number),
+        "--json",
+        "headRefOid",
+        "-q",
+        ".headRefOid",
+      ],
+      repo,
+      30_000
+    );
+    return out.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export const defaultSweepDeps = (): SweepDeps => ({
+  now: Date.now(),
+  root: WORKTREES_DIR,
+  panes: openPaneFolders,
+  settled: defaultSettledDeps(),
+  size: duBytes,
+  prHead: prHeadOf,
+  busy: () => currentLevel() === "red",
+});
+
+// A path under the root, never the root itself or something outside it.
+const inRoot = (root: string, p: string) => {
+  const rel = path.relative(path.resolve(root), path.resolve(p));
+  return !!rel && !rel.startsWith("..") && !path.isAbsolute(rel);
+};
+
+async function repoOfSession(c: Candidate): Promise<string | null> {
+  if (c.repo) return c.repo;
+  try {
+    return (
+      await git(
+        c.path,
+        "rev-parse",
+        "--path-format=absolute",
+        "--git-common-dir"
+      )
+    ).replace(/\/\.git\/?$/, "");
+  } catch {
+    return null;
+  }
+}
+
+async function removeOne(
+  c: Candidate,
+  repo: string | null,
+  runId: number
+): Promise<void> {
+  if (c.sessionId) {
+    await keepSessionFiles(c.sessionId).catch(() => {});
+    recordSwept(c.sessionId, c.path, c.branch ?? null, runId);
+  }
+  if (repo && fs.existsSync(repo) && c.kind !== "test-leak")
+    await deleteWorktree(c.path, repo, false).catch(() => {});
+  if (fs.existsSync(c.path))
+    await fs.promises.rm(c.path, { recursive: true, force: true });
+  if (repo && fs.existsSync(repo))
+    await git(repo, "worktree", "prune").catch(() => "");
+}
+
+export async function sweep(
+  opts: { dryRun?: boolean } = {},
+  deps: SweepDeps = defaultSweepDeps()
+): Promise<{ runId: number; summary: SweepSummary }> {
+  const dryRun = !!opts.dryRun;
+  const runId = startRun(dryRun);
+  const summary: SweepSummary = { removed: [], skipped: [], freedBytes: 0 };
+  let error: string | null = null;
+  try {
+    const panes = await deps.panes();
+    const s = await findSettled({ ...deps.settled, now: deps.now, panes });
+    const o = await findOrphans({ now: deps.now, root: deps.root, panes });
+    // Reasons that need a look come before the ones that only need time.
+    const young = (k: { reason: string }) => /less than \d+ day/.test(k.reason);
+    summary.skipped.push(
+      ...[...s.skipped, ...o.skipped].sort(
+        (a, b) => Number(young(a)) - Number(young(b))
+      )
+    );
+    const pruned = new Set<string>();
+    for (const c of [...s.candidates, ...o.candidates]) {
+      if (deps.busy()) {
+        summary.skipped.push({
+          path: c.path,
+          kind: c.kind,
+          reason: "the machine is busy; left for the next run",
+          sessionId: c.sessionId,
+        });
+        continue;
+      }
+      if (!inRoot(deps.root, c.path)) continue;
+      const skip = (reason: string) =>
+        summary.skipped.push({
+          path: c.path,
+          kind: c.kind,
+          reason,
+          sessionId: c.sessionId,
+        });
+      const repo = await repoOfSession(c);
+      const why =
+        c.kind === "test-leak"
+          ? "a test's throwaway repository"
+          : "clean and nothing would be lost";
+      if (c.kind !== "test-leak" && (repo || c.kind === "settled")) {
+        if (!repo) {
+          // Git can't read it: it goes only when it holds nothing of anyone's.
+          if (!holdsNothing(c.path)) {
+            skip("it isn't a git worktree any more");
+            continue;
+          }
+        } else {
+          let verdict = await judgeWorktree(c.path, repo, { branch: c.branch });
+          // A squash merge leaves the branch's commits only in the PR's head.
+          if (!verdict.remove && c.prNumber) {
+            const prHead = await deps.prHead(repo, c.prNumber);
+            if (prHead)
+              verdict = await judgeWorktree(c.path, repo, {
+                branch: c.branch,
+                prHead,
+              });
+          }
+          if (!verdict.remove) {
+            skip(verdict.reason);
+            continue;
+          }
+        }
+      }
+      const bytes = await deps.size(c.path);
+      if (!dryRun) {
+        await removeOne(c, repo, runId);
+        if (fs.existsSync(c.path)) {
+          skip("removing it failed");
+          continue;
+        }
+        if (repo) pruned.add(repo);
+      }
+      summary.removed.push({
+        path: c.path,
+        kind: c.kind,
+        why,
+        bytes,
+        sessionId: c.sessionId,
+      });
+      summary.freedBytes += bytes;
+    }
+    if (!dryRun) await pruneProjects([...pruned]);
+  } catch (e) {
+    error = e instanceof Error ? e.message : String(e);
+  }
+  finishRun(runId, summary, error);
+  console.log(describeRun(summary, dryRun, error));
+  return { runId, summary };
+}
+
+// `git worktree prune` in every repository AgentOS knows, so entries for
+// folders that are gone stop piling up.
+async function pruneProjects(extra: string[]): Promise<void> {
+  const rows = db
+    .prepare(
+      `SELECT working_directory FROM projects WHERE working_directory IS NOT NULL`
+    )
+    .all() as Array<Pick<Session, "working_directory">>;
+  const repos = new Set([...extra, ...rows.map((r) => r.working_directory)]);
+  for (const repo of repos)
+    if (repo && fs.existsSync(repo))
+      await git(repo, "worktree", "prune").catch(() => "");
+}
+
+const gb = (b: number) => `${(b / 1024 ** 3).toFixed(2)} GB`;
+
+export function describeRun(
+  s: SweepSummary,
+  dryRun = false,
+  error: string | null = null
+): string {
+  const reasons = new Map<string, number>();
+  for (const k of s.skipped) {
+    const r = k.reason.replace(/\(.*\)/, "").trim();
+    reasons.set(r, (reasons.get(r) ?? 0) + 1);
+  }
+  const why = [...reasons].map(([r, n]) => `${n} ${r}`).join("; ");
+  const leaks = s.removed.filter((r) => r.kind === "test-leak").length;
+  return `[worktree-sweep] ${dryRun ? "would remove" : "removed"} ${s.removed.length} (${gb(s.freedBytes)}${leaks ? `, ${leaks} test leftovers` : ""}), skipped ${s.skipped.length}${why ? `: ${why}` : ""}${error ? `; failed: ${error}` : ""}`;
+}

package/lib/worktree-sweep/settings.ts

@@ -0,0 +1,83 @@
+/**
+ * How many days a settled worktree stays before the sweep removes it.
+ * Global, with a per-project override; 0 turns it off. Default 7.
+ */
+
+import { z } from "zod";
+import { db } from "../db";
+import type { ResolvedDays } from "./types";
+
+export const DEFAULT_SWEEP_DAYS = 7;
+export const MAX_SWEEP_DAYS = 365;
+
+const GLOBAL_KEY = "worktree_sweep";
+const projectKey = (projectId: string) => `worktree_sweep.project.${projectId}`;
+
+export const sweepDays = z.number().int().min(0).max(MAX_SWEEP_DAYS);
+const stored = z.object({ days: sweepDays });
+
+function read(key: string): number | null {
+  const row = db
+    .prepare(`SELECT value FROM settings WHERE key = ?`)
+    .get(key) as { value: string } | undefined;
+  if (!row) return null;
+  try {
+    const got = stored.safeParse(JSON.parse(row.value));
+    return got.success ? got.data.days : null;
+  } catch {
+    return null;
+  }
+}
+
+function write(key: string, days: number | null): number | null {
+  if (days === null) {
+    db.prepare(`DELETE FROM settings WHERE key = ?`).run(key);
+    return null;
+  }
+  const got = sweepDays.safeParse(days);
+  if (!got.success)
+    throw new Error(
+      `Days must be a whole number from 0 to ${MAX_SWEEP_DAYS} (0 turns the clean-up off)`
+    );
+  db.prepare(
+    `INSERT INTO settings (key, value) VALUES (?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  ).run(key, JSON.stringify({ days: got.data }));
+  return got.data;
+}
+
+export const globalSweepDays = () => read(GLOBAL_KEY);
+export const setGlobalSweepDays = (days: number | null) =>
+  write(GLOBAL_KEY, days);
+export const projectSweepDays = (projectId: string) =>
+  read(projectKey(projectId));
+export const setProjectSweepDays = (projectId: string, days: number | null) =>
+  write(projectKey(projectId), days);
+
+// The project's own setting, else the global one, else the default.
+export function resolveSweepDays(
+  projectId: string | null | undefined
+): ResolvedDays {
+  const own = projectId ? projectSweepDays(projectId) : null;
+  if (own !== null) return { days: own, from: "project" };
+  const global = globalSweepDays();
+  if (global !== null) return { days: global, from: "global" };
+  return { days: DEFAULT_SWEEP_DAYS, from: "default" };
+}
+
+// Projects with their own number, for the settings page.
+export function projectSweepOverrides(): Array<{
+  projectId: string;
+  days: number;
+}> {
+  const rows = db
+    .prepare(
+      `SELECT key FROM settings WHERE key LIKE 'worktree_sweep.project.%'`
+    )
+    .all() as Array<{ key: string }>;
+  return rows.flatMap(({ key }) => {
+    const projectId = key.slice("worktree_sweep.project.".length);
+    const days = read(key);
+    return days === null ? [] : [{ projectId, days }];
+  });
+}