@saadnvd1/agent-os 0.3.662 → 0.3.664

package/lib/sessions/leftovers.ts

@@ -0,0 +1,61 @@
+/**
+ * What a task leaves outside its checkout, released when it ends (merge,
+ * drop, done, move, delete): its dev server, its private database and what
+ * the project derived from it, and its temp folder. The worktree itself is
+ * removed by the caller, which knows whether anything in it would be lost.
+ */
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { stopDevServer } from "../dev-instance/stopDevServer";
+import { dropSessionDatabase } from "../project-config/database";
+
+export const SESSION_TMP_PREFIX = "agentos-s-";
+
+// The whole id: a shortened one could name two sessions' folders alike.
+export const tmpName = (sessionId: string) => sessionId.replace(/[^\w-]/g, "");
+
+export const sessionTmpDir = (sessionId: string) =>
+  path.join(os.tmpdir(), `${SESSION_TMP_PREFIX}${tmpName(sessionId)}`);
+
+export interface LeftoverDeps {
+  stopDev: (worktree: string) => Promise<unknown>;
+  dropDatabase: (sessionId: string) => Promise<void>;
+  removeDir: (dir: string) => Promise<void>;
+}
+
+const realDeps: LeftoverDeps = {
+  stopDev: (worktree) => stopDevServer(worktree),
+  dropDatabase: dropSessionDatabase,
+  removeDir: (dir) => fs.promises.rm(dir, { recursive: true, force: true }),
+};
+
+/**
+ * Never throws and never waits on a step that can't be reached: each is
+ * tried on its own. Callers read the session row first and don't await this.
+ */
+export async function releaseSessionLeftovers(
+  session: { id: string; worktree_path?: string | null },
+  deps: Partial<LeftoverDeps> = {}
+): Promise<void> {
+  const d = { ...realDeps, ...deps };
+  const steps: Array<[string, () => Promise<unknown>]> = [
+    // First: its row is read before the caller deletes it.
+    ["database", () => d.dropDatabase(session.id)],
+    [
+      "dev server",
+      async () => {
+        if (session.worktree_path) await d.stopDev(session.worktree_path);
+      },
+    ],
+    ["temp folder", () => d.removeDir(sessionTmpDir(session.id))],
+  ];
+  for (const [what, step] of steps) {
+    try {
+      await step();
+    } catch (error) {
+      console.error(`[leftovers] ${what} for ${session.id}:`, error);
+    }
+  }
+}

package/lib/simulator/agent-device.ts

@@ -5,9 +5,9 @@
  * here, so it can only drive its own simulator.
  */
 
+import { agentosHome } from "../agentos-home";
 import { execFile } from "child_process";
 import fs from "fs";
-import os from "os";
 import path from "path";
 import { promisify } from "util";
 
@@ -15,7 +15,7 @@ const execFileAsync = promisify(execFile);
 
 export const AGENT_DEVICE_VERSION = "0.21.27";
 
-const root = () => path.join(os.homedir(), ".agent-os");
+const root = () => agentosHome();
 export const toolDir = () =>
   path.join(root(), "tools", `agent-device-${AGENT_DEVICE_VERSION}`);
 export const toolBin = () =>

package/lib/tasks/finish.ts

@@ -34,7 +34,7 @@ import {
   prFor,
   projectPathFor,
 } from "./session";
-import { dropSessionDatabase } from "../project-config/database";
+import { releaseSessionLeftovers } from "../sessions/leftovers";
 import { captureMergedTask } from "../session-logs";
 import { sessionEnded } from "../experiments/hooks";
 import { snapshotWorktree } from "../resurrect/snapshot";
@@ -62,7 +62,7 @@ async function cleanup(
   const keepRemoteBranch = opts.keepRemoteBranch ?? false;
   await endSessionAgent(session);
   // Never waited on: the row is read now, and Postgres can't hold this up.
-  void dropSessionDatabase(session.id);
+  void releaseSessionLeftovers(session);
   if (session.worktree_path && opts.merged) {
     const fate = await settleWorktree(session, opts.merged).catch(() => null);
     if (fate?.action === "kept")

package/lib/tasks/import.ts

@@ -5,6 +5,7 @@
  * again returns the task it made the first time.
  */
 
+import { releaseSessionLeftovers } from "../sessions/leftovers";
 import fs from "fs";
 import os from "os";
 import path from "path";
@@ -13,10 +14,7 @@ import { db, queries, type Session } from "../db";
 import { setupWorktree } from "../env-setup";
 import { allocatePorts } from "../ports";
 import { loadProjectConfig, portBases } from "../project-config";
-import {
-  dropSessionDatabase,
-  ensureSessionDatabase,
-} from "../project-config/database";
+import { ensureSessionDatabase } from "../project-config/database";
 import { runInBackground } from "../async-operations";
 import { launchClaude } from "../agents/launch";
 import { resolveModelForAgent } from "../model-catalog";
@@ -238,7 +236,7 @@ async function arrive(
   } catch (err) {
     // Nothing runs here, so the source may resume it: leave no row behind,
     // and no database (the drop reads the row before it goes).
-    void dropSessionDatabase(id);
+    void releaseSessionLeftovers({ id });
     if (bundle.chat) {
       stopChat(id);
       dropChat(id);

package/lib/tasks/move.ts

@@ -26,7 +26,7 @@ import {
 } from "./move-bundle";
 import { stepProgress } from "./move-progress";
 import { PLAN_FILE } from "../models/plan-step";
-import { dropSessionDatabase } from "../project-config/database";
+import { releaseSessionLeftovers } from "../sessions/leftovers";
 import { releaseChat } from "../chat/runner";
 import { collectWhileMoving } from "../chat/hold";
 import { packChat, stopChatForMove } from "./move-chat";
@@ -258,7 +258,7 @@ export function markMoved(id: string, to: string): void {
     { task_status: ["running", "moving"] }
   );
   // It goes on there with a copy of its own.
-  if (moved) void dropSessionDatabase(id);
+  if (moved) void releaseSessionLeftovers({ id });
 }
 
 /**

package/lib/tasks/moved-away.ts

@@ -5,6 +5,7 @@
  * no commit a remote lacks). The row stays, archived, as history.
  */
 
+import { releaseSessionLeftovers } from "../sessions/leftovers";
 import { db, type Session } from "../db";
 import { endSessionAgent } from "../sessions/end";
 import { releasePorts } from "../ports";
@@ -28,6 +29,7 @@ export async function cleanUpMovedAway(id: string): Promise<WorktreeFate> {
       path: s.worktree_path ?? "",
     })
   );
+  void releaseSessionLeftovers(s);
   archiveSession(id);
   if (fate.action === "kept")
     console.warn(

package/lib/tasks/state.ts

@@ -137,6 +137,10 @@ const UNFINISHED = [
 const outcome = (c: RollupEntry) =>
   (c.conclusion || c.state || c.status || "").toUpperCase();
 
+// A skipped or neutral run is settled and says nothing about a rerun, so it
+// never makes a check look unsettled.
+const counts = (c: RollupEntry) => !["SKIPPED", "NEUTRAL"].includes(outcome(c));
+
 // Job names repeat across workflows, and a status context can share a check
 // run's name, so a check is its kind, workflow and name together.
 const checkKey = (c: RollupEntry) => {
@@ -198,7 +202,7 @@ const groupByCheck = <T extends RollupEntry>(rollup: T[]) => {
 // rollup can't tell one attempt from the next.
 function shownAttempts(rollup: RollupEntry[]): Map<string, number | null> {
   const shown = new Map<string, number | null>();
-  for (const c of rollup) {
+  for (const c of rollup.filter(counts)) {
     const run = actionsRunOf(c);
     if (!run) continue;
     const key = `${run.repo}#${run.id}`;
@@ -226,7 +230,7 @@ export function rerunsToLookUp(
     string,
     { repo: string; id: string; attempt: string | null }
   >();
-  for (const group of groupByCheck(rollup).values()) {
+  for (const group of groupByCheck(rollup.filter(counts)).values()) {
     if (group.length < 2) continue;
     for (const c of group) {
       const run = actionsRunOf(c);
@@ -259,7 +263,7 @@ export function settleReruns<T extends RollupEntry>(
   const shown = shownAttempts(rollup);
   const drop = new Set<RollupEntry>();
   const unsettled: RollupEntry[] = [];
-  for (const group of groupByCheck(rollup).values()) {
+  for (const group of groupByCheck(rollup.filter(counts)).values()) {
     if (group.length < 2) continue;
     const located = group.map((c) => ({ c, run: actionsRunOf(c) }));
     // Not all GitHub Actions: nothing says which run is stale, so all count.

package/lib/tasks/ui-brief.ts

@@ -80,6 +80,6 @@ If your diff changes what a user sees, run the app and look at every changed scr
 - Log in and go to pages by URL, from the login, pages and map under "Running this project" when they are there. Exploring the UI to find a page is the most expensive thing a session does.
 - One snapshot to find a uid, then act. Verify with a screenshot of the one element or a small \`evaluate_script\` returning the one value you need, not another full snapshot.
 - Verify the thing that would be wrong, not the thing that is easy to see: a page that rendered proves it rendered. Fix anything visibly off (gaps, clipping, overlap, horizontal scroll, stray bands, misalignment; measure rects with \`evaluate_script\` and report numbers) and read the console for errors.
-- Save screenshots of the final changed screens with \`filePath\` under \`${SCREENSHOT_DIR}/\`, after \`mkdir -p ${SCREENSHOT_DIR} && printf '*\\n' > .agentos/.gitignore\`. That folder is inside the browser's allowed root and git ignores it; a path in /tmp is refused.
-- Add a **Browser check** section to the PR body: the pages and widths you checked, what you fixed, and the screenshot file names. If you didn't check (no visible change, or no browser), say why in one line.`;
+- Save screenshots of the final changed screens with \`filePath\` under \`${SCREENSHOT_DIR}/\`, after \`mkdir -p ${SCREENSHOT_DIR} && printf '*\\n' > .agentos/.gitignore\`. That folder is inside the browser's allowed root and git ignores it; a path in /tmp is refused. AgentOS keeps these files after the worktree is removed.
+- Add a **Browser check** section to the PR body: the pages and widths you checked, what you fixed, and the screenshot file names (names only, never a worktree path: the worktree is removed when the task ends). If you didn't check (no visible change, or no browser), say why in one line.`;
 }

package/lib/worktree-deps/fastcopy.ts

@@ -5,9 +5,9 @@
  * none works, and the caller installs or copies plainly instead.
  */
 
+import { agentosHome } from "../agentos-home";
 import { execFile } from "child_process";
 import * as fs from "fs";
-import * as os from "os";
 import * as path from "path";
 import { promisify } from "util";
 import type { CopyMode } from "./spare";
@@ -18,7 +18,7 @@ export type FastMode = Exclude<CopyMode, "copy">;
 
 // Where hardlinked dependencies are kept: one real copy per lockfile, so a
 // write through a link can only ever reach this, never the main checkout.
-export const STORE_ROOT = path.join(os.homedir(), ".agent-os", "deps-store");
+export const STORE_ROOT = agentosHome("deps-store");
 
 // Files tools rewrite in place. A hardlink would carry the write back into
 // the store, so these are real copies in every worktree.

package/lib/worktree-deps/spare.ts

@@ -8,13 +8,13 @@
  * one made before the dependencies changed is never taken, and is pruned.
  */
 
+import { agentosHome } from "../agentos-home";
 import { createHash } from "crypto";
 import { spawn } from "child_process";
 import * as fs from "fs";
-import * as os from "os";
 import * as path from "path";
 
-export const SPARE_ROOT = path.join(os.homedir(), ".agent-os", "spare");
+export const SPARE_ROOT = agentosHome("spare");
 
 // A half-built spare left by a restart is removed after this long.
 const BUILDING_TTL_MS = 30 * 60 * 1000;

package/lib/worktree-sweep/caches.ts

@@ -0,0 +1,123 @@
+/**
+ * What a task leaves outside its checkout and the database: dependency
+ * spares nobody took, its temp folder, a crashed preview browser's profile,
+ * and Xcode's build folder for a worktree that no longer exists. Each is
+ * rebuilt or recreated on demand, so the only rule is "old enough, and not
+ * in use".
+ */
+
+import fs from "fs";
+import path from "path";
+import { execFile } from "child_process";
+import { SESSION_TMP_PREFIX, tmpName } from "../sessions/leftovers";
+import type { Candidate, SweepSkipped } from "./types";
+
+const DAY_MS = 24 * 3600_000;
+const SPARE_MIN_AGE_MS = 7 * DAY_MS;
+const BUILDING_MIN_AGE_MS = 3600_000;
+
+export interface CacheDeps {
+  now: number;
+  spareRoot: string;
+  tmpRoot: string;
+  derivedRoot: string;
+  worktreesRoot: string;
+  // Ids of the sessions still running on this machine.
+  liveIds: Set<string>;
+  workspaceOf: (derivedDir: string) => Promise<string | null>;
+  size: (dir: string) => Promise<number>;
+}
+
+export const workspaceFromPlist = (dir: string): Promise<string | null> =>
+  new Promise((resolve) =>
+    execFile(
+      "plutil",
+      [
+        "-extract",
+        "WorkspacePath",
+        "raw",
+        "-o",
+        "-",
+        path.join(dir, "info.plist"),
+      ],
+      { timeout: 10_000 },
+      (error, stdout) => resolve(error ? null : String(stdout).trim() || null)
+    )
+  );
+
+const subdirs = (root: string): string[] => {
+  try {
+    return fs
+      .readdirSync(root, { withFileTypes: true })
+      .filter((e) => e.isDirectory())
+      .map((e) => path.join(root, e.name));
+  } catch {
+    return [];
+  }
+};
+
+const mtime = (p: string) => {
+  try {
+    return fs.statSync(p).mtimeMs;
+  } catch {
+    return 0;
+  }
+};
+
+const inside = (root: string, p: string) => {
+  const rel = path.relative(path.resolve(root), path.resolve(p));
+  return !!rel && !rel.startsWith("..") && !path.isAbsolute(rel);
+};
+
+export async function findCacheLeftovers(deps: CacheDeps): Promise<{
+  candidates: Candidate[];
+  skipped: SweepSkipped[];
+}> {
+  const candidates: Candidate[] = [];
+  const skipped: SweepSkipped[] = [];
+  const add = async (dir: string, kind: Candidate["kind"], why: string) =>
+    candidates.push({ path: dir, kind, why, bytes: await deps.size(dir) });
+
+  for (const dir of subdirs(deps.spareRoot)) {
+    const building = path.basename(dir).includes(".");
+    const min = building ? BUILDING_MIN_AGE_MS : SPARE_MIN_AGE_MS;
+    if (deps.now - mtime(dir) >= min)
+      await add(
+        dir,
+        "spare",
+        building ? "an abandoned build" : "unused for a week"
+      );
+  }
+
+  const livePrefixes = [...deps.liveIds].map(tmpName);
+  for (const dir of subdirs(deps.tmpRoot)) {
+    const name = path.basename(dir);
+    const isSession = name.startsWith(SESSION_TMP_PREFIX);
+    if (!isSession && !name.startsWith("agentos-preview-")) continue;
+    if (deps.now - mtime(dir) < DAY_MS) continue;
+    if (
+      isSession &&
+      livePrefixes.includes(name.slice(SESSION_TMP_PREFIX.length))
+    ) {
+      skipped.push({
+        path: dir,
+        kind: "temp",
+        reason: "its session is running",
+      });
+      continue;
+    }
+    await add(
+      dir,
+      "temp",
+      isSession ? "its task is over" : "a preview browser's profile"
+    );
+  }
+
+  for (const dir of subdirs(deps.derivedRoot)) {
+    const workspace = await deps.workspaceOf(dir);
+    if (!workspace || !inside(deps.worktreesRoot, workspace)) continue;
+    if (fs.existsSync(workspace)) continue;
+    await add(dir, "derived-data", "its worktree is gone");
+  }
+  return { candidates, skipped };
+}

package/lib/worktree-sweep/databases.ts

@@ -0,0 +1,222 @@
+/**
+ * Task databases left behind: copies and what projects derived from them
+ * (`<copy>_test`), found by the `_aos_<12 hex>` token every session's name
+ * carries. A database goes only if its token belongs to no live session,
+ * nobody is connected, it isn't a project's declared source, and it is more
+ * than a day old. Anything without the token is never looked at.
+ *
+ * A session is over only when it is merged, dropped, done or moved away, or
+ * its row is gone: archiving and settling can be undone, and an interactive
+ * session has no end of its own, so neither keeps a database off the list.
+ *
+ * Proof of who made it: a copy must carry the `agentos session <id>` comment
+ * AgentOS gave it, and the id must hash to the token. Something a project
+ * derived from a copy (`<copy>_test`) has no such comment, so it also needs
+ * its token to belong to no session this machine has ever known, and the
+ * server to be local (a host that isn't localhost or a socket is never
+ * reaped on a name alone).
+ */
+
+import { db } from "../db";
+import { loadProjectConfig } from "../project-config";
+import { expandHome } from "../project-config/session";
+import {
+  LOCAL_HOSTS,
+  MARK,
+  SOCKET_DIR,
+  pgEnv,
+  pgRun,
+  sessionHash,
+  taskHashOf,
+  type PgRun,
+} from "../project-config/database";
+import type { Candidate, SweepSkipped } from "./types";
+
+const DAY_MS = 24 * 3600_000;
+
+export interface PgServer {
+  host?: string;
+  port?: number;
+}
+
+export interface DatabaseDeps {
+  now: number;
+  run: PgRun;
+  servers: PgServer[];
+  // Hashes of the sessions that still need their database.
+  live: Set<string>;
+  // Hashes of every session this machine has a row for, over or not.
+  known: Set<string>;
+  // Databases a project declares as its source, never reaped.
+  froms: Set<string>;
+}
+
+const where = (s: PgServer) =>
+  `${s.host ?? "local server"}${s.port ? `:${s.port}` : ""}`;
+
+// Sessions whose work isn't over: everything with a row except a task that
+// merged, was dropped, finished or moved away.
+export function liveSessionIds(): Set<string> {
+  const rows = db
+    .prepare(
+      `SELECT id FROM session_rows
+       WHERE task_status IS NULL
+          OR task_status NOT IN ('merged', 'dropped', 'done', 'moved')`
+    )
+    .all() as Array<{ id: string }>;
+  return new Set(rows.map((r) => r.id));
+}
+
+export const knownSessionIds = (): Set<string> =>
+  new Set(
+    (
+      db.prepare(`SELECT id FROM session_rows`).all() as Array<{ id: string }>
+    ).map((r) => r.id)
+  );
+
+export const hashesOf = (ids: Iterable<string>): Set<string> =>
+  new Set([...ids].map(sessionHash));
+
+export const liveHashes = (ids = liveSessionIds()): Set<string> =>
+  hashesOf(ids);
+
+const isLocal = (s: PgServer) =>
+  !s.host || LOCAL_HOSTS.has(s.host) || SOCKET_DIR.test(s.host);
+
+// Every project's declared database source and server.
+export function declaredDatabases(): {
+  servers: PgServer[];
+  froms: Set<string>;
+} {
+  const rows = db
+    .prepare(
+      `SELECT working_directory FROM projects WHERE working_directory IS NOT NULL`
+    )
+    .all() as Array<{ working_directory: string }>;
+  const servers = new Map<string, PgServer>([[":", {}]]);
+  const froms = new Set<string>();
+  for (const r of rows) {
+    try {
+      const d = loadProjectConfig(expandHome(r.working_directory)).config
+        .database;
+      if (!d) continue;
+      froms.add(d.from);
+      servers.set(`${d.host ?? ""}:${d.port ?? ""}`, {
+        host: d.host,
+        port: d.port,
+      });
+    } catch {
+      // A project whose config can't be read declares nothing.
+    }
+  }
+  return { servers: [...servers.values()], froms };
+}
+
+const LIST = (age: boolean) =>
+  `select d.datname, pg_database_size(d.oid), coalesce(shobj_description(d.oid, 'pg_database'), ''),
+     (select count(*) from pg_stat_activity a where a.datname = d.datname),
+     ${age ? `extract(epoch from (pg_stat_file('base/' || d.oid || '/PG_VERSION')).modification)::bigint` : "0"}
+   from pg_database d where d.datname ~ '_aos_[0-9a-f]{12}'`;
+
+// Why this database can't be shown to be a session's, or null when it can.
+function whoMade(
+  hash: string,
+  note: string,
+  known: Set<string>,
+  server: PgServer
+): string | null {
+  const m = /^agentos session (\S+?)(?: \(copying\))?$/.exec(note);
+  if (m)
+    return sessionHash(m[1]) === hash
+      ? null
+      : "its comment names another session";
+  if (note) return "it has a comment that isn't AgentOS's";
+  if (known.has(hash))
+    return "no AgentOS comment on it, and its session is known here";
+  return isLocal(server) ? null : "no AgentOS comment, and not a local server";
+}
+
+async function list(deps: DatabaseDeps, server: PgServer) {
+  const env = pgEnv(server);
+  for (const age of [true, false]) {
+    const { code, out } = await deps.run(
+      "psql",
+      ["-X", "-d", "postgres", "-tAq", "-F", "\t", "-c", LIST(age)],
+      env
+    );
+    if (code === 0)
+      return out
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+          const [name, size, note, conns, at] = line.split("\t");
+          return {
+            name,
+            bytes: Number(size) || 0,
+            note: note ?? "",
+            conns: Number(conns) || 0,
+            madeAt: Number(at) * 1000 || 0,
+          };
+        });
+    if (code === 127) return "psql isn't installed";
+    if (!age) return `Postgres isn't answering (${out.slice(0, 120)})`;
+  }
+  return "Postgres isn't answering";
+}
+
+export async function findTaskDatabases(deps: DatabaseDeps): Promise<{
+  candidates: Candidate[];
+  skipped: SweepSkipped[];
+}> {
+  const candidates: Candidate[] = [];
+  const skipped: SweepSkipped[] = [];
+  for (const server of deps.servers) {
+    const found = await list(deps, server);
+    if (typeof found === "string") {
+      skipped.push({
+        path: where(server),
+        kind: "database",
+        reason: found,
+      });
+      continue;
+    }
+    for (const d of found) {
+      const hash = taskHashOf(d.name);
+      const skip = (reason: string) =>
+        skipped.push({ path: d.name, kind: "database", reason });
+      if (!hash) continue;
+      const proof = whoMade(hash, d.note, deps.known, server);
+      if (deps.froms.has(d.name)) skip("a project's declared source");
+      else if (proof) skip(proof);
+      else if (deps.live.has(hash)) skip("its session is still running");
+      else if (d.conns > 0) skip(`${d.conns} connection(s) open`);
+      else if (d.madeAt && deps.now - d.madeAt < DAY_MS)
+        skip("made less than a day ago");
+      else
+        candidates.push({
+          path: d.name,
+          kind: "database",
+          server,
+          bytes: d.bytes,
+          why: `no session needs it${d.madeAt ? "" : " (age unknown)"}`,
+        });
+    }
+  }
+  return { candidates, skipped };
+}
+
+// Re-checked here as well: only a name carrying the token is ever dropped,
+// and a plain drop, which Postgres refuses while anyone is connected.
+export async function dropTaskDatabase(
+  c: Candidate,
+  froms: Set<string>,
+  run: PgRun = pgRun
+): Promise<boolean> {
+  if (!taskHashOf(c.path) || froms.has(c.path)) return false;
+  const { code } = await run(
+    "dropdb",
+    ["--if-exists", "--", c.path],
+    pgEnv(c.server ?? {})
+  );
+  return code === 0;
+}

package/lib/worktree-sweep/du.ts

@@ -0,0 +1,13 @@
+import { execFile } from "child_process";
+
+// Disk use of a folder in bytes; 0 when it can't be measured in time.
+export default function duBytes(
+  dir: string,
+  timeout = 300_000
+): Promise<number> {
+  return new Promise((resolve) =>
+    execFile("du", ["-sk", dir], { timeout }, (error, stdout) =>
+      resolve(error ? 0 : (parseInt(String(stdout), 10) || 0) * 1024)
+    )
+  );
+}