@saadnvd1/agent-os 0.3.662 → 0.3.671

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 Saad turns it on for this machine, or
+// the orchestrator does on his word after a dry run from the last hour.
+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/testTemp.ts

@@ -0,0 +1,113 @@
+// Folders the test suite makes in the OS temp folder, by name. The sweep
+// takes only these, never another aos-… or agent-os-… folder, so AgentOS's
+// own temp folders (aos-review-, aos-rebase-…) and a person's are safe.
+// lib/test-temp.test.ts fails when a test uses a prefix missing here.
+export const TEST_TEMP_PREFIXES: readonly string[] = [
+  "agent-os-git-",
+  "agent-os-home-",
+  "agent-os-kept-",
+  "agent-os-limits-",
+  "agent-os-session-logs-",
+  "agent-os-test-",
+  "aos-acc-",
+  "aos-add-",
+  "aos-armed-repo-",
+  "aos-art-",
+  "aos-autodeploy-",
+  "aos-caches-",
+  "aos-channel-",
+  "aos-clone-",
+  "aos-config-",
+  "aos-crypt-",
+  "aos-db-",
+  "aos-db-drops-",
+  "aos-db-wt-",
+  "aos-decl-",
+  "aos-device-keys-",
+  "aos-done-home-",
+  "aos-done-repo-",
+  "aos-env-",
+  "aos-fast-",
+  "aos-files-",
+  "aos-git-",
+  "aos-gr-",
+  "aos-heavy-",
+  "aos-init-route-",
+  "aos-install-",
+  "aos-kind-",
+  "aos-launch-plain-",
+  "aos-launch-repo-",
+  "aos-limits-",
+  "aos-mcp-",
+  "aos-merge-policy-",
+  "aos-mig-",
+  "aos-move-",
+  "aos-no-approvals-",
+  "aos-nogit-",
+  "aos-notify-",
+  "aos-orch-act-",
+  "aos-orch-add-",
+  "aos-orch-approve-",
+  "aos-orch-armed-",
+  "aos-orch-asks-",
+  "aos-orch-brakes-",
+  "aos-orch-ext-repo-",
+  "aos-orch-external-",
+  "aos-orch-home-",
+  "aos-orch-move-",
+  "aos-orch-plain-",
+  "aos-orch-questions-",
+  "aos-orch-recipes-",
+  "aos-orch-remind-",
+  "aos-orch-repo-",
+  "aos-orch-rules-",
+  "aos-orch-settle-",
+  "aos-orch-signoff-",
+  "aos-orch-sweep-",
+  "aos-origin-",
+  "aos-path-",
+  "aos-plain-",
+  "aos-plan-",
+  "aos-ports-",
+  "aos-pr-",
+  "aos-pr-async-",
+  "aos-pr-create-",
+  "aos-pr-gen-",
+  "aos-pr-route-",
+  "aos-prompts-",
+  "aos-quick-",
+  "aos-quick-repo-",
+  "aos-relay-",
+  "aos-relay-none-",
+  "aos-report-",
+  "aos-resurrect-claude-",
+  "aos-resurrect-home-",
+  "aos-run-",
+  "aos-runner-",
+  "aos-sec-",
+  "aos-shot-",
+  "aos-sim-",
+  "aos-spare-",
+  "aos-stack-",
+  "aos-start-opts-",
+  "aos-start-plain-",
+  "aos-sweep-own-",
+  "aos-t-",
+  "aos-task-diff-",
+  "aos-temp-helper-",
+  "aos-tmux-",
+  "aos-transcripts-",
+  "aos-ui-",
+  "aos-upd-",
+  "aos-usage-",
+  "aos-wg-",
+  "aos-wg-path-",
+  "aos-wl-",
+  "aos-worker-env-",
+  "aos-worker-tmux-",
+  "aos-wsl-",
+  "aos-wt-",
+];
+
+export const isTestTempName = (name: string) =>
+  TEST_TEMP_PREFIXES.some((p) => name.startsWith(p));

package/lib/worktree-sweep/types.ts

@@ -1,4 +1,23 @@
-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"
+  | "test-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",
+  "test-temp",
+  "derived-data",
+]);
 
 export interface SweepRemoved {
   path: string;
@@ -15,10 +34,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 +90,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.662",
+  "version": "0.3.671",
   "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/autodeploy.test.ts

@@ -1,8 +1,8 @@
 import { execFileSync } from "child_process";
 import * as fs from "fs";
-import * as os from "os";
 import * as path from "path";
 import { describe, expect, it } from "vitest";
+import { tempDir } from "@/lib/test-temp";
 
 // Runs the real scripts/autodeploy in a scratch clone with a stub redeploy
 // (a pull) and wait-quiet, against a scratch origin and HOME.
@@ -11,7 +11,7 @@ const sh = (cwd: string, ...args: string[]) =>
   execFileSync("git", args, { cwd, encoding: "utf-8" }).trim();
 
 function setup() {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "aos-autodeploy-"));
+  const root = tempDir("aos-autodeploy-");
   const origin = path.join(root, "origin.git");
   const work = path.join(root, "work");
   const clone = path.join(root, "live");

package/scripts/check-bundle.test.ts

@@ -1,13 +1,13 @@
 import { describe, expect, it } from "vitest";
 import { spawnSync } from "child_process";
 import fs from "fs";
-import os from "os";
 import path from "path";
+import { tempDir } from "@/lib/test-temp";
 
 const script = path.join(__dirname, "check-bundle.mjs");
 
 function run(stats: unknown) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "bundle-"));
+  const dir = tempDir("bundle-");
   const file = path.join(dir, "stats.json");
   fs.writeFileSync(file, JSON.stringify(stats));
   const r = spawnSync(process.execPath, [script, file], { encoding: "utf-8" });

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);
+});

package/scripts/hooks/banned-terms.test.ts

@@ -4,11 +4,12 @@ import fs from "fs";
 import os from "os";
 import path from "path";
 import { GENERIC_TERMS, loadTerms, matcher, scanTree } from "./banned-terms";
+import { tempDir } from "@/lib/test-temp";
 
 const generic = GENERIC_TERMS[0];
 
 function tempRepo() {
-  const repo = fs.mkdtempSync(path.join(os.tmpdir(), "banned-terms-"));
+  const repo = tempDir("banned-terms-");
   const git = (...args: string[]) =>
     execFileSync("git", args, { cwd: repo, stdio: "pipe" });
   git("init", "-q");
@@ -22,7 +23,7 @@ describe("loadTerms", () => {
   });
 
   it("adds the private regexes, skipping blanks and comments", () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "banned-names-"));
+    const dir = tempDir("banned-names-");
     const file = path.join(dir, "banned-names");
     fs.writeFileSync(file, "# names\nacme[ -]?widgets\n\n  zorp  \n");
     try {

package/scripts/hooks/staged-secrets.test.ts

@@ -1,9 +1,9 @@
 import { describe, expect, it } from "vitest";
 import { execFileSync, spawnSync } from "child_process";
 import fs from "fs";
-import os from "os";
 import path from "path";
 import { scanDiff } from "./staged-secrets";
+import { tempDir } from "@/lib/test-temp";
 
 // Fakes are built here, never written whole: a literal would be the very
 // thing this scan (and the merge gate) refuses.
@@ -62,7 +62,7 @@ describe("scanDiff", () => {
   });
 
   it("fails the commit on a staged secret, and passes once it's gone", () => {
-    const repo = fs.mkdtempSync(path.join(os.tmpdir(), "staged-secrets-"));
+    const repo = tempDir("staged-secrets-");
     const git = (...args: string[]) =>
       execFileSync("git", args, { cwd: repo, stdio: "pipe" });
     const scan = () =>

package/scripts/lib/build-swap.test.ts

@@ -2,15 +2,14 @@ import { spawnSync } from "node:child_process";
 import {
   existsSync,
   mkdirSync,
-  mkdtempSync,
   readFileSync,
   rmSync,
   utimesSync,
   writeFileSync,
 } from "node:fs";
-import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { tempDir } from "@/lib/test-temp";
 
 const LIB = join(import.meta.dirname, "build-swap.sh");
 
@@ -41,7 +40,7 @@ const BUILD = `
 `;
 
 beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), "build-swap-"));
+  dir = tempDir("build-swap-");
   mkdirSync(join(dir, ".next/cache/turbopack"), { recursive: true });
   writeFileSync(join(dir, ".next/BUILD_ID"), "old\n");
   writeFileSync(join(dir, ".next/cache/turbopack/db"), "cache\n");

package/scripts/lib/wsl.test.ts

@@ -3,15 +3,14 @@ import {
   chmodSync,
   existsSync,
   mkdirSync,
-  mkdtempSync,
   readFileSync,
   rmSync,
   symlinkSync,
   writeFileSync,
 } from "node:fs";
-import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { tempDir } from "@/lib/test-temp";
 
 // The installer's WSL paths, run on any OS: `uname`, `ps`, the browser
 // openers and the package managers are fakes, and the kernel release is a
@@ -60,7 +59,7 @@ function run(
 }
 
 beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), "aos-wsl-"));
+  dir = tempDir("aos-wsl-");
   mkdirSync(join(dir, "bin"));
   for (const tool of TOOLS) {
     const real = ["/usr/bin", "/bin"]

package/scripts/update-run.test.ts

@@ -1,16 +1,16 @@
 import { execFile } from "child_process";
 import fs from "fs";
-import os from "os";
 import path from "path";
 import { promisify } from "util";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { tempDir } from "@/lib/test-temp";
 
 const exec = promisify(execFile);
 const runner = path.join(__dirname, "update-run.mjs");
 
 let dir: string;
 beforeEach(() => {
-  dir = fs.mkdtempSync(path.join(os.tmpdir(), "aos-runner-"));
+  dir = tempDir("aos-runner-");
   fs.writeFileSync(
     path.join(dir, "state.json"),
     JSON.stringify({ id: "r1", phase: "starting", from: "a" })