@saadnvd1/agent-os 0.3.603 → 0.3.606

package/lib/inbox/counts.ts

@@ -0,0 +1,140 @@
+// What the Inbox lists and counts. Pure and client-safe, so the button, the
+// panel and the tests share one rule.
+
+import {
+  needsYouItems,
+  type NeedsYouItem,
+} from "../orchestrator/needs-you-items";
+import type { AskView, QuestionView } from "../orchestrator/ask-view";
+
+export type InboxTab = "needs" | "tasks" | "messages";
+export const INBOX_TABS: readonly InboxTab[] = ["needs", "tasks", "messages"];
+
+export interface NeedsRow {
+  key: string;
+  kind: "input" | "ask" | "question";
+  title: string;
+  sub: string;
+  at: number;
+  // The session or task this is about, when known; what keeps one session
+  // from being counted twice.
+  sessionId: string | null;
+  workspaceId: string | null;
+  ask?: AskView;
+  question?: QuestionView;
+}
+
+export interface OverviewLike {
+  workspaceId: string;
+  asks: AskView[];
+  questions: QuestionView[];
+  dismissed: string[];
+}
+
+const TASK_PREFIX = "task:";
+
+export function needsYouRows(input: {
+  waiting: { id: string; name: string }[];
+  overviews: OverviewLike[];
+}): NeedsRow[] {
+  const rows: NeedsRow[] = [];
+  for (const o of input.overviews) {
+    const items = needsYouItems({
+      asks: o.asks,
+      questions: o.questions,
+      dismissed: o.dismissed,
+    });
+    for (const item of items) {
+      const row = fromItem(item, o.workspaceId);
+      if (row) rows.push(row);
+    }
+  }
+  const covered = new Set(
+    rows.flatMap((r) => (r.sessionId ? [r.sessionId] : []))
+  );
+  for (const s of input.waiting)
+    if (!covered.has(s.id))
+      rows.push({
+        key: `input:${s.id}`,
+        kind: "input",
+        title: s.name,
+        sub: "Waiting for input",
+        at: 0,
+        sessionId: s.id,
+        workspaceId: null,
+      });
+  return rows.sort((a, b) => b.at - a.at);
+}
+
+function fromItem(item: NeedsYouItem, workspaceId: string): NeedsRow | null {
+  if (item.kind === "ask")
+    return {
+      key: item.key,
+      kind: "ask",
+      title: item.title,
+      sub: item.sub,
+      at: item.at,
+      sessionId: item.ask.subject.startsWith(TASK_PREFIX)
+        ? item.ask.subject.slice(TASK_PREFIX.length)
+        : null,
+      workspaceId,
+      ask: item.ask,
+    };
+  if (item.kind === "question")
+    return {
+      key: item.key,
+      kind: "question",
+      title: item.title,
+      sub: item.sub,
+      at: item.at,
+      sessionId: item.question.task,
+      workspaceId,
+      question: item.question,
+    };
+  return null;
+}
+
+export function unreadCount(
+  messages: { id: number }[],
+  seenId: number | null
+): number {
+  if (seenId === null) return 0;
+  return messages.filter((m) => m.id > seenId).length;
+}
+
+export interface InboxCounts {
+  needs: number;
+  tasks: number;
+  messages: number;
+  total: number;
+}
+
+// The badge counts each session once: a task needing you that is already a
+// Needs-you row (waiting for input, or the subject of an ask) adds nothing.
+export function inboxCounts(input: {
+  rows: NeedsRow[];
+  tasksNeedingYou: string[];
+  unread: number;
+}): InboxCounts {
+  const covered = new Set(
+    input.rows.flatMap((r) => (r.sessionId ? [r.sessionId] : []))
+  );
+  const extraTasks = input.tasksNeedingYou.filter((id) => !covered.has(id));
+  return {
+    needs: input.rows.length,
+    tasks: input.tasksNeedingYou.length,
+    messages: input.unread,
+    total: input.rows.length + extraTasks.length + input.unread,
+  };
+}
+
+// Needs you when it has items, else the tab he used last.
+export function pickTab(input: {
+  explicit?: InboxTab;
+  needs: number;
+  last: InboxTab | null;
+}): InboxTab {
+  if (input.explicit) return input.explicit;
+  if (input.needs > 0) return "needs";
+  return input.last ?? "needs";
+}

package/lib/project-config/agentos.schema.json

@@ -48,6 +48,20 @@
         "pattern": "^(?![/~\\\\])(?!(.*[/\\\\])?\\.\\.([/\\\\]|$)).+$"
       }
     },
+    "caches": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "allOf": [
+          {
+            "pattern": "^(?![/~\\\\])(?!(.*[/\\\\])?\\.\\.([/\\\\]|$)).+$"
+          },
+          {
+            "pattern": "^([^*]*[/\\\\])?[^*/\\\\]*\\*?[^*/\\\\]*$"
+          }
+        ]
+      }
+    },
     "dev": {
       "type": "string",
       "minLength": 1

package/lib/project-config/schema.ts

@@ -28,6 +28,15 @@ const projectPath = z
     "must be a path inside the project (relative, no '..')"
   );
 
+// Build caches to seed into a worktree: a path inside the project, with `*`
+// allowed in the last segment (`*.tsbuildinfo`), never `.git`.
+const cachePath = projectPath
+  .regex(
+    /^([^*]*[/\\])?[^*/\\]*\*?[^*/\\]*$/,
+    "`*` is allowed in the last segment only"
+  )
+  .refine((p) => !/(^|[/\\])\.git([/\\]|$)/.test(p), "not .git");
+
 const port = z.number().int().min(1024).max(65000);
 const notes = z.union([z.string(), z.array(z.string())]);
 
@@ -120,6 +129,7 @@ const shape = {
   setup: z.array(z.string().min(1)).optional(),
   copy: z.array(projectPath).optional(),
   clone: z.array(projectPath).optional(),
+  caches: z.array(cachePath).optional(),
   dev: z.string().min(1).optional(),
   ready: ready.optional(),
   deploy: deploy.optional(),

package/lib/worktree-deps/caches.ts

@@ -0,0 +1,250 @@
+/**
+ * Build caches seeded into a new worktree from the main checkout, so its
+ * first typecheck, test and build start warm: `.next/cache`, `.next/dev/cache`
+ * and `*.tsbuildinfo` for a Node project, or exactly agentos.json's `caches`.
+ * (Vitest's own cache is not a default: it only orders tests, and seeding it
+ * measured no gain.) A cache is seeded only when it is fresh, built since the
+ * worktree's base commit, and not huge: an old one makes the first run
+ * slower, not faster. Best effort: a cache that can't be seeded is skipped and never
+ * fails a setup.
+ *
+ * Only ever a copy: an APFS clone, a reflink, or (on a filesystem with
+ * neither) a plain copy of a small cache. Never a hardlink or a symlink, so
+ * nothing a worktree writes can reach the main checkout, and never from a
+ * place other than the main checkout.
+ */
+
+import { execFile } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { promisify } from "util";
+import { gitResult, isGitError } from "../git-exec";
+import { findNodeModules } from "./clone";
+import { fastCopyMode } from "./fastcopy";
+import { inside, realExisting } from "./paths";
+import { copyTree } from "./spare";
+import type { CopyMode } from "./spare";
+
+const execFileAsync = promisify(execFile);
+
+// Past these sizes a cache is skipped. A copy for real (no clone, no reflink)
+// costs the disk; a clone of a huge one costs time, since the build then
+// loads it: a main checkout's .next/cache that has grown to gigabytes built
+// slower for a new worktree than starting empty (measured).
+const DEFAULT_MAX_COPY_MB = 512;
+const DEFAULT_MAX_CLONE_MB = 1024;
+
+interface Stack {
+  name: string;
+  // Cache paths, relative to the checkout, for a project of this stack.
+  paths(sourcePath: string): Promise<string[]>;
+}
+
+const hasNext = (dir: string) => {
+  if (fs.readdirSync(dir).some((f) => /^next\.config\./.test(f))) return true;
+  try {
+    const pkg = JSON.parse(
+      fs.readFileSync(path.join(dir, "package.json"), "utf-8")
+    );
+    return !!(pkg.dependencies?.next ?? pkg.devDependencies?.next);
+  } catch {
+    return false;
+  }
+};
+
+async function nodePaths(sourcePath: string): Promise<string[]> {
+  const dirs = new Set<string>();
+  for (const rel of await findNodeModules(sourcePath))
+    dirs.add(path.dirname(rel));
+  if (fs.existsSync(path.join(sourcePath, "package.json"))) dirs.add(".");
+  const out: string[] = [];
+  for (const dir of dirs) {
+    const abs = path.join(sourcePath, dir);
+    if (!fs.existsSync(path.join(abs, "package.json"))) continue;
+    out.push(path.join(dir, "*.tsbuildinfo"));
+    if (hasNext(abs))
+      out.push(
+        path.join(dir, ".next", "cache"),
+        // Next 16's dev server keeps its Turbopack cache here.
+        path.join(dir, ".next", "dev", "cache")
+      );
+  }
+  return out;
+}
+
+// One entry per stack. Add a stack here to give it defaults; a project can
+// always name its own in agentos.json's `caches`.
+export const STACKS: Stack[] = [
+  { name: "node", paths: nodePaths },
+  // iOS (DerivedData, Pods, ccache) is the agentos-mobile "Faster native iOS
+  // builds" task's: it plugs in here.
+  { name: "ios", paths: async () => [] },
+  // Rails is deliberately absent: bootsnap's load-path cache holds absolute
+  // paths, so a copy in another directory is stale on arrival.
+];
+
+export async function defaultCaches(sourcePath: string): Promise<string[]> {
+  const all = await Promise.all(STACKS.map((s) => s.paths(sourcePath)));
+  return all.flat();
+}
+
+// `*` is allowed in the last segment only.
+async function expand(sourcePath: string, rel: string): Promise<string[]> {
+  const base = path.basename(rel);
+  if (!base.includes("*")) return [rel];
+  const re = new RegExp(
+    "^" + base.split("*").map(escapeRe).join("[^/]*") + "$"
+  );
+  const dir = path.dirname(rel);
+  const names = await fs.promises
+    .readdir(path.join(sourcePath, dir))
+    .catch(() => [] as string[]);
+  return names.filter((n) => re.test(n)).map((n) => path.join(dir, n));
+}
+const escapeRe = (s: string) => s.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+
+// When the worktree's HEAD was committed; null when it can't be told.
+async function headTimeMs(worktreePath: string): Promise<number | null> {
+  try {
+    const { stdout } = await gitResult(worktreePath, [
+      "log",
+      "-1",
+      "--format=%ct",
+    ]);
+    const seconds = parseInt(stdout, 10);
+    return Number.isFinite(seconds) ? seconds * 1000 : null;
+  } catch {
+    return null;
+  }
+}
+
+// The last write to a file, or to a folder or its direct children.
+async function newestMs(p: string): Promise<number> {
+  const st = await fs.promises.stat(p);
+  let newest = st.mtimeMs;
+  if (st.isDirectory())
+    for (const name of await fs.promises.readdir(p)) {
+      const child = await fs.promises
+        .stat(path.join(p, name))
+        .catch(() => null);
+      if (child) newest = Math.max(newest, child.mtimeMs);
+    }
+  return newest;
+}
+
+async function sizeMb(p: string): Promise<number> {
+  const { stdout } = await execFileAsync("du", ["-sk", p]);
+  return parseInt(stdout, 10) / 1024;
+}
+
+// Git ignores it, or seeding it would leave an uncommitted file behind.
+// Outside a repository there is no answer, and it is allowed.
+async function notIgnored(worktreePath: string, rel: string): Promise<boolean> {
+  try {
+    await gitResult(worktreePath, ["check-ignore", "-q", "--", rel]);
+    return false;
+  } catch (error) {
+    return isGitError(error) && error.exitCode === 1;
+  }
+}
+
+export interface SeedResult {
+  seeded: Array<{ rel: string; how: CopyMode }>;
+  skipped: Array<{ rel: string; why: string }>;
+}
+
+export async function seedBuildCaches(opts: {
+  sourcePath: string;
+  worktreePath: string;
+  // agentos.json's `caches`; the stack defaults without it.
+  paths?: string[];
+  mode?: CopyMode;
+  platform?: NodeJS.Platform;
+  maxCopyMb?: number;
+  maxCloneMb?: number;
+  // Caches last written before this (ms) are stale. Default: the worktree's
+  // HEAD commit time; without one every cache counts as fresh.
+  freshAfterMs?: number;
+}): Promise<SeedResult> {
+  const { sourcePath, worktreePath } = opts;
+  const result: SeedResult = { seeded: [], skipped: [] };
+  // The switch for measuring a start without seeding.
+  if (process.env.AGENTOS_NO_BUILD_CACHES) return result;
+  const declared = opts.paths ?? (await defaultCaches(sourcePath));
+  if (!declared.length) return result;
+
+  const fast = await fastCopyMode({
+    sourcePath,
+    worktreePath,
+    platform: opts.platform,
+  });
+  // Hardlinks are for dependencies from the store, never for a cache.
+  const mode: CopyMode =
+    opts.mode ?? (fast === "clone" || fast === "reflink" ? fast : "copy");
+  const max =
+    opts.maxCopyMb ??
+    Number(process.env.AGENTOS_CACHE_COPY_MAX_MB || DEFAULT_MAX_COPY_MB);
+  const maxClone =
+    opts.maxCloneMb ??
+    Number(process.env.AGENTOS_CACHE_CLONE_MAX_MB || DEFAULT_MAX_CLONE_MB);
+  const freshAfter = opts.freshAfterMs ?? (await headTimeMs(worktreePath));
+  const root = await fs.promises.realpath(sourcePath);
+  const target = await fs.promises.realpath(worktreePath);
+
+  const skip = (rel: string, why: string) => result.skipped.push({ rel, why });
+
+  for (const rel of (
+    await Promise.all(declared.map((d) => expand(sourcePath, d)))
+  ).flat()) {
+    const real = await fs.promises
+      .realpath(path.join(sourcePath, rel))
+      .catch(() => null);
+    if (!real) continue; // not built in the main checkout yet
+    if (!inside(root, real)) {
+      skip(rel, "resolves outside the project");
+      continue;
+    }
+    const dir = path.join(target, path.dirname(rel));
+    if (!inside(target, await realExisting(dir))) {
+      skip(rel, "its folder in the worktree resolves outside it");
+      continue;
+    }
+    const dest = path.join(dir, path.basename(rel));
+    if (await fs.promises.lstat(dest).catch(() => null)) continue; // already there
+    if (await notIgnored(worktreePath, rel)) {
+      skip(rel, "not ignored by git");
+      continue;
+    }
+    if (freshAfter !== null && (await newestMs(real)) < freshAfter) {
+      skip(rel, "older than the worktree's base commit");
+      continue;
+    }
+    const limit = mode === "copy" ? max : maxClone;
+    if ((await sizeMb(real).catch(() => Infinity)) > limit) {
+      skip(
+        rel,
+        mode === "copy"
+          ? `bigger than ${limit} MB and this filesystem can't clone`
+          : `bigger than ${limit} MB`
+      );
+      continue;
+    }
+    await fs.promises.mkdir(dir, { recursive: true });
+    if (!inside(target, await fs.promises.realpath(dir))) {
+      skip(rel, "its folder in the worktree resolves outside it");
+      continue;
+    }
+    const partial = `${dest}.aos-partial`;
+    await fs.promises.rm(partial, { recursive: true, force: true });
+    const ok =
+      (await copyTree(real, partial, mode)) &&
+      (await fs.promises.rename(partial, dest).then(
+        () => true,
+        () => false
+      ));
+    await fs.promises.rm(partial, { recursive: true, force: true });
+    if (ok) result.seeded.push({ rel, how: mode });
+    else skip(rel, "the copy failed");
+  }
+  return result;
+}

package/lib/worktree-deps/clone.ts

@@ -10,6 +10,8 @@ import { createHash } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
 import { LOCKFILES } from "./install";
+import { STORE_ROOT, fastCopyMode, unlinkMutable } from "./fastcopy";
+import type { FastMode } from "./fastcopy";
 import {
   SPARE_ROOT,
   copyTree,
@@ -72,11 +74,15 @@ export async function findNodeModules(sourcePath: string): Promise<string[]> {
 
 // Cloned beside the target and renamed into place, so a clone cut off by a
 // restart or a failed cp never passes for a finished one.
-async function cloneWhole(from: string, target: string): Promise<boolean> {
+async function cloneWhole(
+  from: string,
+  target: string,
+  mode: FastMode
+): Promise<boolean> {
   const partial = `${target}.aos-partial`;
   await fs.promises.rm(partial, { recursive: true, force: true });
   const ok =
-    (await copyTree(from, partial)) && (await takeSpare(partial, target));
+    (await copyTree(from, partial, mode)) && (await takeSpare(partial, target));
   await fs.promises.rm(partial, { recursive: true, force: true });
   return ok;
 }
@@ -86,11 +92,14 @@ export interface CloneResult {
   // Why it didn't clone, when it didn't.
   reason?: string;
   cloned: Array<{ rel: string; from: "spare" | "clone" }>;
+  mode?: FastMode;
+  skipped?: string[];
   // The spares being made for the next start. Nothing waits on it but tests.
   refill?: Promise<unknown>;
 }
 
-export const NOT_MAC = "clones are macOS only";
+export const NO_FAST_COPY =
+  "no clone, reflink or hardlink store is possible here";
 
 export async function cloneDeps(opts: {
   sourcePath: string;
@@ -99,13 +108,26 @@ export async function cloneDeps(opts: {
   // node_modules findNodeModules finds.
   only?: string[];
   spareRoot?: string;
+  // Where Linux keeps the hardlinked store (fastcopy.ts).
+  storeRoot?: string;
   platform?: NodeJS.Platform;
+  // Forced instead of detected; null is "none works" (tests).
+  mode?: FastMode | null;
 }): Promise<CloneResult> {
   const { sourcePath, worktreePath, only } = opts;
   const root = opts.spareRoot ?? SPARE_ROOT;
   const cloned: CloneResult["cloned"] = [];
-  if ((opts.platform ?? process.platform) !== "darwin")
-    return { ok: false, reason: NOT_MAC, cloned };
+  const storeRoot = opts.storeRoot ?? STORE_ROOT;
+  const mode =
+    opts.mode !== undefined
+      ? opts.mode
+      : await fastCopyMode({
+          sourcePath,
+          worktreePath,
+          storeRoot,
+          platform: opts.platform,
+        });
+  if (!mode) return { ok: false, reason: NO_FAST_COPY, cloned };
 
   const isModules = (rel: string) => path.basename(rel) === "node_modules";
   const all = only
@@ -124,6 +146,13 @@ export async function cloneDeps(opts: {
       };
     if (!lock)
       return { ok: false, reason: "the main checkout has no lockfile", cloned };
+    if (!(await nodeModulesMatchLock(sourcePath)))
+      return {
+        ok: false,
+        reason:
+          "the main checkout's node_modules is not what its lockfile lists",
+        cloned,
+      };
     if (lock !== (await lockfileHash(worktreePath)))
       return {
         ok: false,
@@ -133,16 +162,22 @@ export async function cloneDeps(opts: {
   }
 
   const spares: Array<{ rel: string; lock: string }> = [];
+  const skipped: string[] = [];
   for (const rel of all) {
     const from = path.join(sourcePath, rel);
     const target = path.join(worktreePath, rel);
     if (!(await isDir(from))) continue;
     // A directory this branch doesn't have, or the files already there.
     if (!(await isDir(path.dirname(target))) || fs.existsSync(target)) continue;
+    if (!isModules(rel) && mode === "hardlink") {
+      // Mutable, and hardlinks would write back: left to the setup commands.
+      skipped.push(`${rel} (not linked)`);
+      continue;
+    }
     if (!isModules(rel)) {
       // Anything else declared (a virtualenv, vendor/bundle) is cloned as
       // is: there is no lockfile AgentOS knows to check it against.
-      if (!(await cloneWhole(from, target)))
+      if (!(await cloneWhole(from, target, mode)))
         return { ok: false, reason: `cloning ${rel} failed`, cloned };
       cloned.push({ rel, from: "clone" });
       continue;
@@ -154,10 +189,30 @@ export async function cloneDeps(opts: {
     if (rel !== "node_modules" && own !== ownHere) continue;
     const key = own ?? lock;
     if (!key) continue;
+    if (mode === "hardlink") {
+      // Linked from the store, never from the checkout; the store is made
+      // once per lockfile with a plain copy.
+      const stored = sparePath(storeRoot, sourcePath, rel, key);
+      if (!fs.existsSync(stored))
+        await replenishSpare(storeRoot, sourcePath, rel, key, "copy").catch(
+          () => undefined
+        );
+      if (!fs.existsSync(stored))
+        return {
+          ok: false,
+          reason: `making the store for ${rel} failed`,
+          cloned,
+        };
+      if (!(await cloneWhole(stored, target, mode)))
+        return { ok: false, reason: `linking ${rel} failed`, cloned };
+      await unlinkMutable(target).catch(() => undefined);
+      cloned.push({ rel, from: "clone" });
+      continue;
+    }
     const spare = sparePath(root, sourcePath, rel, key);
     if (await takeSpare(spare, target)) {
       cloned.push({ rel, from: "spare" });
-    } else if (await cloneWhole(from, target)) {
+    } else if (await cloneWhole(from, target, mode)) {
       cloned.push({ rel, from: "clone" });
     } else {
       return { ok: false, reason: `cloning ${rel} failed`, cloned };
@@ -167,10 +222,40 @@ export async function cloneDeps(opts: {
 
   const refill = Promise.all(
     spares.map(({ rel, lock: key }) =>
-      replenishSpare(root, sourcePath, rel, key).catch((error) =>
+      replenishSpare(root, sourcePath, rel, key, mode).catch((error) =>
         console.error(`Spare for ${rel} failed:`, error)
       )
     )
   );
-  return { ok: true, cloned, refill };
+  return { ok: true, cloned, refill, mode, skipped };
+}
+
+// Whether the checkout's node_modules is what its npm lockfile says: every
+// package the lockfile lists (optional ones, which a platform may skip, aside)
+// is installed at that version. A checkout pulled but never reinstalled is
+// not, and cloning it would hand the worktree missing dependencies. Other
+// package managers have no hidden lockfile to check, so they pass.
+export async function nodeModulesMatchLock(dir: string): Promise<boolean> {
+  const read = (file: string) =>
+    fs.promises
+      .readFile(file, "utf-8")
+      .then(
+        (text) =>
+          JSON.parse(text) as {
+            packages?: Record<string, { version?: string; optional?: boolean }>;
+          }
+      )
+      .catch(() => null);
+  const lock = await read(path.join(dir, "package-lock.json"));
+  if (!lock?.packages) return true;
+  const installed = await read(
+    path.join(dir, "node_modules", ".package-lock.json")
+  );
+  if (!installed?.packages) return false;
+  return Object.entries(lock.packages).every(
+    ([name, pkg]) =>
+      name === "" ||
+      pkg.optional ||
+      installed.packages![name]?.version === pkg.version
+  );
 }