@saadnvd1/agent-os 0.3.794 → 0.3.799

package/lib/updates/banner.ts

@@ -3,22 +3,33 @@
 
 export type UpdatePhase =
   | "starting"
+  | "backing_up"
   | "pulling"
   | "installing"
   | "building"
   | "restarting"
+  | "verifying"
+  | "rolling_back"
   | "done"
   | "built"
+  | "rolled_back"
   | "failed";
 
 export const ACTIVE_PHASES: readonly UpdatePhase[] = [
   "starting",
+  "backing_up",
   "pulling",
   "installing",
   "building",
   "restarting",
+  "verifying",
+  "rolling_back",
 ];
 
+/** How a finished run ended; written by scripts/update-run.mjs. */
+export type UpdateOutcome =
+  "done" | "build_failed" | "rolled_back" | "broken" | "interrupted";
+
 export const isActivePhase = (p: UpdatePhase | undefined | null) =>
   !!p && ACTIVE_PHASES.includes(p);
 
@@ -32,6 +43,44 @@ export interface UpdateRun {
   finishedAt?: number;
   error?: string;
   log?: string[];
+  /** Started by automatic updates, not by someone. */
+  auto?: boolean;
+  /** The commit it updates to. */
+  to?: string;
+  outcome?: UpdateOutcome;
+  /** How far redeploy got: pulled, deps_swapped, build_swapped. */
+  stage?: string;
+  /** The runner's heartbeat and pid, so a cut-off run is told from a slow one. */
+  updatedAt?: number;
+  pid?: number;
+}
+
+/** One finished update, kept in the history Settings shows. */
+export interface UpdateAttempt {
+  id: string;
+  from: string;
+  to: string;
+  fromVersion: string;
+  toVersion: string;
+  auto: boolean;
+  startedAt: number;
+  finishedAt: number;
+  outcome: UpdateOutcome;
+  error?: string;
+}
+
+/** The idle times Settings offers for automatic updates. */
+export const IDLE_MINUTES = [5, 10, 15, 30, 60] as const;
+
+/** What automatic updates are doing, for Settings. */
+export interface AutoUpdateView {
+  enabled: boolean;
+  locked: boolean;
+  managed: boolean;
+  idleMinutes: number;
+  idleLocked: boolean;
+  status: { code: string; text: string } | null;
+  attempts: UpdateAttempt[];
 }
 
 export type UpdateRefusal =
@@ -45,6 +94,7 @@ export type UpdateRefusal =
   | "up_to_date"
   | "unknown"
   | "no_restart"
+  | "disk"
   | "forbidden";
 
 export interface UpdateView {
@@ -68,10 +118,18 @@ export interface UpdateView {
   run: UpdateRun | null;
   pending: { requestedAt: number } | null;
   working: { sessions: number; reviews: number; setups: number };
+  auto?: AutoUpdateView;
 }
 
 export type BannerState =
-  "hidden" | "available" | "pending" | "running" | "failed" | "built";
+  | "hidden"
+  | "available"
+  | "pending"
+  | "running"
+  | "failed"
+  | "built"
+  | "updated"
+  | "rolled_back";
 
 export const DISMISSED_VERSION_KEY = "agentos.update.dismissed";
 export const DISMISSED_RUN_KEY = "agentos.update.dismissedRun";
@@ -79,23 +137,40 @@ export const DISMISSED_RUN_KEY = "agentos.update.dismissedRun";
 /**
  * A result of something the person started (running, failed, built) always
  * shows until its run is dismissed; "available" is the one that can be
- * switched off or dismissed, and only for the version dismissed.
+ * switched off or dismissed, and only for the version dismissed. An
+ * automatic update says it happened ("updated") or that it was rolled back;
+ * an automatic one that failed to build changed nothing, so only Settings
+ * shows it, unless it left the server broken.
  */
+export const UPDATED_NOTE_MS = 3 * 24 * 60 * 60_000;
+
 export function bannerState({
   view,
   dismissedVersion,
   dismissedRun,
+  now = Date.now(),
 }: {
   view: UpdateView | null | undefined;
   dismissedVersion: string | null;
   dismissedRun: string | null;
+  now?: number;
 }): BannerState {
   if (!view) return "hidden";
   const run = view.run;
   if (isActivePhase(run?.phase)) return "running";
   if (run && dismissedRun !== run.id) {
-    if (run.phase === "failed") return "failed";
+    if (run.phase === "rolled_back") return "rolled_back";
+    if (run.phase === "failed" && (!run.auto || run.outcome === "broken"))
+      return "failed";
     if (run.phase === "built") return "built";
+    // A device that wasn't open for days doesn't need the news.
+    if (
+      run.phase === "done" &&
+      run.auto &&
+      view.bannerEnabled &&
+      now - (run.finishedAt ?? 0) < UPDATED_NOTE_MS
+    )
+      return "updated";
   }
   if (view.pending) return "pending";
   if (

package/lib/updates/check.ts

@@ -3,10 +3,14 @@
 // or mirror works too. The working tree is never touched.
 
 import { git, GIT_TIMEOUT_MS } from "@/lib/git-exec";
-import { getSetting, putSetting, bannerEnabled } from "./settings";
+import type { Candidate } from "./auto";
+import { autoEnabled, bannerEnabled, getSetting, putSetting } from "./settings";
 import { isNewer, versionFor } from "./version";
 
 export const CHECK_EVERY_MS = 6 * 60 * 60_000;
+/** With automatic updates on, a release is seen within about an hour. */
+export const AUTO_CHECK_EVERY_MS = 60 * 60_000;
+const CANDIDATES_MAX = 50;
 export const FORCE_FLOOR_MS = 60_000;
 const FIRST_CHECK_MS = 2 * 60_000;
 const NOTES_MAX = 8;
@@ -26,6 +30,8 @@ export interface CheckResult {
   branch: string | null;
   checkedAt: number;
   error: string | null;
+  /** First-parent commits between HEAD and the remote, newest first. */
+  candidates?: Candidate[];
 }
 
 export interface CheckDeps {
@@ -74,7 +80,7 @@ const NO_REPO: Omit<CheckResult, "checkedAt"> = {
   error: null,
 };
 
-async function versionAt(
+export async function versionAt(
   g: CheckDeps["git"],
   ref: string
 ): Promise<{ version: string; sha: string }> {
@@ -145,6 +151,22 @@ export async function compare(deps: CheckDeps): Promise<CheckResult> {
           .map((s) => s.trim())
           .filter(Boolean)
       : [];
+  const candidates =
+    behind > 0 && fastForward
+      ? (
+          await g([
+            "log",
+            "--first-parent",
+            "--format=%H %ct",
+            `-n${CANDIDATES_MAX}`,
+            `HEAD..${remoteRef}`,
+          ])
+        )
+          .split("\n")
+          .map((l) => l.trim().split(" "))
+          .filter(([sha, at]) => /^[0-9a-f]{40}$/.test(sha) && Number(at) > 0)
+          .map(([sha, at]) => ({ sha, at: Number(at) * 1000 }))
+      : [];
   const status = behind > 0 && !fastForward ? "diverged" : "ok";
   return {
     status,
@@ -160,6 +182,7 @@ export async function compare(deps: CheckDeps): Promise<CheckResult> {
     branch,
     checkedAt,
     error: null,
+    candidates,
   };
 }
 
@@ -188,13 +211,36 @@ export async function reconcile(
           available: false,
           behind: 0,
           current: { version: check.latest.version, sha: head },
+          candidates: [],
         }
-      : check;
+      : {
+          ...check,
+          // Commits the checkout already has aren't updates any more.
+          candidates: await keepNewer(check.candidates, deps),
+        };
   } catch {
     return check;
   }
 }
 
+async function keepNewer(
+  candidates: Candidate[] | undefined,
+  deps: Pick<CheckDeps, "git">
+): Promise<Candidate[]> {
+  const out: Candidate[] = [];
+  for (const c of candidates ?? []) {
+    const has = await deps
+      .git(["merge-base", "--is-ancestor", c.sha, "HEAD"])
+      .then(
+        () => true,
+        () => false
+      );
+    if (has) break;
+    out.push(c);
+  }
+  return out;
+}
+
 let memo: CheckResult | null = null;
 let inflight: Promise<CheckResult> | null = null;
 
@@ -214,7 +260,11 @@ export function cachedCheck(deps: CheckDeps = realDeps()): CheckResult | null {
  * fetch keeps the last good answer and notes the error.
  */
 export async function checkForUpdate(
-  { force = false, always = false }: { force?: boolean; always?: boolean } = {},
+  {
+    force = false,
+    always = false,
+    maxAge = CHECK_EVERY_MS,
+  }: { force?: boolean; always?: boolean; maxAge?: number } = {},
   deps: CheckDeps = realDeps()
 ): Promise<{ result: CheckResult; throttled?: number }> {
   const last = cachedCheck(deps);
@@ -224,7 +274,7 @@ export async function checkForUpdate(
       result: last,
       throttled: Math.ceil((FORCE_FLOOR_MS - age) / 1000),
     };
-  if (last && !force && age < CHECK_EVERY_MS) return { result: last };
+  if (last && !force && age < maxAge) return { result: last };
   inflight ??= compare(deps)
     .catch((error: unknown): CheckResult => {
       const message = error instanceof Error ? error.message : String(error);
@@ -254,17 +304,23 @@ export function updateChecksEnabled(
 
 const g = globalThis as unknown as { __agentosUpdateChecks?: NodeJS.Timeout };
 
-/** First check two minutes after boot, then every six hours (jittered). */
+/**
+ * First check two minutes after boot, then every six hours, or every hour
+ * with automatic updates on (jittered). Off when both the banner and
+ * automatic updates are.
+ */
 export function startUpdateChecks(): void {
   if (g.__agentosUpdateChecks) return;
   const schedule = (delay: number): void => {
     g.__agentosUpdateChecks = setTimeout(async () => {
+      const every = autoEnabled() ? AUTO_CHECK_EVERY_MS : CHECK_EVERY_MS;
       try {
-        if (bannerEnabled()) await checkForUpdate();
+        if (bannerEnabled() || autoEnabled())
+          await checkForUpdate({ maxAge: every - 5 * 60_000 });
       } catch (error) {
         console.error("Checking for updates failed:", error);
       }
-      schedule(CHECK_EVERY_MS + Math.floor(Math.random() * 10 * 60_000));
+      schedule(every + Math.floor(Math.random() * 10 * 60_000));
     }, delay);
     g.__agentosUpdateChecks.unref();
   };

package/lib/updates/history.ts

@@ -0,0 +1,99 @@
+// The finished updates, newest first, and what they say about trying a
+// version again. Pure apart from the two setting accessors passed in.
+
+import type { UpdateAttempt, UpdateRun } from "./banner";
+
+export const HISTORY_KEY = "updates.attempts";
+const KEEP = 20;
+/** A version that failed to build is tried again after these waits, then given up on. */
+export const RETRY_AFTER_MS = [60 * 60_000, 6 * 60 * 60_000] as const;
+
+type Get = (key: string) => string | null;
+type Put = (key: string, value: string | null) => void;
+
+export function readAttempts(get: Get): UpdateAttempt[] {
+  try {
+    const list = JSON.parse(get(HISTORY_KEY) ?? "[]") as UpdateAttempt[];
+    return Array.isArray(list) ? list : [];
+  } catch {
+    return [];
+  }
+}
+
+/** The attempt a finished run makes, or null while it runs or when it isn't one. */
+export function attemptOf(run: UpdateRun | null): UpdateAttempt | null {
+  if (!run?.outcome || !run.finishedAt || !run.to) return null;
+  return {
+    id: run.id,
+    from: run.from,
+    to: run.to,
+    fromVersion: run.fromVersion,
+    toVersion: run.toVersion,
+    auto: !!run.auto,
+    startedAt: run.startedAt,
+    finishedAt: run.finishedAt,
+    outcome: run.outcome,
+    ...(run.error ? { error: run.error } : {}),
+  };
+}
+
+/** Adds an attempt once (by id), newest first; true when it was new. */
+export function recordAttempt(
+  get: Get,
+  put: Put,
+  attempt: UpdateAttempt
+): boolean {
+  const list = readAttempts(get);
+  if (list.some((a) => a.id === attempt.id)) return false;
+  put(HISTORY_KEY, JSON.stringify([attempt, ...list].slice(0, KEEP)));
+  return true;
+}
+
+export type Block =
+  | { kind: "bad"; reason: string }
+  | { kind: "later"; until: number; reason: string };
+
+/**
+ * Why a commit shouldn't be tried now: it was rolled back or broke the
+ * server (never again), failed to build too often (never again), or failed
+ * recently (after a wait). Interrupted runs say nothing about the commit.
+ */
+export function blockFor(
+  sha: string,
+  attempts: UpdateAttempt[],
+  now: number
+): Block | null {
+  const mine = attempts.filter((a) => a.to === sha);
+  if (mine.some((a) => a.outcome === "rolled_back" || a.outcome === "broken"))
+    return {
+      kind: "bad",
+      reason: "it didn't start cleanly last time, so it won't be tried again",
+    };
+  // Only failures since it last worked count: a version can be updated to,
+  // rolled back by hand, and updated to again.
+  const fails: UpdateAttempt[] = [];
+  for (const a of mine) {
+    if (a.outcome === "done") break;
+    if (a.outcome === "build_failed") fails.push(a);
+  }
+  if (!fails.length) return null;
+  if (fails.length > RETRY_AFTER_MS.length)
+    return {
+      kind: "bad",
+      reason: `it failed to build ${fails.length} times, so it won't be tried again`,
+    };
+  const until = fails[0].finishedAt + RETRY_AFTER_MS[fails.length - 1];
+  return until > now
+    ? { kind: "later", until, reason: "it failed to build last time" }
+    : null;
+}
+
+/** Failed automatic attempts since the last update that worked (by anyone). */
+export function failedInARow(attempts: UpdateAttempt[]): number {
+  let n = 0;
+  for (const a of attempts) {
+    if (a.outcome === "done") break;
+    if (a.auto && a.outcome !== "interrupted") n++;
+  }
+  return n;
+}