omp-mobile 0.0.0-stage → 0.1.1

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");
+}

package/src/rpc-session.mjs

@@ -0,0 +1,265 @@
+/**
+ * One OMP process in RPC mode (`omp --mode rpc`).
+ *
+ * The daemon owns the process: commands go to stdin as JSON lines, responses
+ * and session events come back on stdout. Nothing here knows the native UI;
+ * `server.mjs` is the only place that decides what a phone may see.
+ */
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { randomUUID } from "node:crypto";
+import { createInterface } from "node:readline";
+
+const START_TIMEOUT_MS = 45_000;
+
+/**
+ * The environment without `BUN_BE_BUN`: /mobile starts the daemon under omp's
+ * embedded Bun with it set, and a child omp that inherits it would run as Bun.
+ */
+function withoutBunFlag(env) {
+  const { BUN_BE_BUN: _ignored, ...rest } = env;
+  return rest;
+}
+const REQUEST_TIMEOUT_MS = 60_000;
+
+/** Events that carry no useful state to the phone. */
+const IGNORED_UI = new Set(["setStatus", "setWidget", "setTitle", "set_editor_text"]);
+
+/**
+ * @typedef {object} RpcSessionOptions
+ * @property {string} cwd
+ * @property {string} [ompBin]
+ * @property {string[]} [extraArgs]
+ * @property {string} [sessionDir]
+ * @property {string} [resume]
+ * @property {boolean} [autoApprove]
+ */
+
+export class RpcSession extends EventEmitter {
+  /** @param {RpcSessionOptions} options */
+  constructor(options) {
+    super();
+    this.cwd = options.cwd;
+    this.ompBin = options.ompBin ?? "omp";
+    this.extraArgs = options.extraArgs ?? [];
+    this.sessionDir = options.sessionDir;
+    this.resume = options.resume;
+    this.autoApprove = options.autoApprove === true;
+    /** @type {import("node:child_process").ChildProcessWithoutNullStreams | undefined} */
+    this.child = undefined;
+    /** @type {Map<string, {resolve: (value: any) => void, reject: (error: Error) => void}>} */
+    this.pending = new Map();
+    /** @type {Map<string, object>} */
+    this.extensionRequests = new Map();
+    this.started = false;
+    this.closed = false;
+    this.startedAt = Date.now();
+    this.updatedAt = Date.now();
+    this.lastState = null;
+    this.lastError = null;
+    this.stderr = "";
+  }
+
+  /** Start the process and resolve once it printed `ready`. */
+  async start() {
+    // rpc-ui gives tools an interactive UI: OMP's approval prompt reaches the
+    // phone as an extension `select` request instead of failing closed.
+    const args = ["--mode", "rpc-ui", "--cwd", this.cwd, ...this.extraArgs];
+    if (this.resume) args.push("--resume", this.resume);
+    if (this.autoApprove) args.push("--auto-approve");
+    if (this.sessionDir) args.push("--session-dir", this.sessionDir);
+    const child = spawn(this.ompBin, args, {
+      cwd: this.cwd,
+      env: { ...withoutBunFlag(process.env), NO_COLOR: "1" },
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    this.child = child;
+    child.on("error", (error) => this.#fail(error));
+    child.on("exit", (code, signal) => {
+      this.closed = true;
+      // Nothing can answer the dialogs of a process that is gone.
+      for (const id of [...this.extensionRequests.keys()]) this.#settle(id, "closed");
+      const reason = signal ? `signal ${signal}` : `exit ${code}`;
+      this.emit("closed", { reason, stderr: this.stderr });
+      this.#fail(new Error(`omp exited: ${reason}`));
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      this.stderr = `${this.stderr}${chunk}`.slice(-16_384);
+    });
+    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 onReady = (message) => {
+        clearTimeout(timer);
+        this.off("ready", onReady);
+        resolve(message);
+      };
+      this.once("ready", onReady);
+      this.once("closed", () => {
+        clearTimeout(timer);
+        reject(new Error(`omp exited before ready: ${this.stderr.slice(-500)}`));
+      });
+    });
+    lines.on("line", (line) => this.#onLine(line));
+    await ready;
+    this.started = true;
+    return this;
+  }
+
+  /** @param {string} line */
+  #onLine(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      this.emit("protocol-error", { line: line.slice(0, 500) });
+      return;
+    }
+    this.updatedAt = Date.now();
+    if (message.type === "ready") {
+      this.emit("ready", message);
+      return;
+    }
+    if (message.type === "response") {
+      const pending = message.id ? this.pending.get(message.id) : undefined;
+      if (pending !== undefined && message.id) {
+        this.pending.delete(message.id);
+        if (message.success === false) pending.reject(new Error(message.error || `RPC ${message.command} failed`));
+        else pending.resolve(message);
+        return;
+      }
+      this.emit("response", message);
+      return;
+    }
+    if (message.type === "extension_ui_request") {
+      if (IGNORED_UI.has(message.method)) return;
+      if (message.method === "cancel") {
+        // OMP closed a dialog itself (timeout, abort); a later answer to it is ignored.
+        if (typeof message.targetId === "string") this.#settle(message.targetId, "cancelled");
+        return;
+      }
+      if (message.method === "notify") {
+        this.emit("notice", { level: message.notifyType ?? "info", message: message.message });
+        return;
+      }
+      if (message.method === "open_url") {
+        this.emit("notice", {
+          level: "info",
+          message: message.instructions || message.url,
+          url: message.url,
+          launchUrl: message.launchUrl,
+        });
+        return;
+      }
+      this.extensionRequests.set(message.id, message);
+      this.emit("approval", message);
+      return;
+    }
+    if (message.type === "available_commands_update") {
+      this.emit("commands", message.commands ?? []);
+      return;
+    }
+    this.emit("event", message);
+  }
+
+  /**
+   * Forget an open extension request and say how it ended.
+   * @param {string} id
+   * @param {"answered" | "cancelled" | "closed"} reason
+   */
+  #settle(id, reason) {
+    if (!this.extensionRequests.delete(id)) return;
+    this.emit("approval-resolved", { id, reason });
+  }
+
+  /** @param {Error} error */
+  #fail(error) {
+    this.lastError = error;
+    for (const pending of this.pending.values()) pending.reject(error);
+    this.pending.clear();
+  }
+
+  /**
+   * Send one command and wait for its `response` line.
+   * @param {string} type
+   * @param {Record<string, unknown>} [payload]
+   * @param {number} [timeoutMs]
+   */
+  request(type, payload = {}, timeoutMs = REQUEST_TIMEOUT_MS) {
+    if (this.closed || this.child === undefined) {
+      return Promise.reject(new Error("omp session is closed"));
+    }
+    const id = randomUUID();
+    const line = JSON.stringify({ id, type, ...payload });
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`omp RPC ${type} timed out`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (value) => {
+          clearTimeout(timer);
+          resolve(value);
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        },
+      });
+      this.child.stdin.write(`${line}\n`);
+    });
+  }
+
+  /** @returns {Promise<object>} */
+  async getState() {
+    const response = await this.request("get_state");
+    const data = response.data ?? {};
+    // The full system prompt and tool dump are large and never shown on a phone.
+    delete data.systemPrompt;
+    delete data.dumpTools;
+    this.lastState = data;
+    return data;
+  }
+
+  /** @returns {Promise<{messages: object[]}>} */
+  async getMessages() {
+    const response = await this.request("get_messages");
+    return response.data ?? { messages: [] };
+  }
+
+  /** @param {string} text */
+  async prompt(text) {
+    return this.request("prompt", { message: text });
+  }
+
+  async abort() {
+    return this.request("abort");
+  }
+
+  /**
+   * Answer an extension UI request (select/confirm/input/editor).
+   * @param {string} id
+   * @param {{value?: string, confirmed?: boolean, cancelled?: boolean}} answer
+   */
+  respondExtension(id, answer) {
+    if (this.closed || this.child === undefined) throw new Error("omp session is closed");
+    if (!this.extensionRequests.has(id)) throw new Error("unknown extension request");
+    const response = { type: "extension_ui_response", id, ...answer };
+    this.child.stdin.write(`${JSON.stringify(response)}\n`);
+    this.#settle(id, answer.cancelled === true ? "cancelled" : "answered");
+  }
+
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const pending of this.pending.values()) pending.reject(new Error("omp session closed"));
+    this.pending.clear();
+    this.child?.kill("SIGTERM");
+    setTimeout(() => {
+      if (this.child !== undefined && this.child.exitCode === null) this.child.kill("SIGKILL");
+    }, 2_000).unref();
+  }
+}
+
+export { REQUEST_TIMEOUT_MS, START_TIMEOUT_MS };