omp-mobile 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,6 @@
+OMP Mobile
+Copyright (c) 2026 Rinai
+
+Licensed under the Apache License, Version 2.0. See the LICENSE file.
+
+OMP Mobile is not affiliated with oh-my-pi or Tailscale.

package/README.md

@@ -1,3 +1,76 @@
-# Temporary Holding Version
+<p align="center">
+  <img src="assets/omp-mobile-logo.svg" width="64" height="64" alt="OMP Mobile logo">
+</p>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<h1 align="center">OMP Mobile</h1>
+
+<p align="center">
+  <a href="README.md">English</a> ·
+  <a href="README.zh-CN.md">简体中文</a>
+</p>
+
+<p align="center">Your oh-my-pi sessions, on your phone.</p>
+
+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.
+- **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: 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 plugin into OMP on every computer:
+
+```bash
+omp plugin install omp-mobile
+```
+
+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. **Enter address** takes the address and token by hand, or a pasted pairing link.
+
+For notifications, open **Settings → Notifications** in the app.
+
+A device on your Tailscale account that has the token can run anything OMP can on that computer.
+
+## Development
+
+- `daemon`: the computer side (Node.js), which runs OMP in RPC mode and serves the app
+- `app`: the phone app (Expo, React Native)
+- `app/modules/omp-attention`: the Android notification service (Kotlin)
+
+```bash
+npm install
+npm run typecheck
+npm test                         # daemon and app
+
+npm start -w @omp-mobile/app     # Expo dev server
+
+# Android APK (JDK 17, Android SDK); app/android is generated, not committed
+cd app && npx expo prebuild --platform android --clean --no-install
+cd android && ./gradlew assembleRelease
+```
+
+Against an emulator, run the daemon from the checkout with `npm run daemon -- --host 127.0.0.1` and forward the port with `adb reverse tcp:7390 tcp:7390`. How the daemon works, its options and HTTP API, and the source map are in [ARCHITECTURE.md](ARCHITECTURE.md).
+
+A release is a `v<version>` tag on `main` whose version matches `package.json`, `daemon/package.json`, `app/package.json` and `app/app.json`, with a matching section in [CHANGELOG.md](CHANGELOG.md). CI then publishes `omp-mobile` to npm and a GitHub Release with the APK.
+
+## License
+
+Apache-2.0. OMP Mobile is not affiliated with oh-my-pi or Tailscale.

package/package.json

@@ -1,6 +1,55 @@
 {
   "name": "omp-mobile",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "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",
+    "omp-plugin",
+    "remote",
+    "tailscale"
+  ],
+  "homepage": "https://github.com/Rinai-R/omp-mobile#readme",
+  "bugs": {
+    "url": "https://github.com/Rinai-R/omp-mobile/issues"
+  },
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Rinai",
+    "email": "1130157066@qq.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rinai-R/omp-mobile.git",
+    "directory": "daemon"
+  },
+  "type": "module",
+  "bin": {
+    "omp-mobile": "src/server.mjs"
+  },
+  "omp": {
+    "extensions": [
+      "./src/omp-extension.mjs"
+    ]
+  },
+  "files": [
+    "src",
+    "NOTICE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "start": "node src/server.mjs",
+    "test": "node --test"
+  },
+  "dependencies": {
+    "qrcode-generator": "^2.0.4",
+    "ws": "^8.18.3"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  }
+}

package/src/admission.mjs

@@ -0,0 +1,207 @@
+/**
+ * Tailscale identity admission for the daemon listener.
+ *
+ * The bearer token proves the client was paired; admission proves the request
+ * reached this node on purpose (Host names this node) and comes from a device
+ * of the same tailnet user (`tailscale whois`). Both run before the token.
+ */
+import { execFile } from "node:child_process";
+import { platform } from "node:os";
+
+const MAC_APP_BINARY = "/Applications/Tailscale.app/Contents/MacOS/Tailscale";
+const TIMEOUT_MS = 5_000;
+const WHOIS_TTL_MS = 60_000;
+const FAILURE_TTL_MS = 5_000;
+
+/** @typedef {{ips: string[], dnsName: string, userId: number, loginName: string}} SelfStatus */
+/** @typedef {{userId: number, loginName: string, tags: string[], node: string}} WhoisResult */
+
+/**
+ * Run a command and resolve its stdout.
+ * @param {string} binary
+ * @param {string[]} args
+ * @returns {Promise<string>}
+ */
+function run(binary, args) {
+  return new Promise((resolveRun, reject) => {
+    execFile(binary, args, { timeout: TIMEOUT_MS, maxBuffer: 16 * 1024 * 1024 }, (error, stdout) => {
+      if (error) reject(error);
+      else resolveRun(stdout);
+    });
+  });
+}
+
+/** Thin wrapper over the local `tailscale` CLI. */
+class Tailscale {
+  /**
+   * @param {{binary?: string, run?: typeof run, platform?: string}} [options]
+   */
+  constructor(options = {}) {
+    this.binary = options.binary ?? "tailscale";
+    this.run = options.run ?? run;
+    // A bare "tailscale" that is not on PATH falls back to the macOS app bundle.
+    this.fallbacks =
+      this.binary === "tailscale" && (options.platform ?? platform()) === "darwin" ? [MAC_APP_BINARY] : [];
+  }
+
+  /** @param {string[]} args */
+  async exec(args) {
+    try {
+      return await this.run(this.binary, args);
+    } catch (error) {
+      if (error?.code !== "ENOENT" || this.fallbacks.length === 0) throw error;
+      const next = this.fallbacks.shift();
+      this.binary = next;
+      return this.exec(args);
+    }
+  }
+
+  /** @returns {Promise<SelfStatus>} */
+  async status() {
+    const raw = JSON.parse(await this.exec(["status", "--json"]));
+    const self = raw?.Self ?? {};
+    if (raw?.BackendState !== undefined && raw.BackendState !== "Running") {
+      throw new Error(`tailscale is not running (BackendState ${raw.BackendState})`);
+    }
+    const ips = Array.isArray(self.TailscaleIPs) ? self.TailscaleIPs.map(String) : [];
+    const userId = Number(self.UserID ?? 0);
+    const profile = raw?.User?.[String(userId)];
+    return {
+      ips,
+      dnsName: String(self.DNSName ?? "").replace(/\.$/, "").toLowerCase(),
+      userId: Number.isFinite(userId) ? userId : 0,
+      loginName: typeof profile?.LoginName === "string" ? profile.LoginName : "",
+    };
+  }
+
+  /**
+   * Identify the node and user behind an address. Rejects when the CLI fails,
+   * which includes addresses outside the tailnet (whois exits non-zero).
+   * @param {string} ip
+   * @returns {Promise<WhoisResult>}
+   */
+  async whois(ip) {
+    const raw = JSON.parse(await this.exec(["whois", "--json", ip]));
+    const userId = Number(raw?.Node?.User ?? raw?.UserProfile?.ID ?? 0);
+    return {
+      userId: Number.isFinite(userId) ? userId : 0,
+      loginName: typeof raw?.UserProfile?.LoginName === "string" ? raw.UserProfile.LoginName : "",
+      tags: Array.isArray(raw?.Node?.Tags) ? raw.Node.Tags.map(String) : [],
+      node: String(raw?.Node?.Name ?? "").replace(/\.$/, ""),
+    };
+  }
+}
+
+/**
+ * Host header without port, brackets, trailing dot; lower case.
+ * @param {string | undefined} host
+ */
+function hostnameOf(host) {
+  if (typeof host !== "string") return "";
+  const bracket = /^\[([^\]]+)\]/.exec(host);
+  const name = bracket === null ? host.replace(/:\d+$/, "") : bracket[1];
+  return name.toLowerCase().replace(/\.$/, "");
+}
+
+/**
+ * Socket remote address with IPv4-mapped IPv6 reduced to dotted IPv4.
+ * @param {string | undefined} address
+ */
+function remoteIp(address) {
+  if (typeof address !== "string") return "";
+  return address.toLowerCase().startsWith("::ffff:") && address.includes(".") ? address.slice(7) : address;
+}
+
+/** @param {string} host */
+function isLoopbackHost(host) {
+  return host === "127.0.0.1" || host === "::1" || host === "localhost" || host === "[::1]";
+}
+
+/**
+ * @typedef {{ok: true, ip: string, user: string} | {ok: false, status: number, error: string, ip: string}} Verdict
+ */
+
+/** Listener admission: Host names this node, source is a device of this node's user. */
+class Admission {
+  /**
+   * @param {{
+   *   self: SelfStatus,
+   *   bindHost: string,
+   *   tailscale?: {whois(ip: string): Promise<WhoisResult>},
+   *   whois?: boolean,
+   *   now?: () => number,
+   * }} options
+   */
+  constructor(options) {
+    this.self = options.self;
+    this.tailscale = options.tailscale;
+    this.whoisEnabled = options.whois !== false;
+    this.now = options.now ?? Date.now;
+    this.hosts = new Set(
+      [hostnameOf(options.bindHost), ...options.self.ips.map((ip) => ip.toLowerCase()), options.self.dnsName]
+        .filter(Boolean),
+    );
+    this.ownIps = new Set(options.self.ips.map((ip) => ip.toLowerCase()));
+    /** Pending or settled lookups per address; concurrent requests share one. */
+    /** @type {Map<string, {expires: number, who: Promise<WhoisResult | undefined>}>} */
+    this.cache = new Map();
+  }
+
+  /**
+   * @param {{headers: Record<string, string | string[] | undefined>, socket: {remoteAddress?: string}}} req
+   * @returns {Promise<Verdict>}
+   */
+  async check(req) {
+    const ip = remoteIp(req.socket?.remoteAddress);
+    const host = hostnameOf(/** @type {string | undefined} */ (req.headers.host));
+    if (!this.hosts.has(host)) {
+      return { ok: false, status: 421, ip, error: `misdirected request: host "${host}" does not name this node` };
+    }
+    if (!this.whoisEnabled) return { ok: true, ip, user: "" };
+    // This node's own addresses belong to its user; the token still applies.
+    if (this.ownIps.has(ip.toLowerCase())) return { ok: true, ip, user: this.self.loginName };
+    const who = await this.identify(ip);
+    if (who === undefined) {
+      return { ok: false, status: 403, ip, error: `source ${ip} is not a known tailnet device` };
+    }
+    if (who.tags.length > 0) {
+      return { ok: false, status: 403, ip, error: `source ${ip} is a tagged device (${who.tags.join(", ")}); tagged devices have no user` };
+    }
+    if (who.userId === 0 || who.userId !== this.self.userId) {
+      return {
+        ok: false,
+        status: 403,
+        ip,
+        error: `source ${ip} belongs to ${who.loginName || "another user"}, not ${this.self.loginName || "this node's user"}`,
+      };
+    }
+    return { ok: true, ip, user: who.loginName };
+  }
+
+  /**
+   * Whois with a cache: identities for 60 s, failures for 5 s.
+   * @param {string} ip
+   */
+  identify(ip) {
+    const now = this.now();
+    const hit = this.cache.get(ip);
+    if (hit !== undefined && now < hit.expires) return hit.who;
+    const slot = { expires: now + WHOIS_TTL_MS, who: Promise.resolve(undefined) };
+    slot.who = Promise.resolve()
+      .then(() => this.tailscale?.whois(ip))
+      .then(
+        (found) => {
+          if (found === undefined) slot.expires = this.now() + FAILURE_TTL_MS;
+          return found;
+        },
+        () => {
+          slot.expires = this.now() + FAILURE_TTL_MS;
+          return undefined;
+        },
+      );
+    this.cache.set(ip, slot);
+    return slot.who;
+  }
+}
+
+export { Admission, Tailscale, hostnameOf, remoteIp, isLoopbackHost, MAC_APP_BINARY };