@saadnvd1/agent-os 0.3.794 → 0.3.807

package/data/tips/index.ts

@@ -0,0 +1,49 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { TipsView } from "@/lib/tips/schema";
+
+export const tipsKeys = { all: ["tips"] as const };
+
+// The browser's own date: the tip changes at the user's midnight.
+const localDay = () => new Date().toLocaleDateString("sv");
+
+async function send(init?: { body: object }): Promise<TipsView> {
+  const res = await fetch(
+    init ? "/api/tips" : `/api/tips?day=${localDay()}`,
+    init && {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(init.body),
+    }
+  ).catch(() => {
+    throw new Error("Couldn't reach AgentOS. Try again.");
+  });
+  if (!res.ok) throw new Error(`Tips failed (${res.status})`);
+  return res.json();
+}
+
+// The tips file only changes with an update; the day can change under an open tab.
+export const useTips = () =>
+  useQuery({
+    queryKey: tipsKeys.all,
+    queryFn: () => send(),
+    staleTime: 10 * 60_000,
+    refetchOnWindowFocus: true,
+  });
+
+function useTipsMutation<V>(body: (v: V) => object) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (v: V) => send({ body: body(v) }),
+    onSuccess: (view) => queryClient.setQueryData(tipsKeys.all, view),
+  });
+}
+
+export const useMarkTipSeen = () =>
+  useTipsMutation<string>((id) => ({
+    action: "seen",
+    ids: [id],
+    day: localDay(),
+  }));
+
+export const useSetTipsOff = () =>
+  useTipsMutation<boolean>((off) => ({ action: "off", off }));

package/data/updates/index.ts

@@ -61,3 +61,8 @@ export const useUpdateBannerSetting = () =>
   useUpdateMutation<boolean>((banner) =>
     send("PUT", "/api/updates/settings", { banner })
   );
+
+export const useAutoUpdateSetting = () =>
+  useUpdateMutation<{ auto?: boolean; idleMinutes?: number }>((patch) =>
+    send("PUT", "/api/updates/settings", patch)
+  );

package/hooks/useChatViewsSync.ts

@@ -0,0 +1,12 @@
+import { useEffect } from "react";
+import { useChatViews } from "@/data/chat-views";
+import { chatPositionsActions } from "@/stores/chatPositions";
+
+/** Hands the server's reading positions to the page; chats wait for them to open where they were left. */
+export function useChatViewsSync(): void {
+  const { data, isError } = useChatViews();
+  useEffect(() => {
+    if (data) chatPositionsActions.hydrate(data);
+    else if (isError) chatPositionsActions.giveUp();
+  }, [data, isError]);
+}

package/hooks/useNavActions.ts

@@ -0,0 +1,104 @@
+"use client";
+
+import { Keyboard, MessageSquare, Repeat } from "lucide-react";
+import type { Session } from "@/lib/db";
+import { chordHint } from "@/lib/keybindings/chord";
+import { keysOf } from "@/lib/keybindings/keymap";
+import { previousChatId } from "@/lib/nav/recent";
+import { useNavKeys, useSingleKeys } from "@/hooks/useNavKeys";
+import { usePaletteCommands } from "@/hooks/usePaletteCommands";
+import { bookmarksUiActions } from "@/stores/bookmarksUi";
+import { chatOpened } from "@/stores/chatPositions";
+import { newDraft } from "@/stores/drafts";
+import { inboxUiActions } from "@/stores/inboxUi";
+import { paletteActions, paletteUi } from "@/stores/palette";
+import { settingsUiActions } from "@/stores/settingsUi";
+import { shortcutsUiActions } from "@/stores/shortcutsUi";
+
+/** The chats ⌘P, O C and the like switch between, as the palette's Sessions tab. */
+function openSwitcher() {
+  if (paletteUi.open && paletteUi.tab === "sessions")
+    return paletteActions.setOpen(false);
+  paletteActions.open();
+  paletteActions.setTab("sessions");
+}
+
+/**
+ * What each shortcut in keymap.ts does, and the palette commands that go
+ * with them. Opening a chat goes through `select`, so history, position and
+ * the address follow as they do for a click.
+ */
+export function useNavActions({
+  sessions,
+  activeSessionId,
+  select,
+}: {
+  sessions: Session[];
+  activeSessionId: string | null | undefined;
+  select: (session: Session) => void;
+}) {
+  const [singles, setSingles] = useSingleKeys();
+  const previous = () => {
+    const open = sessions.filter((s) => !s.archived_at);
+    const id = previousChatId(
+      open.map((s) => s.id),
+      chatOpened,
+      activeSessionId
+    );
+    const session = open.find((s) => s.id === id);
+    if (session) select(session);
+  };
+  const actions = {
+    "palette.open": () =>
+      paletteUi.open ? paletteActions.setOpen(false) : paletteActions.open(),
+    "switcher.open": openSwitcher,
+    "chat.open": openSwitcher,
+    "chat.previous": previous,
+    "chat.new": () => newDraft({ kind: "current" }),
+    "go.inbox": () => inboxUiActions.open(),
+    "go.messages": () => inboxUiActions.open("messages"),
+    "go.bookmarks": () => bookmarksUiActions.open(activeSessionId ?? null),
+    "go.settings": () => settingsUiActions.open(),
+    "help.open": shortcutsUiActions.open,
+  };
+  useNavKeys(actions);
+  usePaletteCommands("nav", [
+    {
+      id: "nav.switch",
+      title: "Switch chat",
+      group: "Go to",
+      hint: chordHint(keysOf("switcher.open")),
+      keywords: ["recent", "open chat", "session", "switcher"],
+      icon: MessageSquare,
+      run: openSwitcher,
+    },
+    {
+      id: "nav.previous",
+      title: "Previous chat",
+      group: "Go to",
+      hint: "G P",
+      keywords: ["flip", "alternate", "last", "back"],
+      icon: Repeat,
+      run: previous,
+    },
+    {
+      id: "nav.shortcuts",
+      title: "Keyboard shortcuts",
+      group: "Go to",
+      hint: "?",
+      keywords: ["keys", "help", "hotkeys"],
+      icon: Keyboard,
+      run: shortcutsUiActions.open,
+    },
+    {
+      id: "nav.single-keys",
+      title: singles
+        ? "Turn off single-key shortcuts"
+        : "Turn on single-key shortcuts",
+      group: "Settings",
+      keywords: ["keyboard", "letters", "vim", "linear"],
+      icon: Keyboard,
+      run: () => setSingles(!singles),
+    },
+  ]);
+}

package/hooks/useNavKeys.ts

@@ -0,0 +1,105 @@
+"use client";
+
+import { useEffect, useRef } from "react";
+import { useKeybindings } from "@/hooks/useKeybindings";
+import { useStoredFlag } from "@/hooks/useStoredFlag";
+import { isFreeTarget } from "@/lib/keybindings/focus";
+import { KEYMAP, isSequence, keysOf } from "@/lib/keybindings/keymap";
+import {
+  SEQUENCE_MS,
+  SequenceMatcher,
+  plainKey,
+} from "@/lib/keybindings/sequence";
+import { shortcutsUiActions } from "@/stores/shortcutsUi";
+
+export const SINGLE_KEYS_FLAG = "agentos-single-key-shortcuts";
+
+/** The single-key shortcuts' on/off switch, kept per browser. */
+export const useSingleKeys = () => useStoredFlag(SINGLE_KEYS_FLAG, true);
+
+export type NavActions = Record<string, () => void>;
+
+const SEQUENCES = Object.fromEntries(
+  KEYMAP.filter((k) => k.single && isSequence(k.keys)).map((k) => [
+    k.keys,
+    k.id,
+  ])
+);
+const BARE = Object.fromEntries(
+  KEYMAP.filter((k) => k.single && !isSequence(k.keys)).map((k) => [
+    k.keys,
+    k.id,
+  ])
+);
+
+const CHORD_IDS = ["switcher.open", "palette.open"];
+
+const dialogOpen = () =>
+  !!document.querySelector('[role="dialog"][data-state="open"]');
+
+/**
+ * The app's keys by id (see keymap.ts): chords through the registry, bare
+ * keys and two-key sequences here, only while nothing is being typed into
+ * and the single-key switch is on.
+ */
+export function useNavKeys(actions: NavActions) {
+  const latest = useRef(actions);
+  useEffect(() => {
+    latest.current = actions;
+  });
+  const run = (id: string) => latest.current[id]?.();
+  const [singles] = useSingleKeys();
+  const singlesOn = useRef(singles);
+  useEffect(() => {
+    singlesOn.current = singles;
+  });
+
+  // The sidebar's ⌘↑/⌘↓ are bound by useSessionSwitching, from the same table.
+  useKeybindings(
+    "nav",
+    CHORD_IDS.map((id) => ({ id, keys: keysOf(id), run: () => run(id) }))
+  );
+
+  useEffect(() => {
+    const matcher = new SequenceMatcher(SEQUENCES);
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const clear = () => {
+      clearTimeout(timer);
+      matcher.reset();
+      shortcutsUiActions.setPending(null);
+    };
+    const onKey = (e: KeyboardEvent) => {
+      if (!singlesOn.current) return clear();
+      if (e.metaKey || e.ctrlKey || e.altKey || e.isComposing) return clear();
+      if (!isFreeTarget(e.target) || dialogOpen()) return clear();
+      if (e.key === "Escape") return clear();
+      if (e.key === "Shift") return;
+      const bare = plainKey(e.key, e.shiftKey);
+      if (bare === null) return clear();
+      const waiting = matcher.pending() !== null;
+      const step = matcher.feed(bare);
+      if (step.kind === "match") {
+        e.preventDefault();
+        clear();
+        run(step.id);
+      } else if (step.kind === "pending") {
+        e.preventDefault();
+        shortcutsUiActions.setPending(step.first);
+        clearTimeout(timer);
+        timer = setTimeout(clear, SEQUENCE_MS);
+      } else {
+        clear();
+        const id = BARE[bare.toLowerCase()];
+        if (id && !waiting && !e.repeat) {
+          e.preventDefault();
+          run(id);
+        }
+      }
+    };
+    window.addEventListener("keydown", onKey, true);
+    return () => {
+      window.removeEventListener("keydown", onKey, true);
+      clear();
+    };
+  }, []);
+}

package/hooks/useReloadWhenUpdated.ts

@@ -13,7 +13,11 @@ export function useReloadWhenUpdated(view: UpdateView | undefined) {
   useEffect(() => {
     if (!run) return;
     if (isActivePhase(run.phase)) watched.current = run.id;
-    else if (run.phase === "done" && watched.current === run.id)
+    // A rollback restarted the server onto the old build: reload onto it too.
+    else if (
+      (run.phase === "done" || run.phase === "rolled_back") &&
+      watched.current === run.id
+    )
       window.location.reload();
   }, [run]);
 }

package/hooks/useSessionUrl.ts

@@ -10,6 +10,8 @@ import {
   type SessionRef,
 } from "@/lib/session-url";
 import { usePanes } from "@/contexts/PaneContext";
+import { navHistoryActions } from "@/stores/navHistory";
+import { chatPositionsActions } from "@/stores/chatPositions";
 
 interface Options {
   sessions: Session[];
@@ -59,6 +61,9 @@ export function useSessionUrl({
     };
   });
 
+  const nameOf = (id: string | null) =>
+    (id && latest.current.sessions.find((s) => s.id === id)?.name) || "Chat";
+
   // Made on first use, outside render.
   const syncRef = useRef<SessionUrlSync | null>(null);
   const getSync = useCallback(() => {
@@ -79,8 +84,13 @@ export function useSessionUrl({
     syncRef.current = new SessionUrlSync(
       {
         href: () => window.location.href,
-        push: (href) => window.history.pushState(null, "", href),
-        replace: (href) => window.history.replaceState(null, "", href),
+        push: (href, id) => navHistoryActions.push(href, id, nameOf(id)),
+        replace: (href, id) => navHistoryActions.replace(href, id, nameOf(id)),
+        settle: (id) => {
+          const entry = navHistoryActions.currentState();
+          if (entry?.sessionId !== id)
+            navHistoryActions.replace(window.location.href, id, nameOf(id));
+        },
       },
       {
         find: (ref) => pickSession(ref, latest.current.sessions)?.id ?? null,
@@ -119,8 +129,10 @@ export function useSessionUrl({
   // A rename (by hand, or the title a first turn gives it) moves the slug.
   const focusedName = sessions.find((s) => s.id === focusedId)?.name ?? null;
   useEffect(() => {
-    if (focusedName !== null) getSync().renamed();
-  }, [getSync, focusedName]);
+    if (focusedName === null) return;
+    getSync().renamed();
+    if (focusedId) navHistoryActions.rename(focusedId, focusedName);
+  }, [getSync, focusedName, focusedId]);
 
   const ready = hydrated && loaded;
   useEffect(() => {
@@ -128,7 +140,13 @@ export function useSessionUrl({
   }, [getSync, ready]);
 
   useEffect(() => {
-    const onPop = () => void getSync().popstate();
+    const onPop = () => {
+      // Back or forward onto an entry: it remembers where the reader was.
+      const entry = navHistoryActions.popped();
+      if (entry?.sessionId && entry.pos)
+        chatPositionsActions.setTarget(entry.sessionId, entry.pos);
+      void getSync().popstate();
+    };
     window.addEventListener("popstate", onPop);
     return () => window.removeEventListener("popstate", onPop);
   }, [getSync]);

package/lib/bus/index.ts

@@ -39,6 +39,7 @@ import {
 } from "./waits/store";
 import { HUMAN, overRateLimit, wakeLine, type BusMessageView } from "./format";
 import { groupNames } from "../session-groups/store";
+import { sessionWorkspace } from "../schedules/store";
 
 export * from "./format";
 export {
@@ -103,6 +104,7 @@ export async function listPeers(callerId?: string): Promise<Peer[]> {
   const sessions = liveSessions();
   const named = candidates(sessions);
   const caller = sessionById(callerId);
+  const callerWorkspace = caller ? sessionWorkspace(caller) : null;
   const orchestrator = heldOrchestrator(caller);
   const badges = waitBadges();
   const groups = groupNames();
@@ -127,9 +129,9 @@ export async function listPeers(callerId?: string): Promise<Peer[]> {
           groups.has(s.session_group_id) && {
             group: groups.get(s.session_group_id),
           }),
-        ...(caller?.workspace_id &&
+        ...(callerWorkspace &&
           s.role === "orchestrator" &&
-          s.workspace_id === caller.workspace_id && { yours: true }),
+          s.workspace_id === callerWorkspace && { yours: true }),
       };
     })
   );

package/lib/bus/role-alias.ts

@@ -6,6 +6,7 @@
  */
 
 import type { Session } from "../db";
+import { sessionWorkspace } from "../models/resolve";
 
 type RoleSession = Pick<
   Session,
@@ -56,9 +57,10 @@ export function resolveRoleAlias<T extends RoleSession>(
         error: `"@${role}" matches ${found.length} sessions: ${found.map(label).join(", ")}. Use the name or the id`,
       };
   }
-  if (role === "supervisor" && caller?.workspace_id) {
+  const workspace = caller ? sessionWorkspace(caller) : null;
+  if (role === "supervisor" && workspace) {
     const orchestrator = others.find(
-      (s) => s.role === "orchestrator" && s.workspace_id === caller.workspace_id
+      (s) => s.role === "orchestrator" && s.workspace_id === workspace
     );
     if (orchestrator) return { ok: true, session: orchestrator };
   }

package/lib/bus/targets.ts

@@ -73,7 +73,8 @@ function ownOrchestrator(
   callerId?: string | null
 ): Session | undefined {
   if (!/^(my )?orchestrator$/i.test(ref.trim())) return undefined;
-  const workspace = sessionById(callerId)?.workspace_id;
+  const caller = sessionById(callerId);
+  const workspace = caller ? sessionWorkspace(caller) : null;
   if (!workspace) return undefined;
   return sessions.find(
     (s) => s.role === "orchestrator" && s.workspace_id === workspace

package/lib/busy.ts

@@ -2,12 +2,14 @@ import { db } from "./db";
 import { runningStarts } from "./simulator";
 
 // What a restart would cut off and have to start over: reviews, task
-// setups and simulator starts run in the server. (Chat turns run in their own workers and
+// setups, simulator starts, merges and stack landings run in the server. (Chat turns run in their own workers and
 // outlive it.) Older than half an hour is stuck, not in flight.
 export function inFlight(): {
   reviews: number;
   setups: number;
   simulatorStarts: number;
+  merges: number;
+  landings: number;
 } {
   const count = (sql: string) => (db.prepare(sql).get() as { n: number }).n;
   return {
@@ -22,5 +24,25 @@ export function inFlight(): {
          AND created_at > datetime('now', '-30 minutes')`
     ),
     simulatorStarts: runningStarts(),
+    merges: mergesInFlight(),
+    landings: count(
+      `SELECT COUNT(*) AS n FROM stacks WHERE status = 'landing'`
+    ),
   };
 }
+
+// Between `gh pr merge` and the tidying after it (lib/tasks/finish.ts keeps
+// both on globalThis, so every bundle sees the same ones).
+function mergesInFlight(): number {
+  const g = globalThis as unknown as {
+    __agentosSigningOff?: Set<string>;
+    __agentosAfterMerge?: Map<string, unknown>;
+  };
+  return new Set([
+    ...(g.__agentosSigningOff ?? []),
+    ...(g.__agentosAfterMerge?.keys() ?? []),
+  ]).size;
+}
+
+export const inFlightTotal = (w: ReturnType<typeof inFlight>): number =>
+  w.reviews + w.setups + w.simulatorStarts + w.merges + w.landings;

package/lib/chat/escape.ts

@@ -37,13 +37,16 @@ export function escapeInterrupts(
 }
 
 // What Esc does in a chat: set the composer's suggestion aside, stop the
-// turn, or nothing (something on top takes it, or it isn't a bare Esc).
+// turn, or, with nothing else to do, leave the composer so the bare-key
+// shortcuts (g i) work; nothing when something on top takes it or it isn't
+// a bare Esc.
 export function escapeAction(
   e: EscapeKey,
   running: boolean,
   overlayOpen: boolean,
-  ghostShown: boolean
-): "dismiss" | "interrupt" | null {
+  ghostShown: boolean,
+  inComposer = false
+): "dismiss" | "interrupt" | "blur" | null {
   const bare =
     e.key === "Escape" &&
     !e.repeat &&
@@ -51,5 +54,6 @@ export function escapeAction(
     !(e.metaKey || e.ctrlKey || e.altKey || e.shiftKey);
   if (!bare || overlayOpen) return null;
   if (ghostShown) return "dismiss";
-  return running ? "interrupt" : null;
+  if (running) return "interrupt";
+  return inComposer ? "blur" : null;
 }

package/lib/chat-views/body.ts

@@ -0,0 +1,41 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { readCapped } from "../security/read-capped";
+import type { ChatViewInput } from "./types";
+
+const MAX_BODY_BYTES = 2048;
+
+const position = z.object({
+  itemId: z.string().min(1).max(200).nullable(),
+  offsetPx: z.number().int().min(-100000).max(100000),
+  atEnd: z.boolean(),
+  // False keeps `viewed_at` as it was: the reader left with newer items below
+  // them that they haven't seen.
+  advance: z.boolean().optional(),
+});
+const body = z.union([position, z.object({ viewed: z.literal(true) })]);
+
+/** The PUT body: a position to save, `null` for "opened just now", or the
+ * response that refuses it. */
+export async function readViewBody(
+  request: Request
+): Promise<{ input: ChatViewInput | null } | NextResponse> {
+  const raw = await readCapped(request, MAX_BODY_BYTES);
+  if (raw === null)
+    return NextResponse.json({ error: "Too large" }, { status: 413 });
+  let json: unknown = null;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    // Not JSON: refused below.
+  }
+  const parsed = body.safeParse(json);
+  if (!parsed.success)
+    return NextResponse.json({ error: "Bad request" }, { status: 400 });
+  return {
+    input:
+      "viewed" in parsed.data
+        ? null
+        : { ...parsed.data, advance: parsed.data.advance !== false },
+  };
+}

package/lib/chat-views/store.ts

@@ -0,0 +1,67 @@
+import { db } from "../db";
+import { MAX_VIEWS, type ChatView, type ChatViewInput } from "./types";
+
+interface Row {
+  session_id: string;
+  item_id: string | null;
+  offset_px: number;
+  at_end: number;
+  viewed_at: number;
+}
+
+const toView = (r: Row): ChatView => ({
+  sessionId: r.session_id,
+  itemId: r.item_id,
+  offsetPx: r.offset_px,
+  atEnd: r.at_end === 1,
+  viewedAt: r.viewed_at,
+});
+
+/** The most recently viewed chats first. */
+export function listChatViews(limit = MAX_VIEWS): ChatView[] {
+  return (
+    db
+      .prepare(`SELECT * FROM chat_views ORDER BY viewed_at DESC LIMIT ?`)
+      .all(limit) as Row[]
+  ).map(toView);
+}
+
+/** Saves where the reader is. Without a position it only marks the chat as
+ * viewed now (opening it), keeping what was saved. */
+export function saveChatView(
+  sessionId: string,
+  input: ChatViewInput | null,
+  now = Date.now()
+): ChatView {
+  if (input) {
+    db.prepare(
+      `INSERT INTO chat_views (session_id, item_id, offset_px, at_end, viewed_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(session_id) DO UPDATE SET item_id = excluded.item_id,
+         offset_px = excluded.offset_px, at_end = excluded.at_end,
+         viewed_at = CASE WHEN ? = 1 THEN excluded.viewed_at
+                          ELSE chat_views.viewed_at END`
+    ).run(
+      sessionId,
+      input.itemId,
+      input.offsetPx,
+      input.atEnd ? 1 : 0,
+      now,
+      input.advance ? 1 : 0
+    );
+  } else {
+    db.prepare(
+      `INSERT INTO chat_views (session_id, viewed_at) VALUES (?, ?)
+       ON CONFLICT(session_id) DO UPDATE SET viewed_at = excluded.viewed_at`
+    ).run(sessionId, now);
+  }
+  return toView(
+    db
+      .prepare(`SELECT * FROM chat_views WHERE session_id = ?`)
+      .get(sessionId) as Row
+  );
+}
+
+export function deleteChatView(sessionId: string): void {
+  db.prepare(`DELETE FROM chat_views WHERE session_id = ?`).run(sessionId);
+}

package/lib/chat-views/types.ts

@@ -0,0 +1,20 @@
+/** Where a chat was last being read: the first row in view, how far down it
+ * sat, and whether the reader was following the latest output. */
+export interface ChatView {
+  sessionId: string;
+  itemId: string | null;
+  offsetPx: number;
+  atEnd: boolean;
+  /** Epoch ms of the last time the reader had this chat open. */
+  viewedAt: number;
+}
+
+export interface ChatViewInput {
+  itemId: string | null;
+  offsetPx: number;
+  atEnd: boolean;
+  /** Whether this counts as having seen everything up to now. */
+  advance: boolean;
+}
+
+export const MAX_VIEWS = 500;

package/lib/db/migrations/20261031T1500_chat_views.ts

@@ -0,0 +1,30 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261031T1500_chat_views",
+  up: (db) => {
+    // Where each chat was last being read, for the person, on any device. No
+    // FK to sessions, like chat_bookmarks; a trigger drops a deleted chat's row.
+    // viewed_at is epoch milliseconds, the unit chat items carry.
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS chat_views (
+        session_id TEXT PRIMARY KEY,
+        item_id TEXT,
+        offset_px INTEGER NOT NULL DEFAULT 0,
+        at_end INTEGER NOT NULL DEFAULT 1,
+        viewed_at INTEGER NOT NULL
+      )
+    `);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_chat_views_viewed
+         ON chat_views(viewed_at DESC)`
+    );
+    db.exec(`
+      CREATE TRIGGER IF NOT EXISTS chat_views_session_deleted
+      AFTER DELETE ON sessions
+      BEGIN
+        DELETE FROM chat_views WHERE session_id = OLD.id;
+      END
+    `);
+  },
+} satisfies Migration;