omp-mobile 0.1.0 → 0.1.1

package/README.md

@@ -19,29 +19,31 @@ OMP Mobile is a native phone app for [oh-my-pi](https://github.com/can1357/oh-my
 - **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.1.1",
   "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. */
@@ -61,7 +70,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;

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,6 +25,7 @@ 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. */
@@ -45,6 +46,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 +88,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 +136,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 +144,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")
@@ -397,6 +403,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 +487,19 @@ class Daemon {
       sendJson(res, 401, { error: "unauthorized" });
       return;
     }
+    this.noteClient(req);
+    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 +676,7 @@ class Daemon {
       socket.destroy();
       return;
     }
+    this.noteClient(req);
     void this.ensureLive(decodeURIComponent(match[1]))
       .then((entry) => {
         this.wsServer.handleUpgrade(req, socket, head, (ws) => {
@@ -714,6 +738,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 +809,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 +864,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.