@saadnvd1/agent-os 0.3.603 → 0.3.606

package/lib/worktree-deps/fastcopy.ts

@@ -0,0 +1,89 @@
+/**
+ * How a Linux (or macOS) worktree can be given a copy of the main checkout's
+ * files without paying for every byte: an APFS clone, a reflink where the
+ * filesystem has them, or hardlinks from a store AgentOS owns. Null when
+ * none works, and the caller installs or copies plainly instead.
+ */
+
+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";
+
+const execFileAsync = promisify(execFile);
+
+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");
+
+// Files tools rewrite in place. A hardlink would carry the write back into
+// the store, so these are real copies in every worktree.
+export const MUTABLE_IN_MODULES = [".package-lock.json", ".cache", ".vite"];
+
+const probed = new Map<string, boolean>();
+
+// Whether `dir`'s filesystem reflinks: tried on a scratch file made there.
+export async function canReflink(dir: string): Promise<boolean> {
+  const dev = String((await fs.promises.stat(dir)).dev);
+  const known = probed.get(dev);
+  if (known !== undefined) return known;
+  const probe = path.join(dir, `.aos-reflink-probe-${process.pid}`);
+  let ok = false;
+  try {
+    await fs.promises.writeFile(probe, "x");
+    await execFileAsync("cp", ["--reflink=always", probe, `${probe}.copy`]);
+    ok = true;
+  } catch {
+    ok = false;
+  } finally {
+    await fs.promises.rm(probe, { force: true });
+    await fs.promises.rm(`${probe}.copy`, { force: true });
+  }
+  probed.set(dev, ok);
+  return ok;
+}
+
+const device = (p: string) =>
+  fs.promises.stat(p).then(
+    (s) => s.dev,
+    () => null
+  );
+
+export async function fastCopyMode(opts: {
+  sourcePath: string;
+  worktreePath: string;
+  storeRoot?: string;
+  platform?: NodeJS.Platform;
+}): Promise<FastMode | null> {
+  const platform = opts.platform ?? process.platform;
+  if (platform === "darwin") return "clone";
+  if (platform !== "linux") return null;
+  const wt = await device(opts.worktreePath);
+  if (wt === null) return null;
+  if (
+    (await device(opts.sourcePath)) === wt &&
+    (await canReflink(opts.worktreePath))
+  )
+    return "reflink";
+  const store = opts.storeRoot ?? STORE_ROOT;
+  await fs.promises.mkdir(store, { recursive: true }).catch(() => undefined);
+  return (await device(store)) === wt ? "hardlink" : null;
+}
+
+// Replace the entries of a hardlinked node_modules that tools rewrite in
+// place with real copies.
+export async function unlinkMutable(modules: string): Promise<void> {
+  for (const name of MUTABLE_IN_MODULES) {
+    const entry = path.join(modules, name);
+    if (!(await fs.promises.lstat(entry).catch(() => null))) continue;
+    const copy = `${entry}.aos-copy`;
+    await fs.promises.rm(copy, { recursive: true, force: true });
+    await fs.promises.cp(entry, copy, { recursive: true });
+    await fs.promises.rm(entry, { recursive: true, force: true });
+    await fs.promises.rename(copy, entry);
+  }
+}

package/lib/worktree-deps/index.ts

@@ -6,11 +6,17 @@
 import { exec } from "child_process";
 import { promisify } from "util";
 import type { SetupResult } from "../env-setup";
-import { NOT_MAC, cloneDeps } from "./clone";
+import { NO_FAST_COPY, cloneDeps } from "./clone";
 import { detectPackageManager, setupEnv } from "./install";
 
 const execAsync = promisify(exec);
 
+const COMMANDS = {
+  clone: "cp -Rc",
+  reflink: "cp -a --reflink=always",
+  hardlink: "cp -al (from the store)",
+};
+
 /**
  * Run a setup command in the worktree directory
  */
@@ -57,15 +63,18 @@ export async function bringDependencies(
   if (pm) result.packageManager = pm.name;
 
   const clone = await deps.clone({ sourcePath, worktreePath, only });
-  // Off macOS only node_modules has a fallback (the install below).
-  if (!pm && !clone.ok && !clone.cloned.length && clone.reason === NOT_MAC)
+  // Without a fast copy only node_modules has a fallback (the install below).
+  if (!pm && !clone.ok && !clone.cloned.length && clone.reason === NO_FAST_COPY)
     return;
   if (clone.ok || !pm) {
     result.steps.push({
       name: "Clone dependencies",
-      command: "cp -Rc",
+      command: clone.mode ? COMMANDS[clone.mode] : "cp",
       success: clone.ok,
-      output: clone.cloned.map((c) => `${c.rel} (${c.from})`).join(", "),
+      output: [
+        ...clone.cloned.map((c) => `${c.rel} (${c.from})`),
+        ...(clone.skipped ?? []).map((r) => `skipped ${r}`),
+      ].join(", "),
       error: clone.ok ? undefined : clone.reason,
     });
     if (!clone.ok) result.success = false;

package/lib/worktree-deps/paths.ts

@@ -0,0 +1,20 @@
+/**
+ * Path checks shared by what setup places into a worktree (agentos.json's
+ * `copy`, `clone` and `caches`): everything resolved through symlinks to a
+ * place inside its checkout, so a link can't carry a copy somewhere else.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+
+export const inside = (root: string, p: string) =>
+  p === root || p.startsWith(root + path.sep);
+
+// The real path of `p`'s deepest part that exists.
+export async function realExisting(p: string): Promise<string> {
+  for (let at = p; ; at = path.dirname(at)) {
+    const real = await fs.promises.realpath(at).catch(() => null);
+    if (real) return real;
+    if (path.dirname(at) === at) return at;
+  }
+}

package/lib/worktree-deps/spare.ts

@@ -49,18 +49,35 @@ export async function takeSpare(
   }
 }
 
-// macOS clones (APFS, no extra disk); elsewhere this is a plain copy, which
-// production never asks for: Linux worktrees install instead.
-export const cloneArgs = (from: string, to: string) =>
-  process.platform === "darwin" ? ["-Rc", from, to] : ["-R", from, to];
+// How a tree is copied: an APFS clone (macOS), a reflink (Linux on a
+// copy-on-write filesystem), hardlinks (Linux, from AgentOS's own store), or
+// a plain copy.
+export type CopyMode = "clone" | "reflink" | "hardlink" | "copy";
+
+export const copyArgs = (mode: CopyMode, from: string, to: string) =>
+  mode === "clone"
+    ? [process.platform === "darwin" ? "-Rc" : "-R", from, to]
+    : mode === "reflink"
+      ? ["-a", "--reflink=always", from, to]
+      : mode === "hardlink"
+        ? ["-al", from, to]
+        : ["-a", from, to];
+
+// What a copy with no mode given does: clones on macOS, a plain copy elsewhere.
+const defaultMode = (): CopyMode =>
+  process.platform === "darwin" ? "clone" : "copy";
 
 // A clone that stalls (a locked or dying volume) is killed rather than
 // holding a task's start forever.
 const COPY_TIMEOUT_MS = 10 * 60 * 1000;
 
-export function copyTree(from: string, to: string): Promise<boolean> {
+export function copyTree(
+  from: string,
+  to: string,
+  mode: CopyMode = defaultMode()
+): Promise<boolean> {
   return new Promise((resolve) => {
-    const child = spawn("cp", cloneArgs(from, to), {
+    const child = spawn("cp", copyArgs(mode, from, to), {
       stdio: "ignore",
       timeout: COPY_TIMEOUT_MS,
       killSignal: "SIGKILL",
@@ -104,7 +121,8 @@ export async function replenishSpare(
   root: string,
   sourcePath: string,
   rel: string,
-  lockHash: string
+  lockHash: string,
+  mode?: CopyMode
 ): Promise<"made" | "exists" | "failed"> {
   const spare = sparePath(root, sourcePath, rel, lockHash);
   if (building.has(spare) || fs.existsSync(spare)) return "exists";
@@ -113,7 +131,7 @@ export async function replenishSpare(
     await fs.promises.mkdir(root, { recursive: true });
     await pruneSpares(root, sourcePath, rel, spare);
     const tmp = `${spare}.${process.pid}-${Date.now()}`;
-    let made = await copyTree(path.join(sourcePath, rel), tmp);
+    let made = await copyTree(path.join(sourcePath, rel), tmp, mode);
     if (made) made = await takeSpare(tmp, spare);
     await fs.promises.rm(tmp, { recursive: true, force: true });
     return made ? "made" : "failed";

package/package.json

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

package/scripts/bench/worktree-setup.ts

@@ -0,0 +1,101 @@
+/**
+ * Times a new worktree's setup and its first typecheck, test and build, and
+ * the disk it takes, against a checkout. Run it with the seeding on, then
+ * with AGENTOS_NO_BUILD_CACHES=1 (and, to see an install on Linux, --install).
+ *
+ *   npx tsx scripts/bench/worktree-setup.ts <checkout> [--test <file>]
+ *     [--build] [--install] [--cwd <subdir>] [--drop <seeded path>]
+ *
+ * It makes a throwaway git worktree of the checkout's HEAD in the temp
+ * directory and removes it at the end; it touches nothing else.
+ */
+
+import { execFileSync, spawnSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { setupWorktree } from "../../lib/env-setup";
+
+const args = process.argv.slice(2);
+const flag = (name: string) => args.includes(name);
+const value = (name: string) => args[args.indexOf(name) + 1];
+const source = path.resolve(args[0]);
+const sub = flag("--cwd") ? value("--cwd") : ".";
+
+const freeKb = (dir: string) =>
+  Number(
+    execFileSync("df", ["-Pk", dir], { encoding: "utf-8" })
+      .trim()
+      .split("\n")[1]
+      .split(/\s+/)[3]
+  );
+
+function timed(command: string, cwd: string) {
+  const start = Date.now();
+  const run = spawnSync(command, { cwd, shell: true, stdio: "ignore" });
+  return { seconds: (Date.now() - start) / 1000, ok: run.status === 0 };
+}
+
+async function main() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "aos-bench-"));
+  const worktree = path.join(root, "wt");
+  execFileSync("git", ["worktree", "add", "-q", "--detach", worktree, "HEAD"], {
+    cwd: source,
+  });
+  const out: Record<string, unknown> = {
+    source: path.basename(source),
+    platform: process.platform,
+    seeding: process.env.AGENTOS_NO_BUILD_CACHES ? "off" : "on",
+  };
+  try {
+    const before = freeKb(root);
+    const start = Date.now();
+    let steps: string[] = [];
+    if (flag("--install")) {
+      const r = timed("npm ci --include=dev", worktree);
+      steps = [`npm ci ok=${r.ok}`];
+    } else {
+      const result = await setupWorktree({
+        worktreePath: worktree,
+        sourcePath: source,
+      });
+      steps = result.steps.map(
+        (s) => `${s.name}: ${s.success ? "ok" : "failed"}`
+      );
+    }
+    out.setupSeconds = (Date.now() - start) / 1000;
+    out.setupSteps = steps;
+    out.diskMbAfterSetup = Math.round((before - freeKb(root)) / 1024);
+    // Take a seeded cache back out to measure without it.
+    if (flag("--drop"))
+      fs.rmSync(path.join(worktree, value("--drop")), {
+        recursive: true,
+        force: true,
+      });
+    const dir = path.join(worktree, sub);
+    const pkg = path.join(dir, "package.json");
+    const typecheck = fs.existsSync(pkg)
+      ? JSON.parse(fs.readFileSync(pkg, "utf-8")).scripts?.typecheck
+      : undefined;
+    if (typecheck) out.typecheck = timed("npm run typecheck", dir);
+    else if (fs.existsSync(path.join(dir, "tsconfig.json")))
+      out.typecheck = timed("npx tsc --noEmit", dir);
+    if (flag("--test"))
+      out.test = timed(`npx vitest run ${value("--test")}`, dir);
+    if (flag("--build")) {
+      out.build = timed("npx next build", dir);
+      out.diskMbAfterBuild = Math.round((before - freeKb(root)) / 1024);
+    }
+  } finally {
+    execFileSync("git", ["worktree", "remove", "--force", worktree], {
+      cwd: source,
+    });
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+  console.log(JSON.stringify(out));
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/scripts/check-bundle.mjs

@@ -1,7 +1,10 @@
-// The app's first-load JavaScript, held under a budget: a heavy library
-// imported eagerly (a syntax highlighter's every grammar, a diagram renderer)
-// fails here instead of shipping to the phone. Run after `next build`.
-import { readFileSync } from "fs";
+// The app's first-load JavaScript, watched against a budget. Going over it
+// warns rather than fails: growth is sometimes worth it, and the point is to
+// notice a big jump (a syntax highlighter's every grammar, a diagram renderer
+// imported eagerly) before it ships to the phone. On CI the warning becomes an
+// annotation on the PR. A missing or unreadable size still fails, so a broken
+// check can't pass quietly. Run after `next build`.
+import { appendFileSync, readFileSync } from "fs";
 
 // Bytes, uncompressed. 1.04 MB when this was set (2026-10-07), down from 2.07.
 const BUDGETS = { "/": 1_200_000 };
@@ -9,7 +12,20 @@ const BUDGETS = { "/": 1_200_000 };
 const statsPath =
   process.argv[2] ?? ".next/diagnostics/route-bundle-stats.json";
 const stats = JSON.parse(readFileSync(statsPath, "utf-8"));
+const kb = (n) => `${Math.round(n / 1024)} KB`;
 let failed = false;
+
+function warn(text) {
+  console.warn(`bundle: ${text}`);
+  if (process.env.GITHUB_ACTIONS)
+    console.log(`::warning title=Bundle size::${text}`);
+  if (process.env.GITHUB_STEP_SUMMARY)
+    appendFileSync(
+      process.env.GITHUB_STEP_SUMMARY,
+      `> [!WARNING]\n> ${text}\n`
+    );
+}
+
 for (const [route, budget] of Object.entries(BUDGETS)) {
   const entry = stats.find((r) => r.route === route);
   if (!entry) {
@@ -18,18 +34,17 @@ for (const [route, budget] of Object.entries(BUDGETS)) {
     continue;
   }
   const bytes = entry.firstLoadUncompressedJsBytes;
-  const kb = (n) => `${Math.round(n / 1024)} KB`;
   if (typeof bytes !== "number" || !Number.isFinite(bytes)) {
     // A Next.js upgrade that renames the field must not pass by default.
     console.error(`bundle: no firstLoadUncompressedJsBytes for ${route}`);
     failed = true;
   } else if (bytes > budget) {
-    console.error(
-      `bundle: ${route} loads ${kb(bytes)} of JS first, over its ${kb(budget)} budget.\n` +
-        "  Load the heavy part with next/dynamic or import(); see what's in it with\n" +
-        "  `npx next experimental-analyze`."
+    const over = Math.round(((bytes - budget) / budget) * 100);
+    warn(
+      `${route} loads ${kb(bytes)} of JS first, ${over}% over its ${kb(budget)} budget. ` +
+        "If that's not worth it, load the heavy part with next/dynamic or import(); " +
+        "`npx next experimental-analyze` shows what's in it."
     );
-    failed = true;
   } else {
     console.log(`bundle: ${route} ${kb(bytes)} of ${kb(budget)}`);
   }

package/scripts/check-bundle.test.ts

@@ -21,9 +21,9 @@ describe("the first-load JS budget", () => {
     expect(r.code).toBe(0);
   });
 
-  it("fails a build over budget", () => {
+  it("warns, without failing, on a build over budget", () => {
     const r = run([{ route: "/", firstLoadUncompressedJsBytes: 2_000_000 }]);
-    expect([r.code, r.out]).toEqual([1, expect.stringContaining("over its")]);
+    expect([r.code, r.out]).toEqual([0, expect.stringContaining("% over its")]);
   });
 
   it("fails closed when the size is missing or not a number", () => {

package/stores/inboxUi.ts

@@ -0,0 +1,60 @@
+import { proxy } from "valtio";
+import { INBOX_TABS, type InboxTab } from "@/lib/inbox/counts";
+
+const TAB_KEY = "agentos:inbox-tab";
+const SEEN_KEY = "agentos:inbox-messages-seen";
+
+const read = (key: string) => {
+  try {
+    return typeof window === "undefined" ? null : localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+};
+const write = (key: string, value: string) => {
+  try {
+    localStorage.setItem(key, value);
+  } catch {
+    // Private mode: the choice just isn't kept.
+  }
+};
+
+export const lastInboxTab = (): InboxTab | null => {
+  const saved = read(TAB_KEY);
+  return INBOX_TABS.find((t) => t === saved) ?? null;
+};
+
+// The Inbox panel, shared by the bar, the sidebar menu and the palette.
+// `request` is an explicit tab to open on; without one the panel picks.
+export const inboxUi = proxy<{
+  open: boolean;
+  request: InboxTab | null;
+  // The newest message he has looked at; null until first seen.
+  seenMessageId: number | null;
+}>({
+  open: false,
+  request: null,
+  seenMessageId: null,
+});
+
+export const inboxUiActions = {
+  open: (tab?: InboxTab) => {
+    inboxUi.request = tab ?? null;
+    inboxUi.open = true;
+  },
+  setOpen: (open: boolean) => {
+    inboxUi.open = open;
+  },
+  rememberTab: (tab: InboxTab) => write(TAB_KEY, tab),
+  loadSeen: () => {
+    if (inboxUi.seenMessageId !== null) return;
+    const saved = read(SEEN_KEY);
+    if (saved !== null && Number.isFinite(Number(saved)))
+      inboxUi.seenMessageId = Number(saved);
+  },
+  markSeen: (id: number) => {
+    if (inboxUi.seenMessageId !== null && id <= inboxUi.seenMessageId) return;
+    inboxUi.seenMessageId = id;
+    write(SEEN_KEY, String(id));
+  },
+};

package/stores/needsYouFocus.ts

@@ -1,13 +1,21 @@
 import { proxy } from "valtio";
 
-// "Show this ask", raised by the Needs-you strip and handled by the asks list
-// above the chat, which opens itself and scrolls the card into view.
+// "Show this ask", raised by the Needs-you strip and the Inbox and handled
+// by the asks list above the chat, which opens itself and scrolls the card
+// into view. "Reply to this question" is handled by the orchestrator's chat.
 export const needsYouFocus = proxy<{
   ask: { id: number; at: number } | null;
-}>({ ask: null });
+  reply: { workspaceId: string; id: number; text: string; at: number } | null;
+}>({ ask: null, reply: null });
 
 export const needsYouFocusActions = {
   ask: (id: number) => {
     needsYouFocus.ask = { id, at: Date.now() };
   },
+  reply: (workspaceId: string, id: number, text: string) => {
+    needsYouFocus.reply = { workspaceId, id, text, at: Date.now() };
+  },
+  clearReply: () => {
+    needsYouFocus.reply = null;
+  },
 };

package/components/Bus/MessagesButton.tsx

@@ -1,25 +0,0 @@
-"use client";
-
-import { MessagesSquare } from "lucide-react";
-import { Button } from "@/components/ui/button";
-import { busUiActions } from "@/stores/busUi";
-
-export function MessagesButton({
-  labelClassName,
-}: {
-  labelClassName?: string;
-}) {
-  return (
-    <Button
-      size="sm"
-      variant="ghost"
-      aria-label="Messages"
-      title="Messages"
-      className="h-7 px-2"
-      onClick={busUiActions.open}
-    >
-      <MessagesSquare className="h-4 w-4" />
-      <span className={labelClassName}>Messages</span>
-    </Button>
-  );
-}