@saadnvd1/agent-os 0.3.513 → 0.3.516

package/lib/security/devices.ts

@@ -5,6 +5,12 @@
 
 import crypto from "crypto";
 import { getDb } from "@/lib/db";
+import { enabledCategories } from "@/lib/notify/copy";
+import type {
+  PushCategory,
+  PushEnvironment,
+  PushPlatform,
+} from "@/lib/notify/push-types";
 
 export interface Device {
   id: string;
@@ -115,13 +121,162 @@ export function revokeDevice(id: string): boolean {
   const changed =
     getDb()
       .prepare(
-        `UPDATE devices SET revoked_at = datetime('now') WHERE id = ? AND revoked_at IS NULL`
+        `UPDATE devices SET revoked_at = datetime('now'),
+           push_token = NULL, push_platform = NULL, push_environment = NULL,
+           push_categories = NULL, push_updated_at = NULL, push_last_error = NULL
+         WHERE id = ? AND revoked_at IS NULL`
       )
       .run(id).changes > 0;
   if (changed) dropDeviceSockets(id);
   return changed;
 }
 
+export interface DevicePush {
+  token: string;
+  platform: PushPlatform;
+  environment: PushEnvironment;
+  /** What it receives: its saved list, or the defaults. */
+  categories: PushCategory[];
+  updatedAt: string;
+  lastError: string | null;
+}
+
+interface PushRow {
+  push_token: string | null;
+  push_platform: PushPlatform;
+  push_environment: PushEnvironment;
+  push_categories: string | null;
+  push_updated_at: string;
+  push_last_error: string | null;
+}
+
+// A corrupt saved list reads as "none saved", so the defaults apply.
+function parseCategories(raw: string | null): unknown[] | null {
+  if (!raw) return null;
+  try {
+    const v = JSON.parse(raw);
+    return Array.isArray(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+
+const pushOf = (r: PushRow | undefined): DevicePush | null =>
+  r?.push_token
+    ? {
+        token: r.push_token,
+        platform: r.push_platform,
+        environment: r.push_environment,
+        categories: enabledCategories(parseCategories(r.push_categories)),
+        updatedAt: r.push_updated_at,
+        lastError: r.push_last_error,
+      }
+    : null;
+
+const PUSH_COLS = `push_token, push_platform, push_environment, push_categories,
+  push_updated_at, push_last_error`;
+
+export function getDevicePush(id: string): DevicePush | null {
+  return pushOf(
+    getDb()
+      .prepare(
+        `SELECT ${PUSH_COLS} FROM devices WHERE id = ? AND revoked_at IS NULL`
+      )
+      .get(id) as PushRow | undefined
+  );
+}
+
+/** Every live device that can be sent a push, for the sender. */
+export function listPushDevices(): { id: string; push: DevicePush }[] {
+  const rows = getDb()
+    .prepare(
+      `SELECT id, ${PUSH_COLS} FROM devices
+       WHERE revoked_at IS NULL AND push_token IS NOT NULL`
+    )
+    .all() as (PushRow & { id: string })[];
+  return rows.flatMap((r) => {
+    const push = pushOf(r);
+    return push ? [{ id: r.id, push }] : [];
+  });
+}
+
+/**
+ * Registers or refreshes a device's push token. Idempotent. Saved categories
+ * are kept unless new ones are given. A token belongs to one device: if
+ * another row held it (a re-pair on the same phone), that row loses it so
+ * nothing is sent twice.
+ */
+export function setDevicePush(
+  id: string,
+  p: {
+    token: string;
+    platform: PushPlatform;
+    environment: PushEnvironment;
+    categories?: PushCategory[];
+  }
+): boolean {
+  const db = getDb();
+  return db.transaction(() => {
+    db.prepare(
+      `UPDATE devices SET push_token = NULL, push_platform = NULL,
+         push_environment = NULL, push_categories = NULL,
+         push_updated_at = NULL, push_last_error = NULL
+       WHERE push_token = ? AND id != ?`
+    ).run(p.token, id);
+    return (
+      db
+        .prepare(
+          `UPDATE devices SET push_token = ?, push_platform = ?, push_environment = ?,
+             push_categories = COALESCE(?, push_categories),
+             push_updated_at = datetime('now'), push_last_error = NULL
+           WHERE id = ? AND revoked_at IS NULL`
+        )
+        .run(
+          p.token,
+          p.platform,
+          p.environment,
+          p.categories ? JSON.stringify(p.categories) : null,
+          id
+        ).changes > 0
+    );
+  })();
+}
+
+/** False when the device has no push registered. */
+export function setDevicePushCategories(
+  id: string,
+  categories: PushCategory[]
+): boolean {
+  return (
+    getDb()
+      .prepare(
+        `UPDATE devices SET push_categories = ?, push_updated_at = datetime('now')
+         WHERE id = ? AND revoked_at IS NULL AND push_token IS NOT NULL`
+      )
+      .run(JSON.stringify(categories), id).changes > 0
+  );
+}
+
+/** The sender records why a send failed, so the Devices page can say. */
+export function setDevicePushError(id: string, error: string | null): void {
+  getDb()
+    .prepare(`UPDATE devices SET push_last_error = ? WHERE id = ?`)
+    .run(error ? error.slice(0, 200) : null, id);
+}
+
+export function clearDevicePush(id: string): boolean {
+  return (
+    getDb()
+      .prepare(
+        `UPDATE devices SET push_token = NULL, push_platform = NULL,
+           push_environment = NULL, push_categories = NULL,
+           push_updated_at = NULL, push_last_error = NULL
+         WHERE id = ? AND push_token IS NOT NULL`
+      )
+      .run(id).changes > 0
+  );
+}
+
 // Open WebSockets per device, so revoking one cuts its live terminal too.
 // On globalThis because server.ts and Next's route bundles load this module
 // separately.

package/lib/security/net.ts

@@ -5,6 +5,7 @@
  * another site's page (drive-by requests from any website the user visits).
  */
 
+import { isIP } from "net";
 import os from "os";
 
 const TAILSCALE_V4 = /^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./; // 100.64.0.0/10
@@ -72,6 +73,8 @@ export function bindAddresses(
 export interface AccessPolicy {
   bound: string[];
   extraHosts: string[];
+  /** This machine's Connect address (connect.json), when it has one. */
+  machineHost?: () => string | null;
 }
 
 const LOCAL_NAMES = new Set(["localhost", "127.0.0.1", "::1"]);
@@ -82,6 +85,23 @@ function hostname(hostOrUrlHost: string): string {
   return h.replace(/:\d+$/, "");
 }
 
+// Every Connect machine is m-<16 hex>.runagentos.com, so all of them are
+// the same site: another machine's page is never one of ours.
+const MACHINE_HOST = /^m-[0-9a-f]{16}\.runagentos\.com$/;
+
+const machineHostOf = (policy: AccessPolicy) =>
+  policy.machineHost?.()?.toLowerCase() || null;
+
+/** Names that are this machine whatever it's bound to. */
+function ownHost(h: string, policy: AccessPolicy): boolean {
+  return (
+    LOCAL_NAMES.has(h) ||
+    (h !== "0.0.0.0" && policy.bound.includes(h)) ||
+    policy.extraHosts.includes(h) ||
+    machineHostOf(policy) === h
+  );
+}
+
 export function hostAllowed(
   host: string | undefined,
   policy: AccessPolicy
@@ -89,25 +109,39 @@ export function hostAllowed(
   if (!host) return false;
   if (policy.bound.includes("0.0.0.0")) return true;
   const h = hostname(host);
-  return (
-    LOCAL_NAMES.has(h) ||
-    policy.bound.includes(h) ||
-    h.endsWith(".ts.net") ||
-    policy.extraHosts.includes(h)
-  );
+  return ownHost(h, policy) || h.endsWith(".ts.net");
 }
 
+/**
+ * A page may talk to this machine only from one of this machine's own
+ * origins, whatever AGENTOS_BIND says: its loopback, bound and configured
+ * names, its own Connect address, or the host the request itself names when
+ * that is one of its addresses (a page served here on any of its ports; the
+ * mobile app's native socket sends that one). A wildcard bind widens the
+ * Host check, never this one: not another machine's m- address, not a name
+ * rebound to this machine's address.
+ */
 export function originAllowed(
   origin: string | undefined,
-  policy: AccessPolicy
+  policy: AccessPolicy,
+  requestHost?: string
 ): boolean {
-  if (!origin) return true; // not a browser page: curl, aos, server-side
+  if (!origin) return true; // not a browser page: curl, aos, peers, the app
   if (origin === "null") return false;
+  let h: string;
   try {
-    return hostAllowed(new URL(origin).host, policy);
+    h = hostname(new URL(origin).host);
   } catch {
     return false;
   }
+  if (!h) return false;
+  if (MACHINE_HOST.test(h)) return h === machineHostOf(policy);
+  if (ownHost(h, policy)) return true;
+  return (
+    !!requestHost &&
+    h === hostname(requestHost) &&
+    (h.endsWith(".ts.net") || isIP(h) !== 0)
+  );
 }
 
 const SAFE_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
@@ -145,7 +179,7 @@ export function requestAllowed(
   if (!req.url?.startsWith("/api/")) return true;
   if (req.fetchSite === "cross-site") return crossSiteNavigationAllowed(req);
   if (!SAFE_METHODS.has((req.method ?? "GET").toUpperCase())) {
-    return originAllowed(req.origin, policy);
+    return originAllowed(req.origin, policy, req.host);
   }
   return true;
 }
@@ -154,5 +188,7 @@ export function upgradeAllowed(
   req: { host?: string; origin?: string },
   policy: AccessPolicy
 ): boolean {
-  return hostAllowed(req.host, policy) && originAllowed(req.origin, policy);
+  return (
+    hostAllowed(req.host, policy) && originAllowed(req.origin, policy, req.host)
+  );
 }

package/lib/status/collect.ts

@@ -19,7 +19,8 @@ import {
   getProviderIdFromSessionName,
   getSessionIdFromName,
 } from "../providers/registry";
-import { getDb, type Session } from "../db";
+import { getDb } from "../db";
+import { beginPass, chatMemo } from "./incremental";
 import { chatCompacting, chatState } from "../chat/runner";
 import { chatActivityLine, chatStall } from "../chat/activity";
 import {
@@ -243,32 +244,16 @@ function getAgentTypeFromSessionName(sessionName: string): AgentType {
   return getProviderIdFromSessionName(sessionName) || "claude";
 }
 
-function terminalRow(db: ReturnType<typeof getDb>, id: string) {
-  return db
-    .prepare(
-      `SELECT id, view, updated_at, last_seen_at FROM sessions WHERE id = ?`
-    )
-    .get(id) as
-    | Pick<Session, "id" | "view" | "updated_at" | "last_seen_at">
-    | undefined;
-}
-
-async function collect(): Promise<StatusSnapshot> {
+async function collect(full = false): Promise<StatusSnapshot> {
   const sessions = await getTmuxSessions();
 
   const db = getDb();
+  // Read once the sessions are listed, so what was kept is as new as it.
+  const pass = beginPass(Date.now(), full);
+  const rows = [...pass.rows.values()];
   const panes = managedPanes(
     sessions,
-    db
-      .prepare(
-        `SELECT id, tmux_name, agent_type, host_id FROM sessions WHERE archived_at IS NULL AND (view IS NULL OR view != 'chat')`
-      )
-      .all() as {
-      id: string;
-      tmux_name: string | null;
-      agent_type: string | null;
-      host_id: string | null;
-    }[],
+    rows.filter((s) => s.view !== "chat"),
     (name) => UUID_PATTERN.test(name),
     getSessionIdFromName
   );
@@ -351,7 +336,7 @@ async function collect(): Promise<StatusSnapshot> {
     lastLine,
     agentType,
   } of results) {
-    const row = terminalRow(db, id);
+    const row = pass.rows.get(id);
     const shared = {
       sessionName,
       lastLine,
@@ -418,6 +403,8 @@ async function collect(): Promise<StatusSnapshot> {
   // Update claude_session_id directly here instead of requiring separate API calls
   for (const { id, claudeSessionId, agentType } of results) {
     if (!claudeSessionId) continue;
+    // Already stored (as the rows above read it): nothing to write.
+    if (pass.rows.get(id)?.claude_session_id === claudeSessionId) continue;
     if (agentType === "claude")
       updateClaudeIdStmt.run(claudeSessionId, id, claudeSessionId);
     else
@@ -432,14 +419,9 @@ async function collect(): Promise<StatusSnapshot> {
 
   // A linked machine's sessions: its AgentOS says how they are.
   const linked = linkedHostIds();
-  const mirrors = (
-    db
-      .prepare(
-        `SELECT id, tmux_name, agent_type, host_id FROM sessions
-          WHERE archived_at IS NULL AND host_id IS NOT NULL AND host_id != 'local'`
-      )
-      .all() as Pick<Session, "id" | "tmux_name" | "agent_type" | "host_id">[]
-  ).filter((s) => linked.has(s.host_id));
+  const mirrors = rows.filter(
+    (s) => s.host_id && s.host_id !== "local" && linked.has(s.host_id)
+  );
   for (const s of mirrors) {
     const status = peerStatus(s.host_id, s.id);
     if (status)
@@ -452,36 +434,39 @@ async function collect(): Promise<StatusSnapshot> {
 
   // Chat sessions have no tmux pane: their live conversation is the status.
   // A linked machine's chats are its own (above).
-  for (const session of db
-    .prepare(
-      `SELECT * FROM sessions WHERE view = 'chat' AND archived_at IS NULL
-         AND (host_id IS NULL OR host_id = 'local')`
-    )
-    .all() as Session[]) {
+  for (const session of rows.filter(
+    (s) => s.view === "chat" && (!s.host_id || s.host_id === "local")
+  )) {
     const state = chatState(session.id);
-    const asks =
-      session.role === "orchestrator" ? openAskCount(session.workspace_id) : 0;
+    const orchestrator = session.role === "orchestrator";
+    // What the database says; the rest below moves with time or the process.
+    const base = chatMemo(pass, session.id, orchestrator, state ?? "", () => {
+      const asks = orchestrator ? openAskCount(session.workspace_id) : 0;
+      return {
+        asks,
+        waiting: needsYou(session, state),
+        need: chatNeed(session, state, asks),
+        unread: isUnread(session, state),
+        lastTask: lastUserTask(session.id),
+      };
+    });
     statusMap[session.id] = {
       sessionName: session.tmux_name,
       status:
-        state === "running"
-          ? "running"
-          : needsYou(session, state)
-            ? "waiting"
-            : "idle",
-      task: chatActivityLine(session.id) ?? lastUserTask(session.id),
+        state === "running" ? "running" : base.waiting ? "waiting" : "idle",
+      task: chatActivityLine(session.id) ?? base.lastTask,
       agentType: session.agent_type,
-      need: chatNeed(session, state, asks),
-      unread: isUnread(session, state),
+      need: base.need,
+      unread: base.unread,
       ...(chatStall(session.id) && { stalled: true }),
       ...(chatCompacting(session.id) && {
         compacting: chatCompacting(session.id)!,
       }),
-      ...(session.role === "orchestrator" && { asks }),
+      ...(orchestrator && { asks: base.asks }),
     };
   }
 
-  addPrStages(statusMap);
+  addPrStages(statusMap, pass);
 
   // Cleanup old trackers
   statusDetector.cleanup();
@@ -492,8 +477,11 @@ async function collect(): Promise<StatusSnapshot> {
 // Callers at the same moment share one pass over tmux.
 let inflight: Promise<StatusSnapshot> | null = null;
 
-export function collectStatuses(): Promise<StatusSnapshot> {
-  inflight ??= collect().finally(() => {
+/** `full`: recompute everything kept from earlier passes. */
+export function collectStatuses({
+  full = false,
+}: { full?: boolean } = {}): Promise<StatusSnapshot> {
+  inflight ??= collect(full).finally(() => {
     inflight = null;
   });
   return inflight;

package/lib/status/dirty.ts

@@ -0,0 +1,42 @@
+// Which sessions' status inputs changed since the last pass, so a pass
+// recomputes those and reuses the rest (lib/status/incremental.ts). Marked
+// from the places that write them. No imports, so any module can call it.
+//
+// Shared by the custom server and the Next.js route bundles.
+interface Dirty {
+  all: boolean;
+  // A session's id and the time before which it stays marked.
+  ids: Map<string, number>;
+}
+
+const g = globalThis as unknown as { __agentosStatusDirty?: Dirty };
+const dirty: Dirty = (g.__agentosStatusDirty ??= {
+  all: false,
+  ids: new Map(),
+});
+
+/**
+ * `id`'s inputs changed. With `settleMs` it stays marked, so every pass
+ * recomputes it, until a pass at or after that time: a write still on its
+ * way (a worker's buffered chat items) can't be cached half-seen.
+ */
+export function markStatusDirty(id: string, settleMs = 0): void {
+  const until = Date.now() + settleMs;
+  dirty.ids.set(id, Math.max(dirty.ids.get(id) ?? 0, until));
+}
+
+/** Something every session's status may depend on changed. */
+export function markAllStatusDirty(): void {
+  dirty.all = true;
+}
+
+/** What a pass starting at `now` recomputes; the marks it settles are cleared. */
+export function takeDirty(now = Date.now()): {
+  all: boolean;
+  ids: Set<string>;
+} {
+  const taken = { all: dirty.all, ids: new Set(dirty.ids.keys()) };
+  dirty.all = false;
+  for (const [id, until] of dirty.ids) if (until <= now) dirty.ids.delete(id);
+  return taken;
+}

package/lib/status/incremental.ts

@@ -0,0 +1,151 @@
+// What a status pass keeps from the one before, so its cost follows what
+// changed and not how many sessions there are:
+//  - the session rows, re-read only when `sessions` or `projects` moved
+//    (lib/db/changes.ts: every writer is seen) and compared to find the
+//    sessions that changed;
+//  - per chat and per task, what is worked out from the database, recomputed
+//    when its session is marked dirty (lib/status/dirty.ts).
+// Every FULL_RECOMPUTE_MS a pass recomputes everything, so an invalidation
+// nobody made self-heals.
+import { getDb, type Session } from "../db";
+import { changeWatcher } from "../db/changes";
+import { takeDirty } from "./dirty";
+
+export const FULL_RECOMPUTE_MS = 30_000;
+
+// A session row, and the workspace of its project.
+export type SessionRow = Session & { project_workspace_id: string | null };
+
+export interface Pass {
+  // Everything is recomputed.
+  full: boolean;
+  // Sessions whose inputs changed (all of them on a full pass).
+  dirty: Set<string>;
+  // An orchestrator's asks changed: they and the tasks that read them.
+  asksMoved: boolean;
+  rows: Map<string, SessionRow>;
+}
+
+type Entry<T> = { key: string; value: T };
+
+interface Cache {
+  rows: Map<string, { row: SessionRow; json: string }>;
+  watch: (() => string[]) | null;
+  lastFullAt: number;
+  loaded: boolean;
+  chats: Map<string, Entry<unknown>>;
+  prs: Map<string, Entry<unknown>>;
+}
+
+const g = globalThis as unknown as { __agentosStatusCache?: Cache };
+const cache: Cache = (g.__agentosStatusCache ??= {
+  rows: new Map(),
+  watch: null,
+  lastFullAt: 0,
+  loaded: false,
+  chats: new Map(),
+  prs: new Map(),
+});
+
+/** Forget everything kept: the next pass computes it all. */
+export function resetStatusCaches(): void {
+  cache.rows.clear();
+  cache.chats.clear();
+  cache.prs.clear();
+  cache.watch = null;
+  cache.loaded = false;
+  cache.lastFullAt = 0;
+}
+
+function loadRows(dirty: Set<string>): void {
+  const rows = getDb()
+    .prepare(
+      `SELECT s.*, p.workspace_id AS project_workspace_id FROM sessions s
+         LEFT JOIN projects p ON p.id = s.project_id
+        WHERE s.archived_at IS NULL`
+    )
+    .all() as SessionRow[];
+  const before = cache.rows;
+  cache.rows = new Map();
+  for (const row of rows) {
+    const json = JSON.stringify(row);
+    if (before.get(row.id)?.json !== json) dirty.add(row.id);
+    cache.rows.set(row.id, { row, json });
+  }
+  for (const id of before.keys())
+    if (!cache.rows.has(id)) {
+      cache.chats.delete(id);
+      cache.prs.delete(id);
+    }
+}
+
+export function beginPass(now = Date.now(), forceFull = false): Pass {
+  // Read before the rows, so a write between the two is seen next time.
+  const moved = (cache.watch ??= changeWatcher(getDb))();
+  const taken = takeDirty(now);
+  const full =
+    forceFull ||
+    !cache.loaded ||
+    taken.all ||
+    now - cache.lastFullAt >= FULL_RECOMPUTE_MS;
+  const dirty = taken.ids;
+  if (full || moved.includes("sessions") || moved.includes("projects")) {
+    loadRows(dirty);
+    cache.loaded = true;
+  }
+  if (full) {
+    cache.chats.clear();
+    cache.prs.clear();
+    cache.lastFullAt = now;
+  }
+  return {
+    full,
+    dirty,
+    asksMoved: moved.includes("orchestrator_asks"),
+    rows: new Map([...cache.rows].map(([id, e]) => [id, e.row])),
+  };
+}
+
+function remembered<T>(
+  store: Map<string, Entry<unknown>>,
+  id: string,
+  stale: boolean,
+  key: string,
+  compute: () => { value: T; keep: boolean }
+): T {
+  const kept = store.get(id);
+  if (!stale && kept && kept.key === key) return kept.value as T;
+  const { value, keep } = compute();
+  if (keep) store.set(id, { key, value });
+  else store.delete(id);
+  return value;
+}
+
+/**
+ * A chat's database-derived status, from the last pass unless it changed.
+ * `key` is what else it was computed from (its state).
+ */
+export function chatMemo<T>(
+  pass: Pass,
+  id: string,
+  orchestrator: boolean,
+  key: string,
+  compute: () => T
+): T {
+  const stale =
+    pass.full || pass.dirty.has(id) || (orchestrator && pass.asksMoved);
+  return remembered(cache.chats, id, stale, key, () => ({
+    value: compute(),
+    keep: true,
+  }));
+}
+
+/** A task's PR stage; `compute` says whether it can be kept (time moves it). */
+export function prMemo<T>(
+  pass: Pass,
+  id: string,
+  compute: () => { value: T; keep: boolean }
+): T {
+  const stale = pass.full || pass.dirty.has(id) || pass.asksMoved;
+  return remembered(cache.prs, id, stale, "", compute);
+}