@saadnvd1/agent-os 0.3.794 → 0.3.799

package/app/api/busy/route.ts

@@ -1,5 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
-import { inFlight } from "@/lib/busy";
+import { inFlight, inFlightTotal } from "@/lib/busy";
 import { requireLocalTrust } from "@/lib/security/route-guard";
 
 // GET /api/busy - work a restart would cut off; scripts/redeploy waits
@@ -8,6 +8,6 @@ export async function GET(request: NextRequest) {
   const refused = requireLocalTrust(request);
   if (refused) return refused;
   const work = inFlight();
-  const busy = work.reviews + work.setups + work.simulatorStarts > 0;
+  const busy = inFlightTotal(work) > 0;
   return NextResponse.json({ ...work, busy });
 }

package/app/api/tips/route.test.ts

@@ -0,0 +1,56 @@
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it } from "vitest";
+import { putSetting } from "@/lib/settings-store";
+import { GET, POST } from "./route";
+
+beforeEach(() => {
+  for (const k of ["tips.off", "tips.seen", "tips.today"]) putSetting(k, null);
+});
+
+const get = (q = "?day=2026-11-01", headers: Record<string, string> = {}) =>
+  GET(new NextRequest(`http://localhost/api/tips${q}`, { headers }));
+const post = (body: unknown) =>
+  POST(
+    new NextRequest("http://localhost/api/tips", {
+      method: "POST",
+      body: JSON.stringify(body),
+    })
+  );
+
+describe("/api/tips", () => {
+  it("returns today's tip and the deck, and 304s on the same ETag", async () => {
+    const res = await get();
+    const body = await res.json();
+    expect(body.today.id).toEqual(expect.any(String));
+    expect(body.deck.length).toBeGreaterThan(10);
+    const again = await get("?day=2026-11-01", {
+      "if-none-match": res.headers.get("etag")!,
+    });
+    expect(again.status).toBe(304);
+  });
+
+  it("rejects a bad day and a bad body", async () => {
+    expect((await get("?day=tomorrow")).status).toBe(400);
+    expect((await post({ action: "dance" })).status).toBe(400);
+    expect((await post({ action: "seen", ids: ["a"], day: "x" })).status).toBe(
+      400
+    );
+  });
+
+  it("remembers a tip as read", async () => {
+    const { today } = await (await get()).json();
+    const after = await (
+      await post({ action: "seen", ids: [today.id], day: "2026-11-01" })
+    ).json();
+    expect(after.today).toEqual({ id: today.id, read: true });
+    expect((await (await get()).json()).today.read).toBe(true);
+  });
+
+  it("turns tips off and on", async () => {
+    const off = await (await post({ action: "off", off: true })).json();
+    expect(off).toMatchObject({ off: true, today: null, deck: [] });
+    expect((await (await get()).json()).off).toBe(true);
+    const on = await (await post({ action: "off", off: false })).json();
+    expect(on.off).toBe(false);
+  });
+});

package/app/api/tips/route.ts

@@ -0,0 +1,45 @@
+import { createHash } from "crypto";
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { markSeen, setTipsOff, tipsView } from "@/lib/tips";
+
+const day = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
+
+const post = z.discriminatedUnion("action", [
+  z.object({
+    action: z.literal("seen"),
+    ids: z.array(z.string().max(80)).max(100),
+    day,
+  }),
+  z.object({ action: z.literal("off"), off: z.boolean() }),
+]);
+
+// GET /api/tips?day=YYYY-MM-DD - today's tip and the deck that applies now.
+// `day` is the caller's local date, so the tip changes at their midnight.
+export async function GET(request: NextRequest) {
+  const parsed = day
+    .optional()
+    .safeParse(request.nextUrl.searchParams.get("day") ?? undefined);
+  if (!parsed.success)
+    return NextResponse.json({ error: "Bad day" }, { status: 400 });
+  const text = JSON.stringify(tipsView(parsed.data));
+  const etag = `"${createHash("sha1").update(text).digest("hex").slice(0, 16)}"`;
+  const headers = { ETag: etag, "Cache-Control": "private, no-cache" };
+  if (request.headers.get("if-none-match") === etag)
+    return new NextResponse(null, { status: 304, headers });
+  return new NextResponse(text, {
+    headers: { ...headers, "Content-Type": "application/json" },
+  });
+}
+
+// POST /api/tips - { action: "seen", ids, day } or { action: "off", off }.
+export async function POST(request: NextRequest) {
+  const body = post.safeParse(await request.json().catch(() => null));
+  if (!body.success)
+    return NextResponse.json({ error: "Bad request" }, { status: 400 });
+  if (body.data.action === "seen") markSeen(body.data.ids, body.data.day);
+  else setTipsOff(body.data.off);
+  return NextResponse.json(
+    tipsView(body.data.action === "seen" ? body.data.day : undefined)
+  );
+}

package/app/api/updates/health/route.ts

@@ -0,0 +1,22 @@
+import { NextResponse } from "next/server";
+import { buildId } from "@/lib/build";
+import { db } from "@/lib/db";
+import { migrationStatus } from "@/lib/db/migrations";
+
+const startedAt = new Date(Date.now() - process.uptime() * 1000).toISOString();
+
+// GET /api/updates/health - what scripts/update-run.mjs checks after an
+// update's restart: the build this server runs, whether every migration it
+// knows applied, and when it started (a change means it crashed and came back).
+export function GET() {
+  let migrations: { known: number; applied: number } | null = null;
+  try {
+    migrations = migrationStatus(db);
+  } catch {}
+  return NextResponse.json({
+    ok: !!migrations,
+    build: buildId(),
+    startedAt,
+    migrations,
+  });
+}

package/app/api/updates/route.test.ts

@@ -32,6 +32,7 @@ const root = await import("./route");
 const runRoute = await import("./run/route");
 const checkRoute = await import("./check/route");
 const settingsRoute = await import("./settings/route");
+const healthRoute = await import("./health/route");
 
 const req = (
   path: string,
@@ -65,6 +66,7 @@ beforeEach(() => {
   throttled = undefined;
   refreshed = null;
   delete process.env.AGENTOS_UPDATE_BANNER;
+  delete process.env.AGENTOS_AUTO_UPDATE;
   process.env.AGENTOS_DEV = "1";
   db.prepare(`DELETE FROM settings WHERE key LIKE 'updates.%'`).run();
 });
@@ -205,3 +207,54 @@ describe("PUT /api/updates/settings", () => {
     ).toBe(409);
   });
 });
+
+describe("automatic updates settings", () => {
+  it("are on by default, and turn off and back on, with an idle time", async () => {
+    const first = await (await root.GET(req("", "GET", loopback))).json();
+    expect(first.auto).toMatchObject({
+      enabled: true,
+      locked: false,
+      idleMinutes: 10,
+    });
+    let view = await (
+      await settingsRoute.PUT(
+        req("/settings", "PUT", loopback, { auto: false, idleMinutes: 30 })
+      )
+    ).json();
+    expect(view.auto).toMatchObject({ enabled: false, idleMinutes: 30 });
+    view = await (
+      await settingsRoute.PUT(req("/settings", "PUT", loopback, { auto: true }))
+    ).json();
+    expect(view.auto.enabled).toBe(true);
+  });
+
+  it("refuses an idle time it doesn't offer, and a pinned switch", async () => {
+    expect(
+      (
+        await settingsRoute.PUT(
+          req("/settings", "PUT", loopback, { idleMinutes: 7 })
+        )
+      ).status
+    ).toBe(400);
+    process.env.AGENTOS_AUTO_UPDATE = "off";
+    expect(
+      (
+        await settingsRoute.PUT(
+          req("/settings", "PUT", loopback, { auto: true })
+        )
+      ).status
+    ).toBe(409);
+    const view = await (await root.GET(req("", "GET", loopback))).json();
+    expect(view.auto).toMatchObject({ enabled: false, locked: true });
+  });
+});
+
+describe("GET /api/updates/health", () => {
+  it("says which build runs and that every migration applied", async () => {
+    const body = await healthRoute.GET().json();
+    expect(body.ok).toBe(true);
+    expect(body.build).toBeTruthy();
+    expect(body.migrations.known).toBeGreaterThan(0);
+    expect(body.migrations.applied).toBe(body.migrations.known);
+  });
+});

package/app/api/updates/settings/route.ts

@@ -1,25 +1,52 @@
 import { NextRequest, NextResponse } from "next/server";
 import { requireApprover } from "@/lib/security/approver";
-import { bannerLocked, setBannerEnabled } from "@/lib/updates/settings";
+import {
+  IDLE_MINUTES,
+  autoLocked,
+  bannerLocked,
+  idleMinutesLocked,
+  setAutoEnabled,
+  setBannerEnabled,
+  setIdleMinutes,
+} from "@/lib/updates/settings";
 import { updateView } from "@/lib/updates/view";
 
-// PUT /api/updates/settings {banner: boolean} - show the update banner or not.
+const conflict = (error: string) =>
+  NextResponse.json({ error }, { status: 409 });
+
+// PUT /api/updates/settings {banner?, auto?, idleMinutes?} - show the update
+// banner, install updates automatically, and how long everything must be
+// idle first.
 export async function PUT(request: NextRequest) {
   const allowed = requireApprover(request);
   if (!allowed.ok) return allowed.response;
   const body = (await request.json().catch(() => null)) as {
     banner?: unknown;
+    auto?: unknown;
+    idleMinutes?: unknown;
   } | null;
-  if (typeof body?.banner !== "boolean")
+  const { banner, auto, idleMinutes } = body ?? {};
+  if (
+    (banner === undefined && auto === undefined && idleMinutes === undefined) ||
+    (banner !== undefined && typeof banner !== "boolean") ||
+    (auto !== undefined && typeof auto !== "boolean") ||
+    (idleMinutes !== undefined &&
+      !(IDLE_MINUTES as readonly unknown[]).includes(idleMinutes))
+  )
     return NextResponse.json(
-      { error: "banner must be true or false." },
+      {
+        error: `Send banner or auto (true or false), or idleMinutes (${IDLE_MINUTES.join(", ")}).`,
+      },
       { status: 400 }
     );
-  if (bannerLocked())
-    return NextResponse.json(
-      { error: "The banner is pinned off by AGENTOS_UPDATE_BANNER." },
-      { status: 409 }
-    );
-  setBannerEnabled(body.banner);
+  if (banner !== undefined && bannerLocked())
+    return conflict("The banner is pinned off by AGENTOS_UPDATE_BANNER.");
+  if (auto !== undefined && autoLocked())
+    return conflict("Automatic updates are pinned off by AGENTOS_AUTO_UPDATE.");
+  if (idleMinutes !== undefined && idleMinutesLocked())
+    return conflict("The idle time is pinned by AGENTOS_AUTO_UPDATE_IDLE_MIN.");
+  if (typeof banner === "boolean") setBannerEnabled(banner);
+  if (typeof auto === "boolean") setAutoEnabled(auto);
+  if (typeof idleMinutes === "number") setIdleMinutes(idleMinutes);
   return NextResponse.json(await updateView({ mayUpdate: true }));
 }

package/components/Chat/ChatPanel.tsx

@@ -63,6 +63,7 @@ import { ContextMeter } from "./ContextMeter";
 import { SetupCard } from "./SetupCard";
 import { UserTurn } from "./EventRow";
 import { EventGroup } from "./EventTurns";
+import { needsMoreHistory } from "./needs-more-history";
 import { useGoToItem } from "./useGoToItem";
 import { NeedsYouStrip } from "@/components/Orchestrator/NeedsYouStrip";
 import { useResolveQuestion } from "@/data/orchestrators";
@@ -525,6 +526,33 @@ export function ChatPanel({
     if (el && o.hasMore && !o.loadingOlder && el.scrollTop < el.clientHeight)
       o.loadOlder();
   }, []);
+  // Fill the screen on open: a page can fold into too few rows to scroll.
+  // One request per item count, so a page that fails or adds nothing stops it.
+  const filledAt = useRef({ sessionId, count: -1 });
+  useLayoutEffect(() => {
+    const el = listRef.current;
+    if (filledAt.current.sessionId !== sessionId)
+      filledAt.current = { sessionId, count: -1 };
+    if (!el || filledAt.current.count === items.length) return;
+    if (
+      needsMoreHistory({
+        hasMore,
+        loading: loadingOlder,
+        scrollHeight: el.scrollHeight,
+        clientHeight: el.clientHeight,
+      })
+    ) {
+      filledAt.current.count = items.length;
+      loadOlder();
+    }
+  }, [
+    sessionId,
+    items.length,
+    hasMore,
+    loadingOlder,
+    loadOlder,
+    blocks.length,
+  ]);
   const scrollToBlock = useCallback(async (key: string) => {
     // The row may only just have been added.
     await new Promise((r) => requestAnimationFrame(r));

package/components/Chat/needs-more-history.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { needsMoreHistory } from "./needs-more-history";
+
+const base = {
+  hasMore: true,
+  loading: false,
+  scrollHeight: 300,
+  clientHeight: 600,
+};
+
+describe("needsMoreHistory", () => {
+  it("asks for more when the list is shorter than the screen", () => {
+    expect(needsMoreHistory(base)).toBe(true);
+  });
+  it("asks while less than one extra screen overflows", () => {
+    expect(needsMoreHistory({ ...base, scrollHeight: 1200 })).toBe(true);
+  });
+  it("stops once there is more than a screen of overflow", () => {
+    expect(needsMoreHistory({ ...base, scrollHeight: 1201 })).toBe(false);
+  });
+  it("does nothing without more history or while a page is loading", () => {
+    expect(needsMoreHistory({ ...base, hasMore: false })).toBe(false);
+    expect(needsMoreHistory({ ...base, loading: true })).toBe(false);
+  });
+  it("ignores a list that has no size yet", () => {
+    expect(needsMoreHistory({ ...base, clientHeight: 0 })).toBe(false);
+  });
+});

package/components/Chat/needs-more-history.ts

@@ -0,0 +1,14 @@
+export interface HistoryFill {
+  hasMore: boolean;
+  loading: boolean;
+  scrollHeight: number;
+  clientHeight: number;
+}
+
+// An older page can fold into a few collapsed rows, leaving a list too short
+// to scroll, so no scroll event would ever ask for the next page. Keep about
+// one extra screen of content above the fold.
+export function needsMoreHistory(f: HistoryFill): boolean {
+  if (!f.hasMore || f.loading || f.clientHeight <= 0) return false;
+  return f.scrollHeight <= f.clientHeight * 2;
+}

package/components/Recipes/TimerFields.tsx

@@ -77,7 +77,8 @@ export function timerProblem(v: TimerValue): string | null {
   if (!isTimezone(v.timezone)) return "Unknown time zone";
   const bad = cronError(cron);
   if (bad) return bad;
-  return minGapMinutes(cron, v.timezone) < MIN_GAP_MINUTES
+  return minGapMinutes(cron, v.timezone, Date.now(), MIN_GAP_MINUTES) <
+    MIN_GAP_MINUTES
     ? "A recipe runs at most once an hour"
     : null;
 }

package/components/Schedules/ScheduleForm.tsx

@@ -303,7 +303,7 @@ export function ScheduleForm({
       !once &&
       !cronProblem &&
       tzOk &&
-      minGapMinutes(cron, timezone, openedAt) < minGap,
+      minGapMinutes(cron, timezone, openedAt, minGap) < minGap,
     [minGap, once, cron, cronProblem, timezone, tzOk, openedAt]
   );
 

package/components/Settings/SettingsDialog.tsx

@@ -126,7 +126,7 @@ export const SECTION_INFO: Record<
   },
   updates: {
     label: "Updates",
-    hint: "Version, check for updates, the update banner",
+    hint: "Version, check for updates, the update banner, tips",
     icon: RefreshCw,
   },
   experiments: {

package/components/SidebarFooter.tsx

@@ -1,3 +1,4 @@
+import { TipButton } from "@/components/Tips";
 import { WhatsNewButton } from "@/components/WhatsNew";
 import { ThemeToggle } from "@/components/ThemeToggle";
 import {
@@ -12,6 +13,7 @@ export function SidebarFooter() {
       <div className="flex items-center justify-between">
         <span className="label-mono text-muted-foreground">Theme</span>
         <div className="flex items-center">
+          <TipButton />
           <WhatsNewButton />
           <ThemeToggle />
         </div>

package/components/Tips/TipButton.tsx

@@ -0,0 +1,39 @@
+"use client";
+
+import { Lightbulb } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { useTips } from "@/data/tips";
+import { cn } from "@/lib/utils";
+import { tipsActions } from "@/stores/tips";
+
+/** A small footer icon that opens the tip dialog; a dot marks today's unread tip. */
+export function TipButton() {
+  const { data } = useTips();
+  if (data && (data.off || !data.deck.length)) return null;
+  // Holds the icon's place while the first answer loads, so What's New doesn't jump.
+  const fresh = !!data && !data.quiet && data.today?.read === false;
+  return (
+    <Button
+      type="button"
+      variant="ghost"
+      size="icon"
+      title="Tip of the Day"
+      aria-label={fresh ? "Tip of the Day (new tip)" : "Tip of the Day"}
+      disabled={!data}
+      onClick={() => tipsActions.open()}
+      // The ::after widens the tap area to 44px on a phone without adding height.
+      className={cn(
+        "text-muted-foreground relative h-8 w-8 after:absolute after:-inset-1.5 after:content-[''] md:after:hidden [@media(hover:none)]:md:h-11 [@media(hover:none)]:md:w-11",
+        !data && "invisible"
+      )}
+    >
+      <Lightbulb className="h-4 w-4" />
+      {fresh && (
+        <span
+          data-testid="tip-dot"
+          className="bg-primary absolute top-1.5 right-1.5 size-1.5 rounded-full"
+        />
+      )}
+    </Button>
+  );
+}

package/components/Tips/TipDialog.tsx

@@ -0,0 +1,148 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { ChevronLeft, ChevronRight, Lightbulb, X } from "lucide-react";
+import { toast } from "sonner";
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogClose,
+  DialogContent,
+  DialogDescription,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { useMarkTipSeen, useSetTipsOff, useTips } from "@/data/tips";
+import { useMediaQuery } from "@/hooks/useMediaQuery";
+import { TipMedia } from "./TipMedia";
+
+export function TipDialog({
+  open,
+  onOpenChange,
+}: {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+}) {
+  const wide = useMediaQuery("(min-width: 768px)");
+  const { data } = useTips();
+  const markSeen = useMarkTipSeen();
+  const setOff = useSetTipsOff();
+  const deck = data?.deck ?? [];
+  const [index, setIndex] = useState(() =>
+    Math.max(
+      0,
+      deck.findIndex((t) => t.id === data?.today?.id)
+    )
+  );
+  const tip = deck[index];
+
+  // Whatever tip is on screen counts as seen; today's one clears the dot.
+  const tipId = tip?.id;
+  useEffect(() => {
+    if (tipId) markSeen.mutate(tipId);
+    // markSeen is a new object each render; the tip is the trigger.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [tipId]);
+
+  const step = (by: number) =>
+    setIndex((i) => (i + by + deck.length) % deck.length);
+
+  const turnOff = () => {
+    setOff.mutate(true, {
+      onSuccess: () =>
+        toast("Tips are off. Turn them back on in Settings → Updates.", {
+          action: { label: "Undo", onClick: () => setOff.mutate(false) },
+        }),
+    });
+    onOpenChange(false);
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent
+        showCloseButton={false}
+        placement={wide ? "center" : "sheet"}
+        className="flex max-h-[85dvh] flex-col gap-0 overflow-hidden p-0 sm:max-w-[26rem]"
+      >
+        <div className="bg-muted-foreground/40 mx-auto mt-2 h-1 w-9 rounded-full md:hidden" />
+        <div className="flex items-center gap-2 px-4 pt-3 pb-1">
+          <span className="bg-muted grid size-7 shrink-0 place-items-center rounded-lg">
+            <Lightbulb className="size-4" />
+          </span>
+          <DialogDescription className="label-mono text-muted-foreground min-w-0 flex-1 text-xs">
+            Tip of the Day
+            {deck.length > 1 && ` · ${index + 1} of ${deck.length}`}
+          </DialogDescription>
+          <DialogClose asChild>
+            <Button
+              variant="ghost"
+              size="icon-sm"
+              aria-label="Close"
+              className="-mr-2 size-11 shrink-0 md:size-8"
+            >
+              <X className="size-4" />
+            </Button>
+          </DialogClose>
+        </div>
+        <div className="flex min-h-0 flex-1 flex-col gap-3 overflow-y-auto px-4 pt-2 pb-4">
+          {tip ? (
+            <>
+              {tip.media && <TipMedia key={tip.id} media={tip.media} />}
+              <DialogTitle className="text-base font-semibold">
+                {tip.title}
+              </DialogTitle>
+              <p className="text-muted-foreground text-sm leading-relaxed">
+                {tip.body}
+              </p>
+              {tip.url && (
+                <a
+                  href={tip.url}
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  className="text-primary w-fit text-sm underline"
+                >
+                  Learn more
+                </a>
+              )}
+            </>
+          ) : (
+            <DialogTitle className="text-sm font-medium">
+              No tips right now.
+            </DialogTitle>
+          )}
+        </div>
+        <div className="bg-muted/40 flex items-center gap-2 px-4 py-2">
+          <Button
+            variant="ghost"
+            size="sm"
+            className="text-muted-foreground h-11 px-2 md:h-8"
+            onClick={turnOff}
+          >
+            Don&apos;t show tips
+          </Button>
+          <div className="ml-auto flex items-center gap-1">
+            <Button
+              variant="ghost"
+              size="icon-sm"
+              aria-label="Previous tip"
+              disabled={deck.length < 2}
+              onClick={() => step(-1)}
+              className="size-11 md:size-8"
+            >
+              <ChevronLeft className="size-4" />
+            </Button>
+            <Button
+              variant="ghost"
+              size="icon-sm"
+              aria-label="Next tip"
+              disabled={deck.length < 2}
+              onClick={() => step(1)}
+              className="size-11 md:size-8"
+            >
+              <ChevronRight className="size-4" />
+            </Button>
+          </div>
+        </div>
+      </DialogContent>
+    </Dialog>
+  );
+}

package/components/Tips/TipHost.tsx

@@ -0,0 +1,14 @@
+"use client";
+
+import { useSnapshot } from "valtio";
+import { tipsActions, tipsStore } from "@/stores/tips";
+import { TipDialog } from "./TipDialog";
+
+/** Mounted once, near the top of the app: the footer icon opens it. */
+export function TipHost() {
+  const { open } = useSnapshot(tipsStore);
+  if (!open) return null;
+  return (
+    <TipDialog open onOpenChange={(next) => !next && tipsActions.close()} />
+  );
+}