@saadnvd1/agent-os 0.3.552 → 0.3.555

package/data/updates/index.ts

@@ -0,0 +1,63 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { isActivePhase, type UpdateView } from "@/lib/updates/banner";
+
+export const updateKeys = { all: ["updates"] as const };
+
+async function send(
+  method: string,
+  url: string,
+  body?: object
+): Promise<UpdateView> {
+  const res = await fetch(url, {
+    method,
+    ...(body && {
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    }),
+  }).catch(() => {
+    throw new Error("Couldn't reach AgentOS. Try again.");
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok)
+    throw Object.assign(
+      new Error(data.error || `Request failed (${res.status})`),
+      { status: res.status }
+    );
+  return data;
+}
+
+// Polled quickly only while an update runs; the server looks for new
+// versions itself, so a half hour is plenty for the rest.
+export function useUpdates() {
+  return useQuery({
+    queryKey: updateKeys.all,
+    queryFn: () => send("GET", "/api/updates"),
+    staleTime: 5 * 60_000,
+    refetchInterval: (query) =>
+      isActivePhase(query.state.data?.run?.phase) ? 2000 : 30 * 60_000,
+  });
+}
+
+function useUpdateMutation<V>(fn: (v: V) => Promise<UpdateView>) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: fn,
+    onSuccess: (view) => queryClient.setQueryData(updateKeys.all, view),
+  });
+}
+
+export const useCheckForUpdates = () =>
+  useUpdateMutation<void>(() => send("POST", "/api/updates/check"));
+
+export const useRunUpdate = () =>
+  useUpdateMutation<"now" | "idle">((when) =>
+    send("POST", "/api/updates/run", { when })
+  );
+
+export const useCancelUpdate = () =>
+  useUpdateMutation<void>(() => send("DELETE", "/api/updates/run"));
+
+export const useUpdateBannerSetting = () =>
+  useUpdateMutation<boolean>((banner) =>
+    send("PUT", "/api/updates/settings", { banner })
+  );

package/hooks/useDismissedUpdate.ts

@@ -0,0 +1,56 @@
+"use client";
+
+import { useCallback, useSyncExternalStore } from "react";
+import { DISMISSED_RUN_KEY, DISMISSED_VERSION_KEY } from "@/lib/updates/banner";
+
+// What this browser has dismissed: the version whose banner was closed, and
+// the failed or built run whose notice was. In localStorage, so it holds
+// across reloads, and per browser because a tab with no device identity
+// can't be told apart server-side.
+const listeners = new Set<() => void>();
+
+function read(key: string): string | null {
+  try {
+    return localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+
+function subscribe(fn: () => void) {
+  listeners.add(fn);
+  window.addEventListener("storage", fn);
+  return () => {
+    listeners.delete(fn);
+    window.removeEventListener("storage", fn);
+  };
+}
+
+function write(key: string, value: string) {
+  try {
+    localStorage.setItem(key, value);
+  } catch {}
+  listeners.forEach((fn) => fn());
+}
+
+export function useDismissedUpdate() {
+  const version = useSyncExternalStore(
+    subscribe,
+    () => read(DISMISSED_VERSION_KEY),
+    () => null
+  );
+  const run = useSyncExternalStore(
+    subscribe,
+    () => read(DISMISSED_RUN_KEY),
+    () => null
+  );
+  const dismissVersion = useCallback(
+    (v: string) => write(DISMISSED_VERSION_KEY, v),
+    []
+  );
+  const dismissRun = useCallback(
+    (id: string) => write(DISMISSED_RUN_KEY, id),
+    []
+  );
+  return { version, run, dismissVersion, dismissRun };
+}

package/hooks/useReloadWhenUpdated.ts

@@ -0,0 +1,19 @@
+"use client";
+
+import { useEffect, useRef } from "react";
+import { isActivePhase, type UpdateView } from "@/lib/updates/banner";
+
+/**
+ * Reloads once the update this page watched run has finished and the server
+ * is back on the new build. A page that never saw it run doesn't reload.
+ */
+export function useReloadWhenUpdated(view: UpdateView | undefined) {
+  const watched = useRef<string | null>(null);
+  const run = view?.run;
+  useEffect(() => {
+    if (!run) return;
+    if (isActivePhase(run.phase)) watched.current = run.id;
+    else if (run.phase === "done" && watched.current === run.id)
+      window.location.reload();
+  }, [run]);
+}

package/lib/chat/quote.ts

@@ -9,6 +9,11 @@ export function quoteMarkdown(selection: string): string {
   return `${lines.map((l) => (l.trim() ? `> ${l}` : ">")).join("\n")}\n\n`;
 }
 
+// A whole message to quote: after whatever is already written.
+export function quoteInsert(text: string, at = Date.now()) {
+  return { text: quoteMarkdown(text), at, append: true };
+}
+
 // Markdown as editor paragraphs, one per line (the composer writes each
 // paragraph as a line), to put in at the caret.
 export function markdownParagraphs(

package/lib/settings-url.ts

@@ -15,6 +15,7 @@ export const SETTINGS_SECTIONS = [
   "schedules",
   "audits",
   "setup",
+  "updates",
 ] as const;
 
 export type SettingsSection = (typeof SETTINGS_SECTIONS)[number];

package/lib/updates/banner.ts

@@ -0,0 +1,114 @@
+// What the update banner shows, from what the server says and what this
+// device has dismissed. Pure, so a native client uses the same rules.
+
+export type UpdatePhase =
+  | "starting"
+  | "pulling"
+  | "installing"
+  | "building"
+  | "restarting"
+  | "done"
+  | "built"
+  | "failed";
+
+export const ACTIVE_PHASES: readonly UpdatePhase[] = [
+  "starting",
+  "pulling",
+  "installing",
+  "building",
+  "restarting",
+];
+
+export const isActivePhase = (p: UpdatePhase | undefined | null) =>
+  !!p && ACTIVE_PHASES.includes(p);
+
+export interface UpdateRun {
+  id: string;
+  phase: UpdatePhase;
+  from: string;
+  fromVersion: string;
+  toVersion: string;
+  startedAt: number;
+  finishedAt?: number;
+  error?: string;
+  log?: string[];
+}
+
+export type UpdateRefusal =
+  | "dev"
+  | "not_git"
+  | "running"
+  | "building"
+  | "dirty"
+  | "branch"
+  | "diverged"
+  | "up_to_date"
+  | "unknown"
+  | "forbidden";
+
+export interface UpdateView {
+  current: { version: string; sha: string } | null;
+  latest: {
+    version: string;
+    sha: string;
+    notes: string[];
+    url: string | null;
+  } | null;
+  available: boolean;
+  behind: number;
+  status: "ok" | "diverged" | "unknown";
+  checkedAt: number | null;
+  checkError: string | null;
+  bannerEnabled: boolean;
+  bannerLocked: boolean;
+  canUpdate: { ok: boolean; code?: UpdateRefusal; reason?: string };
+  run: UpdateRun | null;
+  pending: { requestedAt: number } | null;
+  working: { sessions: number; reviews: number; setups: number };
+}
+
+export type BannerState =
+  | "hidden"
+  | "available"
+  | "pending"
+  | "running"
+  | "failed"
+  | "built";
+
+export const DISMISSED_VERSION_KEY = "agentos.update.dismissed";
+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.
+ */
+export function bannerState({
+  view,
+  dismissedVersion,
+  dismissedRun,
+}: {
+  view: UpdateView | null | undefined;
+  dismissedVersion: string | null;
+  dismissedRun: string | null;
+}): 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 === "built") return "built";
+  }
+  if (view.pending) return "pending";
+  if (
+    view.available &&
+    view.bannerEnabled &&
+    view.latest &&
+    dismissedVersion !== view.latest.version
+  )
+    return "available";
+  return "hidden";
+}
+
+export const workingTotal = (w: UpdateView["working"]) =>
+  w.sessions + w.reviews + w.setups;

package/lib/updates/check.ts

@@ -0,0 +1,240 @@
+// Is a newer AgentOS out? Asked of the install's own remote: fetch the
+// default branch and compare, so there's no service to depend on and a fork
+// 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 { isNewer, versionFor } from "./version";
+
+export const CHECK_EVERY_MS = 6 * 60 * 60_000;
+export const FORCE_FLOOR_MS = 60_000;
+const FIRST_CHECK_MS = 2 * 60_000;
+const NOTES_MAX = 8;
+const CACHE_KEY = "updates.check";
+
+export interface CheckResult {
+  status: "ok" | "diverged" | "unknown";
+  current: { version: string; sha: string } | null;
+  latest: {
+    version: string;
+    sha: string;
+    notes: string[];
+    url: string | null;
+  } | null;
+  behind: number;
+  available: boolean;
+  branch: string | null;
+  checkedAt: number;
+  error: string | null;
+}
+
+export interface CheckDeps {
+  git: (args: string[]) => Promise<string>;
+  now: () => number;
+  load: () => CheckResult | null;
+  save: (result: CheckResult) => void;
+}
+
+export const realDeps = (cwd = process.cwd()): CheckDeps => ({
+  git: (args) => git(cwd, args, { timeout: Math.min(GIT_TIMEOUT_MS, 30_000) }),
+  now: Date.now,
+  load: () => {
+    try {
+      const raw = getSetting(CACHE_KEY);
+      return raw ? (JSON.parse(raw) as CheckResult) : null;
+    } catch {
+      return null;
+    }
+  },
+  save: (result) => putSetting(CACHE_KEY, JSON.stringify(result)),
+});
+
+/** A browsable compare link for a GitHub remote, else null. Credentials are dropped. */
+export function compareUrl(
+  remote: string,
+  from: string,
+  to: string
+): string | null {
+  const m =
+    /^(?:https?:\/\/(?:[^/@]+@)?|git@|ssh:\/\/git@)github\.com[/:]([\w.-]+)\/([\w.-]+?)(?:\.git)?\/?$/.exec(
+      remote.trim()
+    );
+  return m
+    ? `https://github.com/${m[1]}/${m[2]}/compare/${from.slice(0, 12)}...${to.slice(0, 12)}`
+    : null;
+}
+
+const NO_REPO: Omit<CheckResult, "checkedAt"> = {
+  status: "unknown",
+  current: null,
+  latest: null,
+  behind: 0,
+  available: false,
+  branch: null,
+  error: null,
+};
+
+async function versionAt(
+  g: CheckDeps["git"],
+  ref: string
+): Promise<{ version: string; sha: string }> {
+  const [sha, count, pkg] = await Promise.all([
+    g(["rev-parse", ref]),
+    g(["rev-list", "--count", ref]),
+    g(["show", `${ref}:package.json`]),
+  ]);
+  const version = versionFor(
+    (JSON.parse(pkg) as { version?: string }).version ?? "",
+    Number(count.trim())
+  );
+  if (!version) throw new Error("package.json has no version");
+  return { version, sha: sha.trim() };
+}
+
+/** Fetches the default branch and compares it with HEAD. Throws when git can't say. */
+export async function compare(deps: CheckDeps): Promise<CheckResult> {
+  const g = deps.git;
+  const checkedAt = deps.now();
+  if ((await g(["rev-parse", "--is-shallow-repository"])).trim() === "true")
+    return {
+      ...NO_REPO,
+      checkedAt,
+      error: "This is a shallow clone, so versions can't be counted.",
+    };
+  const head = await g(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"])
+    .then((s) => s.trim().replace(/^origin\//, ""))
+    .catch(() => "main");
+  const branch =
+    /^[\w./-]+$/.test(head) && !head.startsWith("-") ? head : "main";
+  await g([
+    "fetch",
+    "-q",
+    "origin",
+    `+refs/heads/${branch}:refs/remotes/origin/${branch}`,
+  ]);
+  const remoteRef = `refs/remotes/origin/${branch}`;
+  const [current, latest, remote] = await Promise.all([
+    versionAt(g, "HEAD"),
+    versionAt(g, remoteRef),
+    g(["remote", "get-url", "origin"]).catch(() => ""),
+  ]);
+  const behind = Number(
+    (await g(["rev-list", "--count", `HEAD..${remoteRef}`])).trim()
+  );
+  const fastForward = await g([
+    "merge-base",
+    "--is-ancestor",
+    "HEAD",
+    remoteRef,
+  ]).then(
+    () => true,
+    () => false
+  );
+  const notes =
+    behind > 0 && fastForward
+      ? (
+          await g([
+            "log",
+            "--first-parent",
+            "--format=%s",
+            `-n${NOTES_MAX}`,
+            `HEAD..${remoteRef}`,
+          ])
+        )
+          .split("\n")
+          .map((s) => s.trim())
+          .filter(Boolean)
+      : [];
+  const status = behind > 0 && !fastForward ? "diverged" : "ok";
+  return {
+    status,
+    current,
+    latest: {
+      ...latest,
+      notes,
+      url: compareUrl(remote, current.sha, latest.sha),
+    },
+    behind,
+    available:
+      status === "ok" && behind > 0 && isNewer(latest.version, current.version),
+    branch,
+    checkedAt,
+    error: null,
+  };
+}
+
+let memo: CheckResult | null = null;
+let inflight: Promise<CheckResult> | null = null;
+
+export const resetCheckCache = () => {
+  memo = null;
+  inflight = null;
+};
+
+export function cachedCheck(deps: CheckDeps = realDeps()): CheckResult | null {
+  return (memo ??= deps.load());
+}
+
+/**
+ * The cached answer, or a fresh one when it's older than six hours. `force`
+ * asks now, at most once a minute (`throttled`: the seconds left); `always`
+ * skips that floor, for a check owed after an update. A failed
+ * fetch keeps the last good answer and notes the error.
+ */
+export async function checkForUpdate(
+  { force = false, always = false }: { force?: boolean; always?: boolean } = {},
+  deps: CheckDeps = realDeps()
+): Promise<{ result: CheckResult; throttled?: number }> {
+  const last = cachedCheck(deps);
+  const age = last ? deps.now() - last.checkedAt : Infinity;
+  if (last && force && !always && age < FORCE_FLOOR_MS)
+    return {
+      result: last,
+      throttled: Math.ceil((FORCE_FLOOR_MS - age) / 1000),
+    };
+  if (last && !force && age < CHECK_EVERY_MS) return { result: last };
+  inflight ??= compare(deps)
+    .catch((error: unknown): CheckResult => {
+      const message = error instanceof Error ? error.message : String(error);
+      return last
+        ? { ...last, error: message }
+        : { ...NO_REPO, checkedAt: deps.now(), error: message };
+    })
+    .then((result) => {
+      memo = result;
+      deps.save(result);
+      return result;
+    })
+    .finally(() => {
+      inflight = null;
+    });
+  return { result: await inflight };
+}
+
+/** Dev servers and tests don't check unless asked; AGENTOS_UPDATE_CHECK=off pins it off. */
+export function updateChecksEnabled(
+  env: Record<string, string | undefined> = process.env
+): boolean {
+  if (env.AGENTOS_UPDATE_CHECK === "off") return false;
+  if (env.AGENTOS_UPDATE_CHECK === "on") return true;
+  return env.AGENTOS_DEV !== "1" && env.NODE_ENV === "production";
+}
+
+const g = globalThis as unknown as { __agentosUpdateChecks?: NodeJS.Timeout };
+
+/** First check two minutes after boot, then every six hours (jittered). */
+export function startUpdateChecks(): void {
+  if (g.__agentosUpdateChecks) return;
+  const schedule = (delay: number): void => {
+    g.__agentosUpdateChecks = setTimeout(async () => {
+      try {
+        if (bannerEnabled()) await checkForUpdate();
+      } catch (error) {
+        console.error("Checking for updates failed:", error);
+      }
+      schedule(CHECK_EVERY_MS + Math.floor(Math.random() * 10 * 60_000));
+    }, delay);
+    g.__agentosUpdateChecks.unref();
+  };
+  schedule(FIRST_CHECK_MS);
+}