@saadnvd1/agent-os 0.3.794 → 0.3.807

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/chat-views/[sessionId]/route.ts

@@ -0,0 +1,19 @@
+import { NextResponse } from "next/server";
+import { readViewBody } from "@/lib/chat-views/body";
+import { saveChatView } from "@/lib/chat-views/store";
+
+type Ctx = { params: Promise<{ sessionId: string }> };
+
+// Ids are uuids today; anything id-shaped fits other machines' sessions too.
+const ID_SHAPE = /^[A-Za-z0-9_-]{1,128}$/;
+
+// PUT /api/chat-views/:sessionId { itemId, offsetPx, atEnd } - the reader is
+// here in this chat; or { viewed: true } - they just opened it.
+export async function PUT(request: Request, { params }: Ctx) {
+  const { sessionId } = await params;
+  if (!ID_SHAPE.test(sessionId))
+    return NextResponse.json({ error: "Bad request" }, { status: 400 });
+  const body = await readViewBody(request);
+  if (body instanceof NextResponse) return body;
+  return NextResponse.json({ view: saveChatView(sessionId, body.input) });
+}

package/app/api/chat-views/route.test.ts

@@ -0,0 +1,79 @@
+import { randomUUID } from "crypto";
+import { describe, expect, it } from "vitest";
+import { getDb } from "@/lib/db";
+import * as one from "./[sessionId]/route";
+import * as list from "./route";
+
+const put = (sessionId: string, body: unknown, raw = false) =>
+  one.PUT(
+    new Request("http://x/api/chat-views/" + sessionId, {
+      method: "PUT",
+      body: raw ? (body as string) : JSON.stringify(body),
+    }),
+    { params: Promise.resolve({ sessionId }) }
+  );
+const views = async () =>
+  (await (await list.GET()).json()).views as {
+    sessionId: string;
+    itemId: string | null;
+    offsetPx: number;
+    atEnd: boolean;
+    viewedAt: number;
+  }[];
+
+describe("/api/chat-views", () => {
+  it("saves a position, keeps it when a chat is only opened, and lists newest first", async () => {
+    const a = randomUUID();
+    const b = randomUUID();
+    const res = await put(a, { itemId: "i1", offsetPx: 40, atEnd: false });
+    expect(res.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 5));
+    await put(b, { viewed: true });
+    await new Promise((r) => setTimeout(r, 5));
+    await put(a, { viewed: true });
+    const mine = (await views()).filter(
+      (v) => v.sessionId === a || v.sessionId === b
+    );
+    expect(mine.map((v) => v.sessionId)).toEqual([a, b]);
+    expect(mine[0]).toMatchObject({ itemId: "i1", offsetPx: 40, atEnd: false });
+    expect(mine[1]).toMatchObject({ itemId: null, atEnd: true });
+    expect(mine[0].viewedAt).toBeGreaterThan(mine[1].viewedAt);
+  });
+
+  it("keeps viewed_at when the reader left with things unseen below", async () => {
+    const id = randomUUID();
+    await put(id, { viewed: true });
+    const first = (await views()).find((v) => v.sessionId === id)!.viewedAt;
+    await new Promise((r) => setTimeout(r, 5));
+    await put(id, { itemId: "i", offsetPx: 3, atEnd: false, advance: false });
+    const kept = (await views()).find((v) => v.sessionId === id)!;
+    expect(kept).toMatchObject({ itemId: "i", offsetPx: 3, atEnd: false });
+    expect(kept.viewedAt).toBe(first);
+  });
+
+  it("refuses a bad body and a bad id", async () => {
+    const id = randomUUID();
+    expect((await put(id, { offsetPx: "x" })).status).toBe(400);
+    expect((await put(id, "not json", true)).status).toBe(400);
+    expect(
+      (await put(id, { itemId: "", offsetPx: 0, atEnd: true })).status
+    ).toBe(400);
+    expect((await put("bad id!", { viewed: true })).status).toBe(400);
+    expect((await put(id, { viewed: true, x: "y".repeat(5000) })).status).toBe(
+      413
+    );
+  });
+
+  it("is dropped with its chat", async () => {
+    const id = randomUUID();
+    getDb()
+      .prepare(
+        `INSERT INTO sessions (id, name, tmux_name, working_directory) VALUES (?, 'v', ?, '/tmp')`
+      )
+      .run(id, `claude-${id}`);
+    await put(id, { viewed: true });
+    expect((await views()).some((v) => v.sessionId === id)).toBe(true);
+    getDb().prepare(`DELETE FROM sessions WHERE id = ?`).run(id);
+    expect((await views()).some((v) => v.sessionId === id)).toBe(false);
+  });
+});

package/app/api/chat-views/route.ts

@@ -0,0 +1,8 @@
+import { NextResponse } from "next/server";
+import { listChatViews } from "@/lib/chat-views/store";
+
+// GET /api/chat-views - where each chat was last being read and when, newest
+// first: the switcher's recent order and the place a chat reopens at.
+export async function GET() {
+  return NextResponse.json({ views: listChatViews() });
+}

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/app/page.tsx

@@ -7,6 +7,9 @@ import { subscribe } from "valtio";
 import { viewSwitchStore, viewSwitchActions } from "@/stores/viewSwitch";
 import { useOpenSession } from "@/hooks/useOpenSession";
 import { useSessionUrl } from "@/hooks/useSessionUrl";
+import { useNavActions } from "@/hooks/useNavActions";
+import { useChatViewsSync } from "@/hooks/useChatViewsSync";
+import { chatPositionsActions } from "@/stores/chatPositions";
 import { tmuxAttachStore, tmuxAttachActions } from "@/stores/tmuxAttach";
 import type { AttachSpec } from "@/lib/hosts/attach";
 import { memo, useState, useEffect, useCallback, useMemo, useRef } from "react";
@@ -55,7 +58,8 @@ import { useDraftKeys } from "@/hooks/useDraftKeys";
 import { useDraftRequests } from "@/hooks/useDraftRequests";
 import { newDraft } from "@/stores/drafts";
 import { useOpenOrchestrator } from "@/hooks/useOpenOrchestrator";
-import { paletteActions, paletteUi } from "@/stores/palette";
+import { ShortcutsDialog } from "@/components/Shortcuts/ShortcutsDialog";
+import { PendingKeys } from "@/components/Shortcuts/PendingKeys";
 import { useAppCommands } from "@/components/CommandPalette/useAppCommands";
 import { useMoveCommands } from "@/components/Tasks/useMoveCommands";
 import dynamic from "next/dynamic";
@@ -187,6 +191,8 @@ const AppDialogs = memo(function AppDialogs({
       <AwayReport />
       <IncomingLinks />
       <CommandPalette />
+      <ShortcutsDialog />
+      <PendingKeys />
     </>
   );
 });
@@ -530,9 +536,12 @@ function HomeContent() {
     isMobile,
   });
 
+  useChatViewsSync();
+
   // Notification click handler
   const handleNotificationClick = useCallback(
     (sessionId: string) => {
+      chatPositionsActions.wantLatest(sessionId);
       const session = sessions.find((s) => s.id === sessionId);
       if (session) {
         attachToSession(session);
@@ -571,19 +580,6 @@ function HomeContent() {
     if (isHydrated && !isMobile) setSidebarOpen(true);
   }, [isMobile, isHydrated]);
 
-  // Cmd+K: the command palette, which searches sessions too.
-  useEffect(() => {
-    const handleKeyDown = (e: KeyboardEvent) => {
-      if ((e.metaKey || e.ctrlKey) && e.key.toLowerCase() === "k") {
-        e.preventDefault();
-        if (paletteUi.open) paletteActions.setOpen(false);
-        else paletteActions.open();
-      }
-    };
-    window.addEventListener("keydown", handleKeyDown);
-    return () => window.removeEventListener("keydown", handleKeyDown);
-  }, []);
-
   // Picking a session with a tap, ⌘K or the keyboard: the composer is focused
   // inside the gesture, which iOS requires. Other ways in (URL, notification,
   // a session just created) use attachToSession's later focus.
@@ -674,6 +670,7 @@ function HomeContent() {
   // A workspace's orchestrator row opens its chat, made on first open.
   const handleOrchestratorOpened = useCallback(
     (sessionId: string) => {
+      chatPositionsActions.wantLatest(sessionId);
       if (isMobile) setSidebarOpen(false);
       void handleSessionCreated(sessionId);
     },
@@ -724,8 +721,14 @@ function HomeContent() {
     chatMetaActions.setActive(focusedActiveTab?.sessionId ?? null);
   }, [focusedActiveTab?.sessionId]);
 
+  useNavActions({
+    sessions,
+    activeSessionId: focusedActiveTab?.sessionId,
+    select: selectSession,
+  });
   useAppCommands({
     sessions,
+    activeSessionId: focusedActiveTab?.sessionId,
     statuses: sessionStatuses,
     onSelectSession: selectSession,
     onSearchCode: () => setShowQuickSwitcher(true),