@saadnvd1/agent-os 0.3.553 → 0.3.556

package/components/Chat/composer/insert.ts

@@ -0,0 +1,18 @@
+import type { Editor } from "@tiptap/core";
+import type { markdownParagraphs } from "@/lib/chat/quote";
+
+// Puts paragraphs in at the caret, or with `append` after everything already
+// written (on new lines), leaving the caret after them.
+export function insertMarkdown(
+  editor: Editor,
+  content: ReturnType<typeof markdownParagraphs>,
+  append = false
+) {
+  if (append && !editor.isEmpty) {
+    editor
+      .chain()
+      .insertContentAt(editor.state.doc.content.size, content)
+      .focus("end")
+      .run();
+  } else editor.chain().focus().insertContent(content).run();
+}

package/components/SessionList/useDoneAction.test.ts

@@ -0,0 +1,149 @@
+import "@/components/Chat/composer/test-dom";
+import { act, createElement, useEffect } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { Session } from "@/lib/db/types";
+
+const toast = vi.hoisted(() =>
+  Object.assign(vi.fn(), {
+    loading: vi.fn(() => "t1"),
+    success: vi.fn(),
+    error: vi.fn(),
+  })
+);
+vi.mock("sonner", () => ({ toast }));
+
+const { useDoneAction } = await import("./useDoneAction");
+
+(
+  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+let root: Root;
+let host: HTMLElement;
+const hook: { current: (s: Session) => void } = { current: () => {} };
+const confirmSpy = vi.fn(() => false);
+const fetchSpy = vi.fn();
+
+function Probe() {
+  const markDone = useDoneAction();
+  useEffect(() => {
+    hook.current = markDone;
+  });
+  return null;
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.stubGlobal("confirm", confirmSpy);
+  vi.stubGlobal("fetch", fetchSpy);
+  host = document.createElement("div");
+  document.body.append(host);
+  root = createRoot(host);
+  act(() =>
+    root.render(
+      createElement(
+        QueryClientProvider,
+        { client: new QueryClient() },
+        createElement(Probe)
+      )
+    )
+  );
+});
+afterEach(() => {
+  act(() => root.unmount());
+  host.remove();
+  vi.unstubAllGlobals();
+});
+
+const quick = {
+  id: "q1",
+  name: "Fix pair page menu label",
+  quick_of: "orch",
+  task_status: "running",
+  pr_status: "open",
+  pr_number: 281,
+} as Session;
+
+const respond = (status: number, body: object) =>
+  fetchSpy.mockResolvedValue({
+    ok: status < 400,
+    status,
+    json: async () => body,
+  });
+// Done on an open PR asks first, in a toast; Merge is its action.
+const confirmMerge = () => {
+  const [, opts] = toast.mock.calls.at(-1) as unknown as [
+    string,
+    { action: { onClick: () => void } },
+  ];
+  act(() => opts.action.onClick());
+};
+const settle = () => act(() => new Promise((r) => setTimeout(r, 0)));
+
+describe("Done from a row's menu", () => {
+  it("asks in the app, not with confirm(), and does nothing until Merge is chosen", async () => {
+    respond(200, {
+      outcome: {
+        id: "q1",
+        name: quick.name,
+        merged: "Merged.",
+        worktree: { action: "none" },
+        text: "Merged. Agent stopped, no worktree.",
+      },
+    });
+    act(() => hook.current(quick));
+    expect(fetchSpy).not.toHaveBeenCalled();
+    confirmMerge();
+    await settle();
+    expect(confirmSpy).not.toHaveBeenCalled();
+    expect(fetchSpy).toHaveBeenCalledWith(
+      "/api/sessions/q1/done",
+      expect.objectContaining({ method: "POST" })
+    );
+    expect(toast.success).toHaveBeenCalledWith(
+      "Merged. Agent stopped, no worktree.",
+      expect.objectContaining({ id: "t1" })
+    );
+  });
+
+  it("shows a refusal as a toast naming the gate, for a quick change and a task", async () => {
+    respond(409, {
+      error: "Not done, nothing merged.\n- ci failed: CI failed",
+    });
+    act(() => hook.current(quick));
+    confirmMerge();
+    await settle();
+    act(() => hook.current({ ...quick, id: "t2", quick_of: null } as Session));
+    confirmMerge();
+    await settle();
+    expect(fetchSpy).toHaveBeenCalledTimes(2);
+    expect(toast.error).toHaveBeenCalledTimes(2);
+    expect(toast.error).toHaveBeenCalledWith(
+      expect.stringContaining("ci failed"),
+      expect.objectContaining({ id: "t1" })
+    );
+  });
+
+  it("ends the Merging toast with an error when the server never answers", async () => {
+    vi.useFakeTimers();
+    fetchSpy.mockImplementation(
+      (_url: string, init: { signal?: AbortSignal }) =>
+        new Promise((_, reject) =>
+          init.signal?.addEventListener("abort", () =>
+            reject(init.signal?.reason)
+          )
+        )
+    );
+    act(() => hook.current(quick));
+    confirmMerge();
+    expect(toast.error).not.toHaveBeenCalled();
+    await act(() => vi.advanceTimersByTimeAsync(181_000));
+    vi.useRealTimers();
+    expect(toast.error).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({ id: "t1" })
+    );
+  });
+});

package/components/SessionList/useDoneAction.ts

@@ -7,21 +7,12 @@ import {
 } from "@/data/done";
 import { useSettleSession } from "@/data/sessions/shelf";
 
-// Done from a session's menu: an open PR merges through the gates, so that
-// one asks first; the rest can be undone from the toast.
+// Done from a session's menu: an open PR merges through the gates, after an
+// in-app confirmation; a failing gate comes back as an error toast naming it.
 export function useDoneAction() {
   const done = useDoneSession();
   const settle = useSettleSession();
-  return (session: Session) => {
-    const merges =
-      session.task_status === "running" && session.pr_status === "open";
-    if (
-      merges &&
-      !confirm(
-        `Merge ${session.name}'s PR through the gates and finish it? A failing gate refuses and nothing merges.`
-      )
-    )
-      return;
+  const run = (session: Session, merges: boolean) => {
     const id = toast.loading(
       merges ? `Merging ${session.name}…` : `Finishing ${session.name}…`
     );
@@ -45,6 +36,20 @@ export function useDoneAction() {
       onError: (e) => toast.error(e.message, { id, duration: 12000 }),
     });
   };
+  return (session: Session) => {
+    const merges =
+      session.task_status === "running" && session.pr_status === "open";
+    if (!merges) return run(session, false);
+    // Merging is the one Done that can't be undone: asked in the app, not
+    // with confirm(), which a webview drops.
+    toast(`Merge ${session.name}'s PR and finish it?`, {
+      description:
+        "It merges only through the orchestrator's gates; a failing gate refuses and nothing merges.",
+      duration: 15000,
+      action: { label: "Merge", onClick: () => run(session, true) },
+      cancel: { label: "Cancel", onClick: () => {} },
+    });
+  };
 }
 
 // Archive from a session's menu: puts it away; Unarchive brings it back.

package/components/Settings/SettingsDialog.test.ts

@@ -44,6 +44,9 @@ vi.mock("@/components/Schedules", () => ({
 vi.mock("@/components/Audits/AuditsPanel", () => ({
   AuditsPanel: stub("audits"),
 }));
+vi.mock("@/components/Updates/UpdatesSection", () => ({
+  UpdatesSection: stub("updates"),
+}));
 vi.mock("./NotificationsSection", () => ({
   NotificationsSection: stub("notifications"),
 }));

package/components/Settings/SettingsDialog.tsx

@@ -14,6 +14,7 @@ import {
   LayoutGrid,
   ListChecks,
   ShieldOff,
+  RefreshCw,
   Smartphone,
   X,
   type LucideIcon,
@@ -31,6 +32,7 @@ import { DevicesPanel } from "@/components/Devices";
 import { GlobalMergeSection } from "@/components/Merge/GlobalMergeSection";
 import { ModelsSection } from "@/components/Models/ModelsSection";
 import { SchedulesPanel } from "@/components/Schedules";
+import { UpdatesSection } from "@/components/Updates/UpdatesSection";
 import { WorkspaceSettings } from "@/components/Workspaces";
 import { useSettingsUrl } from "@/hooks/useSettingsUrl";
 import { SETTINGS_SECTIONS, type SettingsSection } from "@/lib/settings-url";
@@ -99,6 +101,11 @@ export const SECTION_INFO: Record<
     hint: "What this machine has, agents, first-run setup",
     icon: ListChecks,
   },
+  updates: {
+    label: "Updates",
+    hint: "Version, check for updates, the update banner",
+    icon: RefreshCw,
+  },
 };
 
 function SectionBody({
@@ -129,6 +136,8 @@ function SectionBody({
       return <AuditsPanel />;
     case "setup":
       return <SetupSection />;
+    case "updates":
+      return <UpdatesSection />;
   }
 }
 

package/components/Settings/commands.ts

@@ -5,6 +5,7 @@ import {
   Cpu,
   GitMerge,
   LayoutGrid,
+  RefreshCw,
   Settings,
   Smartphone,
 } from "lucide-react";
@@ -102,5 +103,13 @@ export function settingsCommands(workspaceId: string | null): PaletteCommand[] {
       icon: ClipboardList,
       run: () => settingsUiActions.open("audits"),
     },
+    {
+      id: "app.updates",
+      title: "Check for updates",
+      group,
+      keywords: ["update", "upgrade", "version", "new version", "banner"],
+      icon: RefreshCw,
+      run: () => settingsUiActions.open("updates"),
+    },
   ];
 }

package/components/Settings/entry-points.test.ts

@@ -27,6 +27,7 @@ describe("⌘K entry points", () => {
     ["app.phone-notifications", "notifications"],
     ["app.schedules", "schedules"],
     ["app.audits", "audits"],
+    ["app.updates", "updates"],
   ] as const)("%s opens Settings at %s", (id, section) => {
     run(id);
     expect(settingsUi.open).toBe(true);

package/components/Updates/UpdateActions.tsx

@@ -0,0 +1,93 @@
+"use client";
+
+import { useState } from "react";
+import { toast } from "sonner";
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { useCancelUpdate, useRunUpdate } from "@/data/updates";
+import { workingTotal, type UpdateView } from "@/lib/updates/banner";
+
+const plural = (n: number, word: string) => `${n} ${word}${n === 1 ? "" : "s"}`;
+
+const toastError = (e: unknown) =>
+  toast.error(e instanceof Error ? e.message : String(e));
+
+/** What a restart cuts, in words. */
+export function workingWarning(w: UpdateView["working"]): string {
+  const parts: string[] = [];
+  if (w.sessions) parts.push(`${plural(w.sessions, "session")} working`);
+  if (w.reviews) parts.push(`${plural(w.reviews, "review")} running`);
+  if (w.setups) parts.push(`${plural(w.setups, "task setup")} running`);
+  return parts.join(", ");
+}
+
+/**
+ * Update now, or Cancel for an update waiting for quiet. When something is
+ * working, Update now asks first and offers to wait.
+ */
+export function UpdateActions({ view }: { view: UpdateView }) {
+  const run = useRunUpdate();
+  const cancel = useCancelUpdate();
+  const [confirm, setConfirm] = useState(false);
+  const busy = workingTotal(view.working) > 0;
+
+  if (view.pending)
+    return (
+      <Button
+        size="sm"
+        className="min-h-11 md:min-h-0"
+        variant="outline"
+        disabled={cancel.isPending}
+        onClick={() => cancel.mutate(undefined, { onError: toastError })}
+      >
+        Cancel
+      </Button>
+    );
+  if (!view.canUpdate.ok) return null;
+
+  const start = (when: "now" | "idle") => {
+    setConfirm(false);
+    run.mutate(when, { onError: toastError });
+  };
+
+  return (
+    <>
+      <Button
+        size="sm"
+        className="min-h-11 md:min-h-0"
+        disabled={run.isPending}
+        onClick={() => (busy ? setConfirm(true) : start("now"))}
+      >
+        Update now
+      </Button>
+      <Dialog open={confirm} onOpenChange={setConfirm}>
+        <DialogContent className="max-w-md">
+          <DialogHeader>
+            <DialogTitle>Update while work is running?</DialogTitle>
+            <DialogDescription>
+              {workingWarning(view.working)}. Terminals and chats keep running
+              through the restart; reviews and task setups in progress start
+              over when AgentOS is back.
+            </DialogDescription>
+          </DialogHeader>
+          <DialogFooter className="gap-2 max-sm:flex-col-reverse">
+            <Button variant="ghost" onClick={() => setConfirm(false)}>
+              Cancel
+            </Button>
+            <Button variant="outline" onClick={() => start("now")}>
+              Update now
+            </Button>
+            <Button onClick={() => start("idle")}>Update when idle</Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </>
+  );
+}

package/components/Updates/UpdateBanner.test.ts

@@ -0,0 +1,198 @@
+import "@/components/Chat/composer/test-dom";
+import { act, createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { UpdateView } from "@/lib/updates/banner";
+
+// Radix dispatches its own events; they must be jsdom's, not Node's.
+for (const key of [
+  "Event",
+  "CustomEvent",
+  "FocusEvent",
+  "PopStateEvent",
+  "NodeFilter",
+  "HTMLButtonElement",
+])
+  Object.defineProperty(globalThis, key, {
+    value: (window as unknown as Record<string, unknown>)[key],
+    configurable: true,
+    writable: true,
+  });
+
+let view: UpdateView | undefined;
+const runMutate = vi.fn();
+const cancelMutate = vi.fn();
+vi.mock("@/data/updates", () => ({
+  useUpdates: () => ({ data: view }),
+  useRunUpdate: () => ({ mutate: runMutate, isPending: false }),
+  useCancelUpdate: () => ({ mutate: cancelMutate, isPending: false }),
+}));
+vi.mock("sonner", () => ({ toast: { error: vi.fn() } }));
+
+const { UpdateBanner } = await import("./UpdateBanner");
+
+(
+  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+const make = (over: Partial<UpdateView> = {}): UpdateView => ({
+  current: { version: "0.3.1", sha: "a" },
+  latest: {
+    version: "0.3.5",
+    sha: "b",
+    notes: ["Faster boot (#9)"],
+    url: "https://example.com/compare",
+  },
+  available: true,
+  behind: 4,
+  status: "ok",
+  checkedAt: 1,
+  checkError: null,
+  bannerEnabled: true,
+  bannerLocked: false,
+  canUpdate: { ok: true },
+  run: null,
+  pending: null,
+  working: { sessions: 0, reviews: 0, setups: 0 },
+  ...over,
+});
+
+let root: Root;
+let host: HTMLElement;
+const render = () => act(async () => root.render(createElement(UpdateBanner)));
+const text = () => document.body.textContent ?? "";
+const button = (label: string) =>
+  [...document.querySelectorAll<HTMLButtonElement>("button")].find(
+    (b) =>
+      b.textContent?.trim() === label || b.getAttribute("aria-label") === label
+  );
+
+beforeEach(() => {
+  localStorage.clear();
+  runMutate.mockReset();
+  cancelMutate.mockReset();
+  view = make();
+  host = document.createElement("div");
+  document.body.appendChild(host);
+  root = createRoot(host);
+});
+afterEach(async () => {
+  await act(async () => root.unmount());
+  host.remove();
+});
+
+describe("UpdateBanner", () => {
+  it("says which version is available, with a link to the notes", async () => {
+    await render();
+    expect(text()).toContain("AgentOS 0.3.5 is available");
+    expect(
+      document.querySelector<HTMLAnchorElement>("a")?.getAttribute("href")
+    ).toBe("https://example.com/compare");
+    await act(async () => button("What's new")!.click());
+    expect(text()).toContain("Faster boot (#9)");
+  });
+
+  it("Dismiss hides it for that version and survives a reload", async () => {
+    await render();
+    await act(async () => button("Dismiss until the next version")!.click());
+    expect(text()).not.toContain("is available");
+    expect(localStorage.getItem("agentos.update.dismissed")).toBe("0.3.5");
+
+    // A new page load reads the same dismissal.
+    await act(async () => root.unmount());
+    root = createRoot(host);
+    await render();
+    expect(text()).not.toContain("is available");
+  });
+
+  it("shows again for a newer version", async () => {
+    localStorage.setItem("agentos.update.dismissed", "0.3.5");
+    view = make({
+      latest: { version: "0.3.6", sha: "c", notes: [], url: null },
+    });
+    await render();
+    expect(text()).toContain("AgentOS 0.3.6 is available");
+  });
+
+  it("is absent when the banner is switched off or nothing is newer", async () => {
+    view = make({ bannerEnabled: false });
+    await render();
+    expect(text()).toBe("");
+    view = make({ available: false });
+    await render();
+    expect(text()).toBe("");
+  });
+
+  it("offers no Update button to a caller who can't update, and says why", async () => {
+    view = make({
+      canUpdate: {
+        ok: false,
+        code: "forbidden",
+        reason: "Ask a device that can approve.",
+      },
+    });
+    await render();
+    expect(button("Update now")).toBeUndefined();
+    expect(text()).toContain("Ask a device that can approve.");
+  });
+
+  it("Update now starts at once when nothing is working", async () => {
+    await render();
+    await act(async () => button("Update now")!.click());
+    expect(runMutate).toHaveBeenCalledWith("now", expect.anything());
+  });
+
+  it("warns when work is running, and can wait for idle", async () => {
+    view = make({ working: { sessions: 3, reviews: 0, setups: 0 } });
+    await render();
+    await act(async () => button("Update now")!.click());
+    expect(runMutate).not.toHaveBeenCalled();
+    expect(text()).toContain("3 sessions working");
+    await act(async () => button("Update when idle")!.click());
+    expect(runMutate).toHaveBeenCalledWith("idle", expect.anything());
+  });
+
+  it("shows a pending update with Cancel", async () => {
+    view = make({ pending: { requestedAt: 1 } });
+    await render();
+    expect(text()).toContain("will update when nothing is working");
+    await act(async () => button("Cancel")!.click());
+    expect(cancelMutate).toHaveBeenCalled();
+  });
+
+  it("shows progress while updating, with no way to dismiss it", async () => {
+    view = make({
+      run: {
+        id: "r",
+        phase: "building",
+        from: "a",
+        fromVersion: "0.3.1",
+        toVersion: "0.3.5",
+        startedAt: Date.now(),
+      },
+    });
+    await render();
+    expect(text()).toContain("Building… step 3 of 4");
+    expect(button("Dismiss")).toBeUndefined();
+  });
+
+  it("shows a failure with its error until dismissed", async () => {
+    view = make({
+      available: false,
+      run: {
+        id: "r9",
+        phase: "failed",
+        from: "a",
+        fromVersion: "0.3.1",
+        toVersion: "0.3.5",
+        startedAt: 1,
+        error: "build exploded",
+      },
+    });
+    await render();
+    expect(text()).toContain("build exploded");
+    await act(async () => button("Dismiss")!.click());
+    expect(text()).toBe("");
+    expect(localStorage.getItem("agentos.update.dismissedRun")).toBe("r9");
+  });
+});