omp-mobile 0.0.0-stage → 0.1.1

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-extension.mjs

@@ -0,0 +1,270 @@
+/**
+ * The OMP extension of omp-mobile: `/mobile` in the interactive OMP.
+ *
+ * `/mobile` starts the daemon in the background if it is not running, then
+ * shows its pairing QR code above the composer until a phone connects. The
+ * daemon is its own process (detached, in its own session, logging to
+ * `~/.omp-mobile/daemon.log`), so it keeps serving the phone after this
+ * terminal and this OMP exit; `/mobile stop` ends it.
+ *
+ * It runs on the Bun that ships inside omp (`BUN_BE_BUN=1`), so no separate
+ * Node.js is needed, and binds this computer's Tailscale IPv4 (`--host tailscale`).
+ */
+import { spawn } from "node:child_process";
+import { accessSync, closeSync, constants, mkdirSync, openSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { renderQr } from "./qr.mjs";
+
+const HOME = join(homedir(), ".omp-mobile");
+const STATE_FILE = join(HOME, "daemon.json");
+const LOG_FILE = join(HOME, "daemon.log");
+const SERVER = fileURLToPath(new URL("./server.mjs", import.meta.url));
+const WIDGET = "omp-mobile";
+const START_TIMEOUT_MS = 20_000;
+const POLL_MS = 1_500;
+/** How long the code stays up without a phone connecting. */
+const SHOW_MS = 5 * 60_000;
+const SUBCOMMANDS = [
+  { value: "status", label: "status", description: "Is the daemon running, and where" },
+  { value: "stop", label: "stop", description: "Stop the background daemon" },
+  { value: "hide", label: "hide", description: "Hide the pairing code" },
+];
+
+/**
+ * The running daemon's record, if its process is alive.
+ * @returns {{pid: number, version: string, url: string, pair: string, startedAt: number} | undefined}
+ */
+export function readState(path = STATE_FILE) {
+  let state;
+  try {
+    state = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return undefined;
+  }
+  if (typeof state?.pid !== "number" || typeof state.url !== "string" || typeof state.pair !== "string") return undefined;
+  return alive(state.pid) ? state : undefined;
+}
+
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // EPERM: it exists but belongs to someone else.
+    return error?.code === "EPERM";
+  }
+}
+
+/** The token inside a pairing link. */
+export function tokenOf(pair) {
+  return new URL(pair.replace(/^omp-mobile:\/\//, "http://x/")).searchParams.get("token") ?? "";
+}
+
+/** The daemon's `/status`, or undefined when it does not answer. */
+async function status(state) {
+  try {
+    const response = await fetch(`${state.url}/status`, {
+      headers: { authorization: `Bearer ${tokenOf(state.pair)}`, "x-omp-mobile-probe": "1" },
+      signal: AbortSignal.timeout(3_000),
+    });
+    return response.ok ? await response.json() : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function logTail(lines = 6) {
+  try {
+    return readFileSync(LOG_FILE, "utf8").trimEnd().split("\n").slice(-lines).join("\n");
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * The omp the daemon starts sessions with: `omp` on PATH when there is one, since
+ * a package manager's link survives an upgrade that removes the versioned binary
+ * this process runs from (Homebrew's Cellar path, for one); else this binary.
+ */
+function ompBinary() {
+  for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+    if (dir === "") continue;
+    const candidate = join(dir, "omp");
+    try {
+      accessSync(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+      // Not in this directory.
+    }
+  }
+  return process.execPath;
+}
+
+/**
+ * Start the daemon detached from this terminal and wait until it serves.
+ * @param {string} cwd Default directory for sessions the phone starts.
+ */
+async function startDaemon(cwd) {
+  mkdirSync(HOME, { recursive: true, mode: 0o700 });
+  const log = openSync(LOG_FILE, "a", 0o600);
+  let child;
+  try {
+    child = spawn(process.execPath, [SERVER, "--host", "tailscale", "--cwd", cwd, "--omp", ompBinary(), "--no-qr"], {
+      cwd,
+      detached: true,
+      stdio: ["ignore", log, log],
+      env: { ...process.env, BUN_BE_BUN: "1" },
+    });
+  } finally {
+    closeSync(log);
+  }
+  let exited = false;
+  child.on("exit", () => {
+    exited = true;
+  });
+  child.on("error", () => {
+    exited = true;
+  });
+  child.unref();
+  const deadline = Date.now() + START_TIMEOUT_MS;
+  while (Date.now() < deadline && !exited) {
+    const state = readState();
+    if (state?.pid === child.pid && (await status(state)) !== undefined) return state;
+    await new Promise((resolveWait) => setTimeout(resolveWait, 250));
+  }
+  const reason = exited ? "it exited" : "it did not answer in time";
+  throw new Error(`The omp-mobile daemon did not start (${reason}).\n${logTail()}`);
+}
+
+async function stopDaemon(state) {
+  process.kill(state.pid, "SIGTERM");
+  const deadline = Date.now() + 5_000;
+  while (Date.now() < deadline && alive(state.pid)) await new Promise((resolveWait) => setTimeout(resolveWait, 100));
+  if (alive(state.pid)) process.kill(state.pid, "SIGKILL");
+}
+
+/** What the pairing widget shows: a title, the code, and where it points. */
+export function pairingContent(state) {
+  const host = new URL(state.url).host;
+  return {
+    title: "OMP Mobile · in the app: Machines → Scan to pair",
+    code: renderQr(state.pair).split("\n"),
+    notes: [
+      `${host} · pid ${state.pid} · keeps running after you exit`,
+      "/mobile hide closes this · /mobile stop stops the daemon",
+    ],
+  };
+}
+
+/** `text` cut to `width` columns (the widget's lines are plain, one column per character). */
+function fit(text, width) {
+  return text.length <= width ? text : `${text.slice(0, Math.max(0, width - 1))}…`;
+}
+
+/**
+ * The pairing widget as a TUI component: a plain line widget is cut at ten
+ * lines, which a QR code needs more than. A code cut at the terminal's edge
+ * would not scan, so a terminal narrower than the code is asked to widen;
+ * the text lines are shortened to fit instead.
+ */
+export function pairingWidget({ title, code, notes }) {
+  const codeWidth = Math.max(...code.map((line) => line.length)) + 1;
+  return () => ({
+    render(width) {
+      const text = (line) => fit(` ${line}`, width);
+      if (width < codeWidth) return [text(`OMP Mobile: widen the terminal to ${codeWidth} columns to show the code.`)];
+      return [text(title), "", ...code.map((line) => ` ${line}`), "", ...notes.map(text)];
+    },
+  });
+}
+
+export default function ompMobile(pi) {
+  /** The pairing code on screen: its watcher and when it appeared. */
+  let showing;
+
+  const hide = (ctx) => {
+    if (showing === undefined) return;
+    ctx.clearTimer(showing.timer);
+    showing = undefined;
+    ctx.ui.setWidget(WIDGET, undefined);
+  };
+
+  const show = (ctx, state) => {
+    hide(ctx);
+    if (ctx.mode !== "tui") {
+      ctx.ui.notify(`OMP Mobile: open this link on the phone: ${state.pair}`, "info");
+      return;
+    }
+    const shownAt = Date.now();
+    ctx.ui.setWidget(WIDGET, pairingWidget(pairingContent(state)), { placement: "aboveEditor" });
+    const timer = ctx.setInterval(async () => {
+      if (showing?.timer !== timer) return;
+      if (Date.now() - shownAt > SHOW_MS) {
+        hide(ctx);
+        return;
+      }
+      const now = await status(state);
+      if (showing?.timer !== timer) return;
+      if (now === undefined) {
+        hide(ctx);
+        ctx.ui.notify("OMP Mobile: the daemon stopped answering.", "warning");
+        return;
+      }
+      if (now.lastPhone !== null && now.lastPhone.at >= shownAt) {
+        hide(ctx);
+        ctx.ui.notify(`OMP Mobile: phone connected from ${now.lastPhone.address}.`, "info");
+      }
+    }, POLL_MS);
+    showing = { timer };
+  };
+
+  pi.registerCommand("mobile", {
+    description: "Pair your phone with this computer (OMP Mobile)",
+    getArgumentCompletions: (prefix) => SUBCOMMANDS.filter((item) => item.value.startsWith(prefix.trim())),
+    handler: async (args, ctx) => {
+      const sub = args.trim();
+      const state = readState();
+      if (sub === "hide") {
+        hide(ctx);
+        return;
+      }
+      if (sub === "stop") {
+        hide(ctx);
+        if (state === undefined) {
+          ctx.ui.notify("OMP Mobile: the daemon is not running.", "info");
+          return;
+        }
+        await stopDaemon(state);
+        ctx.ui.notify(`OMP Mobile: stopped the daemon (pid ${state.pid}).`, "info");
+        return;
+      }
+      if (sub === "status") {
+        const now = state === undefined ? undefined : await status(state);
+        if (state === undefined || now === undefined) {
+          ctx.ui.notify("OMP Mobile: the daemon is not running. /mobile starts it.", "info");
+          return;
+        }
+        const phone = now.lastPhone === null ? "no phone yet" : `last phone ${now.lastPhone.address}`;
+        ctx.ui.notify(`OMP Mobile: ${now.url} · pid ${now.pid} · ${now.liveSessions} live sessions · ${phone}`, "info");
+        return;
+      }
+      if (sub !== "") {
+        ctx.ui.notify(`OMP Mobile: unknown "${sub}". Use /mobile, /mobile status, /mobile stop or /mobile hide.`, "warning");
+        return;
+      }
+      let running = state !== undefined && (await status(state)) !== undefined ? state : undefined;
+      if (running === undefined) {
+        ctx.ui.notify("OMP Mobile: starting the daemon…", "info");
+        try {
+          running = await startDaemon(ctx.cwd);
+        } catch (error) {
+          ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+          return;
+        }
+      }
+      show(ctx, running);
+    },
+  });
+}