@saadnvd1/agent-os 0.3.684 → 0.3.692

package/hooks/useSidebarPinned.ts

@@ -1,6 +1,7 @@
 "use client";
 
-import { useState, useCallback, useEffect } from "react";
+import { useCallback } from "react";
+import { useStoredFlag } from "./useStoredFlag";
 
 const STORAGE_KEY = "agentOS-sidebar-pinned";
 
@@ -11,29 +12,12 @@ const STORAGE_KEY = "agentOS-sidebar-pinned";
  * reveals on hover near the left edge.
  */
 export function useSidebarPinned() {
-  const [isPinned, setIsPinned] = useState(true);
+  const [isPinned, setPinned] = useStoredFlag(STORAGE_KEY, true);
 
-  // Load persisted state on mount
-  useEffect(() => {
-    if (typeof window === "undefined") return;
-    const stored = localStorage.getItem(STORAGE_KEY);
-    if (stored === "false") {
-      setIsPinned(false);
-    }
-  }, []);
-
-  const setPinned = useCallback((pinned: boolean) => {
-    setIsPinned(pinned);
-    localStorage.setItem(STORAGE_KEY, String(pinned));
-  }, []);
-
-  const togglePin = useCallback(() => {
-    setIsPinned((prev) => {
-      const next = !prev;
-      localStorage.setItem(STORAGE_KEY, String(next));
-      return next;
-    });
-  }, []);
+  const togglePin = useCallback(
+    () => setPinned(!isPinned),
+    [isPinned, setPinned]
+  );
 
   return { isPinned, togglePin, setPinned };
 }

package/hooks/useSpeechRecognition.ts

@@ -1,6 +1,12 @@
 "use client";
 
-import { useState, useRef, useCallback, useEffect } from "react";
+import {
+  useState,
+  useRef,
+  useCallback,
+  useEffect,
+  useSyncExternalStore,
+} from "react";
 
 // Web Speech API types
 interface SpeechRecognitionEvent extends Event {
@@ -46,19 +52,27 @@ declare global {
   }
 }
 
+const noopSubscribe = () => () => {};
+
+function getSpeechRecognitionAPI() {
+  return window.SpeechRecognition || window.webkitSpeechRecognition;
+}
+
 export function useSpeechRecognition(
   onTranscript: (text: string, isFinal: boolean) => void
 ) {
   const [isListening, setIsListening] = useState(false);
-  const [isSupported, setIsSupported] = useState(false);
+  const isSupported = useSyncExternalStore(
+    noopSubscribe,
+    () => !!getSpeechRecognitionAPI(),
+    () => false
+  );
   const recognitionRef = useRef<SpeechRecognition | null>(null);
   const lastTranscriptRef = useRef("");
 
   useEffect(() => {
     // Check for browser support
-    const SpeechRecognitionAPI =
-      window.SpeechRecognition || window.webkitSpeechRecognition;
-    setIsSupported(!!SpeechRecognitionAPI);
+    const SpeechRecognitionAPI = getSpeechRecognitionAPI();
 
     if (SpeechRecognitionAPI) {
       const recognition = new SpeechRecognitionAPI();

package/hooks/useStoredFlag.ts

@@ -0,0 +1,47 @@
+"use client";
+
+import { useCallback, useSyncExternalStore } from "react";
+
+const listeners = new Set<() => void>();
+
+function subscribe(fn: () => void) {
+  listeners.add(fn);
+  window.addEventListener("storage", fn);
+  return () => {
+    listeners.delete(fn);
+    window.removeEventListener("storage", fn);
+  };
+}
+
+function read(key: string): string | null {
+  try {
+    return localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+
+// A boolean kept in localStorage, shared by every caller on the page. The
+// server and the hydrating render see `fallback`; the stored value follows.
+export function useStoredFlag(
+  key: string,
+  fallback: boolean
+): [boolean, (next: boolean) => void] {
+  const value = useSyncExternalStore(
+    subscribe,
+    () => read(key),
+    () => null
+  );
+  const set = useCallback(
+    (next: boolean) => {
+      try {
+        localStorage.setItem(key, String(next));
+      } catch {
+        // Storage unavailable: the choice lasts until reload.
+      }
+      listeners.forEach((fn) => fn());
+    },
+    [key]
+  );
+  return [value === null ? fallback : value === "true", set];
+}

package/hooks/useViewport.ts

@@ -1,28 +1,22 @@
 "use client";
 
-import { useState, useEffect } from "react";
+import { useSyncExternalStore } from "react";
+import { useMediaQuery } from "./useMediaQuery";
+
+const noop = () => () => {};
 
 /**
  * Mobile-first viewport detection hook
  * Breakpoint: 768px (md in Tailwind)
  */
 export function useViewport() {
-  const [isMobile, setIsMobile] = useState(false);
-  const [isHydrated, setIsHydrated] = useState(false);
-
-  useEffect(() => {
-    const checkViewport = () => {
-      setIsMobile(window.innerWidth < 768);
-    };
-
-    // Initial check
-    checkViewport();
-    setIsHydrated(true);
-
-    // Listen for resize
-    window.addEventListener("resize", checkViewport);
-    return () => window.removeEventListener("resize", checkViewport);
-  }, []);
+  const isMobile = useMediaQuery("(max-width: 767.98px)");
+  // False on the server and while hydrating, true after.
+  const isHydrated = useSyncExternalStore(
+    noop,
+    () => true,
+    () => false
+  );
 
   return {
     isMobile,

package/lib/approvals/no-approvals.ts

@@ -14,13 +14,7 @@ import { markAllStatusDirty } from "../status/dirty";
 export const NO_APPROVALS_KEY = "approvals.none";
 
 export type AuditSource =
-  | "ask"
-  | "brake"
-  | "plan"
-  | "chat"
-  | "terminal"
-  | "merge-approval"
-  | "mode";
+  "ask" | "brake" | "plan" | "chat" | "terminal" | "merge-approval" | "mode";
 
 export interface AuditRow {
   id: number;

package/lib/artifacts/store.ts

@@ -54,8 +54,7 @@ export function createArtifact(
 export function getArtifact(id: string): Artifact | undefined {
   if (!ID.test(id)) return undefined;
   return db.prepare(`SELECT * FROM artifacts WHERE id = ?`).get(id) as
-    | Artifact
-    | undefined;
+    Artifact | undefined;
 }
 
 export function listArtifacts(sessionId: string): Artifact[] {

package/lib/away/report.ts

@@ -150,8 +150,7 @@ function merged(
   );
   return rows.map((r) => {
     const done = action.get(away.id, `deploy:${r.id}`) as
-      | { kind: string; detail: string | null }
-      | undefined;
+      { kind: string; detail: string | null } | undefined;
     const deploy: DeployState =
       done?.kind === "deploy_ok"
         ? "deployed"

package/lib/away/run.ts

@@ -70,8 +70,7 @@ function orchestrated(): { workspaceId: string; orchestratorId: string }[] {
 
 const sessionRow = (id: string) =>
   db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
-    | Session
-    | undefined;
+    Session | undefined;
 
 // Away mode reaches a workspace only through an orchestrator that's been
 // working inside the window: one left alone isn't told or woken.

package/lib/away/state.ts

@@ -43,8 +43,7 @@ export function activeAway(): AwayRow | null {
 export function getAway(id: number): AwayRow | null {
   return (
     (db.prepare(`SELECT * FROM away_periods WHERE id = ?`).get(id) as
-      | AwayRow
-      | undefined) ?? null
+      AwayRow | undefined) ?? null
   );
 }
 

package/lib/bookmarks/store.ts

@@ -83,8 +83,7 @@ function toBookmark(r: Joined): Bookmark {
 
 export function getBookmark(id: string): Bookmark | null {
   const r = db.prepare(`${SELECT} WHERE b.id = ?`).get(id) as
-    | Joined
-    | undefined;
+    Joined | undefined;
   return r ? toBookmark(r) : null;
 }
 

package/lib/bus/delivery.ts

@@ -7,8 +7,7 @@ import { WORKING_LINE } from "../claude-working-line";
 
 export type DeliveryState = "delivered" | "queued" | "failed";
 export type Delivery =
-  | { state: "delivered" | "queued" }
-  | { state: "failed"; why: string };
+  { state: "delivered" | "queued" } | { state: "failed"; why: string };
 
 export interface PaneView {
   text: string;

package/lib/bus/index.ts

@@ -70,8 +70,7 @@ function candidates(sessions: Session[]): Candidate[] {
 const sessionById = (id: string | null | undefined) =>
   id
     ? (db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
-        | Session
-        | undefined)
+        Session | undefined)
     : undefined;
 
 // A chat has no pane: its worker is the state, and it can always take a

package/lib/chat/compact-context.ts

@@ -31,8 +31,7 @@ export async function compactContext(sessionId: string): Promise<string> {
       `SELECT working_directory, task_prompt, role FROM session_rows WHERE id = ?`
     )
     .get(sessionId) as
-    | Pick<Session, "working_directory" | "task_prompt" | "role">
-    | undefined;
+    Pick<Session, "working_directory" | "task_prompt" | "role"> | undefined;
   // An orchestrator starts fresh instead of compacting.
   if (!session || session.role === "orchestrator") return "";
   const tools = lastItems(sessionId, 400, "tool").filter(

package/lib/chat/discovered-models.ts

@@ -0,0 +1,87 @@
+import os from "os";
+import { discoversModels } from "../model-catalog";
+import { chatDriverFor } from "./drivers";
+import type { ChatModel } from "./events";
+
+const TTL_MS = 5 * 60_000;
+const TIMEOUT_MS = 30_000;
+
+interface Entry {
+  models: ChatModel[];
+  at: number;
+}
+const cache = new Map<string, Entry>();
+const loading = new Map<string, Promise<ChatModel[]>>();
+
+const expand = (p: string) => p.replace(/^~(?=$|\/)/, os.homedir());
+
+async function discover(agentType: string, cwd: string): Promise<ChatModel[]> {
+  const driver = chatDriverFor(agentType);
+  if (!driver) return [];
+  const ac = new AbortController();
+  const timer = setTimeout(
+    () => ac.abort(new Error("Discovery timed out")),
+    TIMEOUT_MS
+  );
+  timer.unref?.();
+  try {
+    const found = await Promise.race([
+      driver.discover({ cwd, env: {}, signal: ac.signal }),
+      new Promise<never>((_, reject) =>
+        ac.signal.addEventListener("abort", () => reject(ac.signal.reason), {
+          once: true,
+        })
+      ),
+    ]);
+    return found.models;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// The models an agent reports for a folder, cached for a few minutes.
+// `refresh` skips the cache; a failure throws and is never cached.
+export async function discoveredModels(
+  agentType: string,
+  folder: string | null | undefined,
+  refresh = false
+): Promise<ChatModel[]> {
+  if (!discoversModels(agentType)) return [];
+  const cwd = expand(folder?.trim() || "~");
+  const key = `${agentType}:${cwd}`;
+  const hit = cache.get(key);
+  if (!refresh && hit && Date.now() - hit.at < TTL_MS) return hit.models;
+  const running = loading.get(key);
+  if (running && !refresh) return running;
+  const run = discover(agentType, cwd)
+    .then((models) => {
+      cache.set(key, { models, at: Date.now() });
+      return models;
+    })
+    .finally(() => {
+      if (loading.get(key) === run) loading.delete(key);
+    });
+  loading.set(key, run);
+  return run;
+}
+
+export function clearDiscoveredModels(): void {
+  cache.clear();
+  loading.clear();
+}
+
+// Whether the agent reports this model. A failed discovery says no, so a
+// launch falls back to the agent's default rather than failing.
+export async function isDiscoveredModel(
+  agentType: string,
+  folder: string | null | undefined,
+  model: string
+): Promise<boolean> {
+  try {
+    return (await discoveredModels(agentType, folder)).some(
+      (m) => m.value === model
+    );
+  } catch {
+    return false;
+  }
+}

package/lib/chat/stop.ts

@@ -70,8 +70,7 @@ export async function stopChatAtTurnEnd(
 }
 
 export type TurnStop =
-  | { stopped: true; killed: boolean }
-  | { stopped: false; reason: string };
+  { stopped: true; killed: boolean } | { stopped: false; reason: string };
 
 export interface TurnStopOptions {
   // How long the turn gets to end after the interrupt before its agent is

package/lib/chat/worker/host.ts

@@ -551,7 +551,7 @@ export class ChatHost {
       this.compactingNow
     )
       return;
-    for (let next; (next = claimNext(this.session.id)); ) {
+    for (let next; (next = claimNext(this.session.id));) {
       this.emit({ type: "queue" });
       this.sendUser(next);
     }

package/lib/code-health/reports.ts

@@ -20,8 +20,7 @@ interface NpmVuln {
   isDirect?: boolean;
   via?: (string | { title?: string; source?: number })[];
   fixAvailable?:
-    | boolean
-    | { name?: string; version?: string; isSemVerMajor?: boolean };
+    boolean | { name?: string; version?: string; isSemVerMajor?: boolean };
 }
 
 interface PnpmAdvisory {

package/lib/db/lumifyhub.ts

@@ -24,8 +24,7 @@ export const ATTEMPT_TTL_MINUTES = 10;
 export const lumifyhubQueries = {
   getConnection: (db: Database.Database) =>
     (db.prepare(`SELECT * FROM lumifyhub_connection WHERE id = 1`).get() as
-      | LumifyHubConnection
-      | undefined) ?? null,
+      LumifyHubConnection | undefined) ?? null,
 
   saveConnection: (
     db: Database.Database,
@@ -65,8 +64,7 @@ export const lumifyhubQueries = {
            FROM lumifyhub_connect_attempts WHERE state = ?`
         )
         .get(`-${ATTEMPT_TTL_MINUTES} minutes`, state) as
-        | (LumifyHubConnectAttempt & { fresh: number })
-        | undefined;
+        (LumifyHubConnectAttempt & { fresh: number }) | undefined;
       db.prepare(`DELETE FROM lumifyhub_connect_attempts WHERE state = ?`).run(
         state
       );

package/lib/db/schedules-move.ts

@@ -200,8 +200,7 @@ export function revertSchedulesMove(db: Database.Database): {
     for (const s of moved) {
       const r = s.recipe_id
         ? (recipe.get(s.recipe_id) as
-            | { brief: string; project_id: string }
-            | undefined)
+            { brief: string; project_id: string } | undefined)
         : undefined;
       restore.run(
         s.migrated_from_kind,

package/lib/db/session-parts/tasks.ts

@@ -20,8 +20,7 @@ export function startTaskClock(
   const row = db
     .prepare(`SELECT created_at, task_since FROM session_rows WHERE id = ?`)
     .get(sessionId) as
-    | { created_at: string; task_since: string | null }
-    | undefined;
+    { created_at: string; task_since: string | null } | undefined;
   if (!row || row.task_since) return;
   setTask(db, sessionId, { task_since: at ?? row.created_at });
 }

package/lib/db/stacks.ts

@@ -1,11 +1,7 @@
 import type Database from "better-sqlite3";
 
 export type StackStatus =
-  | "running"
-  | "paused"
-  | "landing"
-  | "landed"
-  | "failed";
+  "running" | "paused" | "landing" | "landed" | "failed";
 
 export type StackItemStatus =
   | "planned"
@@ -131,8 +127,7 @@ export const stackQueries = {
 
   get: (db: Database.Database, id: string) =>
     (db.prepare(`SELECT * FROM stacks WHERE id = ?`).get(id) as
-      | StackRow
-      | undefined) ?? null,
+      StackRow | undefined) ?? null,
 
   // The board's stack that has not finished yet, if any.
   openForBoard: (db: Database.Database, boardId: string) =>
@@ -150,8 +145,7 @@ export const stackQueries = {
 
   item: (db: Database.Database, id: string) =>
     (db.prepare(`SELECT * FROM stack_items WHERE id = ?`).get(id) as
-      | StackItemRow
-      | undefined) ?? null,
+      StackItemRow | undefined) ?? null,
 
   itemForSession: (db: Database.Database, sessionId: string) =>
     (db

package/lib/db/types.ts

@@ -42,13 +42,7 @@ export interface Session {
   // done: finished without a merge (no PR, or its PR closed).
   // moving: handing it to another machine (moved_to); moved: handed over.
   task_status:
-    | "running"
-    | "merged"
-    | "dropped"
-    | "done"
-    | "moving"
-    | "moved"
-    | null;
+    "running" | "merged" | "dropped" | "done" | "moving" | "moved" | null;
   moved_to: string | null;
   // The session on another machine this task arrived from.
   moved_from: string | null;

package/lib/doctor/checks.ts

@@ -207,15 +207,13 @@ export function runDoctor(
     d
       .probe(fresh)
       .then(checkAgents)
-      .catch(
-        (): DoctorCheck => ({
-          id: "agents",
-          label: "Agent CLI",
-          status: "warn",
-          detail: "Couldn't check the agent CLIs",
-          fix: "Check again",
-        })
-      ),
+      .catch((): DoctorCheck => ({
+        id: "agents",
+        label: "Agent CLI",
+        status: "warn",
+        detail: "Couldn't check the agent CLIs",
+        fix: "Check again",
+      })),
   ]);
   if (!custom) cache = { at: Date.now(), checks };
   return checks;

package/lib/done/archive.ts

@@ -35,8 +35,7 @@ export function unarchiveSession(id: string): Session {
     )
     .run(id).changes;
   const row = db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
-    | Session
-    | undefined;
+    Session | undefined;
   if (!row) throw new Error("Session not found");
   if (!changed) throw new Error(`${row.name} isn't archived`);
   return row;

package/lib/experiments/meter.ts

@@ -18,13 +18,7 @@ import { experimentOn } from ".";
 import { getExperiment, type ExperimentId } from "./registry";
 
 export type ExperimentEvent =
-  | "model"
-  | "script"
-  | "shown"
-  | "accepted"
-  | "dismissed"
-  | "applied"
-  | "error";
+  "model" | "script" | "shown" | "accepted" | "dismissed" | "applied" | "error";
 
 export interface MeterContext {
   trigger: string;

package/lib/health/env/classes.ts

@@ -7,8 +7,6 @@
 
 import type { EnvClass } from "./types";
 
-const OLD_PYTHON =
-  /python3?\.[0-9]\b|Python3?\.framework\/Versions\/3\.[0-9]\b|Python\/3\.[0-9]\b/i;
 const USE_ENV =
   "run it through the repo's own environment (`uv run …` when it has a pyproject.toml or uv.lock, else its .venv/bin/python), not a bare `python3`";
 

package/lib/health/env/recordHit.ts

@@ -19,8 +19,7 @@ export function recordHit(
        WHERE r.id = ?`
     )
     .get(sessionId) as
-    | { project_id: string | null; ws: string | null }
-    | undefined;
+    { project_id: string | null; ws: string | null } | undefined;
   db.prepare(
     `INSERT INTO env_failures
        (session_id, class, project_id, workspace_id, command, line,

package/lib/health/spin.ts

@@ -45,10 +45,7 @@ export interface SpinSample {
 }
 
 export type SpinClass =
-  | "warming"
-  | "sleeping"
-  | "busy-with-output"
-  | "spinning";
+  "warming" | "sleeping" | "busy-with-output" | "spinning";
 
 export function classifySpin(samples: SpinSample[]): SpinClass {
   if (samples.length < 2) return "warming";

package/lib/health/store.ts

@@ -29,8 +29,7 @@ export interface RecordResult {
 
 const rowOf = (id: number) =>
   db.prepare(`SELECT * FROM health_anomalies WHERE id = ?`).get(id) as
-    | AnomalyRow
-    | undefined;
+    AnomalyRow | undefined;
 
 export function anomaly(id: number): AnomalyRow | null {
   return rowOf(id) ?? null;

package/lib/hosts/index.ts

@@ -39,8 +39,7 @@ export function getHost(hostId: string | null | undefined): Host | null {
   if (!isRemoteHost(hostId)) return LOCAL_HOST;
   return (
     (getDb().prepare(`SELECT * FROM hosts WHERE id = ?`).get(hostId) as
-      | Host
-      | undefined) ?? null
+      Host | undefined) ?? null
   );
 }
 

package/lib/hosts/peer-sync.ts

@@ -95,8 +95,7 @@ export function syncPeerMirrors(
     const [name, view, tmuxName, projectId, prUrl, prNumber, prStatus, at] =
       fields;
     const cur = current.get(peer.id, hostId) as
-      | Record<string, string | number | null>
-      | undefined;
+      Record<string, string | number | null> | undefined;
     if (!cur) return;
     const same =
       cur.name === name &&
@@ -126,8 +125,7 @@ export function syncPeerMirrors(
   db.transaction(() => {
     for (const peer of listed) {
       const row = owner.get(peer.id) as
-        | { host_id: string; project_id: string | null }
-        | undefined;
+        { host_id: string; project_id: string | null } | undefined;
       // One started here for a project here keeps it (lib/hosts/peer-actions.ts).
       const kept =
         row?.project_id && here.has(row.project_id) ? row.project_id : null;

package/lib/hosts/remote-api.ts

@@ -21,8 +21,7 @@ export function hostLink(hostId: string | null | undefined): HostLink | null {
          JOIN hosts h ON h.id = l.host_id WHERE l.host_id = ?`
     )
     .get(hostId) as
-    | { host_id: string; url: string; token: string; name: string }
-    | undefined;
+    { host_id: string; url: string; token: string; name: string } | undefined;
   return row
     ? {
         hostId: row.host_id,

package/lib/lumifyhub/types.ts

@@ -23,11 +23,7 @@ export interface LhBoard {
 }
 
 export type LhListCategory =
-  | "backlog"
-  | "unstarted"
-  | "started"
-  | "completed"
-  | "canceled";
+  "backlog" | "unstarted" | "started" | "completed" | "canceled";
 
 export interface LhList {
   id: string;
@@ -39,9 +35,7 @@ export interface LhList {
 
 // A TipTap/ProseMirror document, or a bare string on older cards.
 export type LhRichText =
-  | string
-  | { type?: string; text?: string; content?: LhRichText[] }
-  | null;
+  string | { type?: string; text?: string; content?: LhRichText[] } | null;
 
 export interface LhCard {
   id: string;