omp-mobile 0.4.0 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omp-mobile",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "The computer side of OMP Mobile: runs oh-my-pi sessions and serves them to the phone app over Tailscale.",
   "keywords": [
     "mobile",

package/src/omp-extension.mjs

@@ -33,7 +33,7 @@ const POLL_MS = 1_500;
 /** How long the code stays up without a phone connecting. */
 const SHOW_MS = 5 * 60_000;
 /** How often the session's takeover request is looked for, and how stale one may be. */
-const TAKEOVER_POLL_MS = 1_000;
+const TAKEOVER_POLL_MS = 500;
 const TAKEOVER_MAX_AGE_MS = 60_000;
 /** How long a running turn gets to stop before omp closes anyway. */
 const TAKEOVER_IDLE_WAIT_MS = 5_000;

package/src/rpc-session.mjs

@@ -142,7 +142,15 @@ export class RpcSession extends EventEmitter {
       stdio: ["pipe", "pipe", "pipe"],
     });
     this.child = child;
-    child.on("error", (error) => this.#fail(error));
+    // A process that never started (missing binary, a cwd that was removed)
+    // emits `error` and no `exit`, so `closed` never comes: without its own
+    // signal the `ready` wait would sit out the whole start timeout.
+    child.on("error", (error) => {
+      this.closed = true;
+      this.lastError = error;
+      this.emit("start-error", error);
+      this.#fail(error);
+    });
     child.on("exit", (code, signal) => {
       this.closed = true;
       // Nothing can answer the dialogs of a process that is gone.
@@ -157,7 +165,10 @@ export class RpcSession extends EventEmitter {
     });
     const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
     const ready = new Promise((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error("omp RPC did not become ready")), START_TIMEOUT_MS);
+      const timer = setTimeout(
+        () => reject(new Error(`omp RPC did not become ready in ${Math.round(START_TIMEOUT_MS / 1000)}s: ${this.stderr.trim().slice(-500) || "no output"}`)),
+        START_TIMEOUT_MS,
+      );
       const onReady = (message) => {
         clearTimeout(timer);
         this.off("ready", onReady);
@@ -168,6 +179,14 @@ export class RpcSession extends EventEmitter {
         clearTimeout(timer);
         reject(new Error(`omp exited before ready: ${this.stderr.slice(-500)}`));
       });
+      // `start()` is called from the daemon's request path: the reason a process
+      // cannot start (no omp on PATH, the session's directory is gone) has to
+      // reach the phone instead of a generic timeout.
+      this.once("start-error", (error) => {
+        clearTimeout(timer);
+        this.off("ready", onReady);
+        reject(new Error(`omp could not start in ${this.cwd}: ${error?.message ?? String(error)}`));
+      });
     });
     lines.on("line", (line) => this.#onLine(line));
     const hello = await ready;

package/src/server.mjs

@@ -8,8 +8,8 @@
  * to be exposed to the public internet.
  */
 import { STATUS_CODES, createServer } from "node:http";
-import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { createHash, randomBytes } from "node:crypto";
 import { homedir, hostname, platform } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -43,6 +43,29 @@ const STATE_EVENTS = new Set([
   "todo_auto_clear",
   "goal_updated",
 ]);
+/**
+ * How long OMP's session directory and owner locks are reused for, in ms.
+ * The phone probes every 15 s; without this every probe would rescan every
+ * session file (hundreds, often a gigabyte) and spawn `lsof` again.
+ */
+const SESSION_SCAN_TTL_MS = 3_000;
+const OWNERS_TTL_MS = 1_500;
+/** WebSocket keepalive: a protocol ping plus a `ping` frame, and a dead peer after one missed beat. */
+const HEARTBEAT_MS = 20_000;
+/** A live omp nobody has looked at for this long is closed; the next open resumes it. */
+const IDLE_SESSION_MS = 30 * 60_000;
+const REAP_INTERVAL_MS = 60_000;
+/**
+ * The fields of a tool result's `details` the app reads: an edit's diff, a
+ * read's line count, a command's run time, a screenshot's file. The rest
+ * (an edit's old and new text, a read's display copy) repeats what the
+ * result already says, and was a fifth of a long session's snapshot.
+ */
+const PHONE_DETAILS = ["diff", "totalLines", "wallTimeMs", "mediaPath"];
+/** Inline images shorter than this (base64 characters) stay inline: a reference would save nothing. */
+const STASH_MIN_CHARS = 4_096;
+/** Stashed images untouched this long are dropped at start; the session file still has them. */
+const BLOB_CACHE_MAX_AGE_MS = 30 * 24 * 60 * 60_000;
 /** Image types a phone may attach to a prompt: what the camera and the photo picker produce. */
 const PROMPT_IMAGE_TYPES = new Set(["image/jpeg", "image/png", "image/webp", "image/gif"]);
 /** At most this many images per prompt, each at most this many decoded bytes. */
@@ -75,9 +98,11 @@ export function promptImages(value) {
 /**
  * What this daemon supports beyond protocol 1, for an app to offer only what
  * the computer it talks to can do. `prompt-images`: `prompt` frames carry `images`;
- * `takeover`: `POST /sessions/:id/takeover` continues a session another omp process holds.
+ * `takeover`: `POST /sessions/:id/takeover` continues a session another omp process holds;
+ * `heartbeat`: session sockets get a `ping` frame every 20 s, so the app can
+ * treat a silent link as gone.
  */
-const FEATURES = ["prompt-images", "takeover"];
+const FEATURES = ["prompt-images", "takeover", "heartbeat"];
 /** Who a phone continues a session on, as the terminal it leaves is told. */
 const DEFAULT_DEVICE = "OMP Mobile";
 /** Close code after an `open_failed` frame: the session socket opened only to say why the session could not. */
@@ -249,6 +274,108 @@ function saveRegistry(path, registry) {
   writeFileSync(path, `${JSON.stringify(Object.fromEntries(registry), null, 2)}\n`, { mode: 0o600 });
 }
 
+/**
+ * The directory an omp starts in, recreated when it has been removed (a
+ * session in /tmp outlives its directory). Answers a 410 the phone can show
+ * when it cannot be recreated (a parent that is a file, no permission).
+ * @param {string} cwd
+ * @returns {string}
+ */
+export function ensureWorkingDirectory(cwd) {
+  try {
+    if (statSync(cwd).isDirectory()) return cwd;
+  } catch {
+    // Missing: recreate it below.
+  }
+  try {
+    mkdirSync(cwd, { recursive: true });
+    return cwd;
+  } catch {
+    throw httpError(410, `the session's working directory is gone and cannot be recreated: ${cwd}`);
+  }
+}
+
+/**
+ * Write an inline image to the daemon's blob cache under its SHA-256 and
+ * answer the `blob:sha256:` reference the app loads from `/blobs`; undefined
+ * leaves the image inline (too small, already a reference, not base64, no disk).
+ * @param {{data?: unknown}} part
+ * @param {string} blobDir
+ */
+function stashImage(part, blobDir) {
+  const data = part.data;
+  if (typeof data !== "string" || data.length < STASH_MIN_CHARS || data.startsWith("blob:") || data.startsWith("data:")) return undefined;
+  const bytes = Buffer.from(data, "base64");
+  if (bytes.length === 0) return undefined;
+  const hash = createHash("sha256").update(bytes).digest("hex");
+  const path = join(blobDir, hash);
+  try {
+    if (!existsSync(path)) {
+      mkdirSync(blobDir, { recursive: true, mode: 0o700 });
+      writeFileSync(path, bytes, { mode: 0o600 });
+    }
+  } catch {
+    return undefined;
+  }
+  return `blob:sha256:${hash}`;
+}
+
+/**
+ * A message as a snapshot carries it to the phone: inline images moved to
+ * the blob cache and sent as references (the app loads only the ones it
+ * shows), and tool details cut to {@link PHONE_DETAILS}. A long session's
+ * snapshot was mostly base64 screenshots and copies of edited text --
+ * megabytes the phone downloaded, parsed and cached before it showed anything.
+ * Live events still carry messages whole.
+ * @param {any} message
+ * @param {string | undefined} blobDir no stashing when undefined
+ */
+export function phoneMessage(message, blobDir) {
+  if (message === null || typeof message !== "object") return message;
+  let next = message;
+  if (blobDir !== undefined && Array.isArray(message.content)) {
+    let changed = false;
+    const content = message.content.map((part) => {
+      const ref = part !== null && typeof part === "object" && part.type === "image" ? stashImage(part, blobDir) : undefined;
+      if (ref === undefined) return part;
+      changed = true;
+      return { ...part, data: ref };
+    });
+    if (changed) next = { ...next, content };
+  }
+  const tool = message.role === "toolResult" || message.role === "tool";
+  if (tool && message.details !== null && typeof message.details === "object" && !Array.isArray(message.details)) {
+    const details = {};
+    for (const key of PHONE_DETAILS) if (key in message.details) details[key] = message.details[key];
+    next = { ...next, details };
+  }
+  return next;
+}
+
+/** Drop stashed images older than {@link BLOB_CACHE_MAX_AGE_MS}; the next open of their session stashes them again. */
+export function pruneBlobCache(blobDir, now = Date.now()) {
+  let names;
+  try {
+    names = readdirSync(blobDir);
+  } catch {
+    return 0;
+  }
+  let dropped = 0;
+  for (const name of names) {
+    if (!BLOB_NAME.test(name)) continue;
+    const path = join(blobDir, name);
+    try {
+      if (now - statSync(path).mtimeMs > BLOB_CACHE_MAX_AGE_MS) {
+        unlinkSync(path);
+        dropped += 1;
+      }
+    } catch {
+      // Gone already.
+    }
+  }
+  return dropped;
+}
+
 function storedSummary(stored) {
   return {
     id: stored.id,
@@ -300,13 +427,14 @@ export function blobType(bytes) {
 }
 
 /** A stored image: `GET /blobs/<sha256>[.ext]`, authenticated like every other route. */
-function sendBlob(res, ompHome, name) {
+function sendBlob(res, dirs, name) {
   if (!BLOB_NAME.test(name)) {
     sendJson(res, 400, { error: "bad blob name" });
     return;
   }
-  const path = join(ompHome, "agent", "blobs", name);
-  if (!existsSync(path) || !statSync(path).isFile()) {
+  // OMP's own store first, then the images this daemon stashed from snapshots.
+  const path = dirs.map((dir) => join(dir, name)).find((candidate) => existsSync(candidate) && statSync(candidate).isFile());
+  if (path === undefined) {
     sendJson(res, 404, { error: "no such blob" });
     return;
   }
@@ -388,12 +516,16 @@ class SessionEntry {
      */
     this.onBroadcast = undefined;
     this.closed = false;
+    /** When the last phone left; undefined while one is connected. The reaper reads it. */
+    this.idleSince = undefined;
+    /** Where inline images go (see `phoneMessage`); undefined keeps them inline. */
+    this.blobDir = undefined;
   }
 
   async hydrate() {
     const [state, messages] = await Promise.all([this.rpc.getState(), this.rpc.getMessages()]);
     this.state = state;
-    this.messages = Array.isArray(messages.messages) ? messages.messages : [];
+    this.messages = Array.isArray(messages.messages) ? messages.messages.map((message) => phoneMessage(message, this.blobDir)) : [];
     this.id = state.sessionId ?? "";
     this.title = titleOf(this.messages, state, this.cwd);
     this.updatedAt = Date.now();
@@ -446,7 +578,7 @@ class SessionEntry {
     this.rpc.on("event", (event) => {
       this.updatedAt = Date.now();
       if (event.type === "message_end" && event.message) {
-        this.messages.push(event.message);
+        this.messages.push(phoneMessage(event.message, this.blobDir));
         if (this.messages.length > 5_000) this.messages.splice(0, this.messages.length - 5_000);
         // The first prompt names a session that was created untitled.
         const title = titleOf(this.messages, this.state, this.cwd);
@@ -521,12 +653,24 @@ class Daemon {
     this.streams = new Set();
     /** OMP's own sessions as last listed, for resuming one the app picked. @type {Map<string, import("./omp-sessions.mjs").OmpSession>} */
     this.ompSessions = new Map();
+    /** The last full scan of OMP's session directory, reused within `SESSION_SCAN_TTL_MS`. */
+    this.sessionScan = { at: 0, list: /** @type {import("./omp-sessions.mjs").OmpSession[]} */ ([]), pending: undefined };
+    /** The last `lsof` of the owner locks, pending or settled, reused within `OWNERS_TTL_MS`. */
+    this.ownerLookup = { at: 0, owners: /** @type {Promise<Map<string, number> | undefined> | undefined} */ (undefined) };
+    /** @type {ReturnType<typeof setInterval> | undefined} */
+    this.heartbeat = undefined;
+    /** @type {ReturnType<typeof setInterval> | undefined} */
+    this.reaper = undefined;
     /** Resumes in flight, so two opens of one session start one process. @type {Map<string, Promise<SessionEntry>>} */
     this.starting = new Map();
     /** Takeovers in flight, so two phones asking at once ask the owner once. @type {Map<string, Promise<object>>} */
     this.takingOver = new Map();
+    /** Images stashed out of snapshots, served by `/blobs` next to OMP's own store. */
+    this.blobDir = options.blobDir ?? join(dirname(options.registryFile ?? DEFAULT_REGISTRY_FILE), "blobs");
     this.server = createServer((req, res) => void this.admitHttp(req, res));
-    this.wsServer = new WebSocketServer({ noServer: true });
+    // Compressed frames: a snapshot is JSON text, several times smaller deflated, and
+    // the phone's WebSocket client (OkHttp) asks for permessage-deflate on its own.
+    this.wsServer = new WebSocketServer({ noServer: true, perMessageDeflate: { threshold: 1_024 } });
     this.server.on("upgrade", (req, socket, head) => void this.admitUpgrade(req, socket, head));
   }
 
@@ -598,7 +742,7 @@ class Daemon {
     this.noteClient(req);
     const blob = /^\/blobs\/([0-9a-f]{64})(?:\.[a-z0-9]+)?$/.exec(url.pathname);
     if (blob !== null && req.method === "GET") {
-      sendBlob(res, this.options.ompHome, blob[1]);
+      sendBlob(res, [join(this.options.ompHome, "agent", "blobs"), this.blobDir], blob[1]);
       return;
     }
     if (url.pathname === "/status" && req.method === "GET") {
@@ -657,6 +801,7 @@ class Daemon {
           const live = this.sessions.get(id);
           if (live !== undefined) this.attention.forget(live);
           live?.close();
+          this.forgetOwners();
           this.sessions.delete(id);
           this.registry.delete(id);
           saveRegistry(this.options.registryFile, this.registry);
@@ -685,10 +830,7 @@ class Daemon {
       .filter((stored) => !known.has(stored.id))
       .map((stored) => storedSummary(stored));
     for (const session of dormant) known.add(session.id);
-    const [found, owners] = await Promise.all([
-      listOmpSessions(join(this.options.ompHome, "agent", "sessions"), { limit: OMP_SESSION_LIMIT }),
-      this.owners(),
-    ]);
+    const [found, owners] = await Promise.all([this.scanOmpSessions(), this.owners()]);
     this.ompSessions = new Map(found.map((session) => [session.id, session]));
     const others = found
       .filter((session) => !known.has(session.id))
@@ -713,9 +855,40 @@ class Daemon {
     return { pid, busy: typeof sessionFile === "string" && sessionBusy(sessionFile), terminal: info?.tty !== undefined };
   }
 
-  /** Which sessions some omp process holds open (`undefined`: cannot tell). */
+  /**
+   * OMP's sessions, rescanned at most every `SESSION_SCAN_TTL_MS`: a phone's
+   * probes ask for the same list every few seconds, and reading the first
+   * 512 KB of up to 50 of hundreds of files is the daemon's most expensive read.
+   */
+  scanOmpSessions() {
+    const scan = this.sessionScan;
+    if (Date.now() - scan.at < SESSION_SCAN_TTL_MS) return Promise.resolve(scan.list);
+    if (scan.pending !== undefined) return scan.pending;
+    scan.pending = listOmpSessions(join(this.options.ompHome, "agent", "sessions"), { limit: OMP_SESSION_LIMIT }).then(
+      (list) => {
+        this.sessionScan = { at: Date.now(), list, pending: undefined };
+        return list;
+      },
+      (error) => {
+        scan.pending = undefined;
+        throw error;
+      },
+    );
+    return scan.pending;
+  }
+
+  /** Which sessions some omp process holds open (`undefined`: cannot tell). Cached for `OWNERS_TTL_MS`. */
   owners() {
-    return sessionOwners(join(this.options.ompHome, "run", "session-owners"));
+    const lookup = this.ownerLookup;
+    if (lookup.owners !== undefined && Date.now() - lookup.at < OWNERS_TTL_MS) return lookup.owners;
+    const owners = sessionOwners(join(this.options.ompHome, "run", "session-owners"));
+    this.ownerLookup = { at: Date.now(), owners };
+    return owners;
+  }
+
+  /** The owner locks changed (a takeover, an omp closing): the next look must not reuse the cache. */
+  forgetOwners() {
+    this.ownerLookup = { at: 0, owners: undefined };
   }
 
   remember(entry) {
@@ -754,14 +927,20 @@ class Daemon {
     if (!existsSync(stored.sessionFile)) throw httpError(410, "session file is gone");
     // A second omp on the same file would fork it into a new one; the session
     // stays with the process that has it (a terminal) until that one exits.
+    // This comes before the directory check: a held session is a takeover, not
+    // a broken one, and the phone's Take over button needs the 409.
     const owner = (await this.owners())?.get(id);
     if (owner !== undefined) {
       throw httpError(409, `This session is open in another omp process (pid ${owner}). Close it there to continue here.`, {
         owner: await this.ownerOf(owner, stored.sessionFile),
       });
     }
+    // OMP refuses to start in a directory that no longer exists (a session in
+    // /tmp whose directory was cleaned up). Recreate it here instead of letting
+    // the start wait out its timeout and answer with a bare 500.
+    const cwd = ensureWorkingDirectory(stored.cwd);
     const rpc = new RpcSession({
-      cwd: stored.cwd,
+      cwd,
       ompBin: this.options.omp,
       resume: stored.sessionFile,
       autoApprove: this.options.autoApprove,
@@ -773,6 +952,7 @@ class Daemon {
     try {
       await rpc.start();
       const entry = new SessionEntry(stored.cwd, rpc);
+      entry.blobDir = this.blobDir;
       await entry.hydrate();
       entry.id = id;
       entry.onChange = (changed) => this.remember(changed);
@@ -832,6 +1012,8 @@ class Daemon {
       if (forks.length > 0) this.log(new Error(`taking over ${id} from pid ${pid} left forked session files: ${forks.join(", ")}`));
       outcome = { pid, via: left.via, waitedMs: left.waitedMs, busy, forks };
     }
+    // The owner left: the cached lock map is stale and would refuse this open.
+    this.forgetOwners();
     const entry = await this.ensureLive(id);
     return { ...entry.snapshot(), takeover: outcome };
   }
@@ -847,6 +1029,7 @@ class Daemon {
     try {
       await rpc.start();
       const entry = new SessionEntry(cwd, rpc);
+      entry.blobDir = this.blobDir;
       await entry.hydrate();
       if (entry.id === "") throw new Error("omp returned no session id");
       entry.onChange = (changed) => this.remember(changed);
@@ -875,29 +1058,62 @@ class Daemon {
       return;
     }
     this.noteClient(req);
-    void this.ensureLive(decodeURIComponent(match[1]))
-      .then((entry) => {
-        this.wsServer.handleUpgrade(req, socket, head, (ws) => {
-          entry.clients.add(ws);
-          ws.send(JSON.stringify({ type: "snapshot", ...entry.snapshot() }));
+    const id = decodeURIComponent(match[1]);
+    // Finish the handshake before the session is open: a slow omp can take
+    // tens of seconds, and a phone's WebSocket client gives up after ~10 s --
+    // then retries, starting another omp every time. The snapshot (or
+    // `open_failed`) follows on the open socket instead.
+    this.wsServer.handleUpgrade(req, socket, head, (ws) => {
+      ws.isAlive = true;
+      ws.on("pong", () => {
+        ws.isAlive = true;
+      });
+      /** @type {SessionEntry | undefined} */
+      let entry;
+      /** Frames the phone sent before the session was ready. */
+      const early = [];
+      ws.on("message", (data) => {
+        if (entry === undefined) {
+          early.push(data.toString());
+          return;
+        }
+        void this.handleClientMessage(entry, ws, data.toString());
+      });
+      ws.on("close", () => {
+        if (entry !== undefined) this.detach(entry, ws);
+      });
+      ws.on("error", () => {
+        if (entry !== undefined) this.detach(entry, ws);
+      });
+      void this.ensureLive(id).then(
+        (live) => {
+          entry = live;
+          if (ws.readyState !== 1) return;
+          live.clients.add(ws);
+          live.idleSince = undefined;
+          ws.send(JSON.stringify({ type: "snapshot", ...live.snapshot() }));
           // A dialog opened before this client connected (it may have come from a notification tap).
-          for (const request of entry.openRequests()) ws.send(JSON.stringify({ type: "approval", request }));
-          ws.on("message", (data) => void this.handleClientMessage(entry, ws, data.toString()));
-          ws.on("close", () => entry.clients.delete(ws));
-          ws.on("error", () => entry.clients.delete(ws));
-        });
-      })
-      .catch((error) => {
-        const status = typeof error?.status === "number" ? error.status : 500;
-        if (status >= 500) this.log(error);
-        // A browser-style client only sees that the upgrade failed, never why. Finish
-        // the handshake instead, say why the session cannot open, and close: the app
-        // shows the reason and stops retrying what a retry cannot fix.
-        this.wsServer.handleUpgrade(req, socket, head, (ws) => {
+          for (const request of live.openRequests()) ws.send(JSON.stringify({ type: "approval", request }));
+          for (const data of early) void this.handleClientMessage(live, ws, data);
+          early.length = 0;
+        },
+        (error) => {
+          const status = typeof error?.status === "number" ? error.status : 500;
+          if (status >= 500) this.log(error);
+          if (ws.readyState !== 1) return;
+          // Say why the session cannot open and close: the app shows the reason
+          // and stops retrying what a retry cannot fix.
           ws.send(JSON.stringify({ type: "open_failed", status, ...errorBody(error) }));
           ws.close(OPEN_FAILED_CLOSE_CODE, "session did not open");
-        });
-      });
+        },
+      );
+    });
+  }
+
+  /** A phone left a session: it counts as idle from now, for the reaper. */
+  detach(entry, ws) {
+    if (!entry.clients.delete(ws)) return;
+    if (entry.clients.size === 0) entry.idleSince = Date.now();
   }
 
   async handleClientMessage(entry, ws, text) {
@@ -996,11 +1212,58 @@ class Daemon {
 
   listen() {
     return new Promise((resolveListen) => {
-      this.server.listen(this.options.port, this.options.host, () => resolveListen());
+      this.server.listen(this.options.port, this.options.host, () => {
+        this.startTimers();
+        resolveListen();
+      });
     });
   }
 
+  /** Keepalive pings and the idle-session reaper, once the daemon listens; old stashed images go. */
+  startTimers() {
+    pruneBlobCache(this.blobDir);
+    this.heartbeat = setInterval(() => this.pingClients(), this.options.heartbeatMs ?? HEARTBEAT_MS);
+    this.heartbeat.unref?.();
+    this.reaper = setInterval(() => this.reapIdleSessions(), this.options.reapIntervalMs ?? REAP_INTERVAL_MS);
+    this.reaper.unref?.();
+  }
+
+  /**
+   * Ping every WebSocket and drop the ones that missed the previous beat. A
+   * protocol ping plus a small frame keeps NAT and phone radios from dropping
+   * an idle session silently; the app ignores the frame, older ones too.
+   */
+  pingClients() {
+    const beat = JSON.stringify({ type: "ping", at: Date.now() });
+    for (const ws of this.wsServer.clients) {
+      if (ws.isAlive === false) {
+        ws.terminate();
+        continue;
+      }
+      ws.isAlive = false;
+      try {
+        ws.ping();
+        ws.send(beat);
+      } catch {
+        // Closing; the close handler cleans up.
+      }
+    }
+  }
+
+  /** Close live sessions no phone has looked at for `IDLE_SESSION_MS` (never mid-turn). */
+  reapIdleSessions() {
+    const now = Date.now();
+    for (const [id, entry] of this.sessions) {
+      if (entry.clients.size > 0 || entry.state?.isStreaming === true) continue;
+      if (now - (entry.idleSince ?? entry.updatedAt) < (this.options.idleSessionMs ?? IDLE_SESSION_MS)) continue;
+      entry.close();
+      this.sessions.delete(id);
+    }
+  }
+
   async close() {
+    clearInterval(this.heartbeat);
+    clearInterval(this.reaper);
     for (const end of this.streams) end();
     this.streams.clear();
     // Each omp saves and releases its session before the daemon exits.

package/src/takeover.mjs

@@ -24,15 +24,20 @@ import { execFile } from "node:child_process";
 import { closeSync, constants, openSync, readdirSync, readSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 
-/** How long each step waits before the next, in milliseconds. */
+/**
+ * How long each step waits before the next, in milliseconds. The extension
+ * path (a terminal with the plugin loaded) answers within a second or two;
+ * the signal path is the fallback for an omp that predates the extension, and
+ * OMP leaves on SIGINT promptly, so the waits are short rather than generous.
+ */
 export const TAKEOVER_TIMINGS = {
-  /** For the extension to pick up the request (it polls every second). */
-  ack: 2_500,
+  /** For the extension to pick up the request (it polls every 500 ms). */
+  ack: 1_500,
   /** For an owner whose extension took the request to exit (OMP closes once its session is idle). */
   extensionExit: 10_000,
   /** After `SIGINT`, then after `SIGTERM`. */
-  sigint: 10_000,
-  sigterm: 10_000,
+  sigint: 5_000,
+  sigterm: 5_000,
   poll: 100,
 };