@saadnvd1/agent-os 0.3.731 → 0.3.734

package/components/Updates/UpdateActions.tsx

@@ -50,6 +50,12 @@ export function UpdateActions({ view }: { view: UpdateView }) {
         Cancel
       </Button>
     );
+  if (view.canUpdate.code === "no_restart")
+    return (
+      <Button size="sm" className="min-h-11 md:min-h-0" disabled>
+        Update now
+      </Button>
+    );
   if (!view.canUpdate.ok) return null;
 
   const start = (when: "now" | "idle") => {

package/components/Updates/UpdateBanner.test.ts

@@ -50,6 +50,7 @@ const make = (over: Partial<UpdateView> = {}): UpdateView => ({
   checkError: null,
   bannerEnabled: true,
   bannerLocked: false,
+  canRestart: true,
   canUpdate: { ok: true },
   run: null,
   pending: null,

package/lib/claims/collectLocal.ts

@@ -7,6 +7,7 @@ import { git } from "../git-exec";
 import { repoKey } from "../git-remote";
 import { IN_FLIGHT } from "../tasks/queue-rows";
 import { expandHome } from "../tasks/session";
+import { isNoise } from "./overlap";
 import { MAX_FILES } from "./types";
 import {
   localLiveSessionIds,
@@ -47,7 +48,8 @@ export async function changedFiles(
     git(dir, ["ls-files", "--others", "--exclude-standard", "-z"], OPTS),
   ]);
   return [...new Set([...paths(committed), ...paths(untracked)])].filter(
-    (p) => !p.split("/").some((seg) => seg.endsWith(".aos-partial"))
+    (p) =>
+      !p.split("/").some((seg) => seg.endsWith(".aos-partial")) && !isNoise(p)
   );
 }
 

package/lib/claims/overlap.ts

@@ -7,8 +7,28 @@ import type { Claim, Overlap } from "./types";
 const NOISE =
   /(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|Gemfile\.lock|Cargo\.lock|go\.sum|poetry\.lock|uv\.lock|composer\.lock|CHANGELOG[^/]*|__snapshots__\/.*|migrations\.generated\.ts)$/i;
 
-export const isNoise = (path: string) =>
-  NOISE.test(path) || /(^|\/)__snapshots__\//.test(path);
+// Build output, caches and OS files: directory segments (never name substrings).
+const NOISE_DIRS = new Set([
+  "__pycache__",
+  "node_modules",
+  ".next",
+  "dist",
+  "build",
+  "coverage",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache",
+]);
+const NOISE_FILE = /(\.(pyc|pyo|tsbuildinfo)|^\.DS_Store)$/;
+
+export const isNoise = (path: string) => {
+  if (NOISE.test(path) || /(^|\/)__snapshots__\//.test(path)) return true;
+  const segs = path.split("/");
+  return (
+    segs.slice(0, -1).some((s) => NOISE_DIRS.has(s)) ||
+    NOISE_FILE.test(segs[segs.length - 1])
+  );
+};
 
 // A path this many claims touch is a shared index or router, not a signal.
 export const HUB_CLAIMS = 4;

package/lib/orchestrator/write-guard.ts

@@ -313,14 +313,20 @@ export async function orchestratorWriteBounds(
 // Read at most once a minute, not on every write.
 const HOOKS_TTL_MS = 60_000;
 let hooksCache: { key: string; at: number; dirs: string[] } | null = null;
+// The last answer git gave, kept apart from the cache above: a read that
+// times out under load may fall back to one this recent, since a hooks folder
+// rarely moves in minutes. It is never refreshed from a fallback.
+const HOOKS_STALE_OK_MS = 10 * 60_000;
+const lastGoodHooks = new Map<string, { at: number; dirs: string[] }>();
 
 export async function hooksPaths(repos: string[]): Promise<string[]> {
   const key = repos.join("\0");
   if (hooksCache?.key === key && Date.now() - hooksCache.at < HOOKS_TTL_MS)
     return hooksCache.dirs;
   // Only "not set" and "not a repository" mean there's nothing to protect;
-  // any other failure (a timeout under load) throws, so the write is
-  // refused and nothing is cached.
+  // any other failure (a timeout under load) uses the last good answer if
+  // it's under ten minutes old, else throws, so the write is refused and
+  // nothing is cached.
   const run = (cwd: string, args: string[]) =>
     git(cwd, args, { timeout: 5000 })
       .then((out) => out.trim())
@@ -336,33 +342,47 @@ export async function hooksPaths(repos: string[]): Promise<string[]> {
   // The user's, expanded by git (~ and ~user). A relative one is taken from
   // each repo's top, so it names no one folder: each project's answer
   // below covers it there. Each project's comes as git itself resolves it.
-  const global = await run(os.homedir(), [
-    "config",
-    "--global",
-    "--type=path",
-    "--get",
-    "core.hooksPath",
-  ]);
-  const found = await Promise.all(
-    repos.map(async (r) => {
-      // A project whose folder is gone has no hooks to run.
-      if (!fs.existsSync(r)) return "";
-      const dir = await run(r, [
-        "rev-parse",
-        "--path-format=absolute",
-        "--git-path",
-        "hooks",
-      ]);
-      if (dir !== "" && !dir.startsWith("/"))
-        throw new Error(`git named no folder for ${r}'s hooks`);
-      return dir;
-    })
-  );
-  const dirs = [
-    ...new Set([global, ...found].filter((d) => d.startsWith("/"))),
-  ];
-  hooksCache = { key, at: Date.now(), dirs };
-  return dirs;
+  try {
+    return await read();
+  } catch (e) {
+    const good = lastGoodHooks.get(key);
+    if (!good || Date.now() - good.at >= HOOKS_STALE_OK_MS) throw e;
+    console.warn(
+      `[write-guard] ${e instanceof Error ? e.message : e}; using the answer from ${Math.round((Date.now() - good.at) / 1000)}s ago`
+    );
+    return good.dirs;
+  }
+
+  async function read(): Promise<string[]> {
+    const global = await run(os.homedir(), [
+      "config",
+      "--global",
+      "--type=path",
+      "--get",
+      "core.hooksPath",
+    ]);
+    const found = await Promise.all(
+      repos.map(async (r) => {
+        // A project whose folder is gone has no hooks to run.
+        if (!fs.existsSync(r)) return "";
+        const dir = await run(r, [
+          "rev-parse",
+          "--path-format=absolute",
+          "--git-path",
+          "hooks",
+        ]);
+        if (dir !== "" && !dir.startsWith("/"))
+          throw new Error(`git named no folder for ${r}'s hooks`);
+        return dir;
+      })
+    );
+    const dirs = [
+      ...new Set([global, ...found].filter((d) => d.startsWith("/"))),
+    ];
+    hooksCache = { key, at: Date.now(), dirs };
+    lastGoodHooks.set(key, { at: Date.now(), dirs });
+    return dirs;
+  }
 }
 
 // The check a PreToolUse hook makes: why this tool call is refused, or null.

package/lib/updates/banner.ts

@@ -44,6 +44,7 @@ export type UpdateRefusal =
   | "diverged"
   | "up_to_date"
   | "unknown"
+  | "no_restart"
   | "forbidden";
 
 export interface UpdateView {
@@ -61,6 +62,8 @@ export interface UpdateView {
   checkError: string | null;
   bannerEnabled: boolean;
   bannerLocked: boolean;
+  /** False when the server has no command to restart itself with. */
+  canRestart: boolean;
   canUpdate: { ok: boolean; code?: UpdateRefusal; reason?: string };
   run: UpdateRun | null;
   pending: { requestedAt: number } | null;

package/lib/updates/run.ts

@@ -197,6 +197,9 @@ export function readLog(deps: Pick<RunDeps, "logFile">, lines = 30): string[] {
 export type Refusal = { code: UpdateRefusal; error: string };
 
 /** Why this checkout can't be updated now; null when it can. No network. */
+export const NO_RESTART =
+  "This server can't restart itself, so an update would leave the old build running on new files. Set AGENTOS_RESTART to its restart command, or start it with agent-os start.";
+
 export async function preflight(
   check: CheckResult | null,
   deps: RunDeps
@@ -258,6 +261,8 @@ export async function preflight(
     };
   if (!check.available)
     return { code: "up_to_date", error: "AgentOS is up to date." };
+  if (!(await deps.restartCommand()))
+    return { code: "no_restart", error: NO_RESTART };
   return null;
 }
 
@@ -339,14 +344,14 @@ async function begin(
     toVersion: result.latest!.version,
     startedAt: deps.now(),
   });
-  const restart = await deps.restartCommand();
+  const restart = (await deps.restartCommand())!;
   const env = { ...deps.env } as NodeJS.ProcessEnv;
   // The restarted server must work out its own build, not inherit this one.
   delete env.AGENTOS_BUILD;
   delete env.AGENTOS_RESTART;
   env.AGENTOS_UPDATE_STATE = deps.stateFile;
   env.AGENTOS_UPDATE_ID = id;
-  if (restart) env.AGENTOS_RESTART = restart;
+  env.AGENTOS_RESTART = restart;
   if (deps.env.PORT) env.PORT = deps.env.PORT;
   deps.spawnRunner(env, deps.logFile);
   return { ok: true, pending: false };

package/lib/updates/view.ts

@@ -53,6 +53,7 @@ export async function updateView(
   const pending = readPending(deps);
   const active = isActivePhase(run?.phase);
   const refusal = mayUpdate ? await preflight(check, deps) : null;
+  const canRestart = !!(await deps.restartCommand());
   const wantsWorking = !active && !!(check?.available || pending);
   return {
     current: check?.current ?? null,
@@ -64,6 +65,7 @@ export async function updateView(
     checkError: check?.error ?? null,
     bannerEnabled: bannerEnabled(deps.env),
     bannerLocked: bannerLocked(deps.env),
+    canRestart,
     canUpdate: !mayUpdate
       ? { ok: false, code: "forbidden", reason: NOT_ALLOWED }
       : refusal

package/package.json

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

package/scripts/redeploy

@@ -2,6 +2,7 @@
 # Update a running checkout to origin's branch: pull, install, build beside
 # the live server, swap the build in and restart, so neither a build in
 # progress nor a failed one takes the running server down.
+# Without AGENTOS_RESTART it builds and checks but swaps nothing in.
 # Restart with: AGENTOS_RESTART="<command>" scripts/redeploy
 # Put the previous build back: AGENTOS_RESTART="<command>" scripts/redeploy --rollback
 set -euo pipefail
@@ -49,6 +50,14 @@ else
   echo "::phase building"
   # A build that fails on the new dependencies puts the old ones back.
   build_beside || { [ "$swapped" = 1 ] && restore_deps; exit 1; }
+  if [ -z "${AGENTOS_RESTART:-}" ]; then
+    # Nothing can restart the server, and a new build or node_modules under
+    # the old process breaks its pages: leave the live tree as it was.
+    [ "$swapped" = 1 ] && restore_deps
+    echo "Built and verified in $NEXT_BUILD, but not swapped in: nothing here can restart the server."
+    echo "Set AGENTOS_RESTART to its restart command and run scripts/redeploy again to swap and restart."
+    exit 0
+  fi
   swap_build
 fi
 
@@ -68,4 +77,4 @@ if [ -n "${AGENTOS_RESTART:-}" ]; then
   echo "AgentOS did not come back on $port within ${AGENTOS_UP_WAIT:-600}s; scripts/redeploy --rollback puts the last build back" >&2
   exit 1
 fi
-echo "Built. Restart your AgentOS server to run it."
+echo "Rolled back. Restart your AgentOS server to run it."

package/scripts/redeploy.test.ts

@@ -0,0 +1,77 @@
+import { spawnSync } from "node:child_process";
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { beforeEach, describe, expect, it } from "vitest";
+import { tempDir } from "@/lib/test-temp";
+
+// Runs the real scripts/redeploy (--pulled, so no git) in a scratch tree with
+// stub install, build and pnpm.
+let dir: string;
+beforeEach(() => {
+  dir = tempDir("aos-redeploy-");
+  mkdirSync(join(dir, "scripts/lib"), { recursive: true });
+  for (const f of [
+    "redeploy",
+    "lib/build-swap.sh",
+    "lib/pnpm.sh",
+    "lib/deps-swap.sh",
+  ])
+    copyFileSync(join(import.meta.dirname, f), join(dir, "scripts", f));
+  chmodSync(join(dir, "scripts/redeploy"), 0o755);
+  mkdirSync(join(dir, ".next"));
+  writeFileSync(join(dir, ".next/BUILD_ID"), "old");
+  mkdirSync(join(dir, "bin"));
+  for (const name of ["pnpm"])
+    writeFileSync(join(dir, "bin", name), "#!/bin/sh\nexit 0\n", {
+      mode: 0o755,
+    });
+  for (const f of ["package.json", "pnpm-lock.yaml", "pnpm-workspace.yaml"])
+    writeFileSync(join(dir, f), "{}");
+});
+
+const redeploy = (restart?: string) => {
+  const env: NodeJS.ProcessEnv = {
+    ...process.env,
+    HOME: dir,
+    PATH: `${join(dir, "bin")}:${process.env.PATH}`,
+    AGENTOS_INSTALL_CMD: "mkdir -p node_modules",
+    AGENTOS_NATIVE_CHECK: "true",
+    AGENTOS_BUILD_CMD:
+      'mkdir -p "$AGENTOS_DIST_DIR" && echo new > "$AGENTOS_DIST_DIR/BUILD_ID"',
+    AGENTOS_UP_WAIT: "1",
+    PORT: "1",
+  };
+  delete env.AGENTOS_RESTART;
+  if (restart) env.AGENTOS_RESTART = restart;
+  return spawnSync("bash", [join(dir, "scripts/redeploy"), "--pulled"], {
+    cwd: dir,
+    encoding: "utf8",
+    env,
+  });
+};
+const liveBuild = () =>
+  readFileSync(join(dir, ".next/BUILD_ID"), "utf8").trim();
+
+describe("scripts/redeploy", () => {
+  it("without a restart command builds but leaves the live build in place", () => {
+    const r = redeploy();
+    expect(r.status).toBe(0);
+    expect(r.stdout).toContain("not swapped in");
+    expect(liveBuild()).toBe("old");
+    expect(existsSync(join(dir, ".next-prev"))).toBe(false);
+  });
+
+  it("with a restart command swaps the build in and restarts", () => {
+    const r = redeploy(`touch ${join(dir, "restarted")}`);
+    expect(liveBuild()).toBe("new");
+    expect(existsSync(join(dir, "restarted"))).toBe(true);
+    expect(r.stdout).toContain("::phase restarting");
+  });
+});