@saadnvd1/agent-os 0.3.848 → 0.3.851

package/README.md

@@ -10,6 +10,12 @@ and check on all of it from your phone.
   <img alt="AgentOS: sessions grouped by state, a chat with its plan, steps and diffs, and the git panel" src="screenshots/hero.png">
 </picture>
 
+<p align="center">
+  <a href="https://youtu.be/JAukzHLTM5Y"><img alt="Watch the AgentOS video: You're the boss. They do the work." src="screenshots/video-boss.jpg" width="640"></a>
+  <br>
+  <a href="https://youtu.be/JAukzHLTM5Y">▶ Watch: what AgentOS does, in about a minute</a>
+</p>
+
 ## What it does
 
 - **An orchestrator for each workspace.** A chat that starts tasks, answers blocked agents, and merges pull requests only through gates. Anything that is yours to decide waits as an ask. [More](docs/reference/orchestrator.md)

package/app/api/updates/run/route.ts

@@ -28,9 +28,13 @@ export async function POST(request: NextRequest) {
       { code: started.code, error: started.error },
       { status: 409 }
     );
-  return NextResponse.json(await updateView({ mayUpdate: true }), {
-    status: 202,
-  });
+  return NextResponse.json(
+    {
+      ...(await updateView({ mayUpdate: true })),
+      ...(started.message ? { message: started.message } : {}),
+    },
+    { status: 202 }
+  );
 }
 
 // DELETE /api/updates/run - cancel a requested "update when idle". A started

package/components/Updates/UpdateActions.tsx

@@ -1,6 +1,7 @@
 "use client";
 
 import { useState } from "react";
+import { Loader2 } from "lucide-react";
 import { toast } from "sonner";
 import { Button } from "@/components/ui/button";
 import {
@@ -38,6 +39,12 @@ export function UpdateActions({ view }: { view: UpdateView }) {
   const [confirm, setConfirm] = useState(false);
   const busy = workingTotal(view.working) > 0;
 
+  if (view.queued)
+    return (
+      <Button size="sm" className="min-h-11 md:min-h-0" disabled>
+        <Loader2 className="h-4 w-4 animate-spin" /> Updating…
+      </Button>
+    );
   if (view.pending)
     return (
       <Button
@@ -60,7 +67,10 @@ export function UpdateActions({ view }: { view: UpdateView }) {
 
   const start = (when: "now" | "idle") => {
     setConfirm(false);
-    run.mutate(when, { onError: toastError });
+    run.mutate(when, {
+      onError: toastError,
+      onSuccess: (v) => v.message && toast.success(v.message),
+    });
   };
 
   return (
@@ -87,10 +97,15 @@ export function UpdateActions({ view }: { view: UpdateView }) {
             <Button variant="ghost" onClick={() => setConfirm(false)}>
               Cancel
             </Button>
-            <Button variant="outline" onClick={() => start("now")}>
+            <Button
+              variant={view.managed ? "default" : "outline"}
+              onClick={() => start("now")}
+            >
               Update now
             </Button>
-            <Button onClick={() => start("idle")}>Update when idle</Button>
+            {!view.managed && (
+              <Button onClick={() => start("idle")}>Update when idle</Button>
+            )}
           </DialogFooter>
         </DialogContent>
       </Dialog>

package/components/Updates/UpdateToast.test.ts

@@ -96,6 +96,8 @@ const make = (over: Partial<UpdateView> = {}): UpdateView => ({
   canUpdate: { ok: true },
   run: null,
   pending: null,
+  managed: false,
+  queued: null,
   working: { sessions: 0, reviews: 0, setups: 0 },
   ...over,
 });
@@ -212,6 +214,21 @@ describe("UpdateToast", () => {
     expect(runMutate).toHaveBeenCalledWith("idle", expect.anything());
   });
 
+  it("on a machine autodeploy manages, explains and still offers Update now", async () => {
+    view = make({ managed: true });
+    await render();
+    expect(text()).toContain("deployed by autodeploy");
+    await act(async () => button("Update now")!.click());
+    expect(runMutate).toHaveBeenCalledWith("now", expect.anything());
+  });
+
+  it("shows a queued request as a disabled Updating… button", async () => {
+    view = make({ managed: true, queued: { requestedAt: 1 } });
+    await render();
+    expect(button("Updating…")?.disabled).toBe(true);
+    expect(button("Update now")).toBeUndefined();
+  });
+
   it("shows a pending update with Cancel", async () => {
     view = make({ pending: { requestedAt: 1 } });
     await render();

package/components/Updates/UpdateToast.tsx

@@ -10,6 +10,7 @@ import { useDismissedUpdate } from "@/hooks/useDismissedUpdate";
 import { useReloadWhenUpdated } from "@/hooks/useReloadWhenUpdated";
 import {
   bannerState,
+  MANAGED_NOTE,
   type BannerState,
   type UpdateView,
 } from "@/lib/updates/banner";
@@ -72,6 +73,10 @@ export function UpdateToastView({
   if (state === "available") text = <>AgentOS {latest?.version} is available</>;
   else if (state === "pending")
     text = <>AgentOS will update when nothing is working</>;
+  else if (state === "queued")
+    text = (
+      <>Updating AgentOS to {latest?.version}. It deploys within a minute.</>
+    );
   else if (state === "built")
     text = <>Built {run?.toVersion}. Restart AgentOS to finish updating.</>;
   else if (failed) text = <>The update didn&apos;t finish. {run?.error}</>;
@@ -110,7 +115,7 @@ export function UpdateToastView({
       )}
     >
       <span className="flex h-6 shrink-0 items-center">
-        {state === "running" ? (
+        {state === "running" || state === "queued" ? (
           <Loader2 className="text-muted-foreground h-4 w-4 animate-spin" />
         ) : (
           <ArrowUpCircle
@@ -130,6 +135,9 @@ export function UpdateToastView({
               {view.canUpdate.reason}
             </p>
           )}
+        {state === "available" && view.managed && view.canUpdate.ok && (
+          <p className="text-muted-foreground text-xs">{MANAGED_NOTE}</p>
+        )}
         {notesOpen && latest && (
           <ul className="text-muted-foreground list-disc space-y-0.5 pl-4 text-xs">
             {latest.notes.map((n, i) => (
@@ -138,9 +146,9 @@ export function UpdateToastView({
           </ul>
         )}
         <div className="flex flex-wrap items-center gap-x-3 gap-y-1">
-          {(state === "available" || state === "pending") && (
-            <UpdateActions view={view} />
-          )}
+          {(state === "available" ||
+            state === "pending" ||
+            state === "queued") && <UpdateActions view={view} />}
           {state === "running" && elapsed > SLOW_MS && (
             <Button size="sm" onClick={() => window.location.reload()}>
               Reload
@@ -243,7 +251,9 @@ export function UpdateToast() {
       ? `running:${view?.run?.id}`
       : computed === "pending"
         ? `pending:${view?.pending?.requestedAt}`
-        : null;
+        : computed === "queued"
+          ? `queued:${view?.queued?.requestedAt}`
+          : null;
   const state = key && key === closed ? "hidden" : computed;
 
   const { dismissVersion, dismissRun } = dismissed;

package/components/Updates/UpdatesSection.tsx

@@ -11,7 +11,7 @@ import {
   useUpdateBannerSetting,
   useUpdates,
 } from "@/data/updates";
-import { isActivePhase } from "@/lib/updates/banner";
+import { isActivePhase, MANAGED_NOTE } from "@/lib/updates/banner";
 import { AutoUpdates } from "./AutoUpdates";
 import { UpdateActions } from "./UpdateActions";
 
@@ -108,9 +108,17 @@ export function UpdatesSection() {
           {view.run?.phase})…
         </p>
       )}
+      {view.available && view.managed && view.canUpdate.ok && (
+        <p className="text-muted-foreground text-xs">{MANAGED_NOTE}</p>
+      )}
       {view.available && !view.canUpdate.ok && view.canUpdate.reason && (
         <p className="text-muted-foreground text-xs">{view.canUpdate.reason}</p>
       )}
+      {view.queued && (
+        <p className="text-muted-foreground text-sm">
+          Queued for autodeploy. It deploys within about a minute.
+        </p>
+      )}
       {view.pending && (
         <p className="text-muted-foreground text-sm">
           Will update when nothing is working.

package/content/whats-new.json

@@ -2025,6 +2025,14 @@
       "area": "Settings",
       "text": "Settings is tidier: clearer switches, shorter lists, one Approvals page, and a General page for your name and alerts.",
       "url": "https://github.com/saadnvd1/agent-os/pull/570"
+    },
+    {
+      "id": 571,
+      "date": "2026-11-02",
+      "kind": "fixed",
+      "area": "Updates",
+      "text": "You can update AgentOS by hand again on machines that deploy themselves, and Update now skips the hourly wait.",
+      "url": "https://github.com/saadnvd1/agent-os/pull/571"
     }
   ]
 }

package/hooks/useReloadWhenUpdated.ts

@@ -9,7 +9,16 @@ import { isActivePhase, type UpdateView } from "@/lib/updates/banner";
  */
 export function useReloadWhenUpdated(view: UpdateView | undefined) {
   const watched = useRef<string | null>(null);
+  const queuedFrom = useRef<string | null>(null);
   const run = view?.run;
+  // An Update now that autodeploy took: the page was loaded from the old build.
+  const sha = view?.current?.sha;
+  useEffect(() => {
+    if (!sha) return;
+    if (view?.queued) queuedFrom.current = sha;
+    else if (queuedFrom.current && queuedFrom.current !== sha)
+      window.location.reload();
+  }, [view?.queued, sha]);
   useEffect(() => {
     if (!run) return;
     if (isActivePhase(run.phase)) watched.current = run.id;

package/lib/updates/banner.ts

@@ -94,7 +94,7 @@ export type UpdateRefusal =
   | "up_to_date"
   | "unknown"
   | "no_restart"
-  | "managed"
+  | "deploying"
   | "disk"
   | "forbidden";
 
@@ -118,6 +118,12 @@ export interface UpdateView {
   canUpdate: { ok: boolean; code?: UpdateRefusal; reason?: string };
   run: UpdateRun | null;
   pending: { requestedAt: number } | null;
+  /** autodeploy deploys this checkout (its heartbeat is fresh). */
+  managed: boolean;
+  /** An Update now click waiting for autodeploy to pick it up. */
+  queued: { requestedAt: number } | null;
+  /** What the server said about the click that produced this view. */
+  message?: string;
   working: { sessions: number; reviews: number; setups: number };
   auto?: AutoUpdateView;
 }
@@ -126,6 +132,7 @@ export type BannerState =
   | "hidden"
   | "available"
   | "pending"
+  | "queued"
   | "running"
   | "failed"
   | "built"
@@ -173,8 +180,8 @@ export function bannerState({
     )
       return "updated";
   }
+  if (view.queued) return "queued";
   if (view.pending) return "pending";
-  if (view.canUpdate.code === "managed") return "hidden";
   if (
     view.available &&
     view.bannerEnabled &&
@@ -185,5 +192,8 @@ export function bannerState({
   return "hidden";
 }
 
+export const MANAGED_NOTE =
+  "Updates on this machine are deployed by autodeploy. Update now deploys it within a minute.";
+
 export const workingTotal = (w: UpdateView["working"]) =>
   w.sessions + w.reviews + w.setups;

package/lib/updates/request.ts

@@ -0,0 +1,29 @@
+// The "deploy now" request a click leaves for scripts/autodeploy, which owns
+// deploys on its machine: $AGENT_OS_HOME/autodeploy/now. The script skips the
+// restart gap and the settle wait for it and removes it once the deploy ran.
+
+import fs from "fs";
+import path from "path";
+
+/** autodeploy ignores a request older than this (its find -mmin +30). */
+export const REQUEST_FRESH_MS = 30 * 60_000;
+
+export function readDeployRequest(
+  file: string,
+  now: number
+): { requestedAt: number } | null {
+  try {
+    const at = Number(fs.readFileSync(file, "utf8").trim());
+    if (Number.isFinite(at) && now - at < REQUEST_FRESH_MS)
+      return { requestedAt: at };
+  } catch {}
+  return null;
+}
+
+/** Written to a temp name and renamed, so the script never sees half a file. */
+export function writeDeployRequest(file: string, now: number): void {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, `${now}\n`);
+  fs.renameSync(tmp, file);
+}

package/lib/updates/run.ts

@@ -15,6 +15,7 @@ import { git } from "@/lib/git-exec";
 import { buildId } from "@/lib/build";
 import { agentosHome } from "@/lib/agentos-home";
 import { dbPath } from "@/lib/db/path";
+import { readDeployRequest, writeDeployRequest } from "./request";
 import {
   isActivePhase,
   workingTotal,
@@ -87,6 +88,8 @@ export interface RunDeps {
   managed: () => boolean;
   /** True while scripts/autodeploy is deploying (its lock directory exists). */
   deployLocked: () => boolean;
+  /** The file an Update now click leaves for scripts/autodeploy. */
+  requestFile: string;
   /** What a restart would interrupt, as short labels; empty when nothing. */
   busy: () => Promise<string[]>;
   /** The database the runner backs up first, and where to. */
@@ -217,6 +220,7 @@ export function realRunDeps(): RunDeps {
       }
     },
     deployLocked: () => fs.existsSync(agentosHome("autodeploy", "lock")),
+    requestFile: agentosHome("autodeploy", "now"),
     busy: busyLabels,
     dbFile: path.resolve(dbPath()),
     backupDir: agentosHome("backups"),
@@ -358,12 +362,13 @@ export async function preflight(
       error:
         "AgentOS isn't running from a git checkout, so it can't update itself.",
     };
-  if (deps.managed() || deps.deployLocked())
+  if (deps.deployLocked())
     return {
-      code: "managed",
-      error:
-        "This machine is updated by its own deploy job, so updating from here would race it. It deploys new versions by itself.",
+      code: "deploying",
+      error: "A deploy is running on this machine now. Try again when it ends.",
     };
+  // autodeploy owns restarts, disk and the restart command on a machine it manages.
+  const managed = deps.managed();
   const run = readRun(deps);
   if (run && isActivePhase(run.phase))
     return {
@@ -404,6 +409,7 @@ export async function preflight(
     };
   if (!check.available)
     return { code: "up_to_date", error: "AgentOS is up to date." };
+  if (managed) return null;
   if (!(await deps.restartCommand()))
     return { code: "no_restart", error: NO_RESTART };
   const free = deps.freeBytes();
@@ -418,8 +424,12 @@ export async function preflight(
 
 // ── starting ─────────────────────────────────────────────────────────────
 
+export const QUEUED_MESSAGE =
+  "Queued for autodeploy. It will deploy within about a minute.";
+
 export type StartResult =
-  { ok: true; pending: boolean } | ({ ok: false } & Refusal);
+  | { ok: true; pending: boolean; queued?: boolean; message?: string }
+  | ({ ok: false } & Refusal);
 
 /** Takes the right to start, atomically, so two requests can't both run. */
 function claimStart(deps: Pick<RunDeps, "stateFile" | "now">): boolean {
@@ -484,6 +494,12 @@ async function begin(
   await discardGenerated(deps);
   const refused = await preflight(result, deps);
   if (refused) return { ok: false, ...refused };
+  // autodeploy deploys this checkout: starting a second updater would race
+  // it, so the click goes to it as a request instead.
+  if (deps.managed()) {
+    writeDeployRequest(deps.requestFile, deps.now());
+    return { ok: true, pending: false, queued: true, message: QUEUED_MESSAGE };
+  }
   if (when === "idle") {
     deps.putSetting(
       PENDING_KEY,
@@ -553,6 +569,9 @@ export function readPending(
   return null;
 }
 
+export const readQueued = (deps: Pick<RunDeps, "requestFile" | "now">) =>
+  readDeployRequest(deps.requestFile, deps.now());
+
 export const cancelPending = (
   deps: Pick<RunDeps, "putSetting"> = realRunDeps()
 ) => deps.putSetting(PENDING_KEY, null);

package/lib/updates/view.ts

@@ -8,6 +8,7 @@ import {
   preflight,
   readLog,
   readPending,
+  readQueued,
   readRun,
   realRunDeps,
   recordFinishedRun,
@@ -102,6 +103,8 @@ export async function updateView(
         : { ok: true },
     run,
     pending,
+    managed: deps.managed(),
+    queued: readQueued(deps),
     auto: await autoView(deps, check, refusal).then((auto) =>
       mayUpdate
         ? auto

package/package.json

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

package/scripts/autodeploy

@@ -9,7 +9,11 @@
 # Restarts are spaced AGENTOS_MIN_GAP seconds apart (an hour; 0 turns it
 # off): a head that lands inside the gap waits and is deployed, whatever it
 # has become by then, when the gap ends. A commit message with [deploy-now]
-# (in any commit the deploy would take) skips the gap. Each hold logs one line:
+# (in any commit the deploy would take) skips the gap, and so does the request
+# file $state/now, which the in-app Update now button writes
+# (lib/updates/run.ts requestDeploy): it also skips the settle wait, is removed
+# once the deploy ran or origin/main is already deployed, and is ignored when
+# older than 30 minutes. Each hold logs one line:
 #   HELD <sha> <seconds> left in the restart gap (since <last restart sha>)
 # Another machine (a server) runs it with AGENTOS_PUBLISH=0: deploy
 # only, and its own AGENTOS_RESTART. Only one machine publishes to npm.
@@ -54,12 +58,26 @@ done
 mkdir "$state/lock" 2>/dev/null || exit 0
 trap 'rmdir "$state/lock"' EXIT
 
+# An "Update now" click (lib/updates/run.ts requestDeploy) leaves this file.
+now_file="$state/now"
+want_now=0
+if [ -f "$now_file" ]; then
+  if [ -n "$(find "$now_file" -maxdepth 0 -mmin +30)" ]; then
+    rm -f "$now_file"
+  else
+    want_now=1
+  fi
+fi
+
 git fetch -q origin main
 head=$(git rev-parse origin/main)
 deployed=$(cat "$state/deployed" 2>/dev/null || true)
 published=$(cat "$state/published" 2>/dev/null || true)
 [ "${AGENTOS_PUBLISH:-1}" = 0 ] && published=$head
-[ "$head" = "$deployed" ] && [ "$head" = "$published" ] && exit 0
+if [ "$head" = "$deployed" ]; then
+  rm -f "$now_file"
+  [ "$head" = "$published" ] && exit 0
+fi
 log() { echo "$(date '+%Y-%m-%d %-I:%M %p') $*"; }
 
 # shellcheck source=lib/generated.sh
@@ -75,6 +93,7 @@ if [ "$head" != "$deployed" ] && [ -n "$deployed" ] &&
   git merge -q --ff-only "$head" 2>/dev/null; then
   deployed=$head
   git rev-parse HEAD > "$state/deployed"
+  rm -f "$now_file"
   [ "$head" = "$published" ] && exit 0
 fi
 
@@ -82,7 +101,7 @@ fi
 # minutes) waits for the next run, so a burst is one build and one restart.
 # Its commit time is the merge's, so this never holds a deploy forever.
 settle="${AGENTOS_SETTLE:-120}"
-if [ "$head" != "$deployed" ] && [ "$settle" -gt 0 ] &&
+if [ "$head" != "$deployed" ] && [ "$settle" -gt 0 ] && [ "$want_now" = 0 ] &&
   [ $(( $(date +%s) - $(git log -1 --format=%ct "$head") )) -lt "$settle" ]; then
   exit 0
 fi
@@ -98,6 +117,8 @@ if [ "$head" != "$deployed" ] && [ "$gap" -gt 0 ]; then
     msgs=$(git log --format=%B "${deployed:+$deployed..}$head" 2>/dev/null || git log -1 --format=%B "$head")
     if printf '%s' "$msgs" | grep -qF '[deploy-now]'; then
       log "Restart gap skipped for ${head:0:7}: [deploy-now]"
+    elif [ "$want_now" = 1 ]; then
+      log "Restart gap skipped for ${head:0:7}: update requested"
     else
       # Once per head, not once per minute, so the log counts holds.
       if [ "$(cat "$state/held" 2>/dev/null)" != "$head" ]; then
@@ -136,6 +157,7 @@ if [ "$head" != "$deployed" ]; then
   # The pull takes what landed while it waited, too.
   git rev-parse HEAD > "$state/deployed"
   date +%s > "$state/restarted"
+  rm -f "$now_file"
   # A link into an older clone would run an old aos on this machine.
   scripts/sync-cli-links || log "CLI link sync failed"
 fi

package/scripts/autodeploy.test.ts

@@ -143,6 +143,53 @@ describe("autodeploy restart gap", () => {
   });
 });
 
+describe("autodeploy update request", () => {
+  const request = (t: ReturnType<typeof setup>, ageMs = 0) => {
+    fs.mkdirSync(t.state, { recursive: true });
+    const file = path.join(t.state, "now");
+    fs.writeFileSync(file, `${Date.now()}\n`);
+    const at = new Date(Date.now() - ageMs);
+    fs.utimesSync(file, at, at);
+    return file;
+  };
+
+  it("skips the gap and the settle wait, then removes the request", () => {
+    const t = setup();
+    t.commit("a");
+    t.run();
+    const b = t.commit("b");
+    const file = request(t);
+    const out = t.run({ AGENTOS_SETTLE: "3600" });
+    expect(out).toMatch(
+      /Restart gap skipped for [0-9a-f]{7}: update requested/
+    );
+    expect(t.deployed()).toBe(b);
+    expect(t.restarts()).toBe(2);
+    expect(fs.existsSync(file)).toBe(false);
+  });
+
+  it("is removed straight away when origin/main is already deployed", () => {
+    const t = setup();
+    t.commit("a");
+    t.run();
+    const file = request(t);
+    expect(t.run()).toBe("");
+    expect(fs.existsSync(file)).toBe(false);
+    expect(t.restarts()).toBe(1);
+  });
+
+  it("ignores, and removes, a request older than 30 minutes", () => {
+    const t = setup();
+    t.commit("a");
+    t.run();
+    const b = t.commit("b");
+    const file = request(t, 31 * 60_000);
+    expect(t.run()).toMatch(/HELD/);
+    expect(t.deployed()).not.toBe(b);
+    expect(fs.existsSync(file)).toBe(false);
+  });
+});
+
 describe("autodeploy changelog commits", () => {
   const changelog = (t: ReturnType<typeof setup>, also?: string) => {
     const work = path.join(t.root, "work");