@saadnvd1/agent-os 0.3.660 → 0.3.664

package/lib/worktree-sweep/runSweep.ts

@@ -6,7 +6,6 @@
 
 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";
@@ -19,10 +18,14 @@ import {
   type SettledDeps,
 } from "./findSettled";
 import { findOrphans, holdsNothing } from "./findOrphans";
+import duBytes from "./du";
+import { findExtras, defaultExtras, type Extras } from "./extras";
+import { reaperArmed } from "./settings";
+import { writeDiskReport } from "./report";
 import { judgeWorktree } from "./judge";
 import { openPaneFolders } from "./panes";
 import { finishRun, recordSwept, startRun } from "./store";
-import type { Candidate, SweepSummary } from "./types";
+import { ARMED_KINDS, type Candidate, type SweepSummary } from "./types";
 
 export interface SweepDeps {
   now: number;
@@ -33,19 +36,15 @@ export interface SweepDeps {
   prHead: (repo: string, number: number) => Promise<string | null>;
   // Stop early when the machine is busy.
   busy: () => boolean;
+  // Task databases, spares, temp folders and build caches.
+  extras: (opts?: { fresh?: boolean }) => Promise<Extras>;
+  // Written by a dry run: where its list goes.
+  report: (summary: SweepSummary) => string | null;
 }
 
 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(
@@ -73,9 +72,18 @@ export const defaultSweepDeps = (): SweepDeps => ({
   root: WORKTREES_DIR,
   panes: openPaneFolders,
   settled: defaultSettledDeps(),
-  size: duBytes,
+  size: (dir) => duBytes(dir, 120_000),
   prHead: prHeadOf,
   busy: () => currentLevel() === "red",
+  extras: defaultExtras,
+  report: (summary) => {
+    try {
+      return writeDiskReport(summary);
+    } catch (error) {
+      console.error("[worktree-sweep] report not written:", error);
+      return null;
+    }
+  },
 });
 
 // A path under the root, never the root itself or something outside it.
@@ -123,7 +131,14 @@ export async function sweep(
 ): Promise<{ runId: number; summary: SweepSummary }> {
   const dryRun = !!opts.dryRun;
   const runId = startRun(dryRun);
-  const summary: SweepSummary = { removed: [], skipped: [], freedBytes: 0 };
+  const armed = reaperArmed();
+  const summary: SweepSummary = {
+    removed: [],
+    skipped: [],
+    freedBytes: 0,
+    pending: [],
+    armed,
+  };
   let error: string | null = null;
   try {
     const panes = await deps.panes();
@@ -155,6 +170,18 @@ export async function sweep(
           reason,
           sessionId: c.sessionId,
         });
+      if (ARMED_KINDS.has(c.kind) && !armed) {
+        summary.pending!.push({
+          path: c.path,
+          kind: c.kind,
+          why:
+            c.kind === "test-leak"
+              ? "a test's throwaway repository"
+              : "an orphan worktree",
+          bytes: await deps.size(c.path),
+        });
+        continue;
+      }
       const repo = await repoOfSession(c);
       const why =
         c.kind === "test-leak"
@@ -203,9 +230,12 @@ export async function sweep(
       summary.freedBytes += bytes;
     }
     if (!dryRun) await pruneProjects([...pruned]);
+    const extras = await findExtras(deps, summary, { armed, dryRun });
+    summary.totals = extras.totals;
   } catch (e) {
     error = e instanceof Error ? e.message : String(e);
   }
+  if (dryRun) summary.report = deps.report(summary) ?? undefined;
   finishRun(runId, summary, error);
   console.log(describeRun(summary, dryRun, error));
   return { runId, summary };
@@ -239,5 +269,8 @@ export function describeRun(
   }
   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}` : ""}`;
+  const pending = s.pending?.length
+    ? `, ${s.pending.length} more (${gb(s.pending.reduce((n, p) => n + p.bytes, 0))}) wait for the full clean-up to be turned on`
+    : "";
+  return `[worktree-sweep] ${dryRun ? "would remove" : "removed"} ${s.removed.length} (${gb(s.freedBytes)}${leaks ? `, ${leaks} test leftovers` : ""})${pending}, skipped ${s.skipped.length}${why ? `: ${why}` : ""}${error ? `; failed: ${error}` : ""}`;
 }

package/lib/worktree-sweep/settings.ts

@@ -81,3 +81,27 @@ export function projectSweepOverrides(): Array<{
     return days === null ? [] : [{ projectId, days }];
   });
 }
+
+// The full clean-up (test leftovers, task databases, spares, temp folders,
+// build caches) removes nothing until a person turns it on for this machine,
+// after reading what a dry run found.
+const ARMED_KEY = "worktree_sweep.reaper";
+
+export function reaperArmed(): boolean {
+  const row = db
+    .prepare(`SELECT value FROM settings WHERE key = ?`)
+    .get(ARMED_KEY) as { value: string } | undefined;
+  if (!row) return false;
+  try {
+    return JSON.parse(row.value)?.armed === true;
+  } catch {
+    return false;
+  }
+}
+
+export function setReaperArmed(armed: boolean): void {
+  db.prepare(
+    `INSERT INTO settings (key, value) VALUES (?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  ).run(ARMED_KEY, JSON.stringify({ armed, at: new Date().toISOString() }));
+}

package/lib/worktree-sweep/state.ts

@@ -3,6 +3,7 @@ import {
   DEFAULT_SWEEP_DAYS,
   globalSweepDays,
   projectSweepOverrides,
+  reaperArmed,
 } from "./settings";
 import { recentRuns } from "./store";
 import type { SweepRun } from "./types";
@@ -13,6 +14,9 @@ export interface SweepState {
   defaultDays: number;
   overrides: Array<{ projectId: string; name: string; days: number }>;
   runs: SweepRun[];
+  // Whether the full clean-up (test leftovers, task databases, spares, temp
+  // folders, build caches) removes anything on this machine.
+  armed: boolean;
 }
 
 export function sweepState(): SweepState {
@@ -32,5 +36,6 @@ export function sweepState(): SweepState {
         : []
     ),
     runs: recentRuns(),
+    armed: reaperArmed(),
   };
 }

package/lib/worktree-sweep/store.ts

@@ -51,6 +51,17 @@ export function finishRun(
     summary.skipped.length,
     JSON.stringify({
       ...summary,
+      // The biggest first: they are what a person looks for.
+      removed: [...summary.removed]
+        .sort((a, b) => b.bytes - a.bytes)
+        .slice(0, DETAIL_CAP),
+      pending: [...(summary.pending ?? [])]
+        .sort((a, b) => b.bytes - a.bytes)
+        .slice(0, DETAIL_CAP),
+      pendingTotal: {
+        count: summary.pending?.length ?? 0,
+        bytes: (summary.pending ?? []).reduce((n, p) => n + p.bytes, 0),
+      },
       skipped: summary.skipped.slice(0, DETAIL_CAP),
     }),
     error,

package/lib/worktree-sweep/types.ts

@@ -1,4 +1,21 @@
-export type SweepKind = "settled" | "orphan" | "test-leak";
+export type SweepKind =
+  | "settled"
+  | "orphan"
+  | "test-leak"
+  // What a task left beside its checkout, found by the full clean-up.
+  | "database"
+  | "spare"
+  | "temp"
+  | "derived-data";
+
+// Kinds that go only once the full clean-up is turned on.
+export const ARMED_KINDS: ReadonlySet<SweepKind> = new Set([
+  "test-leak",
+  "database",
+  "spare",
+  "temp",
+  "derived-data",
+]);
 
 export interface SweepRemoved {
   path: string;
@@ -15,10 +32,31 @@ export interface SweepSkipped {
   sessionId?: string;
 }
 
+export interface CategoryTotal {
+  count: number;
+  bytes: number;
+}
+
+// What is on disk after the run, for the one-line summary.
+export interface SweepTotals {
+  worktrees: CategoryTotal;
+  databases: CategoryTotal;
+  spares: CategoryTotal;
+  temp: CategoryTotal;
+}
+
 export interface SweepSummary {
   removed: SweepRemoved[];
   skipped: SweepSkipped[];
   freedBytes: number;
+  // Found but left, because the full clean-up isn't turned on.
+  pending?: SweepRemoved[];
+  // The whole of pending, once a stored run keeps only its biggest.
+  pendingTotal?: CategoryTotal;
+  totals?: SweepTotals;
+  armed?: boolean;
+  // Where a dry run wrote its list.
+  report?: string;
 }
 
 export interface SweepRun {
@@ -50,4 +88,9 @@ export interface Candidate {
   // The PR head a merge took, when the session has one.
   prNumber?: number | null;
   branch?: string | null;
+  // A database: the server it lives on, and why it's reapable.
+  server?: { host?: string; port?: number };
+  why?: string;
+  // Known without measuring (a database's size).
+  bytes?: number;
 }

package/lib/worktrees.ts

@@ -2,6 +2,7 @@
  * Git Worktree management for isolated feature development
  */
 
+import { stopDevServer } from "./dev-instance/stopDevServer";
 import * as path from "path";
 import * as fs from "fs";
 import * as os from "os";
@@ -301,6 +302,8 @@ export function deleteWorktree(
   let marker: string | null = null;
   const done = (async () => {
     await branch;
+    // A dev server left running would outlive the folder it runs in.
+    await stopDevServer(key).catch(() => {});
     // Before anything is removed, so no reader catches it half-deleted.
     marker = markRemoving(key);
     await removeWorktree(key, repo);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.660",
+  "version": "0.3.664",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"
@@ -33,6 +33,7 @@
     "dev": "AGENTOS_DEV=1 tsx server.ts",
     "dev:task": "tsx scripts/dev-task.ts",
     "dev:stop": "tsx scripts/dev-stop.ts",
+    "disk:dry-run": "tsx scripts/disk-dry-run.ts",
     "prebuild": "node scripts/gen-migrations-index.mjs",
     "build": "next build",
     "prestart": "node scripts/ensure-native.mjs && node scripts/gen-migrations-index.mjs",

package/scripts/disk-dry-run.ts

@@ -0,0 +1,57 @@
+/**
+ * What the disk clean-up would remove, without removing anything: runs a dry
+ * sweep against a copy of the live database and writes the list to
+ * ~/.agent-os/audits/disk-cleanup/<date>.md.
+ *
+ *   npm run disk:dry-run -- --db <path to the live agent-os.db>
+ *
+ * The live database is opened read-only for the copy and never written; the
+ * copy is deleted afterwards. Nothing on disk or in Postgres is touched.
+ */
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import Database from "better-sqlite3";
+
+const arg = process.argv.indexOf("--db");
+const live: string = (arg > 0 && process.argv[arg + 1]) || "";
+if (!live || !fs.existsSync(live)) {
+  console.error("usage: npm run disk:dry-run -- --db <path to agent-os.db>");
+  process.exit(1);
+}
+
+async function main() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "aos-disk-dry-"));
+  const copy = path.join(dir, "agent-os.db");
+  try {
+    const src = new Database(live, { readonly: true });
+    await src.backup(copy);
+    src.close();
+    process.env.DB_PATH = copy;
+
+    const { sweep, defaultSweepDeps } =
+      await import("../lib/worktree-sweep/runSweep");
+    const { summary } = await sweep(
+      { dryRun: true },
+      { ...defaultSweepDeps(), busy: () => false }
+    );
+    const all = [...summary.removed, ...(summary.pending ?? [])];
+    const gb = (b: number) => `${(b / 1024 ** 3).toFixed(2)} GB`;
+    for (const kind of new Set(all.map((i) => i.kind))) {
+      const items = all.filter((i) => i.kind === kind);
+      console.log(
+        `${kind}: ${items.length} (${gb(items.reduce((n, i) => n + i.bytes, 0))})`
+      );
+    }
+    console.log(`kept: ${summary.skipped.length}`);
+    console.log(`list: ${summary.report ?? "(not written)"}`);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});