omp-mobile 0.0.0-stage → 0.1.0

package/src/attention.mjs

@@ -0,0 +1,243 @@
+/**
+ * Attention stream: the moments a phone should hear about while the app is in
+ * the background — a tool approval or another question waiting for an answer,
+ * the answer (or cancellation) that settles it, and an agent run that finished
+ * or failed — folded from what every live session broadcasts, across all
+ * sessions, and served as one Server-Sent Events stream (`GET /events`).
+ *
+ * The tracker reads the same payloads `SessionEntry.broadcast` sends its
+ * WebSocket clients (`{type: "event" | "approval" | "approval_resolved" |
+ * "notice" | "closed", ...}`), so a frame never depends on a client being
+ * connected to that session.
+ */
+import { hostname } from "node:os";
+
+/** @typedef {"approval" | "question" | "resolved" | "done" | "failed"} AttentionKind */
+
+/**
+ * @typedef {object} AttentionFrame
+ * @property {AttentionKind} kind
+ * @property {string} key Waiting-item identity: the extension request id; `run:<n>` for done/failed.
+ * @property {string} sessionId
+ * @property {string} sessionTitle
+ * @property {string} machine This computer's hostname.
+ * @property {string} text Human text: the question, the final answer, or the failure.
+ * @property {number} time Epoch ms.
+ */
+
+/** @typedef {{id: string, title?: string}} SessionLike */
+
+/** The listener sends a comment this often so phones can tell a dead link from a quiet one. */
+export const HEARTBEAT_MS = 25_000;
+/** OMP's tool approval is a `select` whose title starts with this. */
+export const TOOL_APPROVAL_PREFIX = "Allow tool:";
+const ASKING = new Set(["select", "confirm", "input", "editor"]);
+const TEXT_MAX = 280;
+
+function clip(value) {
+  const text = typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
+  return text.length > TEXT_MAX ? `${text.slice(0, TEXT_MAX - 1)}…` : text;
+}
+
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((part) => (part && typeof part === "object" && part.type === "text" && typeof part.text === "string" ? part.text : ""))
+    .join("");
+}
+
+/**
+ * Whether an extension UI request is OMP's tool approval rather than another question.
+ * @param {{method?: string, title?: unknown}} request
+ */
+export function isToolApproval(request) {
+  return request.method === "select" && typeof request.title === "string" && request.title.startsWith(TOOL_APPROVAL_PREFIX);
+}
+
+function lastAssistant(messages) {
+  if (!Array.isArray(messages)) return undefined;
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    if (messages[i]?.role === "assistant") return messages[i];
+  }
+  return undefined;
+}
+
+/** Folds session broadcasts into attention frames and fans them out. */
+export class AttentionTracker {
+  /** @param {{machine?: string, now?: () => number}} [options] */
+  constructor(options = {}) {
+    this.machine = options.machine ?? hostname();
+    this.now = options.now ?? (() => Date.now());
+    /** @type {Map<string, {open: Map<string, AttentionFrame>, runs: number, error: string, last: object | undefined}>} */
+    this.sessions = new Map();
+    /** @type {Set<(frame: AttentionFrame) => void>} */
+    this.subscribers = new Set();
+  }
+
+  /** Approvals and questions still waiting, across all sessions, oldest first. */
+  pending() {
+    const open = [];
+    for (const state of this.sessions.values()) open.push(...state.open.values());
+    return open.sort((a, b) => a.time - b.time);
+  }
+
+  /**
+   * @param {(frame: AttentionFrame) => void} listener
+   * @returns {() => void} unsubscribe
+   */
+  subscribe(listener) {
+    this.subscribers.add(listener);
+    return () => this.subscribers.delete(listener);
+  }
+
+  /** Drop a session that is gone, resolving whatever it still had open. */
+  forget(session) {
+    this.observe(session, { type: "closed" });
+    this.sessions.delete(session.id);
+  }
+
+  /**
+   * Fold one payload a session broadcast.
+   * @param {SessionLike} session
+   * @param {{type: string, [key: string]: any}} payload
+   * @returns {AttentionFrame[]} the frames it produced
+   */
+  observe(session, payload) {
+    const state = this.#state(session.id);
+    const frames = [];
+    const emit = (kind, key, text) => {
+      const frame = {
+        kind,
+        key,
+        sessionId: session.id,
+        sessionTitle: session.title ?? "",
+        machine: this.machine,
+        text: clip(text),
+        time: this.now(),
+      };
+      frames.push(frame);
+      return frame;
+    };
+    switch (payload?.type) {
+      case "approval": {
+        const request = payload.request ?? {};
+        if (typeof request.id !== "string" || !ASKING.has(request.method)) break;
+        if (state.open.has(request.id)) break;
+        const approval = isToolApproval(request);
+        const title = typeof request.title === "string" ? request.title : "";
+        // OMP's tool approval title is `Allow tool: bash\nCommand: echo hi`: the tool, then its details.
+        const lines = (approval ? title.slice(TOOL_APPROVAL_PREFIX.length) : title).split("\n").map((line) => line.trim());
+        const text = [...lines, request.message].filter(Boolean).join(" · ");
+        state.open.set(request.id, emit(approval ? "approval" : "question", request.id, text));
+        break;
+      }
+      case "approval_resolved": {
+        if (typeof payload.id !== "string" || !state.open.delete(payload.id)) break;
+        emit("resolved", payload.id, typeof payload.reason === "string" ? payload.reason : "answered");
+        break;
+      }
+      case "closed": {
+        for (const key of [...state.open.keys()]) {
+          state.open.delete(key);
+          emit("resolved", key, "closed");
+        }
+        break;
+      }
+      case "notice": {
+        if (payload.level === "error") state.error = typeof payload.message === "string" ? payload.message : "error";
+        break;
+      }
+      case "event":
+        this.#event(state, payload.event ?? {}, emit);
+        break;
+      default:
+    }
+    for (const frame of frames) for (const listener of this.subscribers) listener(frame);
+    return frames;
+  }
+
+  #event(state, event, emit) {
+    switch (event.type) {
+      case "agent_start":
+        state.error = "";
+        state.last = undefined;
+        return;
+      case "notice":
+        if (event.level === "error") state.error = typeof event.message === "string" ? event.message : "error";
+        return;
+      case "message_end":
+        if (event.message?.role === "assistant") state.last = event.message;
+        return;
+      case "agent_end": {
+        state.runs += 1;
+        const key = `run:${state.runs}`;
+        const last = lastAssistant(event.messages) ?? state.last;
+        const stop = last?.stopReason;
+        if (stop === "error" || stop === "aborted") {
+          const reason = typeof last.errorMessage === "string" && last.errorMessage !== "" ? last.errorMessage : stop === "aborted" ? "Aborted" : "Failed";
+          emit("failed", key, reason);
+        } else if (state.error !== "") {
+          emit("failed", key, state.error);
+        } else {
+          emit("done", key, textOf(last?.content));
+        }
+        state.error = "";
+        state.last = undefined;
+        return;
+      }
+      default:
+    }
+  }
+
+  #state(sessionId) {
+    let state = this.sessions.get(sessionId);
+    if (state === undefined) {
+      state = { open: new Map(), runs: 0, error: "", last: undefined };
+      this.sessions.set(sessionId, state);
+    }
+    return state;
+  }
+}
+
+/** One SSE frame of data. */
+export function sseData(frame) {
+  return `data: ${JSON.stringify(frame)}\n\n`;
+}
+
+/**
+ * Serve the stream on an authorized request: open approvals/questions first,
+ * then `event: live`, then frames as they happen, with a heartbeat comment.
+ * @param {AttentionTracker} tracker
+ * @param {import("node:http").IncomingMessage} req
+ * @param {import("node:http").ServerResponse} res
+ * @param {{heartbeatMs?: number}} [options]
+ * @returns {() => void} ends the stream
+ */
+export function serveEvents(tracker, req, res, options = {}) {
+  res.writeHead(200, {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-store",
+    connection: "keep-alive",
+    "x-accel-buffering": "no",
+  });
+  req.socket.setNoDelay(true);
+  req.socket.setKeepAlive(true, 30_000);
+  res.write(": omp-mobile attention\n\n");
+  for (const frame of tracker.pending()) res.write(sseData(frame));
+  res.write("event: live\ndata: {}\n\n");
+  const off = tracker.subscribe((frame) => res.write(sseData(frame)));
+  const heartbeat = setInterval(() => res.write(": ping\n\n"), options.heartbeatMs ?? HEARTBEAT_MS);
+  let ended = false;
+  const end = () => {
+    if (ended) return;
+    ended = true;
+    off();
+    clearInterval(heartbeat);
+    if (!res.writableEnded) res.end();
+  };
+  req.on("close", end);
+  res.on("close", end);
+  res.on("error", end);
+  return end;
+}

package/src/omp-sessions.mjs

@@ -0,0 +1,203 @@
+/**
+ * Sessions OMP wrote outside this daemon: the terminal sessions in OMP's own
+ * session directory, and which of them another omp process holds open.
+ *
+ * Reads only what OMP documents as its on-disk contract: one directory per
+ * cwd under `<omp home>/agent/sessions`, JSONL files that begin with an
+ * optional fixed-width `title` slot and the `session` header, and the owner
+ * lock each writing process holds in `<omp home>/run/session-owners/<id>.lock`.
+ */
+import { execFile } from "node:child_process";
+import { open, readdir, stat } from "node:fs/promises";
+import { basename, join } from "node:path";
+
+/** How far into a file the first prompt is looked for; headers and setup entries come first. */
+const TITLE_SCAN_BYTES = 512 * 1024;
+const CHUNK_BYTES = 64 * 1024;
+const LSOF_TIMEOUT_MS = 5_000;
+
+/** @typedef {{id: string, title: string, cwd: string, createdAt: number, updatedAt: number, sessionFile: string}} OmpSession */
+
+/** Text of an OMP message content field (string or content-part array). */
+function textOfContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (part && typeof part === "object" && typeof part.text === "string") return part.text;
+        return "";
+      })
+      .join("");
+  }
+  return "";
+}
+
+/** The first user prompt, as one line of at most 80 characters. */
+export function promptTitle(content) {
+  return oneLine(textOfContent(content));
+}
+
+/**
+ * A title as one line of at most 80 characters. OMP's title cards start with
+ * a Nerd Font icon (private-use code points) a phone font has no glyph for.
+ */
+function oneLine(text) {
+  return text
+    .replace(/[\uE000-\uF8FF\u{F0000}-\u{10FFFF}]/gu, "")
+    .trim()
+    .replace(/\s+/g, " ")
+    .slice(0, 80);
+}
+
+/**
+ * Read a session file's identity and title.
+ * Undefined when the file has no `session` header (not an OMP session, or still empty).
+ * @param {string} file
+ * @returns {Promise<OmpSession | undefined>}
+ */
+export async function readSessionFile(file) {
+  const handle = await open(file, "r");
+  try {
+    const info = await handle.stat();
+    let header;
+    let slotTitle = "";
+    let firstPrompt = "";
+    let rest = "";
+    let offset = 0;
+    const buffer = Buffer.alloc(CHUNK_BYTES);
+    scan: while (offset < TITLE_SCAN_BYTES) {
+      const { bytesRead } = await handle.read(buffer, 0, CHUNK_BYTES, offset);
+      if (bytesRead === 0) break;
+      offset += bytesRead;
+      rest += buffer.toString("utf8", 0, bytesRead);
+      const lines = rest.split("\n");
+      rest = lines.pop() ?? "";
+      for (const line of lines) {
+        let entry;
+        try {
+          entry = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (entry?.type === "title" && header === undefined) {
+          if (typeof entry.title === "string") slotTitle = oneLine(entry.title);
+        } else if (entry?.type === "session") {
+          header = entry;
+          if (slotTitle === "" && typeof entry.title === "string") slotTitle = oneLine(entry.title);
+          if (slotTitle !== "") break scan;
+        } else if (header === undefined) {
+          // Legacy files begin with the header; anything else first is not a session.
+          return undefined;
+        } else if (entry?.type === "message" && entry.message?.role === "user") {
+          firstPrompt = promptTitle(entry.message.content);
+          if (firstPrompt !== "") break scan;
+        }
+      }
+    }
+    if (header === undefined || typeof header.id !== "string" || typeof header.cwd !== "string") return undefined;
+    const created = Date.parse(header.timestamp);
+    return {
+      id: header.id,
+      title: slotTitle || firstPrompt || basename(header.cwd) || "session",
+      cwd: header.cwd,
+      createdAt: Number.isFinite(created) ? created : info.birthtimeMs,
+      updatedAt: info.mtimeMs,
+      sessionFile: file,
+    };
+  } finally {
+    await handle.close();
+  }
+}
+
+/**
+ * The most recently written sessions under OMP's session root, newest first.
+ * A missing root is no sessions; unreadable or foreign files are skipped.
+ * @param {string} root `<omp home>/agent/sessions`
+ * @param {{limit?: number}} [options]
+ * @returns {Promise<OmpSession[]>}
+ */
+export async function listOmpSessions(root, { limit = 50 } = {}) {
+  let dirs;
+  try {
+    dirs = await readdir(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  /** @type {{file: string, mtime: number}[]} */
+  const files = [];
+  await Promise.all(
+    dirs
+      .filter((dir) => dir.isDirectory())
+      .map(async (dir) => {
+        const path = join(root, dir.name);
+        let names;
+        try {
+          names = await readdir(path);
+        } catch {
+          return;
+        }
+        await Promise.all(
+          names
+            .filter((name) => name.endsWith(".jsonl"))
+            .map(async (name) => {
+              const file = join(path, name);
+              try {
+                files.push({ file, mtime: (await stat(file)).mtimeMs });
+              } catch {
+                // Removed while listing.
+              }
+            }),
+        );
+      }),
+  );
+  files.sort((a, b) => b.mtime - a.mtime);
+  const sessions = [];
+  const seen = new Set();
+  for (const { file } of files) {
+    if (sessions.length >= limit) break;
+    let session;
+    try {
+      session = await readSessionFile(file);
+    } catch {
+      continue;
+    }
+    // A moved session can leave an older copy; the newest file wins.
+    if (session === undefined || seen.has(session.id)) continue;
+    seen.add(session.id);
+    sessions.push(session);
+  }
+  return sessions;
+}
+
+/**
+ * Session ids whose owner lock some process holds open, with that process id.
+ * `undefined` when ownership cannot be read (no `lsof`), which callers must not treat as "nobody".
+ * @param {string} ownersDir `<omp home>/run/session-owners`
+ * @param {{lsof?: string}} [options]
+ * @returns {Promise<Map<string, number> | undefined>}
+ */
+export function sessionOwners(ownersDir, { lsof = "lsof" } = {}) {
+  return new Promise((resolveOwners) => {
+    // -F pn: one `p<pid>` line per process, then `n<path>` per open file.
+    execFile(lsof, ["-n", "-w", "-F", "pn", "+d", ownersDir], { timeout: LSOF_TIMEOUT_MS }, (error, stdout) => {
+      // lsof exits 1 when nothing in the directory is open; that is an answer.
+      if (error && (typeof error.code !== "number" || stdout === "")) {
+        resolveOwners(error.code === 1 ? new Map() : undefined);
+        return;
+      }
+      resolveOwners(parseLsof(stdout));
+    });
+  });
+}
+
+/** @param {string} output `lsof -F pn` output */
+export function parseLsof(output) {
+  const owners = new Map();
+  let pid = 0;
+  for (const line of output.split("\n")) {
+    if (line.startsWith("p")) pid = Number(line.slice(1));
+    else if (line.startsWith("n") && line.endsWith(".lock") && pid > 0) owners.set(basename(line.slice(1), ".lock"), pid);
+  }
+  return owners;
+}

package/src/qr.mjs

@@ -0,0 +1,67 @@
+/**
+ * Terminal QR codes for the pairing URI, drawn with Unicode half blocks.
+ *
+ * Each text line carries two module rows: "▀" is a dark top half, "▄" a dark
+ * bottom half, "█" both and a space neither. Dark modules are the terminal's
+ * foreground and the quiet zone is plain spaces, so on a light terminal the
+ * code is dark on light, and on a dark terminal it is the same code inverted,
+ * which the phone scanners (ML Kit, Vision) read as well. No colors are used,
+ * so the output survives logs, tmux and terminals without ANSI support.
+ */
+import qrcode from "qrcode-generator";
+
+/** Modules of blank margin on every side. */
+export const QUIET_ZONE = 2;
+
+/** Error correction level: M survives a slightly blurry photo of a screen. */
+const LEVEL = "M";
+
+/**
+ * The QR module matrix for `text`, `true` for a dark module.
+ * @param {string} text
+ * @returns {boolean[][]}
+ */
+export function qrMatrix(text) {
+  // Type 0 picks the smallest version that fits; byte mode keeps URIs intact.
+  const code = qrcode(0, LEVEL);
+  code.addData(text, "Byte");
+  code.make();
+  const size = code.getModuleCount();
+  const rows = [];
+  for (let row = 0; row < size; row += 1) {
+    const cells = [];
+    for (let col = 0; col < size; col += 1) cells.push(code.isDark(row, col));
+    rows.push(cells);
+  }
+  return rows;
+}
+
+/**
+ * Render `text` as a QR code of half blocks with a blank quiet zone.
+ * Every line has the same width; lines are joined with "\n" (no trailing newline).
+ * @param {string} text
+ * @returns {string}
+ */
+export function renderQr(text) {
+  const matrix = qrMatrix(text);
+  const size = matrix.length;
+  const total = size + QUIET_ZONE * 2;
+  /** Whether the module at (row, col) of the padded grid is dark. */
+  const dark = (row, col) => {
+    const r = row - QUIET_ZONE;
+    const c = col - QUIET_ZONE;
+    return r >= 0 && r < size && c >= 0 && c < size && matrix[r][c] === true;
+  };
+  const lines = [];
+  // An odd row count leaves the last line's bottom half outside the grid: blank.
+  for (let row = 0; row < total; row += 2) {
+    let line = "";
+    for (let col = 0; col < total; col += 1) {
+      const top = dark(row, col);
+      const bottom = row + 1 < total && dark(row + 1, col);
+      line += top ? (bottom ? "█" : "▀") : bottom ? "▄" : " ";
+    }
+    lines.push(line);
+  }
+  return lines.join("\n");
+}