omp-mobile 0.1.0 → 0.2.0

package/README.md

@@ -14,34 +14,38 @@
 OMP Mobile is a native phone app for [oh-my-pi](https://github.com/can1357/oh-my-pi) (OMP), with a small daemon on each computer. Start, follow and steer OMP sessions from the phone: transcript, tool calls, approvals, and the sessions you started in a terminal.
 
 - **Native app:** The app draws the transcript, tool cards, thinking, Markdown and composer itself. No WebView, no web page.
+- **The whole transcript:** images the user sent and images tools produce (screenshots, opened files), edit diffs with their intent, tool results, Markdown tables, OMP's todo list, context usage and queued messages.
+- **Model switching:** tap the model in the composer to pick from OMP's catalog — grouped by provider and searchable — and set its thinking level. The model chip follows the session when it changes.
 - **Approvals on the phone:** OMP's own tool approvals and questions arrive as a sheet, and the turn waits for your answer.
 - **Terminal sessions:** Sessions you started in a terminal on the computer are listed too and continue on the phone. One still open in a terminal waits until that terminal exits.
 - **Notifications:** Android notifications for approvals, questions, and finished turns while the app is in the background.
 - **All your machines:** Pair each computer by QR code, switch between them from the session list. A reopened chat shows at once, also offline.
 - **Tailscale only:** The daemon listens on the computer's Tailscale address and admits only your own devices. No relay or cloud service of its own.
+- **An OMP plugin:** `/mobile` in OMP starts the daemon in the background and shows the pairing code. The daemon keeps running after the terminal closes.
 
 ## Getting started
 
 ### Prerequisites
 
-- On every computer: Node.js 22.19 or newer, and OMP 18.x on `PATH`
+- On every computer: OMP 18.x
 - [Tailscale](https://tailscale.com) signed in to the same account on the computer and the phone
 - An Android phone
 
 ### Computer
 
-Install the daemon on every computer and run it bound to the computer's Tailscale IPv4 address (`tailscale ip -4`):
+Install the plugin into OMP on every computer:
 
 ```bash
-npm install -g omp-mobile
-omp-mobile --host 100.x.y.z --cwd ~/project
+omp plugin install omp-mobile
 ```
 
-It prints its address, a token, and a pairing link with the same link as a QR code. New sessions start in `--cwd`.
+Then in OMP, run `/mobile`. It starts the daemon in the background, bound to the computer's Tailscale address, and shows a pairing code above the composer until the phone connects. The daemon runs on the Bun inside OMP and outlives the terminal and OMP; `/mobile status` shows it and `/mobile stop` ends it. Phone sessions start in the directory where you ran `/mobile` the first time.
+
+Without the plugin, the same daemon runs from npm (Node.js 22.19 or newer) in the foreground: `npm install -g omp-mobile`, then `omp-mobile --host tailscale --cwd ~/project`. It prints the same code.
 
 ### Phone
 
-Install the APK from the [releases page](https://github.com/Rinai-R/omp-mobile/releases). In the app, tap **Scan to pair** and scan the code the daemon printed. **Enter address** takes the address and token by hand, or a pasted pairing link.
+Install the APK from the [releases page](https://github.com/Rinai-R/omp-mobile/releases). In the app, tap **Scan to pair** and scan the code. **Enter address** takes the address and token by hand, or a pasted pairing link.
 
 For notifications, open **Settings → Notifications** in the app.
 

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "omp-mobile",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "The computer side of OMP Mobile: runs oh-my-pi sessions and serves them to the phone app over Tailscale.",
   "keywords": [
+    "mobile",
     "oh-my-pi",
     "omp",
-    "mobile",
+    "omp-plugin",
     "remote",
     "tailscale"
   ],
@@ -27,6 +28,11 @@
   "bin": {
     "omp-mobile": "src/server.mjs"
   },
+  "omp": {
+    "extensions": [
+      "./src/omp-extension.mjs"
+    ]
+  },
   "files": [
     "src",
     "NOTICE"

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

package/src/rpc-session.mjs

@@ -11,6 +11,15 @@ 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. */
@@ -26,6 +35,36 @@ const IGNORED_UI = new Set(["setStatus", "setWidget", "setTitle", "set_editor_te
  * @property {boolean} [autoApprove]
  */
 
+/**
+ * One entry of OMP's model catalog, cut to what a phone lists: provider, name,
+ * context window and input kinds. The full object carries endpoints, cost and
+ * compatibility fields the app never shows.
+ * @param {Record<string, unknown>} model
+ */
+export function compactModel(model) {
+  const thinking = model.thinking;
+  const cost = model.cost;
+  return {
+    provider: typeof model.provider === "string" ? model.provider : "",
+    id: typeof model.id === "string" ? model.id : "",
+    name: typeof model.name === "string" ? model.name : typeof model.id === "string" ? model.id : "",
+    reasoning: model.reasoning === true,
+    input: Array.isArray(model.input) ? model.input.filter((kind) => typeof kind === "string") : [],
+    contextWindow: typeof model.contextWindow === "number" ? model.contextWindow : undefined,
+    cost:
+      cost !== null && typeof cost === "object"
+        ? {
+            input: typeof cost.input === "number" ? cost.input : undefined,
+            output: typeof cost.output === "number" ? cost.output : undefined,
+          }
+        : undefined,
+    efforts:
+      thinking !== null && typeof thinking === "object" && Array.isArray(thinking.efforts)
+        ? thinking.efforts.filter((level) => typeof level === "string")
+        : undefined,
+  };
+}
+
 export class RpcSession extends EventEmitter {
   /** @param {RpcSessionOptions} options */
   constructor(options) {
@@ -61,7 +100,7 @@ export class RpcSession extends EventEmitter {
     if (this.sessionDir) args.push("--session-dir", this.sessionDir);
     const child = spawn(this.ompBin, args, {
       cwd: this.cwd,
-      env: { ...process.env, NO_COLOR: "1" },
+      env: { ...withoutBunFlag(process.env), NO_COLOR: "1" },
       stdio: ["pipe", "pipe", "pipe"],
     });
     this.child = child;
@@ -219,6 +258,41 @@ export class RpcSession extends EventEmitter {
     return response.data ?? { messages: [] };
   }
 
+  /**
+   * The models this session can switch to, compacted for a phone list.
+   * OMP waits out background discovery first, so this can take a few seconds.
+   * @returns {Promise<ReturnType<typeof compactModel>[]>}
+   */
+  async availableModels() {
+    const response = await this.request("get_available_models");
+    const models = response.data?.models;
+    return Array.isArray(models) ? models.map(compactModel) : [];
+  }
+
+  /**
+   * Switch this session to another model. Returns the state afterwards: the
+   * model's thinking efforts decide which levels the phone may offer.
+   * @param {string} provider
+   * @param {string} modelId
+   */
+  async setModel(provider, modelId) {
+    await this.request("set_model", { provider, modelId });
+    return this.getState();
+  }
+
+  /** @returns {Promise<{levels: string[]}>} */
+  async availableThinkingLevels() {
+    const response = await this.request("get_available_thinking_levels");
+    const levels = response.data?.levels;
+    return { levels: Array.isArray(levels) ? levels.filter((level) => typeof level === "string") : [] };
+  }
+
+  /** @param {string} level */
+  async setThinkingLevel(level) {
+    await this.request("set_thinking_level", { level });
+    return this.getState();
+  }
+
   /** @param {string} text */
   async prompt(text) {
     return this.request("prompt", { message: text });

package/src/server.mjs

@@ -8,7 +8,7 @@
  * to be exposed to the public internet.
  */
 import { STATUS_CODES, createServer } from "node:http";
-import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { homedir, hostname, platform } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
@@ -25,10 +25,25 @@ const PROTOCOL = 1;
 const DEFAULT_PORT = 7390;
 const DEFAULT_TOKEN_FILE = join(homedir(), ".omp-mobile", "token");
 const DEFAULT_REGISTRY_FILE = join(homedir(), ".omp-mobile", "sessions.json");
+const DEFAULT_STATE_FILE = join(homedir(), ".omp-mobile", "daemon.json");
 const DEFAULT_OMP_HOME = join(homedir(), ".omp");
 const MAX_BODY = 256 * 1024;
 /** Terminal sessions listed next to the daemon's own, newest first. */
 const OMP_SESSION_LIMIT = 50;
+/**
+ * Session events after which `get_state` differs from what the phone holds:
+ * the model or thinking level changed, or the todo/queue/goal panels moved.
+ */
+const STATE_EVENTS = new Set([
+  "model_changed",
+  "thinking_level_changed",
+  "queue_update",
+  "todo_reminder",
+  "todo_auto_clear",
+  "goal_updated",
+]);
+/** OMP's content-addressed image store under `<omp home>/agent/blobs`. */
+const BLOB_NAME = /^[0-9a-f]{64}$/;
 
 /** @typedef {{id: string, title: string, cwd: string, status: string, model?: string, createdAt: number, updatedAt: number, sessionFile?: string, origin: "daemon" | "omp", openElsewhere?: boolean}} SessionSummary */
 
@@ -45,6 +60,7 @@ function parseArgs(argv) {
     omp: "omp",
     tokenFile: DEFAULT_TOKEN_FILE,
     registryFile: DEFAULT_REGISTRY_FILE,
+    stateFile: DEFAULT_STATE_FILE,
     token: "",
     sessionDir: "",
     ompHome: DEFAULT_OMP_HOME,
@@ -86,6 +102,10 @@ function parseArgs(argv) {
         options.registryFile = resolve(value);
         i += 1;
         break;
+      case "--state-file":
+        options.stateFile = resolve(value);
+        i += 1;
+        break;
       case "--session-dir":
         options.sessionDir = resolve(value);
         i += 1;
@@ -130,8 +150,7 @@ function printHelp() {
 
 Usage: omp-mobile [options]
 
-  --host <address>       Bind address (default 127.0.0.1; use the Tailscale IP for a phone)
-  --port <port>          Port (default ${DEFAULT_PORT})
+  --host <address>       Bind address (default 127.0.0.1). \`tailscale\`: this computer's Tailscale IPv4
   --cwd <dir>            Default working directory for new sessions
   --omp <path>           omp executable (default "omp")
   --session-dir <dir>    OMP session directory for sessions this daemon creates
@@ -139,6 +158,7 @@ Usage: omp-mobile [options]
   --token <token>        Fixed bearer token (otherwise generated and stored)
   --token-file <path>    Token file (default ~/.omp-mobile/token)
   --registry-file <path> Session registry (default ~/.omp-mobile/sessions.json)
+  --state-file <path>    Where the running daemon records its pid and pairing link (default ~/.omp-mobile/daemon.json)
   --auto-approve         Pass --auto-approve to omp (no tool approvals reach the phone)
   --approval-mode <m>    Pass --approval-mode to omp (always-ask, always-ask-cached, write, yolo)
   --tailscale <path>     tailscale CLI used for admission (default "tailscale")
@@ -219,6 +239,39 @@ function sendJson(res, status, body) {
   res.end(data);
 }
 
+/** What a stored blob is, from its first bytes: OMP keeps the extension off the hash name. */
+export function blobType(bytes) {
+  if (bytes.length >= 4 && bytes.toString("ascii", 0, 4) === "RIFF" && bytes.toString("ascii", 8, 12) === "WEBP") {
+    return "image/webp";
+  }
+  if (bytes.length >= 8 && bytes.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {
+    return "image/png";
+  }
+  if (bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) return "image/jpeg";
+  if (bytes.length >= 4 && bytes.toString("ascii", 0, 4) === "GIF8") return "image/gif";
+  return "application/octet-stream";
+}
+
+/** A stored image: `GET /blobs/<sha256>[.ext]`, authenticated like every other route. */
+function sendBlob(res, ompHome, 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()) {
+    sendJson(res, 404, { error: "no such blob" });
+    return;
+  }
+  const bytes = readFileSync(path);
+  res.writeHead(200, {
+    "content-type": blobType(bytes),
+    "content-length": bytes.length,
+    "cache-control": "private, max-age=31536000, immutable",
+  });
+  res.end(bytes);
+}
+
 function readBody(req) {
   return new Promise((resolveBody, reject) => {
     let size = 0;
@@ -353,6 +406,9 @@ class SessionEntry {
           this.onChange?.(this);
         }
       }
+      if (STATE_EVENTS.has(event.type)) void this.refreshState();
+      // A `todo` tool call rewrites the list before any reminder fires.
+      if (event.type === "tool_execution_end" && event.toolName === "todo") void this.refreshState();
       if (event.type === "turn_end" || event.type === "agent_end") void this.refreshState();
       this.broadcast({ type: "event", event });
     });
@@ -397,6 +453,10 @@ class Daemon {
     this.token = token;
     this.admission = identity.admission;
     this.user = identity.user ?? "";
+    this.startedAt = Date.now();
+    /** The last authenticated request from a client (not `/mobile`'s own probe), for `/mobile` to see a phone connect. */
+    /** @type {{address: string, at: number} | null} */
+    this.lastPhone = null;
     /** @type {Map<string, SessionEntry>} */
     this.sessions = new Map();
     /** @type {Map<string, object>} */
@@ -477,6 +537,24 @@ class Daemon {
       sendJson(res, 401, { error: "unauthorized" });
       return;
     }
+    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]);
+      return;
+    }
+    if (url.pathname === "/status" && req.method === "GET") {
+      sendJson(res, 200, {
+        pid: process.pid,
+        version: VERSION,
+        startedAt: this.startedAt,
+        url: this.baseUrl(),
+        liveSessions: this.sessions.size,
+        eventStreams: this.streams.size,
+        lastPhone: this.lastPhone,
+      });
+      return;
+    }
     if (url.pathname === "/events" && req.method === "GET") {
       const end = serveEvents(this.attention, req, res);
       this.streams.add(end);
@@ -653,6 +731,7 @@ class Daemon {
       socket.destroy();
       return;
     }
+    this.noteClient(req);
     void this.ensureLive(decodeURIComponent(match[1]))
       .then((entry) => {
         this.wsServer.handleUpgrade(req, socket, head, (ws) => {
@@ -706,6 +785,39 @@ class Daemon {
         case "refresh":
           await entry.refreshState();
           return;
+        case "models": {
+          const models = await entry.rpc.availableModels();
+          ws.send(JSON.stringify({ type: "models", models }));
+          return;
+        }
+        case "set_model": {
+          if (typeof message.provider !== "string" || typeof message.modelId !== "string") {
+            throw new Error("set_model needs provider and modelId");
+          }
+          const state = await entry.rpc.setModel(message.provider, message.modelId);
+          entry.state = state;
+          entry.updatedAt = Date.now();
+          entry.onChange?.(entry);
+          entry.broadcast({ type: "state", state });
+          ws.send(JSON.stringify({ type: "accepted", command: "set_model" }));
+          return;
+        }
+        case "thinking_levels": {
+          const { levels } = await entry.rpc.availableThinkingLevels();
+          ws.send(
+            JSON.stringify({ type: "thinking_levels", levels, current: entry.state?.thinkingLevel ?? null }),
+          );
+          return;
+        }
+        case "set_thinking_level": {
+          if (typeof message.level !== "string" || message.level === "") throw new Error("set_thinking_level needs a level");
+          const state = await entry.rpc.setThinkingLevel(message.level);
+          entry.state = state;
+          entry.updatedAt = Date.now();
+          entry.broadcast({ type: "state", state });
+          ws.send(JSON.stringify({ type: "accepted", command: "set_thinking_level" }));
+          return;
+        }
         default:
           throw new Error(`unknown command ${String(message.type)}`);
       }
@@ -714,6 +826,17 @@ class Daemon {
     }
   }
 
+  /**
+   * Remember an authenticated client request. `/mobile` marks its own status
+   * polls with `x-omp-mobile-probe`; anything else is the app. An address cannot
+   * tell them apart: an emulator's requests leave from this computer's own address.
+   */
+  noteClient(req) {
+    if (req.headers["x-omp-mobile-probe"] !== undefined) return;
+    const address = String(req.socket?.remoteAddress ?? "").replace(/^::ffff:/i, "");
+    this.lastPhone = { address, at: Date.now() };
+  }
+
   listen() {
     return new Promise((resolveListen) => {
       this.server.listen(this.options.port, this.options.host, () => resolveListen());
@@ -774,14 +897,44 @@ function isTailnetAddress(host) {
   return /\.ts\.net$/i.test(host);
 }
 
+/** This computer's Tailscale IPv4 address, for `--host tailscale`. */
+async function tailscaleHost(options) {
+  let self;
+  try {
+    self = await new Tailscale({ binary: options.tailscale }).status();
+  } catch (error) {
+    throw startupError(`--host tailscale: cannot read tailscale status (${error instanceof Error ? error.message : String(error)})`);
+  }
+  const ipv4 = self.ips.find((ip) => isTailnetAddress(ip));
+  if (ipv4 === undefined) throw startupError("--host tailscale: this computer has no Tailscale IPv4 address");
+  return ipv4;
+}
+
+/** Record the running daemon for `/mobile` (owner-only: the pairing link carries the token). */
+function writeState(path, state) {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+}
+
+/** Remove the state file if it still describes this process. */
+function clearState(path) {
+  try {
+    if (JSON.parse(readFileSync(path, "utf8")).pid === process.pid) unlinkSync(path);
+  } catch {
+    // Already gone or replaced by another daemon.
+  }
+}
+
 async function main() {
   const options = parseArgs(process.argv.slice(2));
+  if (options.host === "tailscale") options.host = await tailscaleHost(options);
   const token = loadToken(options);
   const identity = await resolveIdentity(options);
   const daemon = new Daemon(options, token, identity);
   await daemon.listen();
   const url = daemon.baseUrl();
   const pair = `omp-mobile://pair?url=${encodeURIComponent(url)}&token=${encodeURIComponent(token)}`;
+  writeState(options.stateFile, { pid: process.pid, version: VERSION, url, pair, startedAt: daemon.startedAt });
   console.log(`omp-mobile daemon ${VERSION}`);
   console.log(`  listening  ${url}`);
   console.log(`  cwd        ${options.cwd}`);
@@ -799,11 +952,14 @@ async function main() {
     }
   }
   const shutdown = async () => {
+    clearState(options.stateFile);
     await daemon.close();
     process.exit(0);
   };
   process.on("SIGINT", () => void shutdown());
   process.on("SIGTERM", () => void shutdown());
+  // A daemon started by /mobile has no terminal; a closed one must not stop it.
+  process.on("SIGHUP", () => undefined);
 }
 
 // npm runs the `omp-mobile` bin through a symlink; compare real paths.