@saadnvd1/agent-os 0.3.553 → 0.3.556

package/components/Updates/UpdateBanner.tsx

@@ -0,0 +1,212 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { ArrowUpCircle, ChevronDown, Loader2, X } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { useUpdates } from "@/data/updates";
+import { useDismissedUpdate } from "@/hooks/useDismissedUpdate";
+import { useReloadWhenUpdated } from "@/hooks/useReloadWhenUpdated";
+import {
+  bannerState,
+  type BannerState,
+  type UpdateView,
+} from "@/lib/updates/banner";
+import { cn } from "@/lib/utils";
+import { UpdateActions } from "./UpdateActions";
+
+const STEPS = ["pulling", "installing", "building", "restarting"] as const;
+const LABEL: Record<(typeof STEPS)[number], string> = {
+  pulling: "Pulling the new version",
+  installing: "Installing dependencies",
+  building: "Building",
+  restarting: "Restarting",
+};
+const SLOW_MS = 10 * 60_000;
+
+function useSince(startedAt: number | undefined, on: boolean) {
+  const [now, setNow] = useState(() => Date.now());
+  useEffect(() => {
+    if (!on) return;
+    const t = setInterval(() => setNow(Date.now()), 5000);
+    return () => clearInterval(t);
+  }, [on]);
+  return startedAt ? now - startedAt : 0;
+}
+
+function Log({ lines }: { lines: string[] }) {
+  const [open, setOpen] = useState(false);
+  if (!lines.length) return null;
+  return (
+    <>
+      <button
+        type="button"
+        className="text-muted-foreground hover:text-foreground min-h-11 text-xs underline md:min-h-0"
+        onClick={() => setOpen(!open)}
+      >
+        {open ? "Hide log" : "Show log"}
+      </button>
+      {open && (
+        <pre className="bg-background/60 mt-1 max-h-48 w-full overflow-auto rounded-md p-2 text-xs whitespace-pre-wrap">
+          {lines.join("\n")}
+        </pre>
+      )}
+    </>
+  );
+}
+
+/** The bar itself; what to show and what the buttons do come in as props. */
+export function UpdateBannerView({
+  state,
+  view,
+  onDismiss,
+}: {
+  state: Exclude<BannerState, "hidden">;
+  view: UpdateView;
+  onDismiss: () => void;
+}) {
+  const [notesOpen, setNotesOpen] = useState(false);
+  const run = view.run;
+  const elapsed = useSince(run?.startedAt, state === "running");
+  const latest = view.latest;
+  const failed = state === "failed";
+
+  let text: React.ReactNode;
+  if (state === "available") text = <>AgentOS {latest?.version} is available</>;
+  else if (state === "pending")
+    text = <>AgentOS will update when nothing is working</>;
+  else if (state === "built")
+    text = <>Built {run?.toVersion}. Restart AgentOS to finish updating.</>;
+  else if (failed) text = <>The update didn&apos;t finish. {run?.error}</>;
+  else {
+    const step = Math.max(
+      0,
+      STEPS.indexOf(run!.phase as (typeof STEPS)[number])
+    );
+    text =
+      elapsed > SLOW_MS ? (
+        <>Taking longer than expected. Check the update log, then reload.</>
+      ) : (
+        <>
+          {LABEL[STEPS[step]]}… step {step + 1} of {STEPS.length}
+        </>
+      );
+  }
+
+  const extra = (
+    <>
+      {state === "available" && !view.canUpdate.ok && view.canUpdate.reason && (
+        <p className="text-muted-foreground text-xs">{view.canUpdate.reason}</p>
+      )}
+      {failed && <Log lines={run?.log ?? []} />}
+      {notesOpen && latest && (
+        <ul className="text-muted-foreground list-disc space-y-0.5 pl-4 text-xs">
+          {latest.notes.map((n, i) => (
+            <li key={i}>{n}</li>
+          ))}
+        </ul>
+      )}
+    </>
+  );
+
+  return (
+    <div
+      role={failed ? "alert" : "status"}
+      className={cn(
+        "flex items-start gap-2 border-b px-3 py-2 text-sm",
+        failed ? "bg-destructive/10 text-foreground" : "bg-muted/60"
+      )}
+    >
+      <span className="flex h-6 shrink-0 items-center md:h-8">
+        {state === "running" ? (
+          <Loader2 className="text-muted-foreground h-4 w-4 animate-spin" />
+        ) : (
+          <ArrowUpCircle
+            className={cn(
+              "h-4 w-4",
+              failed ? "text-destructive" : "text-primary"
+            )}
+          />
+        )}
+      </span>
+      <div className="min-w-0 flex-1 space-y-1">
+        <div className="flex flex-wrap items-center gap-x-3 gap-y-1 md:min-h-8">
+          <p className="min-w-0 flex-1 basis-40">{text}</p>
+          {state === "available" && latest && latest.notes.length > 0 && (
+            <button
+              type="button"
+              aria-expanded={notesOpen}
+              className="text-muted-foreground hover:text-foreground inline-flex min-h-11 items-center gap-1 text-xs md:min-h-0"
+              onClick={() => setNotesOpen(!notesOpen)}
+            >
+              What&apos;s new
+              <ChevronDown
+                className={cn(
+                  "h-3 w-3 transition-transform",
+                  notesOpen && "rotate-180"
+                )}
+              />
+            </button>
+          )}
+          {state === "available" && latest?.url && (
+            <a
+              href={latest.url}
+              target="_blank"
+              rel="noreferrer noopener"
+              className="text-primary inline-flex min-h-11 items-center text-xs underline md:min-h-0"
+            >
+              Release notes
+            </a>
+          )}
+          {(state === "available" || state === "pending") && (
+            <UpdateActions view={view} />
+          )}
+          {state === "running" && elapsed > SLOW_MS && (
+            <Button size="sm" onClick={() => window.location.reload()}>
+              Reload
+            </Button>
+          )}
+        </div>
+        {extra}
+      </div>
+      {state !== "running" && state !== "pending" && (
+        <Button
+          variant="ghost"
+          size="icon-sm"
+          aria-label={
+            state === "available" ? "Dismiss until the next version" : "Dismiss"
+          }
+          className="-my-1 -mr-1 h-11 w-11 shrink-0 md:h-8 md:w-8"
+          onClick={onDismiss}
+        >
+          <X className="h-4 w-4" />
+        </Button>
+      )}
+    </div>
+  );
+}
+
+// Held apart: the page re-renders on every status push.
+export function UpdateBanner() {
+  const { data: view } = useUpdates();
+  const dismissed = useDismissedUpdate();
+  useReloadWhenUpdated(view);
+  const state = bannerState({
+    view,
+    dismissedVersion: dismissed.version,
+    dismissedRun: dismissed.run,
+  });
+  if (state === "hidden" || !view) return null;
+  return (
+    <UpdateBannerView
+      state={state}
+      view={view}
+      onDismiss={() =>
+        state === "available" && view.latest
+          ? dismissed.dismissVersion(view.latest.version)
+          : view.run
+            ? dismissed.dismissRun(view.run.id)
+            : undefined
+      }
+    />
+  );
+}

package/components/Updates/UpdatesSection.tsx

@@ -0,0 +1,150 @@
+"use client";
+
+import { toast } from "sonner";
+import { Loader2 } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { SettingToggle } from "@/components/Settings/SettingToggle";
+import {
+  useCheckForUpdates,
+  useUpdateBannerSetting,
+  useUpdates,
+} from "@/data/updates";
+import { isActivePhase } from "@/lib/updates/banner";
+import { UpdateActions } from "./UpdateActions";
+
+function ago(at: number | null): string {
+  if (!at) return "not yet";
+  const min = Math.floor((Date.now() - at) / 60_000);
+  if (min < 1) return "just now";
+  if (min < 60) return `${min} minute${min === 1 ? "" : "s"} ago`;
+  const h = Math.floor(min / 60);
+  return h < 48
+    ? `${h} hour${h === 1 ? "" : "s"} ago`
+    : `${Math.floor(h / 24)} days ago`;
+}
+
+function Row({ label, value }: { label: string; value: React.ReactNode }) {
+  return (
+    <div className="flex items-baseline justify-between gap-4 py-1.5 text-sm">
+      <dt className="text-muted-foreground">{label}</dt>
+      <dd className="min-w-0 text-right font-medium">{value}</dd>
+    </div>
+  );
+}
+
+// Settings > Updates: what's installed, what's out, and the switch for the banner.
+export function UpdatesSection() {
+  const { data: view, isLoading, error } = useUpdates();
+  const check = useCheckForUpdates();
+  const banner = useUpdateBannerSetting();
+
+  if (isLoading || !view)
+    return (
+      <p className="text-muted-foreground text-sm">
+        {error ? "Couldn't load update status." : "Loading…"}
+      </p>
+    );
+
+  const running = isActivePhase(view.run?.phase);
+  const onCheck = () =>
+    check.mutate(undefined, {
+      onError: (e) => {
+        // Asked again inside a minute: the answer on screen is fresh.
+        if ((e as { status?: number }).status !== 429) toast.error(e.message);
+      },
+    });
+
+  let summary = "AgentOS is up to date.";
+  if (view.status === "diverged")
+    summary =
+      "This checkout has commits the remote doesn't, so it can't update itself.";
+  else if (view.status === "unknown")
+    summary = view.checkError ?? "Updates haven't been checked yet.";
+  else if (view.available)
+    summary = `${view.latest?.version} is available (${view.behind} newer change${view.behind === 1 ? "" : "s"}).`;
+
+  return (
+    <div className="space-y-5">
+      <dl className="divide-border divide-y">
+        <Row
+          label="Installed"
+          value={
+            view.current ? (
+              <>
+                {view.current.version}{" "}
+                <span className="text-muted-foreground font-mono text-xs">
+                  {view.current.sha.slice(0, 7)}
+                </span>
+              </>
+            ) : (
+              "Unknown"
+            )
+          }
+        />
+        <Row label="Latest" value={view.latest?.version ?? "Unknown"} />
+        <Row label="Last checked" value={ago(view.checkedAt)} />
+      </dl>
+
+      <p className="text-sm" role="status">
+        {summary}
+      </p>
+      {view.checkError && view.status === "ok" && (
+        <p className="text-muted-foreground text-xs">
+          The last check failed: {view.checkError}
+        </p>
+      )}
+      {view.run?.phase === "failed" && (
+        <p className="text-destructive text-sm" role="alert">
+          The last update failed. {view.run.error}
+        </p>
+      )}
+      {running && (
+        <p className="text-muted-foreground flex items-center gap-2 text-sm">
+          <Loader2 className="h-4 w-4 animate-spin" /> Updating (
+          {view.run?.phase})…
+        </p>
+      )}
+      {view.available && !view.canUpdate.ok && view.canUpdate.reason && (
+        <p className="text-muted-foreground text-xs">{view.canUpdate.reason}</p>
+      )}
+      {view.pending && (
+        <p className="text-muted-foreground text-sm">
+          Will update when nothing is working.
+        </p>
+      )}
+
+      <div className="flex flex-wrap items-center gap-2">
+        <Button
+          variant="outline"
+          size="sm"
+          className="min-h-11 md:min-h-0"
+          disabled={check.isPending || running}
+          onClick={onCheck}
+        >
+          {check.isPending ? "Checking…" : "Check for updates"}
+        </Button>
+        {view.available && !running && <UpdateActions view={view} />}
+        {view.available && view.latest?.url && (
+          <a
+            href={view.latest.url}
+            target="_blank"
+            rel="noreferrer noopener"
+            className="text-primary text-sm underline"
+          >
+            Release notes
+          </a>
+        )}
+      </div>
+
+      <SettingToggle
+        title="Show update banner"
+        detail="Tell everyone using this AgentOS when a newer version is out. Nothing updates unless someone chooses to."
+        checked={view.bannerEnabled}
+        locked={view.bannerLocked}
+        onChange={(on) =>
+          banner.mutate(on, { onError: (e) => toast.error(e.message) })
+        }
+      />
+    </div>
+  );
+}

package/components/Updates/index.ts

@@ -0,0 +1,2 @@
+export { UpdateBanner } from "./UpdateBanner";
+export { UpdatesSection } from "./UpdatesSection";

package/components/views/DesktopView.tsx

@@ -2,6 +2,7 @@
 
 import { DesktopSidebar } from "./DesktopSidebar";
 import { DesktopAppActions, SidebarToggle } from "./DesktopAppActions";
+import { UpdateBanner } from "@/components/Updates";
 import { PaneLayout } from "@/components/PaneLayout";
 import { PaneBarSlotsProvider } from "@/components/Pane/PaneBarSlots";
 import type { ViewProps } from "./types";
@@ -53,6 +54,7 @@ export function DesktopView({
 
       {/* Main content */}
       <div className="flex min-w-0 flex-1 flex-col">
+        <UpdateBanner />
         {/* Pane Layout - full height */}
         <div className="min-h-0 flex-1">
           <PaneBarSlotsProvider

package/components/views/MobileView.tsx

@@ -4,6 +4,7 @@ import { SessionList } from "@/components/SessionList";
 import { SidebarFooter } from "@/components/SidebarFooter";
 import { PaneLayout } from "@/components/PaneLayout";
 import { SwipeSidebar } from "@/components/mobile/SwipeSidebar";
+import { UpdateBanner } from "@/components/Updates";
 import type { ViewProps } from "./types";
 import { QuickSwitcher, StartServerDialog } from "./lazy";
 import { fileOpenActions } from "@/stores/fileOpen";
@@ -29,6 +30,7 @@ export function MobileView({
 }: ViewProps) {
   return (
     <main className="app-backdrop h-app fixed inset-x-0 top-[var(--app-top,0px)] flex flex-col overflow-hidden pb-[env(safe-area-inset-bottom)]">
+      <UpdateBanner />
       {/* Swipe sidebar */}
       <SwipeSidebar isOpen={sidebarOpen} onClose={() => setSidebarOpen(false)}>
         <div className="flex h-full flex-col">

package/data/done/index.ts

@@ -17,12 +17,34 @@ async function json<T>(res: Response): Promise<T> {
   return data;
 }
 
-const post = (url: string, body?: object) =>
-  fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: body ? JSON.stringify(body) : undefined,
-  });
+// Longer than the server's own deadline for done (lib/done/deadline.ts), so
+// the pending toast always ends even if the server never answers.
+export const DONE_REQUEST_TIMEOUT_MS = 180_000;
+
+async function post(url: string, body?: object, timeoutMs?: number) {
+  const abort = new AbortController();
+  const timer = timeoutMs
+    ? setTimeout(
+        () =>
+          abort.abort(
+            new Error(
+              "The server didn't answer in time. It may still be working: check the row, then try again."
+            )
+          ),
+        timeoutMs
+      )
+    : undefined;
+  try {
+    return await fetch(url, {
+      signal: abort.signal,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+}
 
 function useDoneMutation<V, R>(fn: (v: V) => Promise<R>) {
   const queryClient = useQueryClient();
@@ -40,7 +62,11 @@ export function useDoneSession() {
     async (id: string) =>
       (
         await json<{ outcome: DoneOutcome }>(
-          await post(`/api/sessions/${id}/done`)
+          await post(
+            `/api/sessions/${id}/done`,
+            undefined,
+            DONE_REQUEST_TIMEOUT_MS
+          )
         )
       ).outcome
   );

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/done/deadline.ts

@@ -0,0 +1,45 @@
+// Done merges, stops the agent and cleans up; any step can stall on a lock or
+// a slow remote. A request must always end: past this it answers that it is
+// still going, rather than leaving the row on "Merging…".
+export const DONE_DEADLINE_MS = 150_000;
+
+export async function withinDeadline<T>(
+  work: Promise<T>,
+  name: string,
+  ms = DONE_DEADLINE_MS
+): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const late = new Promise<never>((_, reject) => {
+    timer = setTimeout(
+      () =>
+        reject(
+          new Error(
+            `Done on ${name} is taking longer than ${Math.round(ms / 1000)}s and is still running in the background. Check the row in a moment; if it hasn't moved, try Done again.`
+          )
+        ),
+      ms
+    );
+  });
+  // The work keeps going; its late failure must not be an unhandled rejection.
+  work.catch(() => {});
+  try {
+    return await Promise.race([work, late]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// Best-effort: waits for `work` up to `ms`, then carries on without it.
+export async function withTimeout(
+  work: Promise<unknown>,
+  ms: number
+): Promise<void> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  work.catch(() => {});
+  await Promise.race([
+    work,
+    new Promise((resolve) => {
+      timer = setTimeout(resolve, ms);
+    }),
+  ]).finally(() => clearTimeout(timer));
+}

package/lib/done/index.ts

@@ -22,6 +22,7 @@ import { archiveSession } from "./archive";
 import { settleSession } from "../sidebar/shelf-state";
 import { demoMode } from "../security/demo";
 import { planDone } from "./plan";
+import { withTimeout } from "./deadline";
 import { deleteMergedRemote } from "./remote";
 import { settleWorktree, type WorktreeFate } from "./worktree";
 import { sessionMergePolicy } from "../tasks/finish";
@@ -151,7 +152,9 @@ export async function doneSession(
   // A sign-off just before this (the orchestrator's sign_off, then done)
   // is still cleaning up in the background: read what it leaves.
   await mergeSettled(s.id);
-  await statusDetector.refreshCache();
+  // A quick change has no tmux session, and a listing that stalls (a slow
+  // ssh host, a loaded tmux) must not hold up a merge that doesn't read it.
+  if (!s.quick_of) await withTimeout(statusDetector.refreshCache(), 10_000);
   const plan = await planDone(s, opts.callerId);
   if (plan.action === "refuse") throw new Error(plan.reason);
   if (plan.action === "merge" && opts.noMerge)

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];