@saadnvd1/agent-os 0.3.639 → 0.3.644

package/lib/worktree-sweep/start.ts

@@ -0,0 +1,64 @@
+import fs from "fs";
+import path from "path";
+import { dbPath } from "../db/path";
+import { WORKTREES_DIR } from "../worktrees";
+import { sweep } from "./runSweep";
+
+export const SWEEP_EVERY_MS = 6 * 3600_000;
+export const SWEEP_FIRST_AFTER_MS = 10 * 60_000;
+
+const OWNER_FILE = ".sweep-owner";
+
+// A development or test instance has its own database but sees the real
+// worktrees folder: every live worktree would look like an orphan to it. Only
+// a production server, or one asked to, sweeps, and only a folder it owns.
+export const sweepEnabled = (env: NodeJS.ProcessEnv = process.env) =>
+  !env.VITEST &&
+  (env.AGENTOS_WORKTREE_SWEEP === "1" ||
+    (env.NODE_ENV === "production" && env.AGENTOS_WORKTREE_SWEEP !== "0"));
+
+// First sweep claims the folder for this database; another one's claim stands.
+export function ownsWorktrees(
+  claim: boolean,
+  root = WORKTREES_DIR,
+  db = path.resolve(dbPath())
+): boolean {
+  const file = path.join(root, OWNER_FILE);
+  try {
+    return fs.readFileSync(file, "utf8").trim() === db;
+  } catch {
+    // unclaimed
+  }
+  if (!claim) return false;
+  fs.mkdirSync(root, { recursive: true });
+  fs.writeFileSync(file, db);
+  return true;
+}
+
+const g = globalThis as unknown as { __agentosSweeping?: boolean };
+
+// One run at a time, however it was asked for.
+export async function sweepNow(dryRun = false) {
+  if (g.__agentosSweeping) throw new Error("A clean-up is already running");
+  if (!ownsWorktrees(sweepEnabled()))
+    throw new Error("Another AgentOS owns the worktrees folder");
+  g.__agentosSweeping = true;
+  try {
+    return await sweep({ dryRun });
+  } finally {
+    g.__agentosSweeping = false;
+  }
+}
+
+export function startWorktreeSweep(): void {
+  if (!sweepEnabled()) return;
+  const run = () => {
+    sweepNow().catch((error) =>
+      console.error("[worktree-sweep] not run:", error.message)
+    );
+  };
+  setTimeout(() => {
+    run();
+    setInterval(run, SWEEP_EVERY_MS);
+  }, SWEEP_FIRST_AFTER_MS);
+}

package/lib/worktree-sweep/state.ts

@@ -0,0 +1,36 @@
+import { getAllProjects } from "../projects";
+import {
+  DEFAULT_SWEEP_DAYS,
+  globalSweepDays,
+  projectSweepOverrides,
+} from "./settings";
+import { recentRuns } from "./store";
+import type { SweepRun } from "./types";
+
+export interface SweepState {
+  // Null when no number is set globally: the default applies.
+  days: number | null;
+  defaultDays: number;
+  overrides: Array<{ projectId: string; name: string; days: number }>;
+  runs: SweepRun[];
+}
+
+export function sweepState(): SweepState {
+  const names = new Map(getAllProjects().map((p) => [p.id, p.name]));
+  return {
+    days: globalSweepDays(),
+    defaultDays: DEFAULT_SWEEP_DAYS,
+    overrides: projectSweepOverrides().flatMap((o) =>
+      names.has(o.projectId)
+        ? [
+            {
+              projectId: o.projectId,
+              name: names.get(o.projectId)!,
+              days: o.days,
+            },
+          ]
+        : []
+    ),
+    runs: recentRuns(),
+  };
+}

package/lib/worktree-sweep/store.ts

@@ -0,0 +1,96 @@
+import { db } from "../db";
+import type { SweepRun, SweepSummary } from "./types";
+
+interface RunRow {
+  id: number;
+  started_at: string;
+  finished_at: string | null;
+  dry_run: number;
+  removed: number;
+  freed_bytes: number;
+  skipped: number;
+  details: string | null;
+  error: string | null;
+}
+
+// The counts are exact; the lists kept for a run stop here (a first run can
+// skip thousands of folders that are simply too young).
+const DETAIL_CAP = 300;
+
+const view = (r: RunRow): SweepRun => ({
+  id: r.id,
+  startedAt: r.started_at,
+  finishedAt: r.finished_at,
+  dryRun: !!r.dry_run,
+  removed: r.removed,
+  freedBytes: r.freed_bytes,
+  skipped: r.skipped,
+  details: r.details ? (JSON.parse(r.details) as SweepSummary) : null,
+  error: r.error,
+});
+
+export function startRun(dryRun: boolean): number {
+  return Number(
+    db
+      .prepare(`INSERT INTO worktree_sweep_runs (dry_run) VALUES (?)`)
+      .run(dryRun ? 1 : 0).lastInsertRowid
+  );
+}
+
+export function finishRun(
+  id: number,
+  summary: SweepSummary,
+  error: string | null
+): void {
+  db.prepare(
+    `UPDATE worktree_sweep_runs SET finished_at = datetime('now'), removed = ?,
+       freed_bytes = ?, skipped = ?, details = ?, error = ? WHERE id = ?`
+  ).run(
+    summary.removed.length,
+    summary.freedBytes,
+    summary.skipped.length,
+    JSON.stringify({
+      ...summary,
+      skipped: summary.skipped.slice(0, DETAIL_CAP),
+    }),
+    error,
+    id
+  );
+}
+
+export function recentRuns(limit = 30): SweepRun[] {
+  return (
+    db
+      .prepare(`SELECT * FROM worktree_sweep_runs ORDER BY id DESC LIMIT ?`)
+      .all(limit) as RunRow[]
+  ).map(view);
+}
+
+export function recordSwept(
+  sessionId: string,
+  path: string,
+  branch: string | null,
+  runId: number
+): void {
+  db.prepare(
+    `INSERT INTO session_worktree_sweeps (session_id, path, branch, run_id)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(session_id) DO UPDATE SET path = excluded.path,
+       branch = excluded.branch, swept_at = datetime('now'), run_id = excluded.run_id`
+  ).run(sessionId, path, branch, runId);
+}
+
+export function sweptAt(sessionId: string): string | null {
+  const row = db
+    .prepare(
+      `SELECT swept_at FROM session_worktree_sweeps WHERE session_id = ?`
+    )
+    .get(sessionId) as { swept_at: string } | undefined;
+  return row?.swept_at ?? null;
+}
+
+export function forgetSwept(sessionId: string): void {
+  db.prepare(`DELETE FROM session_worktree_sweeps WHERE session_id = ?`).run(
+    sessionId
+  );
+}

package/lib/worktree-sweep/types.ts

@@ -0,0 +1,53 @@
+export type SweepKind = "settled" | "orphan" | "test-leak";
+
+export interface SweepRemoved {
+  path: string;
+  kind: SweepKind;
+  why: string;
+  bytes: number;
+  sessionId?: string;
+}
+
+export interface SweepSkipped {
+  path: string;
+  kind: SweepKind;
+  reason: string;
+  sessionId?: string;
+}
+
+export interface SweepSummary {
+  removed: SweepRemoved[];
+  skipped: SweepSkipped[];
+  freedBytes: number;
+}
+
+export interface SweepRun {
+  id: number;
+  startedAt: string;
+  finishedAt: string | null;
+  dryRun: boolean;
+  removed: number;
+  freedBytes: number;
+  skipped: number;
+  details: SweepSummary | null;
+  error: string | null;
+}
+
+export type DaysSource = "project" | "global" | "default";
+
+export interface ResolvedDays {
+  days: number;
+  from: DaysSource;
+}
+
+// A directory the sweep may remove, once it has been judged.
+export interface Candidate {
+  path: string;
+  kind: SweepKind;
+  sessionId?: string;
+  // The main checkout git knows it by, when it is a registered worktree.
+  repo?: string;
+  // The PR head a merge took, when the session has one.
+  prNumber?: number | null;
+  branch?: string | null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.639",
+  "version": "0.3.644",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/scripts/screenshots/seed.ts

@@ -234,7 +234,7 @@ function tmux(args: string[]): void {
 
 async function seedDb(): Promise<void> {
   process.env.DB_PATH = DB_PATH;
-  const { getDb } = await import("../../lib/db");
+  const { getDb, insertSessionRow } = await import("../../lib/db");
   const db = getDb();
   const projectIds = new Map<string, string>();
   const workspaceIds = new Map<string, string>();
@@ -261,24 +261,25 @@ async function seedDb(): Promise<void> {
     sessionIds.set(s.key, id);
     const tmuxName = `claude-${id}`;
     const when = `-${s.minutesAgo} minutes`;
-    db.prepare(
-      `INSERT INTO sessions (id, name, tmux_name, working_directory, project_id, agent_type, model, view,
-         task_prompt, task_status, branch_name, base_branch, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, 'claude', 'opus', ?, ?, ?, ?, ?, datetime('now', ?), datetime('now', ?))`
-    ).run(
+    const at = (
+      db.prepare(`SELECT datetime('now', ?) AS t`).get(when) as { t: string }
+    ).t;
+    insertSessionRow(db, {
       id,
-      s.name,
-      tmuxName,
-      `~/code/${s.project}`,
-      projectIds.get(s.project),
-      s.view ?? "terminal",
-      s.task?.prompt ?? null,
-      s.task?.status ?? null,
-      s.task?.branch ?? null,
-      s.task ? "main" : null,
-      when,
-      when
-    );
+      name: s.name,
+      tmux_name: tmuxName,
+      working_directory: `~/code/${s.project}`,
+      project_id: projectIds.get(s.project),
+      agent_type: "claude",
+      model: "opus",
+      view: s.view ?? "terminal",
+      task_prompt: s.task?.prompt ?? null,
+      task_status: s.task?.status ?? null,
+      branch_name: s.task?.branch ?? null,
+      base_branch: s.task ? "main" : null,
+      created_at: at,
+      updated_at: at,
+    });
     if (s.chat) {
       const insert = db.prepare(
         `INSERT INTO chat_items (session_id, item_id, seq, data) VALUES (?, ?, ?, ?)`

package/server.ts

@@ -18,6 +18,7 @@ import { recordBoot } from "./lib/health/boots";
 import { realDeps, schedulesEnabled, startScheduler } from "./lib/schedules";
 import { startSettling } from "./lib/recipes";
 import { startAutoArchive } from "./lib/done/auto-archive";
+import { startWorktreeSweep } from "./lib/worktree-sweep/start";
 import { startUsageRollup, usageRollupEnabled } from "./lib/usage/nightly";
 import { resumePhoneOutbox } from "./lib/notify";
 import { resumePushOutbox } from "./lib/notify/push";
@@ -445,6 +446,8 @@ app.prepare().then(async () => {
   startSettling();
   // Sessions that sat in Done for 30 days are archived.
   startAutoArchive();
+  // Settled worktrees older than the setting are removed; branches stay.
+  startWorktreeSweep();
   resumePhoneOutbox();
   resumePushOutbox();
   // The usage ledger's daily rollup and its ratchet alerts.