@saadnvd1/agent-os 0.3.553 → 0.3.555

package/lib/updates/run.ts

@@ -0,0 +1,452 @@
+// Running an update, only when someone asks. The server does no more than
+// check the checkout and start scripts/update-run.mjs detached; that runs
+// scripts/redeploy (pull, install, build beside the live server, swap,
+// restart) and writes where it is to a state file, which the restart outlives.
+
+import { spawn, execFile } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { promisify } from "util";
+import { git } from "@/lib/git-exec";
+import { buildId } from "@/lib/build";
+import {
+  isActivePhase,
+  workingTotal,
+  type UpdateRefusal,
+  type UpdateRun,
+  type UpdateView,
+} from "./banner";
+import {
+  checkForUpdate,
+  realDeps as realCheckDeps,
+  type CheckDeps,
+  type CheckResult,
+} from "./check";
+import { getSetting, putSetting } from "./settings";
+
+const exec = promisify(execFile);
+
+export const STALE_RUN_MS = 30 * 60_000;
+export const PENDING_EXPIRES_MS = 24 * 60 * 60_000;
+export const IDLE_TICK_MS = 30_000;
+const PENDING_KEY = "updates.pending";
+const CLAIM_STALE_MS = 2 * 60_000;
+
+export interface RunDeps {
+  cwd: string;
+  env: Record<string, string | undefined>;
+  git: (args: string[]) => Promise<string>;
+  check: CheckDeps;
+  now: () => number;
+  stateFile: string;
+  logFile: string;
+  lockHeld: () => boolean;
+  restartCommand: () => Promise<string | null>;
+  spawnRunner: (env: NodeJS.ProcessEnv, logFile: string) => void;
+  buildId: () => string;
+  working: () => Promise<UpdateView["working"]>;
+  getSetting: (key: string) => string | null;
+  putSetting: (key: string, value: string | null) => void;
+}
+
+const shellQuote = (s: string) => `'${s.replace(/'/g, `'\\''`)}'`;
+
+async function parentOf(pid: number): Promise<number> {
+  const { stdout } = await exec("ps", ["-o", "ppid=", "-p", String(pid)], {
+    timeout: 2_000,
+  });
+  return Number(stdout.trim()) || 0;
+}
+
+/** True when this process was started by `agent-os start` from this checkout. */
+async function startedByCli(cwd: string, env: RunDeps["env"]) {
+  try {
+    const home = env.AGENT_OS_HOME || path.join(os.homedir(), ".agent-os");
+    if (fs.realpathSync(path.join(home, "repo")) !== fs.realpathSync(cwd))
+      return false;
+    const pid = Number(
+      fs.readFileSync(path.join(home, "agent-os.pid"), "utf8")
+    );
+    let p = process.pid;
+    for (let i = 0; i < 6 && p > 1; i++) {
+      if (p === pid) return true;
+      p = await parentOf(p);
+    }
+  } catch {}
+  return false;
+}
+
+/** AGENTOS_RESTART, else the CLI's restart when it started this server, else none. */
+export async function resolveRestart(
+  cwd: string,
+  env: RunDeps["env"],
+  cli: () => Promise<boolean> = () => startedByCli(cwd, env)
+): Promise<string | null> {
+  if (env.AGENTOS_RESTART) return env.AGENTOS_RESTART;
+  if (await cli())
+    return `${shellQuote(path.join(cwd, "scripts/agent-os"))} restart`;
+  return null;
+}
+
+function updateDir(env: RunDeps["env"], cwd: string) {
+  return env.DB_PATH ? path.dirname(path.resolve(env.DB_PATH)) : cwd;
+}
+
+export function realRunDeps(): RunDeps {
+  const cwd = process.cwd();
+  const env = process.env;
+  const dir = updateDir(env, cwd);
+  return {
+    cwd,
+    env,
+    git: (args) => git(cwd, args, { timeout: 30_000 }),
+    check: realCheckDeps(cwd),
+    now: Date.now,
+    stateFile: path.join(dir, "agent-os-update.json"),
+    logFile: path.join(dir, "agent-os-update.log"),
+    lockHeld: () => {
+      try {
+        return (
+          Date.now() - fs.statSync(path.join(cwd, ".next-build.lock")).mtimeMs <
+          STALE_RUN_MS
+        );
+      } catch {
+        return false;
+      }
+    },
+    restartCommand: () => resolveRestart(cwd, env),
+    spawnRunner: (runnerEnv, logFile) => {
+      const fd = fs.openSync(logFile, "w");
+      const child = spawn(
+        process.execPath,
+        [path.join(cwd, "scripts/update-run.mjs")],
+        {
+          cwd,
+          detached: true,
+          stdio: ["ignore", fd, fd],
+          env: runnerEnv,
+        }
+      );
+      child.on("error", () => {});
+      child.unref();
+      fs.closeSync(fd);
+    },
+    buildId,
+    working: workingSummary,
+    getSetting,
+    putSetting,
+  };
+}
+
+export async function workingSummary(): Promise<UpdateView["working"]> {
+  const { inFlight } = await import("@/lib/busy");
+  const { collectStatuses } = await import("@/lib/status/collect");
+  const { reviews, setups } = inFlight();
+  const { statuses } = await collectStatuses();
+  const sessions = Object.values(statuses).filter(
+    (s) => s.status === "running"
+  ).length;
+  return { sessions, reviews, setups };
+}
+
+// ── run state ────────────────────────────────────────────────────────────
+
+export function readRun(
+  deps: Pick<RunDeps, "stateFile" | "now">
+): UpdateRun | null {
+  try {
+    const run = JSON.parse(
+      fs.readFileSync(deps.stateFile, "utf8")
+    ) as UpdateRun;
+    if (!run?.id || !run.phase) return null;
+    // A run that stopped writing was cut off (the machine went down).
+    if (isActivePhase(run.phase) && deps.now() - run.startedAt > STALE_RUN_MS)
+      return {
+        ...run,
+        phase: "failed",
+        error: "The update stopped answering; see the update log.",
+      };
+    return run;
+  } catch {
+    return null;
+  }
+}
+
+export function writeRun(file: string, run: UpdateRun): void {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(run));
+  fs.renameSync(tmp, file);
+}
+
+export function readLog(deps: Pick<RunDeps, "logFile">, lines = 30): string[] {
+  try {
+    return fs
+      .readFileSync(deps.logFile, "utf8")
+      .trimEnd()
+      .split("\n")
+      .slice(-lines);
+  } catch {
+    return [];
+  }
+}
+
+// ── refusals ─────────────────────────────────────────────────────────────
+
+export type Refusal = { code: UpdateRefusal; error: string };
+
+/** Why this checkout can't be updated now; null when it can. No network. */
+export async function preflight(
+  check: CheckResult | null,
+  deps: RunDeps
+): Promise<Refusal | null> {
+  if (deps.env.AGENTOS_DEV === "1")
+    return {
+      code: "dev",
+      error: "This is a dev server; update its checkout with git.",
+    };
+  const inRepo = await deps.git(["rev-parse", "--git-dir"]).then(
+    () => true,
+    () => false
+  );
+  if (!inRepo)
+    return {
+      code: "not_git",
+      error:
+        "AgentOS isn't running from a git checkout, so it can't update itself.",
+    };
+  const run = readRun(deps);
+  if (run && isActivePhase(run.phase))
+    return {
+      code: "running",
+      error: `An update is already in progress (${run.phase}).`,
+    };
+  if (deps.lockHeld())
+    return {
+      code: "building",
+      error:
+        "Another update or deploy is building. Try again when it finishes.",
+    };
+  const dirty = (
+    await deps.git(["status", "--porcelain", "--untracked-files=no"])
+  )
+    .split("\n")
+    .map((l) => l.slice(3).trim())
+    .filter(Boolean);
+  if (dirty.length)
+    return {
+      code: "dirty",
+      error: `This checkout has local changes: ${dirty.slice(0, 5).join(", ")}${dirty.length > 5 ? ` and ${dirty.length - 5} more` : ""}. Commit or discard them, then update.`,
+    };
+  if (!check || check.status === "unknown")
+    return {
+      code: "unknown",
+      error: `Couldn't look for updates${check?.error ? `: ${check.error}` : "."}`,
+    };
+  const branch = (await deps.git(["branch", "--show-current"])).trim();
+  if (check.branch && branch !== check.branch)
+    return {
+      code: "branch",
+      error: `This checkout is on ${branch || "a detached HEAD"}, not ${check.branch}. Switch back to update.`,
+    };
+  if (check.status === "diverged")
+    return {
+      code: "diverged",
+      error:
+        "This checkout has commits the remote doesn't, so it can't fast-forward.",
+    };
+  if (!check.available)
+    return { code: "up_to_date", error: "AgentOS is up to date." };
+  return null;
+}
+
+// ── starting ─────────────────────────────────────────────────────────────
+
+export type StartResult =
+  | { ok: true; pending: boolean }
+  | ({ ok: false } & Refusal);
+
+/** Takes the right to start, atomically, so two requests can't both run. */
+function claimStart(deps: Pick<RunDeps, "stateFile" | "now">): boolean {
+  const file = `${deps.stateFile}.claim`;
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  for (let i = 0; i < 2; i++) {
+    try {
+      fs.closeSync(fs.openSync(file, "wx"));
+      return true;
+    } catch {
+      try {
+        if (Date.now() - fs.statSync(file).mtimeMs < CLAIM_STALE_MS)
+          return false;
+        fs.unlinkSync(file);
+      } catch {}
+    }
+  }
+  return false;
+}
+
+const releaseStart = (deps: Pick<RunDeps, "stateFile">) => {
+  try {
+    fs.unlinkSync(`${deps.stateFile}.claim`);
+  } catch {}
+};
+
+export async function startUpdate(
+  { when }: { when: "now" | "idle" },
+  deps: RunDeps = realRunDeps()
+): Promise<StartResult> {
+  if (!claimStart(deps))
+    return {
+      ok: false,
+      code: "running",
+      error: "An update is already starting.",
+    };
+  try {
+    return await begin(when, deps);
+  } finally {
+    releaseStart(deps);
+  }
+}
+
+async function begin(
+  when: "now" | "idle",
+  deps: RunDeps
+): Promise<StartResult> {
+  const { result } = await checkForUpdate({ force: true }, deps.check);
+  // A failed look can't vouch for the cached answer.
+  if (result.error)
+    return {
+      ok: false,
+      code: "unknown",
+      error: `Couldn't look for updates: ${result.error}`,
+    };
+  const refused = await preflight(result, deps);
+  if (refused) return { ok: false, ...refused };
+  if (when === "idle") {
+    deps.putSetting(
+      PENDING_KEY,
+      JSON.stringify({ requestedAt: deps.now(), from: result.current!.sha })
+    );
+    return { ok: true, pending: true };
+  }
+  deps.putSetting(PENDING_KEY, null);
+  const id = `${deps.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+  writeRun(deps.stateFile, {
+    id,
+    phase: "starting",
+    from: result.current!.sha,
+    fromVersion: result.current!.version,
+    toVersion: result.latest!.version,
+    startedAt: deps.now(),
+  });
+  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;
+  if (deps.env.PORT) env.PORT = deps.env.PORT;
+  deps.spawnRunner(env, deps.logFile);
+  return { ok: true, pending: false };
+}
+
+// ── update when idle ─────────────────────────────────────────────────────
+
+export function readPending(
+  deps: Pick<RunDeps, "getSetting" | "now" | "putSetting">
+): { requestedAt: number } | null {
+  const raw = deps.getSetting(PENDING_KEY);
+  if (!raw) return null;
+  try {
+    const p = JSON.parse(raw) as { requestedAt: number };
+    if (deps.now() - p.requestedAt < PENDING_EXPIRES_MS) return p;
+  } catch {}
+  deps.putSetting(PENDING_KEY, null);
+  return null;
+}
+
+export const cancelPending = (
+  deps: Pick<RunDeps, "putSetting"> = realRunDeps()
+) => deps.putSetting(PENDING_KEY, null);
+
+/**
+ * Starts a requested "update when idle" once nothing has been working for two
+ * checks in a row, so a gap between two turns doesn't count as quiet.
+ */
+export function createIdleWatcher(deps: RunDeps = realRunDeps()) {
+  let quiet = 0;
+  let busy = false;
+  const tick = async (): Promise<"none" | "waiting" | "started"> => {
+    if (!readPending(deps)) {
+      quiet = 0;
+      return "none";
+    }
+    const run = readRun(deps);
+    if (run && isActivePhase(run.phase)) return "waiting";
+    quiet = workingTotal(await deps.working()) === 0 ? quiet + 1 : 0;
+    if (quiet < 2) return "waiting";
+    quiet = 0;
+    const started = await startUpdate({ when: "now" }, deps);
+    if (!started.ok) {
+      // Don't retry a refused request every tick for a day.
+      deps.putSetting(PENDING_KEY, null);
+      writeRun(deps.stateFile, {
+        id: `idle${deps.now().toString(36)}`,
+        phase: "failed",
+        from: "",
+        fromVersion: "",
+        toVersion: "",
+        startedAt: deps.now(),
+        finishedAt: deps.now(),
+        error: started.error,
+      });
+    }
+    return "started";
+  };
+  return {
+    async tick() {
+      if (busy) return "waiting";
+      busy = true;
+      try {
+        return await tick();
+      } finally {
+        busy = false;
+      }
+    },
+  };
+}
+
+const g = globalThis as unknown as { __agentosIdleWatcher?: NodeJS.Timeout };
+
+export function startIdleWatcher(): void {
+  if (g.__agentosIdleWatcher) return;
+  const watcher = createIdleWatcher();
+  g.__agentosIdleWatcher = setInterval(() => {
+    watcher.tick().catch((error) => console.error("Update when idle:", error));
+  }, IDLE_TICK_MS);
+  g.__agentosIdleWatcher.unref();
+}
+
+// ── after a restart ──────────────────────────────────────────────────────
+
+/** A run that reached "restarting" is done if this server runs a newer build. */
+export function reconcileOnBoot(deps: RunDeps = realRunDeps()): void {
+  const run = readRun(deps);
+  if (!run || run.phase !== "restarting") return;
+  const moved = deps.buildId() !== run.from;
+  writeRun(deps.stateFile, {
+    ...run,
+    phase: moved ? "done" : "failed",
+    finishedAt: deps.now(),
+    ...(moved
+      ? {}
+      : {
+          error:
+            "The server restarted without the new build; see the update log.",
+          log: readLog(deps),
+        }),
+  });
+}

package/lib/updates/settings.ts

@@ -0,0 +1,38 @@
+import { getDb } from "@/lib/db";
+
+// Whether this server shows the update banner, and the checks behind it.
+// AGENTOS_UPDATE_BANNER=off pins it off, like the network settings.
+const KEY = "updates.banner";
+
+type Env = Record<string, string | undefined>;
+
+export const bannerLocked = (env: Env = process.env) =>
+  env.AGENTOS_UPDATE_BANNER === "off";
+
+export function bannerEnabled(env: Env = process.env): boolean {
+  if (bannerLocked(env)) return false;
+  return getSetting(KEY) !== "0";
+}
+
+export const setBannerEnabled = (on: boolean) =>
+  putSetting(KEY, on ? "1" : "0");
+
+export function getSetting(key: string): string | null {
+  const row = getDb()
+    .prepare(`SELECT value FROM settings WHERE key = ?`)
+    .get(key) as { value: string } | undefined;
+  return row?.value ?? null;
+}
+
+export function putSetting(key: string, value: string | null): void {
+  if (value === null) {
+    getDb().prepare(`DELETE FROM settings WHERE key = ?`).run(key);
+    return;
+  }
+  getDb()
+    .prepare(
+      `INSERT INTO settings (key, value) VALUES (?, ?)
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+    )
+    .run(key, value);
+}

package/lib/updates/version.ts

@@ -0,0 +1,30 @@
+// Versions as AgentOS publishes them: MAJOR.MINOR.<commits on the default
+// branch>. Pure, so a native client can use the same comparison.
+
+/** "1.2.3" or "v1.2.3" as numbers; null for anything else (a pre-release, text). */
+export function parseVersion(text: string): number[] | null {
+  const m = /^v?(\d+(?:\.\d+){0,3})$/.exec(text.trim());
+  return m ? m[1].split(".").map(Number) : null;
+}
+
+/** -1, 0 or 1; a missing segment is 0. Null when either side isn't a version. */
+export function compareVersions(a: string, b: string): -1 | 0 | 1 | null {
+  const x = parseVersion(a);
+  const y = parseVersion(b);
+  if (!x || !y) return null;
+  for (let i = 0; i < Math.max(x.length, y.length); i++) {
+    const d = (x[i] ?? 0) - (y[i] ?? 0);
+    if (d) return d < 0 ? -1 : 1;
+  }
+  return 0;
+}
+
+export const isNewer = (latest: string, current: string): boolean =>
+  compareVersions(latest, current) === 1;
+
+/** The version of a commit: package.json's "major.minor" and the commit count. */
+export function versionFor(packageVersion: string, commitCount: number) {
+  const parts = parseVersion(packageVersion);
+  if (!parts) return null;
+  return `${parts[0]}.${parts[1] ?? 0}.${commitCount}`;
+}

package/lib/updates/view.ts

@@ -0,0 +1,80 @@
+// The /api/updates payload: the cached check, the run, what's pending, and
+// whether the caller may start an update.
+
+import { isActivePhase, type UpdateView } from "./banner";
+import { cachedCheck, checkForUpdate } from "./check";
+import {
+  preflight,
+  readLog,
+  readPending,
+  readRun,
+  realRunDeps,
+  type RunDeps,
+} from "./run";
+import { bannerEnabled, bannerLocked } from "./settings";
+
+const NOT_ALLOWED =
+  "Update from the machine running AgentOS, over Tailscale, or from a device with Can approve.";
+
+const redact = (lines: string[]) =>
+  lines.map((l) =>
+    l
+      .replace(/(https?:\/\/)[^/@\s]+@/g, "$1***@")
+      .replace(/\b(gh[pousr]_|github_pat_|npm_|sk-)[\w-]{10,}/g, "***")
+      .replace(/\b[A-Za-z0-9_-]{32,}\b/g, "***")
+  );
+
+export async function updateView(
+  { mayUpdate }: { mayUpdate: boolean },
+  deps: RunDeps = realRunDeps()
+): Promise<UpdateView> {
+  const stored = readRun(deps);
+  let check = cachedCheck(deps.check);
+  // An answer from before the update that just finished says the new version
+  // is still available; ask again once.
+  if (
+    check &&
+    stored?.finishedAt &&
+    (stored.phase === "done" || stored.phase === "built") &&
+    check.checkedAt < stored.finishedAt
+  )
+    check = (await checkForUpdate({ force: true, always: true }, deps.check))
+      .result;
+  // The log can carry paths and remote URLs; only a device that may update sees it.
+  const run =
+    stored && (stored.phase === "failed" || stored.phase === "built")
+      ? {
+          ...stored,
+          log: mayUpdate
+            ? redact(stored.log?.length ? stored.log : readLog(deps))
+            : [],
+        }
+      : stored;
+  const pending = readPending(deps);
+  const active = isActivePhase(run?.phase);
+  const refusal = mayUpdate ? await preflight(check, deps) : null;
+  const wantsWorking = !active && !!(check?.available || pending);
+  return {
+    current: check?.current ?? null,
+    latest: check?.latest ?? null,
+    available: !!check?.available,
+    behind: check?.behind ?? 0,
+    status: check?.status ?? "unknown",
+    checkedAt: check?.checkedAt ?? null,
+    checkError: check?.error ?? null,
+    bannerEnabled: bannerEnabled(deps.env),
+    bannerLocked: bannerLocked(deps.env),
+    canUpdate: !mayUpdate
+      ? { ok: false, code: "forbidden", reason: NOT_ALLOWED }
+      : refusal
+        ? { ok: false, code: refusal.code, reason: refusal.error }
+        : { ok: true },
+    run,
+    pending,
+    working: wantsWorking
+      ? await deps
+          .working()
+          .catch(() => ({ sessions: 0, reviews: 0, setups: 0 }))
+      : { sessions: 0, reviews: 0, setups: 0 },
+  };
+}

package/package.json

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

package/scripts/redeploy

@@ -20,7 +20,9 @@ acquire_build_lock
 if [ "${1:-}" = "--rollback" ]; then
   rollback_build
 else
+  echo "::phase pulling"
   git pull --ff-only
+  echo "::phase installing"
   # The build needs dev dependencies even when the shell runs with
   # NODE_ENV=production (as sessions started by AgentOS do).
   npm install --include=dev --no-audit --no-fund
@@ -28,11 +30,13 @@ else
   # deploy never changes it, and a dirty lockfile would block the next pull.
   git checkout -- package-lock.json 2>/dev/null || true
   node scripts/ensure-native.mjs
+  echo "::phase building"
   build_beside
   swap_build
 fi
 
 if [ -n "${AGENTOS_RESTART:-}" ]; then
+  echo "::phase restarting"
   eval "$AGENTOS_RESTART"
   port="${PORT:-3011}"
   for _ in $(seq 1 40); do