omp-mobile 0.4.4 → 0.6.0

package/NOTICE

@@ -8,3 +8,6 @@ OMP Mobile is not affiliated with oh-my-pi or Tailscale.
 The app bundles the Geist typeface (Copyright 2023 Vercel, in collaboration with basement.studio) and the
 JetBrains Mono typeface (Copyright 2020 The JetBrains Mono Project Authors), both under the SIL Open Font
 License 1.1; see app/assets/fonts.
+
+app/vendor/dsh-remote and daemon/vendor bundle code of DS Harness Remote (Copyright (c) 2026 DSH Remote contributors)
+under the MIT License; see app/vendor/dsh-remote/LICENSE and daemon/vendor/LICENSE.dsh-remote.

package/README.md

@@ -22,7 +22,7 @@ OMP Mobile is a native phone app for [oh-my-pi](https://github.com/can1357/oh-my
 - **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 and give it a name on the phone. Tap a chat's title for every session on every computer — searchable, with what needs you first. The app opens on the computer you used last; 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.
+- **Tailscale, or a relay:** The daemon listens on the computer's Tailscale address and admits only your own devices. Without Tailscale, it can be reached through the open-source ds-harness-remote relay, end-to-end encrypted.
 - **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
@@ -30,7 +30,7 @@ OMP Mobile is a native phone app for [oh-my-pi](https://github.com/can1357/oh-my
 ### Prerequisites
 
 - On every computer: OMP 18.x
-- [Tailscale](https://tailscale.com) signed in to the same account on the computer and the phone
+- [Tailscale](https://tailscale.com) signed in to the same account on the computer and the phone, or the relay (below)
 - An Android phone
 
 ### Computer
@@ -49,7 +49,9 @@ Without the plugin, the same daemon runs from npm (Node.js 22.19 or newer) in th
 
 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.
+#### Through the relay (no Tailscale)
+
+The daemon can also be reached through the public relay of [ds-harness-remote](https://github.com/liguobao/ds-harness-remote) (`https://dsh.r2049.cn`), with no Tailscale and no account. In OMP run `/mobile relay` (or start the daemon with `omp-mobile --relay` and run `omp-mobile relay pair`). Scan the code it shows, or paste its link into **Enter address**; the phone shows the computer's key fingerprint and an 8-digit code, which you type where the computer asks. Traffic is end-to-end encrypted between the phone and the daemon (Noise IK, both keys pinned); the relay only forwards ciphertext. Everything works as over Tailscale. `omp-mobile relay status` lists paired phones, `omp-mobile relay revoke <id>` removes one, and removing the computer on the phone ends the pairing too.
 
 A device on your Tailscale account that has the token can run anything OMP can on that computer.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "omp-mobile",
-  "version": "0.4.4",
-  "description": "The computer side of OMP Mobile: runs oh-my-pi sessions and serves them to the phone app over Tailscale.",
+  "version": "0.6.0",
+  "description": "The computer side of OMP Mobile: runs oh-my-pi sessions and serves them to the phone app over Tailscale or an end-to-end encrypted relay.",
   "keywords": [
     "mobile",
     "oh-my-pi",
@@ -35,6 +35,7 @@
   },
   "files": [
     "src",
+    "vendor",
     "NOTICE"
   ],
   "publishConfig": {

package/src/attention.mjs

@@ -31,6 +31,8 @@ import { hostname } from "node:os";
 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:";
+/** The labels OMP starts approval details with (`Command: `, `Path: `), from its `tools/approval.ts` and each tool. */
+const DETAIL_LABEL = /^(?:Command|Path|Paths|Pattern|Language|Code|Content|URL|Reason|Origin):\s*/;
 const ASKING = new Set(["select", "confirm", "input", "editor"]);
 const TEXT_MAX = 280;
 
@@ -127,7 +129,10 @@ export class AttentionTracker {
         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());
+        // A notification reads in the phone's language, so OMP's English labels (`Command:`) are left out.
+        const lines = (approval ? title.slice(TOOL_APPROVAL_PREFIX.length) : title)
+          .split("\n")
+          .map((line, index) => (approval && index > 0 ? line.replace(DETAIL_LABEL, "") : line).trim());
         const text = [...lines, request.message].filter(Boolean).join(" · ");
         state.open.set(request.id, emit(approval ? "approval" : "question", request.id, text));
         break;

package/src/omp-extension.mjs

@@ -21,10 +21,12 @@ import { homedir } from "node:os";
 import { delimiter, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { renderQr } from "./qr.mjs";
+import { Tailscale } from "./admission.mjs";
 import { requestPath, shellWord } from "./takeover.mjs";
+import { alive, readState, tokenOf } from "./state.mjs";
+import { DEFAULT_RELAY, grouped, pairingOutcome, relayCall, waitForPhone } from "./relay-control.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";
@@ -38,41 +40,12 @@ const TAKEOVER_MAX_AGE_MS = 60_000;
 /** How long a running turn gets to stop before omp closes anyway. */
 const TAKEOVER_IDLE_WAIT_MS = 5_000;
 const SUBCOMMANDS = [
+  { value: "relay", label: "relay", description: "Pair a phone through the ds-harness-remote relay (no Tailscale)" },
   { 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 {
@@ -116,13 +89,23 @@ function ompBinary() {
 /**
  * Start the daemon detached from this terminal and wait until it serves.
  * @param {string} cwd Default directory for sessions the phone starts.
+ * @param {string} [relay] Relay server to serve phones through as well; then
+ *   the daemon binds loopback when this computer has no Tailscale.
  */
-async function startDaemon(cwd) {
+async function startDaemon(cwd, relay) {
   mkdirSync(HOME, { recursive: true, mode: 0o700 });
+  let host = "tailscale";
+  if (relay !== undefined) {
+    host = await new Tailscale({ binary: "tailscale" })
+      .status()
+      .then(() => "tailscale")
+      .catch(() => "127.0.0.1");
+  }
   const log = openSync(LOG_FILE, "a", 0o600);
   let child;
   try {
-    child = spawn(process.execPath, [SERVER, "--host", "tailscale", "--cwd", cwd, "--omp", ompBinary(), "--no-qr"], {
+    const args = [SERVER, "--host", host, "--cwd", cwd, "--omp", ompBinary(), "--no-qr", ...(relay === undefined ? [] : ["--relay", relay])];
+    child = spawn(process.execPath, args, {
       cwd,
       detached: true,
       stdio: ["ignore", log, log],
@@ -278,6 +261,73 @@ export default function ompMobile(pi) {
     showing = { timer };
   };
 
+  /**
+   * `/mobile relay`: make sure the daemon serves through the relay, show the
+   * relay pairing code, and once a phone claims it ask for the code it shows.
+   */
+  const pairThroughRelay = async (ctx, state, server) => {
+    let running = state !== undefined && (await status(state)) !== undefined ? state : undefined;
+    if (running !== undefined && !running.relay) {
+      ctx.ui.notify("OMP Mobile: the daemon runs without the relay. /mobile stop, then /mobile relay.", "warning");
+      return;
+    }
+    if (running === undefined) {
+      ctx.ui.notify("OMP Mobile: starting the daemon with the relay…", "info");
+      try {
+        running = await startDaemon(ctx.cwd, server);
+      } catch (error) {
+        ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+        return;
+      }
+    }
+    let view;
+    try {
+      view = await relayCall(running, "POST", "/relay/pair");
+    } catch (error) {
+      ctx.ui.notify(`OMP Mobile: the relay did not start a pairing: ${error instanceof Error ? error.message : String(error)}`, "error");
+      return;
+    }
+    hide(ctx);
+    if (ctx.mode === "tui") {
+      ctx.ui.setWidget(
+        WIDGET,
+        pairingWidget({
+          title: "OMP Mobile · relay · in the app: Machines → Scan to pair",
+          code: renderQr(view.qrPayload).split("\n"),
+          notes: [`computer key ${grouped(view.hostFingerprint).slice(0, 39)}…`, "then enter the phone's 8-digit code here · /mobile hide closes this"],
+        }),
+        { placement: "aboveEditor" },
+      );
+    } else {
+      ctx.ui.notify(`OMP Mobile: open this link on the phone: ${view.qrPayload}`, "info");
+    }
+    const timer = ctx.setInterval(() => undefined, 60_000);
+    showing = { timer };
+    const claimed = await waitForPhone(running, view.sessionId, () => showing?.timer !== timer).catch(() => undefined);
+    if (showing?.timer !== timer) {
+      // Hidden (or replaced) before a phone came: the pairing is not wanted any more.
+      void relayCall(running, "POST", "/relay/pair/cancel", { sessionId: view.sessionId }).catch(() => undefined);
+      return;
+    }
+    hide(ctx);
+    if (claimed?.state !== "claimed") {
+      ctx.ui.notify(`OMP Mobile: ${claimed === undefined ? "the pairing ended." : pairingOutcome(claimed)}`, "warning");
+      return;
+    }
+    const code = (await ctx.ui.input(`OMP Mobile: code shown on ${claimed.mobile?.name ?? "the phone"} (phone key ${grouped(claimed.mobile?.fingerprint ?? "").slice(0, 19)}…)`, "8 digits, one try"))?.replace(/\D/g, "");
+    if (code === undefined || code === "") {
+      await relayCall(running, "POST", "/relay/pair/cancel", { sessionId: view.sessionId }).catch(() => undefined);
+      ctx.ui.notify("OMP Mobile: pairing cancelled.", "info");
+      return;
+    }
+    try {
+      const done = await relayCall(running, "POST", "/relay/pair/confirm", { sessionId: view.sessionId, code });
+      ctx.ui.notify(`OMP Mobile: ${pairingOutcome(done)}`, done.state === "completed" ? "info" : "warning");
+    } catch (error) {
+      ctx.ui.notify(`OMP Mobile: ${error instanceof Error ? error.message : String(error)}`, "error");
+    }
+  };
+
   pi.registerCommand("mobile", {
     description: "Pair your phone with this computer (OMP Mobile)",
     getArgumentCompletions: (prefix) => SUBCOMMANDS.filter((item) => item.value.startsWith(prefix.trim())),
@@ -308,8 +358,12 @@ export default function ompMobile(pi) {
         ctx.ui.notify(`OMP Mobile: ${now.url} · pid ${now.pid} · ${now.liveSessions} live sessions · ${phone}`, "info");
         return;
       }
+      if (sub === "relay" || sub.startsWith("relay ")) {
+        await pairThroughRelay(ctx, state, sub.slice("relay".length).trim() || DEFAULT_RELAY);
+        return;
+      }
       if (sub !== "") {
-        ctx.ui.notify(`OMP Mobile: unknown "${sub}". Use /mobile, /mobile status, /mobile stop or /mobile hide.`, "warning");
+        ctx.ui.notify(`OMP Mobile: unknown "${sub}". Use /mobile, /mobile relay, /mobile status, /mobile stop or /mobile hide.`, "warning");
         return;
       }
       let running = state !== undefined && (await status(state)) !== undefined ? state : undefined;

package/src/relay-control.mjs

@@ -0,0 +1,104 @@
+/**
+ * Relay pairing from this computer, against the running daemon's local
+ * `/relay` API: shared by `omp-mobile relay ...` and `/mobile relay`.
+ */
+import { createInterface } from "node:readline/promises";
+import { renderQr } from "./qr.mjs";
+import { readState, tokenOf } from "./state.mjs";
+
+/** The public relay of ds-harness-remote: it forwards only ciphertext. */
+export const DEFAULT_RELAY = "https://dsh.r2049.cn";
+const POLL_MS = 1_500;
+
+/** One `/relay` call to the daemon `state` describes; throws its error text. */
+export async function relayCall(state, method, path, body) {
+  const response = await fetch(`${state.url}${path}`, {
+    method,
+    headers: {
+      authorization: `Bearer ${tokenOf(state.pair)}`,
+      "x-omp-mobile-probe": "1",
+      ...(body === undefined ? {} : { "content-type": "application/json" }),
+    },
+    body: body === undefined ? undefined : JSON.stringify(body),
+    signal: AbortSignal.timeout(30_000),
+  });
+  const answer = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(typeof answer.error === "string" ? answer.error : `HTTP ${response.status}`);
+  return answer;
+}
+
+/** The pairing once a phone claimed it, or it ended; polls until then. */
+export async function waitForPhone(state, sessionId, isCancelled = () => false) {
+  for (;;) {
+    if (isCancelled()) return undefined;
+    const { pairing } = await relayCall(state, "GET", "/relay/pair");
+    if (pairing === null || pairing.sessionId !== sessionId || pairing.state !== "created") return pairing ?? undefined;
+    await new Promise((resolveWait) => setTimeout(resolveWait, POLL_MS));
+  }
+}
+
+/** What a finished confirm means, in a line. */
+export function pairingOutcome(view) {
+  if (view.state === "completed") return "Paired. The phone lists this computer and connects through the relay.";
+  if (view.failureReason === "verification_failed") return "The code did not match; this pairing is over. Start a new one.";
+  return `Pairing ended (${view.state}${view.failureReason ? `: ${view.failureReason}` : ""}).`;
+}
+
+/** The phone's fingerprint grouped like the app shows the computer's. */
+export function grouped(fingerprint) {
+  return fingerprint.match(/.{1,4}/g)?.join(" ") ?? fingerprint;
+}
+
+function stateFileOf(args) {
+  const at = args.indexOf("--state-file");
+  return at === -1 ? undefined : args[at + 1];
+}
+
+/** `omp-mobile relay <pair|status|revoke>`: exits the process. */
+export async function runRelayCli(args) {
+  const command = args[0] ?? "status";
+  const state = readState(stateFileOf(args));
+  if (state === undefined) {
+    console.error("omp-mobile: the daemon is not running. Start it with --relay (or /mobile relay in OMP).");
+    process.exit(1);
+  }
+  try {
+    if (command === "status") {
+      const relay = await relayCall(state, "GET", "/relay");
+      console.log(`relay   ${relay.server} · ${relay.paired ? (relay.online ? "online" : "offline") : "not paired yet"}`);
+      for (const phone of relay.phones) console.log(`phone   ${phone.name} (${phone.platform}) ${phone.deviceId}${phone.connected ? " · connected" : ""}`);
+      if (relay.phones.length === 0) console.log("phones  none; pair one with: omp-mobile relay pair");
+      process.exit(0);
+    }
+    if (command === "revoke") {
+      if (args[1] === undefined) throw new Error("usage: omp-mobile relay revoke <phone device id>");
+      await relayCall(state, "DELETE", `/relay/phones/${encodeURIComponent(args[1])}`);
+      console.log("Revoked: that phone can no longer reach this computer.");
+      process.exit(0);
+    }
+    if (command !== "pair") throw new Error(`unknown relay command "${command}" (pair, status, revoke)`);
+    const view = await relayCall(state, "POST", "/relay/pair");
+    let cancelled = false;
+    process.on("SIGINT", () => {
+      cancelled = true;
+      void relayCall(state, "POST", "/relay/pair/cancel", { sessionId: view.sessionId }).finally(() => process.exit(130));
+    });
+    console.log("Scan with OMP on your phone (Machines > Scan to pair), or paste the link into Enter address:\n");
+    console.log(renderQr(view.qrPayload));
+    console.log(`  ${view.qrPayload}`);
+    console.log(`  computer key ${grouped(view.hostFingerprint)}`);
+    console.log(`  expires ${new Date(view.expiresAt).toLocaleTimeString()}\n`);
+    const claimed = await waitForPhone(state, view.sessionId, () => cancelled);
+    if (claimed === undefined || claimed.state !== "claimed") throw new Error(claimed === undefined ? "Pairing ended." : pairingOutcome(claimed));
+    console.log(`Phone: ${claimed.mobile?.name ?? "unknown"} · key ${grouped(claimed.mobile?.fingerprint ?? "")}`);
+    const prompt = createInterface({ input: process.stdin, output: process.stdout });
+    const code = (await prompt.question("Enter the 8-digit code the phone shows (one try): ")).replace(/\D/g, "");
+    prompt.close();
+    const done = await relayCall(state, "POST", "/relay/pair/confirm", { sessionId: view.sessionId, code });
+    console.log(pairingOutcome(done));
+    process.exit(done.state === "completed" ? 0 : 1);
+  } catch (error) {
+    console.error(`omp-mobile: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}