omp-mobile 0.7.1 → 0.7.2

package/README.md

@@ -42,7 +42,7 @@ Install the plugin into OMP on every computer:
 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.
+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. After `omp plugin upgrade omp-mobile`, `omp-mobile restart` puts the running daemon on the new version with the same settings, once no session is mid-turn (safe to run from a phone session). 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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omp-mobile",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "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",

package/src/restart.mjs

@@ -0,0 +1,156 @@
+/**
+ * `omp-mobile restart`: replace the running daemon with the code installed
+ * now (after `omp plugin upgrade omp-mobile`), with the same arguments.
+ *
+ * The daemon runs every phone session's omp as its child, so whoever asks
+ * for a restart from such a session (an agent, a phone) would be cut off by
+ * the stop and could never start the new daemon. The work is therefore done
+ * by a detached worker in its own session: it waits until no session is
+ * running a turn (unless `--now`), stops the daemon, starts the new one and
+ * logs beside the state file (`~/.omp-mobile/daemon.log`). Phones reconnect; sessions resume on open.
+ */
+import { spawn, execFileSync } from "node:child_process";
+import { closeSync, mkdirSync, openSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { STATE_FILE, alive, readState, tokenOf } from "./state.mjs";
+
+const SERVER = join(dirname(fileURLToPath(import.meta.url)), "server.mjs");
+/** How long a restart waits for running turns to end before it goes ahead anyway. */
+const IDLE_WAIT_MS = 10 * 60_000;
+/** How long the old daemon gets to close its omp processes, and the new one to come up. */
+const STOP_TIMEOUT_MS = 25_000;
+const START_TIMEOUT_MS = 30_000;
+
+const sleep = (ms) => new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+
+function log(line) {
+  console.log(`omp-mobile restart: ${line}`);
+}
+
+/**
+ * The arguments and directory the daemon was started with: recorded in its
+ * state since 0.7.2; for an older daemon, read from its process (an argument
+ * with a space in it cannot be told apart there).
+ * @returns {{argv: string[], cwd: string} | undefined}
+ */
+export function launchOf(state) {
+  if (Array.isArray(state.argv) && typeof state.cwd === "string") return { argv: state.argv, cwd: state.cwd };
+  try {
+    const command = execFileSync("ps", ["-o", "command=", "-p", String(state.pid)], { encoding: "utf8" }).trim();
+    const words = command.split(/\s+/);
+    const at = words.findIndex((word) => word.endsWith("server.mjs"));
+    if (at === -1) return undefined;
+    const cwd = execFileSync("lsof", ["-a", "-p", String(state.pid), "-d", "cwd", "-Fn"], { encoding: "utf8" })
+      .split("\n")
+      .find((line) => line.startsWith("n"))
+      ?.slice(1);
+    return { argv: words.slice(at + 1), cwd: cwd ?? homedir() };
+  } catch {
+    return undefined;
+  }
+}
+
+/** A daemon that cannot say whether a turn runs (before 0.7.2) gets this long, so the turn asking can end. */
+const GRACE_MS = 60_000;
+
+/** Sessions running a turn; undefined when the daemon does not report it. */
+async function busySessions(state) {
+  try {
+    const response = await fetch(`${state.url}/status`, { headers: { authorization: `Bearer ${tokenOf(state.pair)}` }, signal: AbortSignal.timeout(5_000) });
+    const status = await response.json();
+    return typeof status.busySessions === "number" ? status.busySessions : undefined;
+  } catch {
+    return 0;
+  }
+}
+
+/** The worker: wait, stop, start. Runs detached; its output goes to the daemon log. */
+/** The log beside the state file: `~/.omp-mobile/daemon.log` for the default one, where /mobile logs too. */
+function logFileOf(stateFile) {
+  return join(dirname(stateFile), "daemon.log");
+}
+
+async function work(stateFile, now) {
+  const state = readState(stateFile);
+  if (state === undefined) {
+    log("no daemon is running; nothing to restart");
+    return 1;
+  }
+  const launch = launchOf(state);
+  if (launch === undefined) {
+    log(`cannot tell how daemon ${state.pid} was started; restart it by hand`);
+    return 1;
+  }
+  if (!now) {
+    const deadline = Date.now() + IDLE_WAIT_MS;
+    let busy = await busySessions(state);
+    if (busy === undefined) await sleep(GRACE_MS);
+    while (busy !== undefined && busy > 0 && Date.now() < deadline) {
+      await sleep(2_000);
+      busy = await busySessions(state);
+    }
+  }
+  log(`stopping daemon ${state.pid} (${state.version})`);
+  process.kill(state.pid, "SIGTERM");
+  const stopBy = Date.now() + STOP_TIMEOUT_MS;
+  while (Date.now() < stopBy && alive(state.pid)) await sleep(100);
+  if (alive(state.pid)) process.kill(state.pid, "SIGKILL");
+  const out = openSync(logFileOf(stateFile), "a", 0o600);
+  let child;
+  try {
+    child = spawn(process.execPath, [SERVER, ...launch.argv], { cwd: launch.cwd, detached: true, stdio: ["ignore", out, out], env: process.env });
+  } finally {
+    closeSync(out);
+  }
+  child.unref();
+  const startBy = Date.now() + START_TIMEOUT_MS;
+  while (Date.now() < startBy) {
+    const next = readState(stateFile);
+    if (next?.pid === child.pid) {
+      log(`daemon ${next.pid} (${next.version}) is running`);
+      return 0;
+    }
+    if (!alive(child.pid)) break;
+    await sleep(250);
+  }
+  log("the new daemon did not start; see the lines above");
+  return 1;
+}
+
+/**
+ * `omp-mobile restart [--now] [--state-file <path>]`: hand the restart to a
+ * detached worker and return at once, so this process may be one of the
+ * daemon's own sessions.
+ * @param {string[]} args
+ */
+export async function runRestartCli(args) {
+  const at = args.indexOf("--state-file");
+  const stateFile = at === -1 ? STATE_FILE : args[at + 1];
+  const now = args.includes("--now");
+  if (args.includes("--worker")) process.exit(await work(stateFile, now));
+  const state = readState(stateFile);
+  if (state === undefined) {
+    console.error("omp-mobile: the daemon is not running. Start it with /mobile in OMP, or omp-mobile --relay.");
+    process.exit(1);
+  }
+  if (launchOf(state) === undefined) {
+    console.error(`omp-mobile: cannot tell how daemon ${state.pid} was started; stop it and start it again by hand.`);
+    process.exit(1);
+  }
+  const logFile = logFileOf(stateFile);
+  mkdirSync(dirname(logFile), { recursive: true, mode: 0o700 });
+  const out = openSync(logFile, "a", 0o600);
+  const worker = spawn(process.execPath, [SERVER, "restart", "--worker", "--state-file", stateFile, ...(now ? ["--now"] : [])], {
+    detached: true,
+    stdio: ["ignore", out, out],
+  });
+  closeSync(out);
+  worker.unref();
+  console.log(
+    now
+      ? `Restarting daemon ${state.pid} now (log: ${logFile}).`
+      : `Daemon ${state.pid} restarts once no session is running a turn (log: ${logFile}). Phones reconnect by themselves.`,
+  );
+}

package/src/server.mjs

@@ -26,6 +26,7 @@ import { copyArtifacts, isForkPoint, writeCut } from "./fork.mjs";
 import { RELAY_HEADER, RelayHost } from "./relay.mjs";
 import { DEFAULT_RELAY, runRelayCli } from "./relay-control.mjs";
 import { listSubagents, subagentDir, subagentTranscript } from "./subagents.mjs";
+import { runRestartCli } from "./restart.mjs";
 
 const { version: VERSION } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 const PROTOCOL = 1;
@@ -302,6 +303,11 @@ user (403 otherwise), before the token is checked. Loopback hosts skip admission
                          end-to-end encrypted; pair with \`omp-mobile relay pair\` or /mobile relay
   --relay-dir <dir>      Relay identity and device tokens (default ~/.omp-mobile/relay)
 
+Restart (after \`omp plugin upgrade omp-mobile\`; same --state-file):
+  omp-mobile restart          Restart the running daemon on the installed code, with its arguments, once no
+                              session is running a turn; it is done by a detached process, so this is safe to
+                              run from one of the daemon's own sessions. --now: do not wait.
+
 Relay commands (talk to the running daemon; same --state-file):
   omp-mobile relay pair       Show a pairing QR code, then confirm the phone's 8-digit code
   omp-mobile relay status     Relay server, connection and paired phones
@@ -945,6 +951,8 @@ class Daemon {
         startedAt: this.startedAt,
         url: this.baseUrl(),
         liveSessions: this.sessions.size,
+        // Sessions running a turn: `omp-mobile restart` waits for none.
+        busySessions: [...this.sessions.values()].filter((entry) => entry.state?.isStreaming === true).length,
         eventStreams: this.streams.size,
         lastPhone: this.lastPhone,
         relay: this.relay === undefined ? null : await this.relay.status(),
@@ -1804,6 +1812,10 @@ async function main() {
     await runRelayCli(process.argv.slice(3));
     return;
   }
+  if (process.argv[2] === "restart") {
+    await runRestartCli(process.argv.slice(3));
+    return;
+  }
   const options = parseArgs(process.argv.slice(2));
   if (options.host === "tailscale") options.host = await tailscaleHost(options);
   const token = loadToken(options);
@@ -1812,7 +1824,8 @@ async function main() {
   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, relay: options.relay || null, startedAt: daemon.startedAt });
+  // `argv` and `cwd`: how to start it again (`omp-mobile restart`).
+  writeState(options.stateFile, { pid: process.pid, version: VERSION, url, pair, relay: options.relay || null, startedAt: daemon.startedAt, argv: process.argv.slice(2), cwd: process.cwd() });
   console.log(`omp-mobile daemon ${VERSION}`);
   console.log(`  listening  ${url}`);
   console.log(`  cwd        ${options.cwd}`);