@saadnvd1/agent-os 0.3.845 → 0.3.851

package/hooks/useSettingsUrl.ts

@@ -19,8 +19,7 @@ function fromAddress() {
  */
 export function useSettingsUrl() {
   useEffect(() => {
-    fromAddress();
-    const unsubscribe = subscribe(settingsUi, () => {
+    const toAddress = () => {
       const href = window.location.href;
       const next = hrefWithSettings(href, {
         open: settingsUi.open,
@@ -29,7 +28,11 @@ export function useSettingsUrl() {
       const url = new URL(href);
       if (next !== url.pathname + url.search + url.hash)
         window.history.replaceState(window.history.state, "", next);
-    });
+    };
+    fromAddress();
+    // An old link (?settings=setup) is rewritten to where it landed.
+    toAddress();
+    const unsubscribe = subscribe(settingsUi, toAddress);
     window.addEventListener("popstate", fromAddress);
     return () => {
       unsubscribe();

package/lib/approvals/describe.ts

@@ -0,0 +1,64 @@
+// What an auto-approval reads as to a person: a sentence, with the command
+// or other raw text behind a "details" toggle. The audit table keeps the raw
+// subject; this is only how it is shown.
+
+import type { AuditRow } from "./no-approvals";
+
+export interface ApprovalLine {
+  id: number;
+  at: string;
+  // The source in words ("an ask", "a chat").
+  where: string;
+  summary: string;
+  // Raw text (a shell command, a path) for the details toggle.
+  details: string | null;
+}
+
+const WHERE: Record<AuditRow["source"], string> = {
+  ask: "An ask",
+  brake: "A brake",
+  plan: "A plan",
+  chat: "A chat",
+  terminal: "A terminal",
+  "merge-approval": "A merge",
+  mode: "The mode",
+};
+
+const READ = new Set(["Read", "Glob", "Grep", "LS"]);
+const CHANGE = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+
+const SHELL_START = /^(bash|run|shell|execute|command)\b[:\s]/i;
+const SHELL_WORDS =
+  /(^|\s)(cd|ssh|scp|git|npm|npx|pnpm|rm|curl|sudo|cat|ls|sed|grep|kill|tmux|docker|kubectl|python3?|node)\s/;
+const SHELL_CHARS = /&&|\|\||[|;`]|\$\(|\s\/[\w.-]+\/|~\//;
+
+export const looksLikeCommand = (text: string) =>
+  SHELL_START.test(text) || SHELL_WORDS.test(text) || SHELL_CHARS.test(text);
+
+export function describeApproval(row: AuditRow): ApprovalLine {
+  const base = {
+    id: row.id,
+    at: row.at,
+    where: WHERE[row.source] ?? row.source,
+  };
+  const subject = row.subject.trim();
+  if (row.source === "terminal") {
+    const tool = subject.replace(/ in a terminal session$/, "");
+    const summary =
+      tool === "Bash"
+        ? "Ran a command"
+        : CHANGE.has(tool)
+          ? "Changed a file"
+          : READ.has(tool)
+            ? "Read files"
+            : `Used ${tool}`;
+    return { ...base, summary, details: null };
+  }
+  if (row.source === "chat" && looksLikeCommand(subject))
+    return {
+      ...base,
+      summary: "Ran a command",
+      details: subject.replace(SHELL_START, "").trim() || subject,
+    };
+  return { ...base, summary: subject, details: null };
+}

package/lib/health/config.ts

@@ -30,25 +30,78 @@ export const HEALTH_DEFAULTS = {
 export type HealthKey = keyof typeof HEALTH_DEFAULTS;
 export type HealthConfig = Record<HealthKey, number>;
 
-export const HEALTH_LABELS: Record<HealthKey, string> = {
-  loadRedMinutes: "Machine load red for (minutes)",
-  queueHeldMinutes: "Queued task held for (minutes)",
-  bgQuietMinutes: "Background job quiet for (minutes)",
-  portWaitMinutes: "Waiting on a port someone else holds for (minutes)",
-  pieceDupOverlap: "Plan piece matches merged work (0 to 1 overlap)",
-  restartsMax: "Server restarts allowed per window",
-  restartsWindowMinutes: "Restart window (minutes)",
-  ciSlowFallbackMinutes: "CI pending, when no history yet (minutes)",
-  armedStuckMinutes: "PR armed without merging for (minutes)",
-  serverErrorsMin: "Server errors per 10 minutes, at least",
-  serverErrorsFactor: "Server errors, times the usual rate",
-  envBurstSessions: "Environment failure: sessions in the window to alert",
-  envBurstHours: "Environment failure window (hours)",
-  envQuietDays: "Environment failure back after quiet for (days)",
-  wakeUsageCeilingPct: "Stop waking watchers above usage (%)",
-  watchersOn: "Watchers on (1) or off (0)",
+export interface HealthMeta {
+  label: string;
+  unit?: string;
+  min: number;
+  max?: number;
+  integer?: boolean;
+  // A 1/0 value shown as a switch.
+  switch?: boolean;
+}
+
+// How each threshold reads in Settings: the server owns it, so a new
+// threshold needs no client change.
+export const HEALTH_META: Record<HealthKey, HealthMeta> = {
+  loadRedMinutes: { label: "Machine load red for", unit: "min", min: 1 },
+  queueHeldMinutes: { label: "Queued task held for", unit: "min", min: 1 },
+  bgQuietMinutes: { label: "Background job quiet for", unit: "min", min: 1 },
+  portWaitMinutes: {
+    label: "Waiting on a port someone else holds for",
+    unit: "min",
+    min: 1,
+  },
+  pieceDupOverlap: {
+    label: "Plan piece matches merged work",
+    min: 0,
+    max: 1,
+    integer: false,
+  },
+  restartsMax: { label: "Server restarts allowed per window", min: 1 },
+  restartsWindowMinutes: { label: "Restart window", unit: "min", min: 1 },
+  ciSlowFallbackMinutes: {
+    label: "CI pending, when no history yet",
+    unit: "min",
+    min: 1,
+  },
+  armedStuckMinutes: {
+    label: "PR armed without merging for",
+    unit: "min",
+    min: 1,
+  },
+  serverErrorsMin: {
+    label: "Server errors per 10 minutes, at least",
+    min: 1,
+  },
+  serverErrorsFactor: {
+    label: "Server errors, times the usual rate",
+    unit: "×",
+    min: 1,
+    integer: false,
+  },
+  envBurstSessions: {
+    label: "Environment failure: sessions in the window to alert",
+    min: 1,
+  },
+  envBurstHours: { label: "Environment failure window", unit: "hours", min: 1 },
+  envQuietDays: {
+    label: "Environment failure back after quiet for",
+    unit: "days",
+    min: 1,
+  },
+  wakeUsageCeilingPct: {
+    label: "Stop waking watchers above usage",
+    unit: "%",
+    min: 1,
+    max: 100,
+  },
+  watchersOn: { label: "Watchers", min: 0, max: 1, switch: true },
 };
 
+export const HEALTH_LABELS = Object.fromEntries(
+  Object.entries(HEALTH_META).map(([k, m]) => [k, m.label])
+) as Record<HealthKey, string>;
+
 const settingKey = (k: HealthKey) => `health.${k}`;
 
 export function healthConfig(

package/lib/models/providers.ts

@@ -190,5 +190,5 @@ export function describeSecretRef(ref: SecretRef | undefined): string {
     return `tokenvault ${ref.project}${ref.desc ? ` "${ref.desc}"` : ""}`;
   if (ref.kind === "keychain")
     return `Keychain ${ref.service}${ref.account ? ` (${ref.account})` : ""}`;
-  return `$${ref.name}`;
+  return "an environment variable";
 }

package/lib/recipes/settle.ts

@@ -24,6 +24,8 @@ import {
 import { getRecipe, toRun } from "./store";
 import type { Recipe, RecipeRun, RunStatus } from "./types";
 
+// A live run with nothing running behind it for this long is given up on.
+export const LOST_RUN_MS = 24 * 60 * 60_000;
 // A session run that stops without a RESULT line settles from the model's
 // reading after it has been idle this long.
 export const IDLE_SETTLE_MS = 30 * 60_000;
@@ -379,6 +381,26 @@ async function settleOne(
       session,
       now
     );
+  // Nothing live behind it for a day (a terminal session, an archived one, a
+  // worker that's gone): it isn't still running, so it must not say so.
+  if (
+    Number.isFinite(startedMs) &&
+    now - startedMs > LOST_RUN_MS &&
+    state !== "running" &&
+    state !== "waiting"
+  )
+    return void finish(
+      run,
+      {
+        status: "failed",
+        result: line,
+        source: "state",
+        error: "Lost track of it",
+        summary: "Lost track of it",
+      },
+      session,
+      now
+    );
   const idle =
     state === "idle" || session.archived_at != null || state === null;
   if (idle && session.view === "chat") {

package/lib/settings-url.ts

@@ -5,6 +5,7 @@
 export const SETTINGS_PARAM = "settings";
 
 export const SETTINGS_SECTIONS = [
+  "general",
   "merging",
   "approvals",
   "workspaces",
@@ -18,13 +19,19 @@ export const SETTINGS_SECTIONS = [
   "schedules",
   "audits",
   "health",
-  "setup",
   "updates",
   "experiments",
 ] as const;
 
 export type SettingsSection = (typeof SETTINGS_SECTIONS)[number];
 
+// Sections that were folded into another: an old link still lands in the
+// right place.
+export const SECTION_REDIRECTS: Record<string, SettingsSection> = {
+  setup: "health",
+  "no-approvals": "approvals",
+};
+
 export interface SettingsLocation {
   open: boolean;
   // null: the list on a phone, the first section on a wider screen.
@@ -40,7 +47,12 @@ export const isSettingsSection = (v: unknown): v is SettingsSection =>
 export function settingsFromHref(href: string): SettingsLocation {
   const value = new URL(href, BASE).searchParams.get(SETTINGS_PARAM);
   if (value === null) return { open: false, section: null };
-  return { open: true, section: isSettingsSection(value) ? value : null };
+  const section = isSettingsSection(value)
+    ? value
+    : value !== null && Object.hasOwn(SECTION_REDIRECTS, value)
+      ? SECTION_REDIRECTS[value]
+      : null;
+  return { open: true, section };
 }
 
 /** The same address with Settings set (or removed), as path+query+hash. */

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.845",
+  "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");