@saadnvd1/agent-os 0.3.516 → 0.3.518

package/lib/notify/push/index.ts

@@ -0,0 +1,183 @@
+/**
+ * Push for the phone app. `pushEvent` decides whether an event goes out, to
+ * whom, and now or in the Away digest; the sender does the delivering.
+ * Telegram is the fallback only for what Telegram carried before push
+ * (events given a `fallback`); the newer events are push-only.
+ */
+
+import crypto from "crypto";
+import { db } from "../../db";
+import { activeAway } from "../../away/state";
+import { listPushDevices } from "@/lib/security/devices";
+import type { PushEvent } from "../push-types";
+import { encodePush } from "./encode";
+import * as outbox from "./outbox";
+import { atMac } from "./presence";
+import {
+  CAP_PER_HOUR,
+  HOUR_MS,
+  capExempt,
+  foldsWhenAway,
+  presenceGated,
+} from "./policy";
+import { linked, NOT_LINKED } from "./relay";
+import { PushSender } from "./sender";
+
+const g = globalThis as unknown as { __agentosPush?: PushSender };
+
+export function sender(): PushSender {
+  return (g.__agentosPush ??= new PushSender());
+}
+
+/** Whether a message with a push category can go by push right now. */
+export function pushAvailable(): boolean {
+  return linked() && !sender().unavailable() && listPushDevices().length > 0;
+}
+
+export function pushStatus(): { linked: boolean; unavailable: string | null } {
+  return { linked: linked(), unavailable: sender().unavailable() };
+}
+
+export type PushOutcome =
+  | "queued"
+  | "folded"
+  | "dropped"
+  | "muted"
+  | "unavailable";
+
+export interface PushOptions {
+  /** Held text that goes by Telegram if no phone is reached. */
+  fallback?: { source: string; text: string } | null;
+  /** A session the event is about: a mirror of another machine's never pushes. */
+  sessionId?: string | null;
+  /** Explicit sends (a test): no presence, Away, cap or category rules. */
+  bypass?: boolean;
+  deviceIds?: string[];
+}
+
+function isMirrored(sessionId: string): boolean {
+  const s = db
+    .prepare(`SELECT host_id, peer_mirror FROM sessions WHERE id = ?`)
+    .get(sessionId) as
+    | { host_id: string | null; peer_mirror: number | null }
+    | undefined;
+  return !!s && (!!s.peer_mirror || (!!s.host_id && s.host_id !== "local"));
+}
+
+export async function pushEvent(
+  event: PushEvent,
+  opts: PushOptions = {}
+): Promise<PushOutcome> {
+  if (opts.sessionId && isMirrored(opts.sessionId)) return "dropped";
+  const s = sender();
+  if (!linked() || s.unavailable()) return "unavailable";
+  const devices = listPushDevices().filter(
+    (d) => !opts.deviceIds || opts.deviceIds.includes(d.id)
+  );
+  if (!devices.length) return "unavailable";
+  const targets = opts.bypass
+    ? devices
+    : devices.filter((d) => d.push.categories.includes(event.category));
+  if (!targets.length) return "muted";
+
+  const now = Date.now();
+  const key = event.key ?? `${event.category}:${event.id ?? "-"}:${now}`;
+  const enc = encodePush({ ...event, key });
+  const row = {
+    eventKey: key,
+    category: event.category,
+    level: enc.level,
+    payload: enc.payload,
+    collapseId: enc.collapseId,
+    now,
+  };
+  if (!opts.bypass) {
+    if (activeAway() && foldsWhenAway(event.category)) {
+      outbox.enqueue({ ...row, deviceId: "", state: "folded" });
+      return "folded";
+    }
+    if (presenceGated(event.category) && (await atMac())) return "dropped";
+  }
+  let queued = 0;
+  for (const d of targets) {
+    const over =
+      !opts.bypass &&
+      !capExempt(event.category) &&
+      enc.level !== "passive" &&
+      outbox.alertingSince(d.id, now) >= CAP_PER_HOUR;
+    if (over) {
+      outbox.enqueue({ ...row, deviceId: d.id, state: "capped" });
+      // One summary an hour says there was more.
+      const sum = encodePush({
+        category: "digest",
+        key: `overflow:${d.id}:${Math.floor(now / HOUR_MS)}`,
+      });
+      outbox.enqueue({
+        eventKey: `overflow:${d.id}:${Math.floor(now / HOUR_MS)}`,
+        deviceId: d.id,
+        category: "digest",
+        level: sum.level,
+        payload: sum.payload,
+        collapseId: sum.collapseId,
+        now,
+      });
+      queued++;
+      continue;
+    }
+    if (outbox.enqueue({ ...row, deviceId: d.id, fallback: opts.fallback }))
+      queued++;
+  }
+  if (queued) void s.kick();
+  return queued ? "queued" : "dropped";
+}
+
+export interface TestResult {
+  deviceId: string;
+  status: "sent" | "gone" | "failed";
+  error: string | null;
+}
+
+/** A real send to the phones now, ignoring every quiet rule, and its answer. */
+export async function sendTestPush(
+  deviceId?: string
+): Promise<{ results: TestResult[]; unavailable: string | null }> {
+  const s = sender();
+  if (!linked()) return { results: [], unavailable: NOT_LINKED };
+  s.clearUnavailable();
+  const key = `test:${Date.now()}:${crypto.randomBytes(3).toString("hex")}`;
+  const devices = listPushDevices().filter(
+    (d) => !deviceId || d.id === deviceId
+  );
+  const enc = encodePush({ category: "system", key });
+  const now = Date.now();
+  for (const d of devices)
+    outbox.enqueue({
+      eventKey: key,
+      deviceId: d.id,
+      category: "system",
+      level: enc.level,
+      payload: enc.payload,
+      collapseId: enc.collapseId,
+      now,
+    });
+  await s.kick();
+  const results = outbox.rowsFor(key).map((r) => ({
+    deviceId: r.device_id,
+    status: (r.state === "sent"
+      ? "sent"
+      : r.state === "gone"
+        ? "gone"
+        : "failed") as TestResult["status"],
+    error: r.state === "sent" ? null : (r.error ?? "not sent"),
+  }));
+  return { results, unavailable: s.unavailable() };
+}
+
+export function resumePushOutbox(): void {
+  sender().resume();
+}
+
+/** How many held events the next Away digest stands for. */
+export function takeFoldedPushes(now = Date.now()): number {
+  return outbox.takeFolded(now);
+}

package/lib/notify/push/outbox.ts

@@ -0,0 +1,238 @@
+/**
+ * The push outbox (SQLite, so a restart keeps what's waiting): one row per
+ * event and device. A row is marked `sending` before the relay is called; a
+ * restart puts it back to `pending`, and the repeat carries the same collapse
+ * id, so the phone replaces the alert rather than stacking a second.
+ */
+
+import { db } from "../../db";
+import type { PushCategory, PushLevel } from "../push-types";
+import { HOUR_MS } from "./policy";
+
+export type PushState =
+  | "pending"
+  | "sending"
+  | "sent"
+  | "failed"
+  | "gone"
+  | "capped"
+  | "superseded"
+  | "folded"
+  | "digested";
+
+export interface OutboxRow {
+  id: number;
+  event_key: string;
+  device_id: string;
+  category: PushCategory;
+  level: PushLevel;
+  payload: string;
+  collapse_id: string | null;
+  state: PushState;
+  attempts: number;
+  next_attempt_at: number;
+  created_at: number;
+  sent_at: number | null;
+  error: string | null;
+  fallback_source: string | null;
+  fallback_text: string | null;
+}
+
+/** An event older than this isn't worth buzzing about any more. */
+export const MAX_AGE_MS = HOUR_MS;
+const KEEP_MS = 7 * 24 * HOUR_MS;
+
+export const isTestKey = (eventKey: string) => eventKey.startsWith("test:");
+
+export interface NewRow {
+  eventKey: string;
+  deviceId: string;
+  category: PushCategory;
+  level: PushLevel;
+  payload: unknown;
+  collapseId: string | null;
+  state?: "pending" | "capped" | "folded";
+  now: number;
+  fallback?: { source: string; text: string } | null;
+}
+
+/** False when this event was already queued for the device. */
+export function enqueue(r: NewRow): boolean {
+  const state = r.state ?? "pending";
+  return db.transaction(() => {
+    const { changes } = db
+      .prepare(
+        `INSERT OR IGNORE INTO push_outbox
+           (event_key, device_id, category, level, payload, collapse_id, state,
+            next_attempt_at, created_at, fallback_source, fallback_text)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        r.eventKey,
+        r.deviceId,
+        r.category,
+        r.level,
+        JSON.stringify(r.payload),
+        r.collapseId,
+        state,
+        r.now,
+        r.now,
+        r.fallback?.source ?? null,
+        r.fallback?.text ?? null
+      );
+    if (changes && state === "pending" && r.collapseId)
+      db.prepare(
+        `UPDATE push_outbox SET state = 'superseded'
+         WHERE device_id = ? AND collapse_id = ? AND state = 'pending' AND event_key != ?`
+      ).run(r.deviceId, r.collapseId, r.eventKey);
+    return changes > 0;
+  })();
+}
+
+/** Alerting pushes made for a device in the last hour (the cap's count). */
+export function alertingSince(deviceId: string, now: number): number {
+  return (
+    db
+      .prepare(
+        `SELECT COUNT(*) AS n FROM push_outbox
+         WHERE device_id = ? AND created_at > ? AND level != 'passive'
+           AND category != 'asks' AND event_key NOT LIKE 'test:%'
+           AND state IN ('pending', 'sending', 'sent')`
+      )
+      .get(deviceId, now - HOUR_MS) as { n: number }
+  ).n;
+}
+
+/** Folded into the next Away digest: how many were waiting, now counted. */
+export function takeFolded(now: number): number {
+  return db
+    .prepare(
+      `UPDATE push_outbox SET state = 'digested', sent_at = ? WHERE state = 'folded'`
+    )
+    .run(now).changes;
+}
+
+/** Pending rows past their age limit fail; returns their event keys. */
+export function expire(now: number): string[] {
+  const rows = db
+    .prepare(
+      `SELECT DISTINCT event_key FROM push_outbox WHERE state = 'pending' AND created_at < ?`
+    )
+    .all(now - MAX_AGE_MS) as { event_key: string }[];
+  if (rows.length)
+    db.prepare(
+      `UPDATE push_outbox SET state = 'failed', error = 'too old to send'
+       WHERE state = 'pending' AND created_at < ?`
+    ).run(now - MAX_AGE_MS);
+  return rows.map((r) => r.event_key);
+}
+
+/** Due rows, marked sending with the attempt counted. */
+export function claimDue(now: number, limit = 50): OutboxRow[] {
+  return db.transaction(() => {
+    const rows = db
+      .prepare(
+        `SELECT * FROM push_outbox WHERE state = 'pending' AND next_attempt_at <= ?
+         ORDER BY id LIMIT ?`
+      )
+      .all(now, limit) as OutboxRow[];
+    const mark = db.prepare(
+      `UPDATE push_outbox SET state = 'sending', attempts = attempts + 1 WHERE id = ?`
+    );
+    for (const r of rows) {
+      mark.run(r.id);
+      r.attempts += 1;
+      r.state = "sending";
+    }
+    return rows;
+  })();
+}
+
+export function markSent(id: number, now: number): void {
+  db.prepare(
+    `UPDATE push_outbox SET state = 'sent', sent_at = ?, error = NULL WHERE id = ?`
+  ).run(now, id);
+}
+
+export function markFailed(id: number, error: string, gone = false): void {
+  db.prepare(`UPDATE push_outbox SET state = ?, error = ? WHERE id = ?`).run(
+    gone ? "gone" : "failed",
+    error.slice(0, 200),
+    id
+  );
+}
+
+export function markRetry(id: number, at: number, error: string): void {
+  db.prepare(
+    `UPDATE push_outbox SET state = 'pending', next_attempt_at = ?, error = ? WHERE id = ?`
+  ).run(at, error.slice(0, 200), id);
+}
+
+/** Everything waiting fails at once, so a dead relay is asked once, not per row. */
+export function failPending(error: string): string[] {
+  const keys = db
+    .prepare(
+      `SELECT DISTINCT event_key FROM push_outbox WHERE state = 'pending'`
+    )
+    .all() as { event_key: string }[];
+  db.prepare(
+    `UPDATE push_outbox SET state = 'failed', error = ? WHERE state = 'pending'`
+  ).run(error.slice(0, 200));
+  return keys.map((k) => k.event_key);
+}
+
+/** Every row of the event has ended and none reached a phone. */
+export function claimFallback(
+  eventKey: string
+): { source: string; text: string } | null {
+  return db.transaction(() => {
+    const rows = db
+      .prepare(
+        `SELECT state, fallback_source, fallback_text FROM push_outbox WHERE event_key = ?`
+      )
+      .all(eventKey) as Pick<
+      OutboxRow,
+      "state" | "fallback_source" | "fallback_text"
+    >[];
+    if (
+      !rows.length ||
+      !rows.every((r) => r.state === "failed" || r.state === "gone")
+    )
+      return null;
+    const row = rows.find((r) => r.fallback_text);
+    if (!row?.fallback_text) return null;
+    db.prepare(
+      `UPDATE push_outbox SET fallback_text = NULL WHERE event_key = ?`
+    ).run(eventKey);
+    return { source: row.fallback_source ?? "push", text: row.fallback_text };
+  })();
+}
+
+export function nextDueAt(): number | null {
+  const r = db
+    .prepare(
+      `SELECT MIN(next_attempt_at) AS at FROM push_outbox WHERE state = 'pending'`
+    )
+    .get() as { at: number | null };
+  return r.at;
+}
+
+export function rowsFor(eventKey: string): OutboxRow[] {
+  return db
+    .prepare(`SELECT * FROM push_outbox WHERE event_key = ? ORDER BY id`)
+    .all(eventKey) as OutboxRow[];
+}
+
+/** After a restart: what was mid-send goes again; old history is dropped. */
+export function resume(now: number): void {
+  db.prepare(
+    `UPDATE push_outbox SET state = 'pending', next_attempt_at = ? WHERE state = 'sending'`
+  ).run(now);
+  db.prepare(
+    `DELETE FROM push_outbox WHERE state NOT IN ('pending', 'sending', 'folded')
+       AND created_at < ?`
+  ).run(now - KEEP_MS);
+  db.prepare(
+    `DELETE FROM push_outbox WHERE state = 'folded' AND created_at < ?`
+  ).run(now - 24 * HOUR_MS);
+}

package/lib/notify/push/policy.ts

@@ -0,0 +1,33 @@
+/** Which events the quiet rules apply to. Pure. */
+
+import type { PushCategory } from "../push-types";
+
+/** Alerting pushes per device per rolling hour; beyond it, one summary. */
+export const CAP_PER_HOUR = 10;
+export const HOUR_MS = 3_600_000;
+/** The Mac counts as "being used" when the keyboard or mouse moved this recently. */
+export const AT_MAC_MS = 3 * 60_000;
+/** A needs-you push waits this long, and is dropped if the session moves on. */
+export const WAIT_MS = 60_000;
+
+/** At the desk he sees these there. Asks are escalations and always push. */
+const PRESENCE_GATED: ReadonlySet<PushCategory> = new Set([
+  "needs-you",
+  "review",
+  "ci",
+  "merged",
+]);
+/** While Away is on these wait for its 10-minute digest. */
+const FOLDS_WHEN_AWAY: ReadonlySet<PushCategory> = new Set([
+  "needs-you",
+  "review",
+  "ci",
+  "merged",
+  "agents",
+  "system",
+]);
+const CAP_EXEMPT: ReadonlySet<PushCategory> = new Set(["asks"]);
+
+export const presenceGated = (c: PushCategory) => PRESENCE_GATED.has(c);
+export const foldsWhenAway = (c: PushCategory) => FOLDS_WHEN_AWAY.has(c);
+export const capExempt = (c: PushCategory) => CAP_EXEMPT.has(c);

package/lib/notify/push/presence.ts

@@ -0,0 +1,45 @@
+/**
+ * Is Saad at this Mac right now? macOS reports how long the keyboard and
+ * mouse have been still. A machine with no display (or any error) is away.
+ */
+
+import { execFile } from "child_process";
+import { AT_MAC_MS } from "./policy";
+
+/** Seconds idle from `ioreg -c IOHIDSystem` output, or null. */
+export function parseHidIdle(text: string): number | null {
+  const m = /"HIDIdleTime"\s*=\s*(\d+)/.exec(text);
+  return m ? Number(m[1]) / 1e9 : null;
+}
+
+type Run = () => Promise<string>;
+
+const ioreg: Run = () =>
+  new Promise((resolve, reject) =>
+    execFile(
+      "ioreg",
+      ["-c", "IOHIDSystem"],
+      { timeout: 2000, maxBuffer: 4 * 1024 * 1024 },
+      (err, out) => (err ? reject(err) : resolve(out))
+    )
+  );
+
+const CACHE_MS = 15_000;
+let cached: { at: number; present: boolean } | null = null;
+
+export async function atMac(
+  opts: { platform?: string; run?: Run; now?: number } = {}
+): Promise<boolean> {
+  if ((opts.platform ?? process.platform) !== "darwin") return false;
+  const now = opts.now ?? Date.now();
+  if (cached && now - cached.at < CACHE_MS && !opts.run) return cached.present;
+  let present = false;
+  try {
+    const idle = parseHidIdle(await (opts.run ?? ioreg)());
+    present = idle !== null && idle * 1000 < AT_MAC_MS;
+  } catch {
+    present = false;
+  }
+  if (!opts.run) cached = { at: now, present };
+  return present;
+}

package/lib/notify/push/relay.ts

@@ -0,0 +1,50 @@
+/** The Connect push relay, answered in terms the sender can act on. */
+
+import {
+  ApiError,
+  clean,
+  pushRelay,
+  type PushRequestBody,
+  type PushResult,
+} from "@/lib/connect/control-api";
+import { loadConnect } from "@/lib/connect/config";
+
+export type RelayAnswer =
+  | { kind: "results"; results: PushResult[] }
+  // Nothing will go until someone fixes it: don't ask again for a while.
+  | { kind: "unavailable"; reason: string }
+  // The request itself is wrong: retrying can't help.
+  | { kind: "invalid"; reason: string }
+  | { kind: "retry"; reason: string; afterMs?: number };
+
+export const NOT_LINKED = "this machine isn't linked to Connect";
+
+/** Whether this machine can reach the relay at all. */
+export const linked = () => loadConnect() !== null;
+
+export async function relaySend(body: PushRequestBody): Promise<RelayAnswer> {
+  const files = loadConnect();
+  if (!files) return { kind: "unavailable", reason: NOT_LINKED };
+  try {
+    const results = await pushRelay(files.config, files.machineKey, body);
+    return { kind: "results", results };
+  } catch (err) {
+    if (err instanceof ApiError) {
+      const why = clean(err.message, 120);
+      if (err.status === 503 && err.body.error === "push_not_configured")
+        return {
+          kind: "unavailable",
+          reason: "push isn't set up on the Connect service yet",
+        };
+      if (err.status === 401 || err.status === 403 || err.status === 503)
+        return { kind: "unavailable", reason: why };
+      if (err.status === 400 || err.status === 413)
+        return { kind: "invalid", reason: why };
+      return { kind: "retry", reason: why };
+    }
+    return {
+      kind: "retry",
+      reason: err instanceof Error ? clean(err.message, 120) : "network error",
+    };
+  }
+}