@saadnvd1/agent-os 0.3.662 → 0.3.664

package/app/api/sessions/[id]/route.ts

@@ -7,7 +7,7 @@ import {
   mainCheckoutOf,
 } from "@/lib/worktrees";
 import { releasePort } from "@/lib/ports";
-import { dropSessionDatabase } from "@/lib/project-config/database";
+import { releaseSessionLeftovers } from "@/lib/sessions/leftovers";
 import { killWorker } from "@/lib/orchestration";
 import { endSessionAgent } from "@/lib/sessions/end";
 import { endTmuxSession } from "@/lib/tmux/end";
@@ -261,7 +261,7 @@ export async function DELETE(request: NextRequest, { params }: RouteParams) {
       } catch (error) {
         console.error(`Failed to kill worker ${worker.id}:`, error);
       }
-      void dropSessionDatabase(worker.id);
+      void releaseSessionLeftovers(worker);
       queries.deleteSession(db).run(worker.id);
     }
 
@@ -271,7 +271,7 @@ export async function DELETE(request: NextRequest, { params }: RouteParams) {
     }
 
     // Its private Postgres copy: the row is read now, the drop runs on.
-    void dropSessionDatabase(id);
+    void releaseSessionLeftovers(existing);
 
     // Delete from database immediately for instant UI feedback
     // The agent's tmux and processes go on in the background; the worktree

package/app/api/worktree-sweep/route.test.ts

@@ -5,10 +5,11 @@ import { NextRequest } from "next/server";
 const { GET, PUT } = await import("./route");
 const { createProject } = await import("@/lib/projects");
 
-const put = (body: unknown) =>
+const put = (body: unknown, trust: string | null = "loopback") =>
   PUT(
     new NextRequest("http://localhost/api/worktree-sweep", {
       method: "PUT",
+      headers: trust ? { "x-agentos-trust": trust } : {},
       body: JSON.stringify(body),
     })
   );
@@ -30,6 +31,23 @@ describe("/api/worktree-sweep", () => {
     expect((await (await put({ days: null })).json()).days).toBeNull();
   });
 
+  it("turns the full clean-up on and off, off by default", async () => {
+    expect((await (await GET()).json()).armed).toBe(false);
+    expect((await (await put({ armed: true })).json()).armed).toBe(true);
+    expect((await (await GET()).json()).armed).toBe(true);
+    expect((await (await put({ armed: false })).json()).armed).toBe(false);
+    expect((await put({ armed: "yes" })).status).toBe(400);
+  });
+
+  it("turns the full clean-up on only from this machine or the tailnet, off from anywhere", async () => {
+    expect((await put({ armed: true }, null)).status).toBe(403);
+    expect((await put({ armed: true }, "device")).status).toBe(403);
+    expect((await (await GET()).json()).armed).toBe(false);
+    expect((await put({ armed: true }, "tailnet")).status).toBe(200);
+    expect((await put({ armed: false }, null)).status).toBe(200);
+    expect((await (await GET()).json()).armed).toBe(false);
+  });
+
   it("refuses a number that isn't a whole 0-365", async () => {
     for (const days of [-1, 1.5, 400, "7", undefined]) {
       const res = await put({ days });

package/app/api/worktree-sweep/route.ts

@@ -2,16 +2,21 @@ import { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
 import {
   setGlobalSweepDays,
+  setReaperArmed,
   setProjectSweepDays,
   sweepDays,
 } from "@/lib/worktree-sweep/settings";
+import { requireLocalTrust } from "@/lib/security/route-guard";
 import { sweepState } from "@/lib/worktree-sweep/state";
 
-const body = z.object({
-  // Null clears the setting: the global one, then the default, applies.
-  days: sweepDays.nullable(),
-  projectId: z.string().min(1).optional(),
-});
+const body = z.union([
+  z.object({
+    // Null clears the setting: the global one, then the default, applies.
+    days: sweepDays.nullable(),
+    projectId: z.string().min(1).optional(),
+  }),
+  z.object({ armed: z.boolean() }),
+]);
 
 export async function GET() {
   return NextResponse.json(sweepState());
@@ -21,9 +26,23 @@ export async function PUT(request: NextRequest) {
   const got = body.safeParse(await request.json().catch(() => null));
   if (!got.success)
     return NextResponse.json(
-      { error: "days must be a whole number from 0 to 365, or null" },
+      {
+        error:
+          "days must be a whole number from 0 to 365, or null; or armed true or false",
+      },
       { status: 400 }
     );
+  if ("armed" in got.data) {
+    // Turning the removal on is a person's call, made on this machine or
+    // over Tailscale: a stolen device token must not be able to. Turning it
+    // off stays on the ordinary gate.
+    if (got.data.armed) {
+      const refused = requireLocalTrust(request);
+      if (refused) return refused;
+    }
+    setReaperArmed(got.data.armed);
+    return NextResponse.json(sweepState());
+  }
   const { days, projectId } = got.data;
   if (projectId) setProjectSweepDays(projectId, days);
   else setGlobalSweepDays(days);

package/components/Health/SweepRuns.tsx

@@ -1,7 +1,11 @@
 "use client";
 
 import { Button } from "@/components/ui/button";
-import { useRunSweep, useWorktreeSweep } from "@/data/worktree-sweep";
+import {
+  useRunSweep,
+  useSetReaperArmed,
+  useWorktreeSweep,
+} from "@/data/worktree-sweep";
 import { compactTimeAgo, fromSqliteTime } from "@/lib/session-meta";
 import { formatBytes } from "@/lib/share/view";
 import type { SweepRun } from "@/lib/worktree-sweep/types";
@@ -10,8 +14,34 @@ const KIND: Record<string, string> = {
   settled: "settled session",
   orphan: "orphan folder",
   "test-leak": "test leftover",
+  database: "task database",
+  spare: "dependency spare",
+  temp: "temp folder",
+  "derived-data": "Xcode build folder",
 };
 
+// "18.2 GB in 3,876 worktrees · 12 task databases (270 MB) · ..." from the
+// latest run that measured, and what the last real run freed.
+export function diskSummary(runs: SweepRun[]): string | null {
+  const totals = runs.find((r) => r.details?.totals)?.details?.totals;
+  if (!totals) return null;
+  const part = (n: number, bytes: number, what: string) =>
+    `${n.toLocaleString()} ${what}${bytes ? ` (${formatBytes(bytes)})` : ""}`;
+  const last = runs.find((r) => !r.dryRun && r.finishedAt);
+  return [
+    `Task leftovers: ${part(totals.worktrees.count, totals.worktrees.bytes, "worktrees")}`,
+    part(
+      totals.databases.count,
+      totals.databases.bytes,
+      "stale task databases"
+    ),
+    part(totals.spares.count, totals.spares.bytes, "dependency spares"),
+    last
+      ? `last clean-up freed ${formatBytes(last.freedBytes)}, ${compactTimeAgo(fromSqliteTime(last.finishedAt!))}`
+      : "no clean-up has run yet",
+  ].join(" · ");
+}
+
 const name = (p: string) => p.split("/").pop();
 
 function Run({ run }: { run: SweepRun }) {
@@ -51,6 +81,22 @@ function Run({ run }: { run: SweepRun }) {
             </ul>
           </div>
         )}
+        {(run.details?.pending?.length ?? 0) > 0 && (
+          <div className="mt-2 space-y-1 pb-2">
+            <p className="text-sm font-medium">
+              Waiting for the full clean-up to be turned on (
+              {run.details?.pendingTotal?.count ?? 0},{" "}
+              {formatBytes(run.details?.pendingTotal?.bytes ?? 0)})
+            </p>
+            <ul className="text-muted-foreground space-y-1 text-xs">
+              {run.details?.pending?.slice(0, 100).map((p) => (
+                <li key={p.path} className="break-all">
+                  {name(p.path)} ({KIND[p.kind]}, {formatBytes(p.bytes)})
+                </li>
+              ))}
+            </ul>
+          </div>
+        )}
         {removed.length > 0 && (
           <div className="mt-2 space-y-1 pb-2">
             <p className="text-sm font-medium">Removed</p>
@@ -72,8 +118,37 @@ function Run({ run }: { run: SweepRun }) {
 export function SweepRuns() {
   const { data, isPending, error } = useWorktreeSweep();
   const run = useRunSweep();
+  const arm = useSetReaperArmed();
+  const summary = data ? diskSummary(data.runs) : null;
   return (
     <div className="space-y-3">
+      {summary && (
+        <p
+          className="text-sm font-medium tabular-nums"
+          data-testid="disk-summary"
+        >
+          {summary}
+        </p>
+      )}
+      {data && (
+        <div className="flex flex-wrap items-center gap-2">
+          <p className="text-muted-foreground min-w-0 flex-1 text-sm">
+            Full clean-up is {data.armed ? "on" : "off"}: test leftovers, stale
+            task databases, spares, temp folders and build caches{" "}
+            {data.armed
+              ? "are removed with each run."
+              : "are only listed until you turn it on. Read a dry run first."}
+          </p>
+          <Button
+            variant="outline"
+            className="min-h-11 md:min-h-8"
+            disabled={arm.isPending}
+            onClick={() => arm.mutate(!data.armed)}
+          >
+            {data.armed ? "Turn off" : "Turn on"}
+          </Button>
+        </div>
+      )}
       <div className="flex flex-wrap items-center gap-2">
         <p className="text-muted-foreground min-w-0 flex-1 text-sm">
           Settled worktrees older than {data?.days ?? data?.defaultDays ?? 7}{" "}

package/data/worktree-sweep/index.ts

@@ -33,6 +33,21 @@ export function useSetSweepDays() {
   });
 }
 
+export function useSetReaperArmed() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (armed: boolean) =>
+      json<SweepState>(
+        await fetch("/api/worktree-sweep", {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ armed }),
+        })
+      ),
+    onSuccess: (data) => queryClient.setQueryData(sweepKeys.all, data),
+  });
+}
+
 export function useRunSweep() {
   const queryClient = useQueryClient();
   return useMutation({

package/lib/agentos-home.ts

@@ -0,0 +1,11 @@
+import os from "os";
+import path from "path";
+import { refuseRealStateUnderTest } from "./test-home-guard";
+
+// Every path under ~/.agent-os is built here, so a test run that resolves one
+// to the real home throws instead of leaving files in the owner's state.
+export function agentosHome(...parts: string[]): string {
+  return refuseRealStateUnderTest(
+    path.join(os.homedir(), ".agent-os", ...parts)
+  );
+}

package/lib/agents/launch.ts

@@ -1,5 +1,5 @@
+import { agentosHome } from "../agentos-home";
 import fs from "fs";
-import os from "os";
 import path from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -22,12 +22,8 @@ import {
 } from "../project-config/session";
 
 const execFileAsync = promisify(execFile);
-const PROMPTS_DIR = path.join(os.homedir(), ".agent-os", "prompts");
-export const BUS_BRIEF_FILE = path.join(
-  os.homedir(),
-  ".agent-os",
-  "bus-brief.md"
-);
+const PROMPTS_DIR = agentosHome("prompts");
+export const BUS_BRIEF_FILE = agentosHome("bus-brief.md");
 
 export function ensureBusBrief(): void {
   fs.mkdirSync(path.dirname(BUS_BRIEF_FILE), { recursive: true });

package/lib/artifacts/store.ts

@@ -3,8 +3,8 @@
  * ~/.agent-os/artifacts/<session id>/, and a row saying whose it is.
  */
 
+import { agentosHome } from "../agentos-home";
 import fs from "fs";
-import os from "os";
 import path from "path";
 import { randomUUID } from "crypto";
 import { db } from "../db";
@@ -23,10 +23,7 @@ export const MAX_TITLE_CHARS = 120;
 const ID = /^[0-9a-f-]{36}$/;
 
 export function artifactsDir(): string {
-  return (
-    process.env.AGENTOS_ARTIFACTS_DIR ||
-    path.join(os.homedir(), ".agent-os", "artifacts")
-  );
+  return process.env.AGENTOS_ARTIFACTS_DIR || agentosHome("artifacts");
 }
 
 // Session ids are UUIDs; anything else must not become a path segment.

package/lib/chat/drivers/pi-approvals.ts

@@ -1,5 +1,5 @@
+import { agentosHome } from "../../agentos-home";
 import fs from "fs";
-import os from "os";
 import path from "path";
 import { randomUUID } from "crypto";
 import type { ChatAccess, DriverEvent } from "../events";
@@ -9,7 +9,7 @@ import { piTool } from "./pi-mapper";
 type P = Record<string, unknown>;
 const str = (v: unknown) => (typeof v === "string" ? v : "");
 
-const DIR = path.join(os.homedir(), ".agent-os", "pi");
+const DIR = agentosHome("pi");
 const MARK = "agentos:";
 
 // Pi runs every tool without asking. This extension asks the chat first,

package/lib/chat/worker/protocol.ts

@@ -3,8 +3,8 @@
  * worker's Unix socket: one JSON message per line.
  */
 
+import { agentosHome } from "../../agentos-home";
 import crypto from "crypto";
-import os from "os";
 import path from "path";
 import type {
   ApprovalDecision,
@@ -116,7 +116,7 @@ export function workerDir(): string {
     process.env.DB_PATH || path.join(process.cwd(), "agent-os.db")
   );
   const key = crypto.createHash("sha1").update(db).digest("hex").slice(0, 8);
-  return path.join(os.homedir(), ".agent-os", "chat", key);
+  return agentosHome("chat", key);
 }
 
 export const socketPath = (sessionId: string) =>

package/lib/connect/config.ts

@@ -11,8 +11,8 @@
  * each time the tunnel starts.
  */
 
+import { agentosHome } from "../agentos-home";
 import fs from "fs";
-import os from "os";
 import path from "path";
 
 export interface ConnectConfig {
@@ -32,8 +32,7 @@ export interface ConnectFiles {
 export const MACHINE_HOST = /^m-[0-9a-f]{16}\.runagentos\.com$/;
 
 export const connectDir = () =>
-  process.env.AGENTOS_CONNECT_DIR ||
-  path.join(os.homedir(), ".agent-os", "connect");
+  process.env.AGENTOS_CONNECT_DIR || agentosHome("connect");
 
 export type ConnectRead =
   | { ok: true; files: ConnectFiles; enabled: boolean }

package/lib/db/backup.ts

@@ -1,13 +1,13 @@
+import { agentosHome } from "../agentos-home";
 import type Database from "better-sqlite3";
 import Sqlite from "better-sqlite3";
 import { randomBytes } from "crypto";
 import fs from "fs";
-import os from "os";
 import path from "path";
 import { refuseRealStateUnderTest } from "../test-home-guard";
 
 export const backupsDir = (): string =>
-  refuseRealStateUnderTest(path.join(os.homedir(), ".agent-os", "backups"));
+  refuseRealStateUnderTest(agentosHome("backups"));
 
 // A full copy of the database (VACUUM INTO) under ~/.agent-os/backups, taken
 // before a destructive migration. Throws, and the migration must stop, unless

package/lib/db/migrations/20261018T1600_health_boot_deploys.ts

@@ -0,0 +1,13 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261018T1600_health_boot_deploys",
+  up: (db) => {
+    const cols = (
+      db.prepare(`PRAGMA table_info(health_boots)`).all() as { name: string }[]
+    ).map((c) => c.name);
+    // 1 when autodeploy planned the restart that started this boot.
+    if (!cols.includes("deploy"))
+      db.exec(`ALTER TABLE health_boots ADD COLUMN deploy INTEGER`);
+  },
+} satisfies Migration;

package/lib/dev-instance/processInfo.ts

@@ -1,5 +1,27 @@
 import fs from "fs";
-import { execFileSync } from "child_process";
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+const execFileAsync = promisify(execFile);
+
+// These run inside the server (task end, the sweep), so none may block the
+// event loop or hang: a timeout reads as "could not verify".
+export const PROBE_TIMEOUT_MS = 3000;
+
+export class ProbeTimeout extends Error {}
+
+export async function probe(cmd: string, args: string[]): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync(cmd, args, {
+      encoding: "utf8",
+      timeout: PROBE_TIMEOUT_MS,
+    });
+    return stdout;
+  } catch (e) {
+    if ((e as { killed?: boolean }).killed) throw new ProbeTimeout(cmd);
+    throw e;
+  }
+}
 
 export function pidAlive(pid: number): boolean {
   try {
@@ -18,18 +40,18 @@ const real = (p: string): string => {
   }
 };
 
-export function processCwd(pid: number): string | null {
+export async function processCwd(pid: number): Promise<string | null> {
   try {
     if (process.platform === "linux")
       return real(fs.readlinkSync(`/proc/${pid}/cwd`));
-    const out = execFileSync(
-      "lsof",
-      ["-a", "-p", String(pid), "-d", "cwd", "-Fn"],
-      {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-      }
-    );
+    const out = await probe("lsof", [
+      "-a",
+      "-p",
+      String(pid),
+      "-d",
+      "cwd",
+      "-Fn",
+    ]);
     const line = out.split("\n").find((l) => l.startsWith("n"));
     return line ? real(line.slice(1)) : null;
   } catch {
@@ -38,30 +60,29 @@ export function processCwd(pid: number): string | null {
 }
 
 // Whether the process was launched as the live server: its environment
-// carries the marker, or its title is the server's.
-export function looksLive(pid: number): boolean {
+// carries the marker, or its title is the server's. A probe that times out
+// answers true: not being able to tell is a reason to leave it alone.
+export async function looksLive(pid: number): Promise<boolean> {
   try {
     if (process.platform === "linux") {
       const env = fs.readFileSync(`/proc/${pid}/environ`, "utf8").split("\0");
       if (env.includes("AGENTOS_SERVER=live")) return true;
     } else {
-      const out = execFileSync(
-        "ps",
-        ["eww", "-p", String(pid), "-o", "command="],
-        {
-          encoding: "utf8",
-          stdio: ["ignore", "pipe", "ignore"],
-        }
-      );
+      const out = await probe("ps", [
+        "eww",
+        "-p",
+        String(pid),
+        "-o",
+        "command=",
+      ]);
       if (/\bAGENTOS_SERVER=live\b/.test(out)) return true;
     }
-    const comm = execFileSync("ps", ["-p", String(pid), "-o", "comm="], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    });
-    return comm.trim() === "agentos-server";
-  } catch {
-    return false;
+    return (
+      (await probe("ps", ["-p", String(pid), "-o", "comm="])).trim() ===
+      "agentos-server"
+    );
+  } catch (e) {
+    return e instanceof ProbeTimeout;
   }
 }
 

package/lib/dev-instance/startDevServer.ts

@@ -35,7 +35,7 @@ export async function startDevServer(opts: {
   if (
     existing &&
     pidAlive(existing.pid) &&
-    samePath(processCwd(existing.pid) ?? "", worktree)
+    samePath((await processCwd(existing.pid)) ?? "", worktree)
   )
     return { ...existing, reused: true };
 

package/lib/dev-instance/stopDevServer.ts

@@ -1,18 +1,24 @@
 import fs from "fs";
 import path from "path";
-import { execFileSync } from "child_process";
 import { readLiveRecord } from "./liveServer";
-import { pidAlive, looksLive, processCwd, samePath } from "./processInfo";
+import {
+  pidAlive,
+  looksLive,
+  processCwd,
+  samePath,
+  probe,
+  ProbeTimeout,
+} from "./processInfo";
 import { readDevRecord, recordFile } from "./startDevServer";
 
 export interface StopDeps {
   kill: (pid: number, signal: NodeJS.Signals) => void;
-  cwdOf: (pid: number) => string | null;
-  looksLive: (pid: number) => boolean;
+  cwdOf: (pid: number) => string | null | Promise<string | null>;
+  looksLive: (pid: number) => boolean | Promise<boolean>;
   livePid: () => number | null;
   alive: (pid: number) => boolean;
   sleep: (ms: number) => Promise<void>;
-  killTmux: (socket: string) => void;
+  killTmux: (socket: string) => void | Promise<void>;
 }
 
 const realDeps: StopDeps = {
@@ -22,16 +28,13 @@ const realDeps: StopDeps = {
   livePid: () => readLiveRecord()?.pid ?? null,
   alive: pidAlive,
   sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
-  killTmux: (socket) => {
-    const env = { ...process.env };
-    delete env.TMUX;
+  killTmux: async (socket) => {
     try {
-      execFileSync("tmux", ["-S", socket, "kill-server"], {
-        env,
-        stdio: "ignore",
-      });
-    } catch {
-      // No server on it.
+      await probe("env", ["-u", "TMUX", "tmux", "-S", socket, "kill-server"]);
+    } catch (e) {
+      // No server on it, or tmux did not answer in time.
+      if (e instanceof ProbeTimeout)
+        console.warn(`[dev-server] tmux on ${socket} did not answer; left`);
     }
   },
 };
@@ -59,14 +62,14 @@ export async function stopDevServer(
     ok: false,
     message: `Refusing to stop pid ${rec.pid}: ${why}. Nothing was killed.`,
   });
-  const cwd = d.cwdOf(rec.pid);
+  const cwd = await d.cwdOf(rec.pid);
   if (cwd === null || !samePath(cwd, worktree))
     return refuse(
       `its working directory (${cwd ?? "unknown"}) is not ${worktree}`
     );
   if (rec.pid === process.pid || rec.pid === process.ppid)
     return refuse("that is this command's own process");
-  if (rec.pid === d.livePid() || d.looksLive(rec.pid))
+  if (rec.pid === d.livePid() || (await d.looksLive(rec.pid)))
     return refuse("it is the live AgentOS server");
 
   const signal = (s: NodeJS.Signals) => {
@@ -89,7 +92,7 @@ export async function stopDevServer(
     `tmux-${process.getuid?.() ?? 0}`,
     "default"
   );
-  if (fs.existsSync(sock)) d.killTmux(sock);
+  if (fs.existsSync(sock)) await d.killTmux(sock);
   drop();
   return {
     ok: true,

package/lib/dev-servers.ts

@@ -1,3 +1,4 @@
+import { agentosHome } from "./agentos-home";
 import { spawn, execFile } from "child_process";
 import { promisify } from "util";
 import fs from "fs";
@@ -12,7 +13,7 @@ const run = async (file: string, args: string[], cwd?: string) =>
 // A compose service is a name, never an option or more than one word.
 const COMPOSE_SERVICE = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
 
-const LOGS_DIR = path.join(process.env.HOME || "~", ".agent-os", "logs");
+const LOGS_DIR = agentosHome("logs");
 
 // Ensure logs directory exists
 if (!fs.existsSync(LOGS_DIR)) {

package/lib/done/index.ts

@@ -28,7 +28,7 @@ import { deleteMergedRemote } from "./remote";
 import { settleWorktree, type WorktreeFate } from "./worktree";
 import { sessionMergePolicy } from "../tasks/finish";
 import { releasePorts } from "../ports";
-import { dropSessionDatabase } from "../project-config/database";
+import { releaseSessionLeftovers } from "../sessions/leftovers";
 import { doneOnPeer, peerSessionLink } from "../hosts/peer-actions";
 import { hostLink } from "../hosts/remote-api";
 import { doneHeldTask, isHeldRemote } from "../tasks/contract/held-calls";
@@ -70,7 +70,7 @@ async function stopAgent(s: Session): Promise<void> {
   clearQueue(s.id);
   releasePorts(s.id);
   // Never waited on: the row is read now, and Postgres can't hold this up.
-  void dropSessionDatabase(s.id);
+  void releaseSessionLeftovers(s);
 }
 
 function worktreeLine(f: WorktreeFate): string {