@saadnvd1/agent-os 0.3.513 → 0.3.516

package/lib/connect/supervise.ts

@@ -3,13 +3,24 @@
  * the Connect service for a fresh connector token, which goes to the child
  * in TUNNEL_TOKEN only: never argv, never a file, never a log line. The
  * child exits → it's started again with backoff; stop() ends it.
+ *
+ * cloudflared must never outlive AgentOS: it would go on publishing
+ * whatever next holds the tunnel port. So it runs in a process group of its
+ * own under a small shell that kills it the moment AgentOS goes, however it
+ * goes (SIGKILL and out-of-memory included), and a copy a crash left behind
+ * anyway is killed before the next one starts.
  */
 
-import { execFile, spawn as nodeSpawn } from "child_process";
+import {
+  execFile,
+  spawn as nodeSpawn,
+  type ChildProcess,
+  type SpawnOptions,
+} from "child_process";
 import fs from "fs";
 import path from "path";
 import readline from "readline";
-import type { Readable } from "stream";
+import type { Readable, Writable } from "stream";
 import { ApiError, clean } from "./control-api";
 
 export type TunnelState = "connecting" | "up" | "denied" | "error" | "stopped";
@@ -21,6 +32,7 @@ export interface Prepared {
 
 interface Child {
   pid?: number;
+  stdin?: Writable | null;
   stdout: Readable | null;
   stderr: Readable | null;
   kill(signal?: NodeJS.Signals): boolean;
@@ -53,7 +65,48 @@ const DELAYS = {
 // cloudflared can be chatty while the network flaps.
 const LOG_LINES_PER_MINUTE = 20;
 
-/** A cloudflared left running by an AgentOS that died without stopping it. */
+// $1 is cloudflared, the rest its arguments. Its stdin is a pipe only
+// AgentOS holds the other end of: when AgentOS ends, the read sees EOF and
+// cloudflared is killed outright (a SIGTERM would let it drain, still
+// forwarding, for half a minute). The shell exits with cloudflared's code.
+const WATCHDOG = `exec 3<&0 </dev/null
+"$@" 3<&- &
+child=$!
+trap 'kill -TERM "$child" 2>/dev/null' TERM INT HUP
+{ read -r _ <&3; kill -KILL "$child" 2>/dev/null; } &
+watch=$!
+exec 3<&-
+while :; do
+  wait "$child"; code=$?
+  kill -0 "$child" 2>/dev/null || break
+done
+kill "$watch" 2>/dev/null
+exit "$code"`;
+
+/** cloudflared under the watchdog, its group killed as one. */
+export const spawnTunnel: Spawn = (bin, args, opts) => {
+  if (process.platform === "win32")
+    return (nodeSpawn as unknown as Spawn)(bin, args, opts);
+  const proc: ChildProcess = nodeSpawn(
+    "/bin/sh",
+    ["-c", WATCHDOG, "agentos-cloudflared", bin, ...args],
+    {
+      env: opts.env,
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: true,
+    } as SpawnOptions
+  );
+  proc.stdin?.on("error", () => {});
+  return Object.assign(proc, {
+    kill: (signal: NodeJS.Signals = "SIGTERM") => {
+      try {
+        if (proc.pid) return process.kill(-proc.pid, signal);
+      } catch {}
+      return proc.kill(signal);
+    },
+  }) as unknown as Child;
+};
+
 const commandOf = (pid: number) =>
   new Promise<string>((resolve) =>
     execFile(
@@ -64,25 +117,60 @@ const commandOf = (pid: number) =>
     )
   );
 
-async function stopStale(pidFile: string, binDir: string) {
+const signal = (pid: number, sig: NodeJS.Signals | 0) => {
+  try {
+    process.kill(pid, sig);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export interface ReapDeps {
+  commandOf?: (pid: number) => Promise<string>;
+  /** process.kill: false when there was nothing to signal. */
+  kill?: (pid: number, sig: NodeJS.Signals | 0) => boolean;
+  waitMs?: number;
+}
+
+/**
+ * Kills a cloudflared an AgentOS that died left running, named by the pid
+ * file, and only if that pid is still one of ours (pids get reused). Call
+ * it only while holding connect.lock: then no live AgentOS owns it.
+ */
+export async function reapTunnel(
+  dir: string,
+  binDir = path.join(dir, "bin"),
+  deps: ReapDeps = {}
+) {
+  const pidFile = path.join(dir, "cloudflared.pid");
+  const kill = deps.kill ?? signal;
   let pid = 0;
   try {
     pid = Number(fs.readFileSync(pidFile, "utf8")) || 0;
   } catch {
-    return;
+    return false;
   }
+  let reaped = false;
   if (pid > 1) {
-    const command = await commandOf(pid);
-    try {
-      if (command.startsWith(binDir + path.sep)) process.kill(pid, "SIGTERM");
-    } catch {}
+    const command = await (deps.commandOf ?? commandOf)(pid);
+    if (command.includes(binDir + path.sep)) {
+      // Its group (the watchdog and cloudflared), or a bare cloudflared an
+      // older AgentOS started outside one.
+      reaped = kill(-pid, "SIGKILL");
+      reaped = kill(pid, "SIGKILL") || reaped;
+      const end = Date.now() + (deps.waitMs ?? 2000);
+      while (kill(pid, 0) && Date.now() < end)
+        await new Promise((r) => setTimeout(r, 25));
+    }
   }
   fs.rmSync(pidFile, { force: true });
+  return reaped;
 }
 
 export function superviseTunnel(opts: SuperviseOptions) {
   const log = opts.log ?? (() => {});
-  const spawn = opts.spawn ?? (nodeSpawn as unknown as Spawn);
+  const spawn = opts.spawn ?? spawnTunnel;
   const delays = opts.delays ?? DELAYS;
   const pidFile = path.join(opts.dir, "cloudflared.pid");
   const home = path.join(opts.dir, "cloudflared-home");
@@ -145,7 +233,7 @@ export function superviseTunnel(opts: SuperviseOptions) {
 
   const run = async ({ bin, token }: Prepared) => {
     const redact = (line: string) => clean(line.split(token).join("[token]"));
-    await stopStale(pidFile, path.dirname(bin));
+    await reapTunnel(opts.dir, path.dirname(bin));
     if (stopped) return;
     fs.mkdirSync(home, { recursive: true, mode: 0o700 });
     // Its own config and home, so no config.yml elsewhere on the machine
@@ -256,8 +344,18 @@ export function superviseTunnel(opts: SuperviseOptions) {
     proc.on("exit", (code) => end(`cloudflared exited (${code ?? "signal"})`));
   };
 
+  // A stop that never ran (the process exiting, or a signal nobody else
+  // handles) still takes cloudflared's whole group down first.
   const killNow = () => child?.kill("SIGTERM");
+  const SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP"] as const;
+  const onSignal = (sig: NodeJS.Signals) => {
+    killNow();
+    for (const s of SIGNALS) process.removeListener(s, onSignal);
+    // Nobody else handles it: end the way the signal would have.
+    if (process.listenerCount(sig) === 0) process.kill(process.pid, sig);
+  };
   process.once("exit", killNow);
+  for (const s of SIGNALS) process.on(s, onSignal);
   tick();
 
   return {
@@ -268,6 +366,7 @@ export function superviseTunnel(opts: SuperviseOptions) {
       stopped = true;
       state = "stopped";
       process.removeListener("exit", killNow);
+      for (const s of SIGNALS) process.removeListener(s, onSignal);
       if (timer) clearTimeout(timer);
       const proc = child;
       if (!proc) return;

package/lib/db/migrations.ts

@@ -1630,6 +1630,34 @@ const migrations: Migration[] = [
       );
     },
   },
+  {
+    id: 71,
+    name: "devices_push",
+    up: (db) => {
+      // Push belongs to a paired device, so revoking the device clears it.
+      // push_categories is a JSON array; NULL means the defaults.
+      // Each column checked, so a run cut off part way can be run again.
+      const have = new Set(
+        (
+          db.prepare(`PRAGMA table_info(devices)`).all() as { name: string }[]
+        ).map((c) => c.name)
+      );
+      for (const col of [
+        "push_token",
+        "push_platform",
+        "push_environment",
+        "push_categories",
+        "push_updated_at",
+        "push_last_error",
+      ])
+        if (!have.has(col))
+          db.exec(`ALTER TABLE devices ADD COLUMN ${col} TEXT`);
+      db.exec(
+        `CREATE INDEX IF NOT EXISTS idx_devices_push_token ON devices(push_token)
+         WHERE push_token IS NOT NULL`
+      );
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/demo-reseed.ts

@@ -9,6 +9,7 @@ import fs from "fs";
 import type Database from "better-sqlite3";
 import { notifyStatusChanged } from "./status/hub";
 import { resetDemoChat } from "./chat/demo";
+import { markAllStatusDirty } from "./status/dirty";
 
 export const RESEED_MS = 10 * 60 * 1000;
 
@@ -92,6 +93,7 @@ export function startDemoReseed(
     try {
       restoreDemo(db, file);
       resetDemoChat();
+      markAllStatusDirty();
       notifyStatusChanged();
       onRestored();
     } catch (error) {

package/lib/notify/copy.ts

@@ -0,0 +1,190 @@
+/**
+ * The category registry: one entry per kind of event, holding everything
+ * about it (priority, whether it's on by default, the copy, the deep link).
+ * Adding an event is one entry here. Pure, so the mobile app can sync it.
+ */
+
+import {
+  PUSH_CATEGORIES,
+  PUSH_TITLE,
+  type PushCategory,
+  type PushEnvelope,
+  type PushEnvelopeV1,
+  type PushEvent,
+  type PushLevel,
+} from "./push-types";
+import { safeId, safeKey } from "./redact";
+
+export interface CategoryDef {
+  level: PushLevel;
+  defaultOn: boolean;
+  /** Settings label. */
+  label: string;
+  /** The one word or phrase shown as the body. Fixed text, no event data. */
+  word: string;
+  /** App path for an id, or the fallback when the id is missing or unsafe. */
+  link: (id: string | null) => string;
+}
+
+/** Where a tap goes when nothing more specific is known. */
+export const FALLBACK_LINK = "/needs";
+
+export const CATEGORIES: Record<PushCategory, CategoryDef> = {
+  asks: {
+    level: "time-sensitive",
+    defaultOn: true,
+    label: "Asks",
+    word: "Needs your call",
+    link: (id) => (id ? `/orchestrator?workspaceId=${id}` : FALLBACK_LINK),
+  },
+  "needs-you": {
+    level: "active",
+    defaultOn: true,
+    label: "Waiting for you",
+    word: "Needs you",
+    link: (id) => (id ? `/session/${id}` : FALLBACK_LINK),
+  },
+  review: {
+    level: "active",
+    defaultOn: true,
+    label: "Ready for review",
+    word: "Ready for review",
+    link: (id) => (id ? `/task/${id}` : FALLBACK_LINK),
+  },
+  ci: {
+    level: "active",
+    defaultOn: true,
+    label: "CI and review problems",
+    word: "Update",
+    link: (id) => (id ? `/task/${id}` : FALLBACK_LINK),
+  },
+  merged: {
+    level: "passive",
+    defaultOn: false,
+    label: "Merged",
+    word: "Update",
+    link: (id) => (id ? `/task/${id}` : FALLBACK_LINK),
+  },
+  agents: {
+    level: "active",
+    defaultOn: true,
+    label: "Messages from agents",
+    word: "Update",
+    link: (id) => (id ? `/session/${id}` : FALLBACK_LINK),
+  },
+  digest: {
+    level: "passive",
+    defaultOn: true,
+    label: "While you're away",
+    word: "Updates",
+    link: () => FALLBACK_LINK,
+  },
+  system: {
+    level: "active",
+    defaultOn: true,
+    label: "Machine alerts",
+    word: "Update",
+    link: () => "/machines",
+  },
+};
+
+export const isPushCategory = (c: unknown): c is PushCategory =>
+  typeof c === "string" && (PUSH_CATEGORIES as readonly string[]).includes(c);
+
+export function defaultCategories(): PushCategory[] {
+  return PUSH_CATEGORIES.filter((c) => CATEGORIES[c].defaultOn);
+}
+
+/**
+ * The categories a device receives: its saved list, or the defaults when it
+ * has none. Unknown names are dropped so an old row survives a removed
+ * category.
+ */
+export function enabledCategories(
+  saved: readonly unknown[] | null | undefined
+): PushCategory[] {
+  return saved
+    ? PUSH_CATEGORIES.filter((c) => saved.includes(c))
+    : defaultCategories();
+}
+
+/**
+ * The v1 payload for an event. Built only from the registry and a vetted id
+ * and key, so it carries no event text whatever the caller passes.
+ */
+export function buildPushPayload(event: PushEvent): PushEnvelopeV1 {
+  const def = CATEGORIES[event.category];
+  const id = safeId(event.id);
+  return {
+    v: 1,
+    c: event.category,
+    t: PUSH_TITLE,
+    b: def.word,
+    l: def.link(id),
+    k: safeKey(event.key) ?? `${event.category}:${id ?? "-"}`,
+    p: def.level,
+  };
+}
+
+/**
+ * The app side: read what arrived. An unknown version or a malformed body
+ * gives the generic fallback, so a newer server never breaks an older app.
+ */
+export function parsePushEnvelope(raw: unknown): PushEnvelope {
+  const o = (raw && typeof raw === "object" ? raw : {}) as Record<
+    string,
+    unknown
+  >;
+  const category = isPushCategory(o.c) ? o.c : "system";
+  if (o.v === 1 || o.v === 2) {
+    const link =
+      typeof o.l === "string" && isAppLink(o.l)
+        ? o.l
+        : CATEGORIES[category].link(null);
+    const base = {
+      c: category,
+      t: PUSH_TITLE,
+      b: typeof o.b === "string" ? o.b.slice(0, 80) : CATEGORIES[category].word,
+      l: link,
+      k: safeKey(o.k) ?? `${category}:-`,
+      p: CATEGORIES[category].level,
+    } as const;
+    // A v2 body is read as its generic v1 alert until this app can decrypt.
+    return { ...base, v: 1 };
+  }
+  return buildPushPayload({ category });
+}
+
+const APP_PATHS = [
+  /^\/needs$/,
+  /^\/machines$/,
+  /^\/session\/[A-Za-z0-9_-]{1,64}$/,
+  /^\/task\/[A-Za-z0-9_-]{1,64}$/,
+  /^\/orchestrator\?workspaceId=[A-Za-z0-9_-]{1,64}$/,
+];
+
+/** True for a link the registry could have produced. */
+export function isAppLink(link: string): boolean {
+  return APP_PATHS.some((re) => re.test(link));
+}
+
+/**
+ * True only for a payload the registry could have built: fixed title, the
+ * category's own word, a known link shape, a plain key. A sender checks this
+ * before it sends, so nothing else can leave the machine.
+ */
+export function isGenericPayload(p: unknown): p is PushEnvelopeV1 {
+  if (!p || typeof p !== "object") return false;
+  const o = p as Record<string, unknown>;
+  if (o.v !== 1 || !isPushCategory(o.c)) return false;
+  const def = CATEGORIES[o.c];
+  return (
+    Object.keys(o).sort().join() === "b,c,k,l,p,t,v" &&
+    o.t === PUSH_TITLE &&
+    o.b === def.word &&
+    o.p === def.level &&
+    typeof o.l === "string" &&
+    isAppLink(o.l) &&
+    safeKey(o.k) === o.k
+  );
+}

package/lib/notify/push-types.ts

@@ -0,0 +1,77 @@
+/**
+ * Push notification types. Pure: no imports from the app, so the mobile app
+ * can sync this file as is.
+ *
+ * The payload is a versioned envelope. v1 is generic and content-free (a fixed
+ * title, a category word, a deep link). v2 is reserved for encrypted rich
+ * text; an app that doesn't know a version shows the outer alert and opens
+ * the fallback link, so v2 can ship without breaking older apps.
+ */
+
+export const PUSH_CATEGORIES = [
+  "asks",
+  "needs-you",
+  "review",
+  "ci",
+  "merged",
+  "agents",
+  "digest",
+  "system",
+] as const;
+export type PushCategory = (typeof PUSH_CATEGORIES)[number];
+
+/** Maps onto the APNs interruption level. */
+export type PushLevel = "time-sensitive" | "active" | "passive";
+
+export const PUSH_PLATFORMS = ["ios", "android"] as const;
+export type PushPlatform = (typeof PUSH_PLATFORMS)[number];
+
+export const PUSH_ENVIRONMENTS = ["production", "sandbox"] as const;
+export type PushEnvironment = (typeof PUSH_ENVIRONMENTS)[number];
+
+export const PUSH_TITLE = "AgentOS";
+
+/** Plain, content-free alert. */
+export interface PushEnvelopeV1 {
+  v: 1;
+  /** Category, so the app can group and filter. */
+  c: PushCategory;
+  /** Fixed title. */
+  t: typeof PUSH_TITLE;
+  /** Category word from the registry, never event text. */
+  b: string;
+  /** Deep link, an app path like `/session/abc`. */
+  l: string;
+  /** Replaces an earlier alert with the same key. Opaque. */
+  k: string;
+  /** Interruption level. */
+  p: PushLevel;
+}
+
+/** Reserved: encrypted rich text. Not produced yet. */
+export interface PushEnvelopeV2 {
+  v: 2;
+  c: PushCategory;
+  t: typeof PUSH_TITLE;
+  /** Generic fallback body shown if the app can't decrypt. */
+  b: string;
+  l: string;
+  k: string;
+  p: PushLevel;
+  /** Device id the key belongs to. */
+  d: string;
+  /** Base64url nonce and ciphertext. */
+  n: string;
+  x: string;
+}
+
+export type PushEnvelope = PushEnvelopeV1 | PushEnvelopeV2;
+
+/** What a sender needs to say about an event. Ids only, never text. */
+export interface PushEvent {
+  category: PushCategory;
+  /** Session, task or workspace id the link opens, when the category has one. */
+  id?: string | null;
+  /** Dedupe key, e.g. `ask:<id>` or `review:<task>:<sha>`. */
+  key?: string | null;
+}

package/lib/notify/redact.ts

@@ -0,0 +1,57 @@
+/**
+ * Keeps free text and secret-looking strings out of push payloads. Pure, so
+ * the mobile app can sync it.
+ */
+
+const MAX_ID = 64;
+const SAFE_ID = /^[A-Za-z0-9_-]+$/;
+
+/** Hex or base64 runs this long are treated as keys. */
+const LONG_RUN = /[A-Za-z0-9+/_=-]{24,}/g;
+const SECRET_PATTERNS: RegExp[] = [
+  /\baosd_[A-Za-z0-9_-]+/g,
+  /\bsk-[A-Za-z0-9_-]{8,}/g,
+  /\bgh[pousr]_[A-Za-z0-9]{8,}/g,
+  /\bAKIA[0-9A-Z]{8,}/g,
+  /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*/g,
+];
+
+/** True when the string looks like a token, key or JWT. */
+export function looksSecret(text: string): boolean {
+  return [...SECRET_PATTERNS, LONG_RUN].some((re) => {
+    re.lastIndex = 0;
+    return re.test(text);
+  });
+}
+
+/**
+ * First line only, collapsed whitespace, no backticks, secrets replaced by
+ * `…`, clipped. For the rich text of a later envelope version.
+ */
+export function scrubText(text: string | null | undefined, max = 120): string {
+  let s = (text ?? "").split(/\r?\n/).find((l) => l.trim()) ?? "";
+  s = s.replace(/`+/g, "");
+  for (const re of SECRET_PATTERNS) s = s.replace(re, "…");
+  s = s.replace(LONG_RUN, "…");
+  s = s.replace(/\s+/g, " ").trim();
+  return s.length > max ? s.slice(0, max - 1).trimEnd() + "…" : s;
+}
+
+/** An id fit for a link or key: short and plain. Null if it isn't. */
+export function safeId(id: unknown): string | null {
+  if (typeof id !== "string" || id.length === 0 || id.length > MAX_ID)
+    return null;
+  if (!SAFE_ID.test(id)) return null;
+  return looksSecret(id) ? null : id;
+}
+
+/**
+ * A collapse key: opaque and bounded. Anything with characters outside the
+ * plain set, or secret-looking, is dropped rather than cleaned.
+ */
+export function safeKey(key: unknown): string | null {
+  if (typeof key !== "string" || key.length === 0 || key.length > 128)
+    return null;
+  if (!/^[A-Za-z0-9_:.-]+$/.test(key)) return null;
+  return looksSecret(key) ? null : key;
+}

package/lib/orchestrator/armed.ts

@@ -26,6 +26,7 @@ import { isPaused } from "./pause";
 import { review } from "./review";
 import { judge, mergeJudged } from "./signoff";
 import { workspaceTask } from "./targets";
+import { markStatusDirty } from "../status/dirty";
 
 // Judged again at least this often, for what the fingerprint can't see.
 export const ARMED_RECHECK_MS = 5 * 60 * 1000;
@@ -38,6 +39,7 @@ export function setArmed(sessionId: string, armed: boolean): void {
        merge_armed_seen = NULL WHERE id = ?`
   ).run(sessionId);
   looked.delete(sessionId);
+  markStatusDirty(sessionId);
   notifyStatusChanged();
 }
 

package/lib/orchestrator/checks.ts

@@ -6,6 +6,7 @@
 
 import { db } from "../db";
 import { notifyStatusChanged } from "../status/hub";
+import { markAllStatusDirty, markStatusDirty } from "../status/dirty";
 
 // ci: when the check count on a commit last changed, for settling.
 export type CheckKind = "review" | "scope" | "ci";
@@ -58,6 +59,7 @@ export function putCheck(row: {
     row.status,
     row.detail ?? null
   );
+  markStatusDirty(row.sessionId);
   notifyStatusChanged();
   return getCheck(row.sessionId, row.sha, row.kind)!;
 }
@@ -68,4 +70,5 @@ export function clearStaleRunning(maxAgeMinutes = 30): void {
     `UPDATE orchestrator_checks SET status = 'error', detail = 'Interrupted: run it again'
      WHERE status = 'running' AND created_at < datetime('now', ?)`
   ).run(`-${maxAgeMinutes} minutes`);
+  markAllStatusDirty();
 }

package/lib/orchestrator/facts.ts

@@ -20,6 +20,7 @@ import { storedPR } from "../tasks/session";
 import { commitTime, repoOf } from "./repo";
 import { CHECKLESS_MS, checklessFor, ciSettleIn } from "./task-state";
 import { repoHasCI } from "./repo-ci";
+import { markStatusDirty } from "../status/dirty";
 
 export type FactStatus = "running" | "waiting" | "idle" | "dead";
 
@@ -211,7 +212,10 @@ export async function settleIn(
   let at = committed.get(pr.head);
   if (at === undefined) {
     at = await commitTime(repoOf(s), pr.head).catch(() => 0);
-    if (at) committed.set(pr.head, at);
+    if (at) {
+      committed.set(pr.head, at);
+      markStatusDirty(s.id);
+    }
   }
   return ciSettleIn({
     workspaceId,

package/lib/orchestrator/gates.ts

@@ -18,6 +18,7 @@ import type { CheckRow } from "./checks";
 import { APPROVAL_GATES, mergeApprovalsOn } from "./merge-approvals";
 import type { RepoCI } from "./repo-ci";
 import { untrusted } from "./untrusted";
+import { markStatusDirty } from "../status/dirty";
 
 export type GateName =
   | "ci"
@@ -244,6 +245,7 @@ function countOnce(
          last_reason = excluded.last_reason,
          last_sha = excluded.last_sha`
   ).run(sessionId, gate, workspaceId, reason, sha, fresh ? 1 : 0);
+  markStatusDirty(sessionId);
   return failureOf(sessionId, gate)!.count;
 }
 
@@ -261,6 +263,7 @@ export function markEscalated(sessionId: string, gate: string): void {
   db.prepare(
     `UPDATE orchestrator_gate_failures SET escalated_at = datetime('now') WHERE session_id = ? AND gate = ?`
   ).run(sessionId, gate);
+  markStatusDirty(sessionId);
 }
 
 export function escalations(sessionId: string): FailureRow[] {

package/lib/orchestrator/merge-approvals.ts

@@ -7,6 +7,7 @@
  */
 
 import { db } from "../db";
+import { markAllStatusDirty } from "../status/dirty";
 
 const KEY = "orchestrator.merge_approvals";
 
@@ -26,4 +27,5 @@ export function setMergeApprovals(on: boolean): void {
     `INSERT INTO settings (key, value) VALUES (?, ?)
      ON CONFLICT(key) DO UPDATE SET value = excluded.value`
   ).run(KEY, on ? "1" : "0");
+  markAllStatusDirty();
 }

package/lib/security/demo.ts

@@ -59,6 +59,7 @@ export const STATIC_SIBLINGS = [
   "import",
   "init",
   "init-script",
+  "me",
   "items",
   "network",
   "queue",

package/lib/security/device-me.ts

@@ -0,0 +1,12 @@
+import { NextRequest, NextResponse } from "next/server";
+import { DEVICE_HEADER } from "./auth";
+
+/**
+ * The calling device, from the gate's header (never the body). Null when the
+ * request wasn't made with a device token, e.g. from this machine's browser.
+ */
+export const callingDevice = (request: NextRequest): string | null =>
+  request.headers.get(DEVICE_HEADER);
+
+export const needsDevice = () =>
+  NextResponse.json({ error: "Needs a paired device token." }, { status: 403 });