@saadnvd1/agent-os 0.3.792 → 0.3.799

package/lib/tips/schema.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+
+export const CONDITIONS = [
+  "no-paired-device",
+  "no-push-device",
+  "connect-not-linked",
+  "connect-linked",
+  "no-schedules",
+  "no-recipes",
+  "no-shares",
+  "no-groups",
+  "no-bookmarks",
+] as const;
+export type Condition = (typeof CONDITIONS)[number];
+
+const media = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("image"),
+    src: z.string().startsWith("/tips/"),
+    srcDark: z.string().startsWith("/tips/").optional(),
+    alt: z.string().min(1).max(200),
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+  }),
+  z.object({
+    kind: z.literal("video"),
+    src: z.string().startsWith("/tips/"),
+    poster: z.string().startsWith("/tips/"),
+    alt: z.string().min(1).max(200),
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+    durationMs: z.number().int().positive(),
+  }),
+]);
+export type Media = z.infer<typeof media>;
+
+const mediaBrief = z.object({
+  kind: z.enum(["screenshot", "crop", "clip"]),
+  shot: z.string().min(1).max(300),
+  theme: z.enum(["light", "dark", "both"]).optional(),
+});
+export type MediaBrief = z.infer<typeof mediaBrief>;
+
+export const tipSchema = z.object({
+  id: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
+  title: z.string().min(1).max(60),
+  body: z.string().min(1).max(240),
+  guide: z
+    .object({
+      file: z.string().regex(/^[a-z0-9-]+$/),
+      anchor: z.string().optional(),
+    })
+    .optional(),
+  when: z.array(z.enum(CONDITIONS)).optional(),
+  added: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  hidden: z.boolean().optional(),
+  media: media.optional(),
+  mediaBrief: mediaBrief.optional(),
+});
+export type Tip = z.infer<typeof tipSchema>;
+
+export const fileSchema = z.object({
+  v: z.literal(1),
+  tips: z.array(tipSchema),
+});
+
+/** What a client gets: the guide resolved to a link, the brief left out. */
+export interface ClientTip {
+  id: string;
+  title: string;
+  body: string;
+  url?: string;
+  media?: Media;
+}
+
+export interface TipsView {
+  off: boolean;
+  /** Setup isn't finished: the button works but shows no dot. */
+  quiet: boolean;
+  today: { id: string; read: boolean } | null;
+  deck: ClientTip[];
+}

package/lib/tips/state.ts

@@ -0,0 +1,26 @@
+import { getSetting, putSetting } from "@/lib/settings-store";
+import type { Pinned } from "./pick";
+
+const OFF = "tips.off";
+const SEEN = "tips.seen";
+const TODAY = "tips.today";
+
+function json<T>(key: string, fallback: T): T {
+  try {
+    const raw = getSetting(key);
+    return raw ? (JSON.parse(raw) as T) : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+export const tipsOff = (): boolean => getSetting(OFF) === "1";
+export const setTipsOff = (off: boolean) => putSetting(OFF, off ? "1" : null);
+
+/** Tip id -> the day it was last shown. */
+export const readSeen = () => json<Record<string, string>>(SEEN, {});
+export const writeSeen = (seen: Record<string, string>) =>
+  putSetting(SEEN, JSON.stringify(seen));
+
+export const readPinned = () => json<Pinned | null>(TODAY, null);
+export const writePinned = (p: Pinned) => putSetting(TODAY, JSON.stringify(p));

package/lib/tips/view.ts

@@ -0,0 +1,60 @@
+import { readCompletedAt } from "@/lib/welcome";
+import { tipApplies } from "./conditions";
+import { loadTips } from "./load";
+import { orderDeck, pickToday } from "./pick";
+import type { ClientTip, Tip, TipsView } from "./schema";
+import {
+  readPinned,
+  readSeen,
+  setTipsOff,
+  tipsOff,
+  writePinned,
+  writeSeen,
+} from "./state";
+
+const GUIDES = "https://github.com/saadnvd1/agent-os/blob/main/docs/guides";
+
+export const guideUrl = (g: NonNullable<Tip["guide"]>) =>
+  `${GUIDES}/${g.file}.md${g.anchor ? `#${g.anchor}` : ""}`;
+
+const forClient = ({ id, title, body, guide, media }: Tip): ClientTip => ({
+  id,
+  title,
+  body,
+  ...(guide && { url: guideUrl(guide) }),
+  ...(media && { media }),
+});
+
+export const todayLocal = () => new Date().toLocaleDateString("sv");
+
+/** The tips that apply now, and which one is today's. */
+export function tipsView(day: string = todayLocal()): TipsView {
+  const quiet = readCompletedAt() === null;
+  if (tipsOff()) return { off: true, quiet, today: null, deck: [] };
+  const deck = orderDeck(loadTips().filter((t) => tipApplies(t)));
+  const pinned = readPinned();
+  const today = pickToday({ deck, seen: readSeen(), pinned, day });
+  if (today && (today.id !== pinned?.id || today.day !== pinned?.day))
+    writePinned(today);
+  return {
+    off: false,
+    quiet,
+    today: today && { id: today.id, read: today.read },
+    deck: deck.map(forClient),
+  };
+}
+
+/** Records that these tips were shown; today's one becomes read. */
+export function markSeen(ids: string[], day: string = todayLocal()): void {
+  const known = new Set(loadTips().map((t) => t.id));
+  const seen = Object.fromEntries(
+    Object.entries(readSeen()).filter(([id]) => known.has(id))
+  );
+  for (const id of ids) if (known.has(id)) seen[id] = day;
+  writeSeen(seen);
+  const pinned = readPinned();
+  if (pinned && pinned.day === day && ids.includes(pinned.id) && !pinned.read)
+    writePinned({ ...pinned, read: true });
+}
+
+export { setTipsOff };

package/lib/updates/auto.ts

@@ -0,0 +1,149 @@
+// When an automatic update starts, as one pure decision so it can be tested
+// as a table. lib/updates/run.ts gathers the input and acts on the answer.
+//
+//   1. Switched off, pinned off, deployed by autodeploy, or refused (local
+//      changes, diverged, dev server, no restart command...) → skip, say why.
+//   2. The target is the newest commit on the remote's first-parent line
+//      that has been there `soakMs`, so a bad push can be reverted before an
+//      install takes it, and a busy day of merges can't hold it off. A
+//      commit that was rolled back, or failed to build recently, is passed
+//      over for an older one still newer than what's installed.
+//   3. Nothing a restart would interrupt is in flight (agents working, chat
+//      turns, reviews, task setups, simulator starts, merges, stack
+//      landings, an update or deploy), and has not been for `idleMs`.
+//   4. Once a release has waited `deadlineMs` past its soak, a lull of
+//      `lullMs` is enough. It never interrupts work; it keeps waiting.
+
+import type { UpdateAttempt } from "./banner";
+import { blockFor } from "./history";
+
+export interface Candidate {
+  sha: string;
+  /** Commit time, ms. */
+  at: number;
+}
+
+export interface AutoInput {
+  enabled: boolean;
+  locked: boolean;
+  managed: boolean;
+  refusal: string | null;
+  /** First-parent commits newer than the installed one, newest first. */
+  candidates: Candidate[];
+  attempts: UpdateAttempt[];
+  /** What is working now; empty when nothing is. */
+  busy: string[];
+  /** Since when nothing has been working, as far as anyone watched. */
+  quietSince: number | null;
+  now: number;
+  soakMs: number;
+  idleMs: number;
+  deadlineMs: number;
+  lullMs?: number;
+}
+
+export type AutoDecision =
+  | { action: "start"; to: string }
+  | { action: "wait"; code: AutoWait; text: string; to?: string }
+  | { action: "skip"; code: AutoSkip; text: string };
+
+export type AutoSkip = "off" | "locked" | "managed" | "refused" | "up_to_date";
+export type AutoWait = "soaking" | "blocked" | "busy" | "quiet";
+
+export const LULL_MS = 2 * 60_000;
+
+const short = (sha: string) => sha.slice(0, 7);
+const mins = (ms: number) => Math.max(1, Math.ceil(ms / 60_000));
+const plural = (n: number, word: string) => `${n} ${word}${n === 1 ? "" : "s"}`;
+
+/** The commit to update to, or why there's none yet. */
+export function pickTarget(
+  input: Pick<AutoInput, "candidates" | "attempts" | "now" | "soakMs">
+):
+  | { to: string; eligibleSince: number }
+  | {
+      to?: undefined;
+      code: "soaking" | "blocked";
+      text: string;
+      until?: number;
+    } {
+  const { candidates, attempts, now, soakMs } = input;
+  const soaked = candidates.filter((c) => c.at + soakMs <= now);
+  if (!soaked.length) {
+    const next = Math.min(...candidates.map((c) => c.at + soakMs));
+    return {
+      code: "soaking",
+      text: `A new version came out recently; it updates once it has been out ${plural(mins(soakMs), "minute")}.`,
+      until: next,
+    };
+  }
+  let first: string | null = null;
+  for (const c of soaked) {
+    const block = blockFor(c.sha, attempts, now);
+    if (!block)
+      return {
+        to: c.sha,
+        // The oldest waiting release says how long updates have been put off.
+        eligibleSince: soaked[soaked.length - 1].at + soakMs,
+      };
+    first ??= `${short(c.sha)}: ${block.reason}`;
+  }
+  return {
+    code: "blocked",
+    text: `Not updating to ${first}. Waiting for a newer version.`,
+  };
+}
+
+export function decideAutoUpdate(input: AutoInput): AutoDecision {
+  if (input.locked)
+    return {
+      action: "skip",
+      code: "locked",
+      text: "Automatic updates are turned off by AGENTOS_AUTO_UPDATE.",
+    };
+  if (!input.enabled)
+    return { action: "skip", code: "off", text: "Automatic updates are off." };
+  if (input.managed)
+    return {
+      action: "skip",
+      code: "managed",
+      text: "Updates on this machine are deployed by autodeploy.",
+    };
+  if (input.refusal)
+    return {
+      action: "skip",
+      code: "refused",
+      text: `Automatic updates are paused. ${input.refusal}`,
+    };
+  if (!input.candidates.length)
+    return {
+      action: "skip",
+      code: "up_to_date",
+      text: "AgentOS is up to date.",
+    };
+
+  const target = pickTarget(input);
+  if (!("eligibleSince" in target))
+    return { action: "wait", code: target.code, text: target.text };
+
+  if (input.busy.length)
+    return {
+      action: "wait",
+      code: "busy",
+      to: target.to,
+      text: `Updates when nothing is working (now: ${input.busy.join(", ")}).`,
+    };
+  const late = input.now - target.eligibleSince >= input.deadlineMs;
+  const need = late ? (input.lullMs ?? LULL_MS) : input.idleMs;
+  const quietFor = input.quietSince === null ? 0 : input.now - input.quietSince;
+  if (quietFor < need)
+    return {
+      action: "wait",
+      code: "quiet",
+      to: target.to,
+      text: late
+        ? "Has waited a long time for a quiet moment; updates at the next short lull."
+        : `Updates after everything has been idle for ${plural(mins(input.idleMs), "minute")} (${plural(mins(need - quietFor), "minute")} to go).`,
+    };
+  return { action: "start", to: target.to };
+}

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();
   };