ompgui 0.6.5 → 0.7.2

package/bin/ompgui-pair.js

@@ -0,0 +1,108 @@
+"use strict";
+
+const { spawn } = require("child_process");
+const { isPortAvailable } = require("./port-availability");
+
+function cookieHeader(response) {
+  if (typeof response.headers.getSetCookie === "function") {
+    const cookies = response.headers.getSetCookie();
+    if (cookies.length) return cookies.map((value) => value.split(";")[0]).join("; ");
+  }
+  const single = response.headers.get("set-cookie");
+  return single ? single.split(";")[0] : "";
+}
+
+async function ensureLocalSession(base, password, headers) {
+  if (!password) return;
+  const login = await fetch(`${base}/api/web-auth/session`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ password }),
+  });
+  if (!login.ok) {
+    throw new Error("Could not sign in with the configured password. Pass --password or open /pair in the browser.");
+  }
+  const cookie = cookieHeader(login);
+  if (cookie) headers.cookie = cookie;
+}
+
+async function requestJson(url, init) {
+  const response = await fetch(url, init);
+  const text = await response.text();
+  let body = {};
+  try { body = text ? JSON.parse(text) : {}; } catch { body = { error: text }; }
+  if (!response.ok) {
+    throw new Error(body.error || `Request failed (${response.status})`);
+  }
+  return body;
+}
+
+function openPairPage(target) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd.exe" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", target] : [target];
+  try {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {});
+    child.unref();
+  } catch {
+    // printed URL is enough
+  }
+}
+
+async function runPair(options) {
+  const { port, hostname, password, relayUrl, openBrowser } = options;
+  if (await isPortAvailable(port, hostname)) {
+    throw new Error(`ompgui is not running on ${hostname}:${port}. Start it, then run ompgui pair.`);
+  }
+  const base = options.baseUrl;
+  const headers = { "content-type": "application/json" };
+  await ensureLocalSession(base, password, headers);
+  const body = {};
+  if (relayUrl) body.url = relayUrl;
+  const offer = await requestJson(`${base}/api/relay/pair`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+  });
+  console.log(offer.uri);
+  console.log(`Relay: ${offer.relayUrl}`);
+  console.log(`Expires: ${new Date(offer.expiresAt).toISOString()}`);
+  if (openBrowser) openPairPage(`${base}/pair`);
+}
+
+async function runDevices(options) {
+  const { port, hostname, password, extraPositionals } = options;
+  if (await isPortAvailable(port, hostname)) {
+    throw new Error(`ompgui is not running on ${hostname}:${port}. Start it, then run ompgui devices.`);
+  }
+  const base = options.baseUrl;
+  const headers = { "content-type": "application/json" };
+  await ensureLocalSession(base, password, headers);
+
+  if (extraPositionals[0] === "revoke") {
+    const id = extraPositionals[1];
+    if (!id) throw new Error("Usage: ompgui devices revoke <id>");
+    await requestJson(`${base}/api/relay/devices/${encodeURIComponent(id)}`, { method: "DELETE", headers });
+    console.log(`Revoked ${id}`);
+    return;
+  }
+  if (extraPositionals.length) {
+    throw new Error(`Unknown ompgui devices command: ${extraPositionals.join(" ")}`);
+  }
+  const listed = await requestJson(`${base}/api/relay/devices`, { headers });
+  const devices = listed.devices ?? [];
+  if (devices.length === 0) {
+    console.log("No paired devices.");
+    return;
+  }
+  for (const device of devices) {
+    console.log(`${device.id}\t${device.label || ""}\tlastSeen ${device.lastSeenAt}`);
+  }
+}
+
+async function runRelayCli(options) {
+  if (options.command === "pair") return runPair(options);
+  return runDevices(options);
+}
+
+module.exports = { runRelayCli, runPair, runDevices };

package/bin/ompgui-service.js

@@ -0,0 +1,223 @@
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawn, spawnSync } = require("node:child_process");
+const LABEL = "com.hanbinnoh.ompgui";
+const POLL_WAIT = new Int32Array(new SharedArrayBuffer(4));
+const ACTIONS = new Set(["install", "repair", "start", "stop", "restart", "status", "uninstall", "remove", "enable", "disable"]);
+const escapeXml = (value) => String(value).replace(/[<>&"']/g, (char) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;", '"': "&quot;", "'": "&apos;" })[char]);
+function plistValue(value) {
+  if (typeof value === "boolean") return value ? "<true/>" : "<false/>";
+  if (Array.isArray(value)) return `<array>${value.map(plistValue).join("")}</array>`;
+  if (value && typeof value === "object") return `<dict>${Object.entries(value).map(([key, entry]) => `<key>${escapeXml(key)}</key>${plistValue(entry)}`).join("")}</dict>`;
+  return `<string>${escapeXml(value)}</string>`;
+}
+function createServiceManager({ processAlive = (pid) => {
+  try { process.kill(pid, 0); return true; } catch (error) { if (error.code === "ESRCH") return false; throw error; }
+}, now = Date.now, pause = (milliseconds) => Atomics.wait(POLL_WAIT, 0, 0, milliseconds), label = LABEL, platform = process.platform, home = os.homedir(), uid = process.getuid?.(), env = process.env, execPath = process.execPath, cliPath = path.join(__dirname, "ompgui.js"), portAvailable = (port, hostname) => {
+  const probe = spawnSync(process.execPath, [__filename, "--check-port", String(port), hostname], { encoding: "utf8", timeout: 5000 });
+  if (probe.status === 0) return true;
+  if (probe.status === 2) return false;
+  throw new Error("Could not check service port availability");
+}, run = (command, args) => spawnSync(command, args, { encoding: "utf8", timeout: 10000 }) } = {}) {
+  // Internal dependency-injection seam only; CLI and HTTP never accept a label override.
+  if (typeof label !== "string" || !/^com\.hanbinnoh\.ompgui(?:\.verify[A-Za-z0-9-]+)?$/.test(label)) throw new Error("Invalid ompgui service label");
+  const plistPath = path.join(home, "Library", "LaunchAgents", `${label}.plist`);
+  const logPath = path.join(home, "Library", "Logs", "ompgui", "service.log");
+  const domain = `gui/${uid}`;
+  const target = `${domain}/${label}`;
+  function command(args, allowMissing = false) {
+    const result = run("/bin/launchctl", args);
+    if (result.error || result.status !== 0) {
+      // launchctl's missing-service exit status is 113; never hide permission/domain errors.
+      if (allowMissing && result.status === 113) return null;
+      throw new Error(`launchctl ${args[0]} failed${result.error ? `: ${result.error.code || "execution error"}` : ` (exit ${result.status})`}`);
+    }
+    return result.stdout || "";
+  }
+  function ownedExecutable(args) {
+    if (!Array.isArray(args) || args.length < 2 || typeof args[0] !== "string" || typeof args[1] !== "string" || !path.isAbsolute(args[0]) || !path.isAbsolute(args[1]) || path.basename(args[0]) !== "node") return false;
+    try {
+      const resolved = fs.realpathSync(args[1]);
+      if (path.basename(resolved) !== "ompgui.js" || path.basename(path.dirname(resolved)) !== "bin") return false;
+      return JSON.parse(fs.readFileSync(path.join(path.dirname(resolved), "..", "package.json"), "utf8")).name === "ompgui";
+    } catch { return false; }
+  }
+  function readInstalled() {
+    let stat;
+    try { stat = fs.lstatSync(plistPath); } catch (error) { if (error.code === "ENOENT") return null; throw error; }
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.uid !== uid || (stat.mode & 0o022) !== 0) throw new Error("Refusing unmanaged or foreign-owned LaunchAgent");
+    const result = run("/usr/bin/plutil", ["-convert", "json", "-o", "-", plistPath]);
+    if (result.error || result.status !== 0) throw new Error("Cannot read LaunchAgent configuration");
+    let config;
+    try { config = JSON.parse(result.stdout); } catch { throw new Error("Invalid LaunchAgent configuration"); }
+    if (config.Label !== label || !ownedExecutable(config.ProgramArguments) || config.Program) throw new Error("Refusing LaunchAgent not owned by ompgui");
+    return config;
+  }
+  function inspect() {
+    const state = { supported: platform === "darwin", installed: false, running: false, autoStart: false, label, pid: null, logPath: null };
+    if (!state.supported) return { ...state, error: "Service management is supported only on macOS." };
+    const config = readInstalled();
+    state.installed = Boolean(config);
+    state.logPath = typeof config?.StandardOutPath === "string" ? config.StandardOutPath : null;
+    const printed = command(["print", target], true);
+    if (printed !== null) {
+      const source = printed.match(/^\s*path = (.+)$/m)?.[1]?.trim();
+      if (!config || source !== plistPath) throw new Error("Refusing loaded service with unverified ownership");
+      const pid = printed.match(/^\s*pid = (\d+)\s*$/m);
+      state.pid = pid ? Number(pid[1]) : null;
+      state.running = /\bstate = running\b/.test(printed) && state.pid !== null;
+      if (!state.running) state.pid = null;
+    }
+    const disabled = command(["print-disabled", domain]);
+    const explicitlyDisabled = new RegExp(`"${label.replaceAll(".", "\\.")}"\\s*=>\\s*(?:true|disabled)\\b`).test(disabled);
+    state.autoStart = Boolean(config && config.RunAtLoad !== false && !explicitlyDisabled);
+    return { ...state, loaded: printed !== null, explicitlyDisabled };
+  }
+  function status() {
+    try { const state = inspect(); delete state.loaded; delete state.explicitlyDisabled; return state; }
+    catch (error) { return { supported: platform === "darwin", installed: fs.existsSync(plistPath), running: false, autoStart: false, label, pid: null, logPath: null, error: error.message }; }
+  }
+  function validate(action) {
+    if (!ACTIONS.has(action)) throw new Error(`Unknown service action: ${action}`);
+    if (platform !== "darwin") throw new Error("Service management is supported only on macOS.");
+    const state = inspect();
+    if (["start", "restart", "enable", "disable"].includes(action) && !state.installed) throw new Error("Service is not installed. Run ompgui service install first.");
+    return state;
+  }
+  function execute(action, options = {}) {
+    if (action === "status") return status();
+    const before = validate(action);
+    if (action === "remove") action = "uninstall";
+    if (action === "repair") action = before.installed ? "restart" : "install";
+    if (["install", "start", "restart"].includes(action) && !before.running) {
+      const installed = before.installed ? readInstalled() : null;
+      const launch = installed ? require("./ompgui-options").parseLaunchOptions(installed.ProgramArguments.slice(2), installed.EnvironmentVariables || {}) : options;
+      const port = launch.port || "30177";
+      const hostname = launch.hostname || "127.0.0.1";
+      if (!portAvailable(port, hostname)) throw new Error(`Port ${port} on ${hostname} is already in use. Stop the foreground server or other listener, then run ompgui service ${before.installed ? "start" : "install"}. No service configuration was changed.`);
+    }
+    if (action === "install" && !before.installed) {
+      const realCli = fs.realpathSync(cliPath);
+      const packageDir = path.resolve(path.dirname(realCli), "..");
+      if (!ownedExecutable([execPath, realCli]) || fs.existsSync(path.join(packageDir, ".git")) || !fs.existsSync(path.join(packageDir, ".next", "BUILD_ID"))) throw new Error("Install the published ompgui package before installing its service; development checkouts are not supported.");
+      const persistentEnv = {};
+      for (const [key, value] of Object.entries(env)) {
+        if ((/^(OMP_|OMPGUI_|OMP_WEB_)/.test(key) || ["PATH", "HOME", "SHELL", "LANG", "LC_ALL", "PI_CODING_AGENT_DIR", "PI_PROFILE"].includes(key)) && typeof value === "string" && !/(?:PACKAGE_DIR|LAUNCHER_PID)$/.test(key)) persistentEnv[key] = value;
+      }
+      persistentEnv.OMPGUI_NO_OPEN = "1";
+      if (options.password) { persistentEnv.OMPGUI_PASSWORD = options.password; persistentEnv.OMP_WEB_PASSWORD = options.password; }
+      if (options.relayUrl) persistentEnv.OMPGUI_RELAY_URL = options.relayUrl;
+      const config = { Label: label, ProgramArguments: [execPath, realCli, "--port", String(options.port || "30177"), "--hostname", options.hostname || "127.0.0.1", "--no-open"], WorkingDirectory: home, EnvironmentVariables: persistentEnv, RunAtLoad: true, KeepAlive: true, StandardOutPath: logPath, StandardErrorPath: logPath };
+      fs.mkdirSync(path.dirname(plistPath), { recursive: true, mode: 0o700 });
+      fs.mkdirSync(path.dirname(logPath), { recursive: true, mode: 0o700 });
+      const temporary = `${plistPath}.${process.pid}.${require("node:crypto").randomUUID()}.tmp`;
+      try {
+        fs.writeFileSync(temporary, `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0">${plistValue(config)}</plist>\n`, { mode: 0o600, flag: "wx" });
+        fs.renameSync(temporary, plistPath);
+      } finally { fs.rmSync(temporary, { force: true }); }
+    }
+    if (["enable", "disable"].includes(action)) {
+      if (!before.installed) throw new Error("Service is not installed. Run ompgui service install first.");
+      command([action, target]);
+      return status();
+    }
+    if (["stop", "uninstall"].includes(action)) {
+      if (before.loaded) {
+        command(["bootout", target]);
+        // The launcher allows 5 seconds before forcing its Next child to exit.
+        const deadline = now() + 10000;
+        while (command(["print", target], true) !== null) {
+          if (now() >= deadline) throw new Error("Service is still stopping. Configuration was preserved; wait, check ompgui status, and retry the action.");
+          pause(100);
+        }
+        while (before.pid !== null && processAlive(before.pid)) {
+          if (now() >= deadline) throw new Error("Service process is still exiting. Configuration was preserved; wait, check ompgui status, and retry the action.");
+          pause(100);
+        }
+      }
+      if (action === "uninstall" && before.installed) fs.unlinkSync(plistPath);
+    } else {
+      if (!before.installed && action !== "install") throw new Error("Service is not installed. Run ompgui service install first.");
+      if (action === "install") command(["enable", target]);
+      if (!before.loaded) {
+        const restoreDisabled = action !== "install" && before.explicitlyDisabled;
+        if (restoreDisabled) command(["enable", target]);
+        try {
+          command(["bootstrap", domain, plistPath]);
+          command(["kickstart", target]);
+        }
+        finally { if (restoreDisabled) command(["disable", target]); }
+      } else if (action === "restart") command(["kickstart", "-k", target]);
+      else if (!before.running) command(["kickstart", target]);
+    }
+    return status();
+  }
+  function updateSnapshot(packageDir) {
+    if (platform !== "darwin") return null;
+    const before = inspect();
+    if (!before.installed || !before.running) return null;
+    const config = readInstalled();
+    const packagePath = path.resolve(path.dirname(fs.realpathSync(config.ProgramArguments[1])), "..");
+    if (packagePath !== fs.realpathSync(packageDir)) throw new Error("Running ompgui service belongs to another installation; update that installation instead.");
+    const contents = fs.readFileSync(plistPath);
+    const launch = require("./ompgui-options").parseLaunchOptions(config.ProgramArguments.slice(2), config.EnvironmentVariables || {});
+    return {
+      packagePath, port: launch.port, hostname: launch.hostname,
+      verify() {
+        const current = inspect();
+        if (!current.installed || !fs.readFileSync(plistPath).equals(contents) || current.explicitlyDisabled !== before.explicitlyDisabled) throw new Error("Service configuration changed during update; refusing automatic restart.");
+      },
+    };
+  }
+  return { status, execute, validate, updateSnapshot, plistPath };
+}
+async function runServiceCli(options) {
+  const action = options.command === "service" ? options.extraPositionals[0] || "repair" : options.command;
+  if (options.extraPositionals.length > (options.command === "service" ? 1 : 0)) throw new Error("Unexpected service arguments");
+  const manager = createServiceManager();
+  let result;
+  try {
+    if (options.defer) {
+      if (!["stop", "restart", "uninstall"].includes(action)) throw new Error("Only stop, restart, and uninstall can be deferred");
+      manager.validate(action);
+      const child = spawn(process.execPath, [__filename, action], { detached: true, stdio: "ignore", env: process.env });
+      const spawned = Promise.withResolvers();
+      child.once("spawn", spawned.resolve);
+      child.once("error", spawned.reject);
+      await spawned.promise;
+      child.unref();
+      result = { ...manager.status(), accepted: true };
+    } else result = manager.execute(action, options);
+  } catch (error) { result = { ...manager.status(), error: error.message }; }
+  if (options.json) console.log(JSON.stringify(result));
+  else {
+    console.log(`ompgui service: ${result.running ? `running (PID ${result.pid})` : "stopped"}; ${result.installed ? "installed" : "not installed"}; login auto-start ${result.autoStart ? "enabled" : "disabled"}`);
+    if (result.logPath) console.log(`Logs: ${result.logPath}`);
+    if (result.error) console.error(result.error);
+  }
+  if (result.error) process.exitCode = 1;
+  return result;
+}
+if (require.main === module) {
+  const action = process.argv[2];
+  if (["stop", "restart", "uninstall"].includes(action) && process.argv.length === 3) setTimeout(() => {
+    const manager = createServiceManager();
+    const before = manager.status();
+    try {
+      const result = manager.execute(action);
+      if (result.error) throw new Error(result.error);
+    } catch (error) {
+      process.exitCode = 1;
+      if (before.logPath) {
+        try { fs.appendFileSync(before.logPath, `${new Date().toISOString()} Deferred service ${action} failed: ${error.message}\n`, { mode: 0o600 }); } catch { /* No alternate secret-bearing output destination. */ }
+      }
+    }
+  }, 1200);
+  else if (action === "--check-port" && process.argv.length === 5) {
+    require("./port-availability").isPortAvailable(process.argv[3], process.argv[4]).then((available) => { process.exitCode = available ? 0 : 2; }).catch(() => { process.exitCode = 1; });
+  } else process.exitCode = 1;
+}
+module.exports = { LABEL, createServiceManager, runServiceCli };

package/bin/ompgui-update.js

@@ -4,6 +4,18 @@ const { spawn } = require("child_process");
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
+const { createServiceManager } = require("./ompgui-service");
+const { setTimeout: sleep } = require("node:timers/promises");
+
+async function checkReady({ hostname, port }) {
+  const host = hostname === "0.0.0.0" ? "127.0.0.1" : hostname === "::" ? "::1" : hostname;
+  const authority = host.includes(":") ? `[${host}]` : host;
+  try {
+    const response = await fetch(`http://${authority}:${port}/`, { signal: AbortSignal.timeout(1000), redirect: "manual" });
+    await response.body?.cancel();
+    return response.ok || response.status === 307 || response.status === 308;
+  } catch { return false; }
+}
 
 function normalizePath(value, platform) {
   const normalized = path.normalize(value).replaceAll("\\", path.sep);
@@ -35,39 +47,46 @@ function findNpmCli(nodePath = process.execPath, exists = fs.existsSync) {
   }) ?? null;
 }
 
-function getInstallCommand(method, platform = process.platform, nodePath = process.execPath, resolveNpmCli = findNpmCli) {
+function getInstallCommand(method, platform = process.platform, nodePath = process.execPath, resolveNpmCli = findNpmCli, packageDir) {
+  const paths = platform === "win32" ? path.win32 : path;
+  const modules = packageDir && paths.dirname(packageDir);
+  if (packageDir && (paths.basename(packageDir) !== "ompgui" || paths.basename(modules) !== "node_modules")) {
+    throw new Error("Cannot safely update this installation layout. Reinstall ompgui with npm or Bun first.");
+  }
   if (method === "bun") {
-    return { command: platform === "win32" ? "bun.exe" : "bun", args: ["add", "--global", "ompgui@latest"] };
+    const target = packageDir ? ["--global-dir", paths.dirname(modules), "--global-bin-dir", platform === "win32" ? paths.join(paths.dirname(modules), ".bin") : paths.resolve(modules, "../../../bin")] : [];
+    return { command: platform === "win32" ? "bun.exe" : "bun", args: ["add", "--global", ...target, "ompgui@latest"] };
   }
+  const parent = packageDir && paths.dirname(modules);
+  const global = !packageDir || platform === "win32" || paths.basename(parent) === "lib";
+  const target = packageDir ? ["--prefix", global && platform !== "win32" ? paths.dirname(parent) : parent] : [];
+  const args = ["install", ...(global ? ["--global"] : ["--no-save"]), ...target, "ompgui@latest"];
   if (platform === "win32") {
     const npmCli = resolveNpmCli(nodePath);
     if (!npmCli) throw new Error("Could not locate npm-cli.js beside the active Node.js installation.");
-    return { command: nodePath, args: [npmCli, "install", "--global", "ompgui@latest"] };
+    return { command: nodePath, args: [npmCli, ...args] };
   }
-  return { command: "npm", args: ["install", "--global", "ompgui@latest"] };
+  return { command: "npm", args };
 }
 
 function readInstalledVersion(packageDir) {
   try {
     const packageJson = JSON.parse(fs.readFileSync(path.join(packageDir, "package.json"), "utf8"));
-    return typeof packageJson.version === "string" ? packageJson.version : null;
+    return packageJson.name === "ompgui" && typeof packageJson.version === "string" && /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(packageJson.version) ? packageJson.version : null;
   } catch {
     return null;
   }
 }
 
 function runInstaller(command, args, env = process.env) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { env, stdio: "inherit", windowsHide: true });
-    child.once("error", reject);
-    child.once("exit", (code, signal) => {
-      if (code === 0) {
-        resolve();
-        return;
-      }
-      reject(new Error(signal ? `${command} was terminated by ${signal}` : `${command} exited with code ${code ?? "unknown"}`));
-    });
+  const { promise, resolve, reject } = Promise.withResolvers();
+  const child = spawn(command, args, { env, stdio: "inherit", windowsHide: true });
+  child.once("error", reject);
+  child.once("exit", (code, signal) => {
+    if (code === 0) resolve();
+    else reject(new Error(signal ? `${command} was terminated by ${signal}` : `${command} exited with code ${code ?? "unknown"}`));
   });
+  return promise;
 }
 
 async function updateOmpGui({
@@ -77,18 +96,62 @@ async function updateOmpGui({
   homeDir = os.homedir(),
   install = runInstaller,
   stdout = process.stdout,
+  serviceManager = createServiceManager({ platform, home: homeDir, env }),
+  ready = checkReady,
+  pause = sleep,
+  now = Date.now,
+  readinessTimeout = 30000,
 } = {}) {
   if (!packageDir) throw new Error("The ompgui package directory is unavailable.");
 
   const beforeVersion = readInstalledVersion(packageDir);
   const method = detectInstallMethod(packageDir, env, homeDir, platform);
-  const { command, args } = getInstallCommand(method, platform);
-  stdout.write(`Updating ompgui${beforeVersion ? ` v${beforeVersion}` : ""} with ${method}...\n`);
-  await install(command, args, env);
-
-  const afterVersion = readInstalledVersion(packageDir);
-  if (!afterVersion) {
-    throw new Error("The package manager finished, but the installed ompgui version could not be verified.");
+  const { command, args } = getInstallCommand(method, platform, process.execPath, findNpmCli, packageDir);
+  const snapshot = platform === "darwin" ? serviceManager.updateSnapshot(packageDir) : null;
+  async function startAndWait() {
+    snapshot.verify();
+    const started = await serviceManager.execute("start");
+    if (started.error) throw new Error(started.error);
+    const deadline = now() + readinessTimeout;
+    while (now() < deadline) {
+      const state = serviceManager.status();
+      if (state.error) throw new Error(state.error);
+      if (state.running && await ready(snapshot)) {
+        snapshot.verify();
+        return;
+      }
+      await pause(Math.min(100, Math.max(0, deadline - now())));
+    }
+    throw new Error("Service did not become ready before the deadline. Check ompgui status and service logs.");
+  }
+  if (snapshot) {
+    stdout.write("Stopping the running ompgui service before updating...\n");
+    const stopped = await serviceManager.execute("stop");
+    if (stopped.error) throw new Error(stopped.error);
+    snapshot.verify();
+  }
+  let afterVersion;
+  try {
+    stdout.write(`Updating ompgui${beforeVersion ? ` v${beforeVersion}` : ""} with ${method}...\n`);
+    await install(command, args, env);
+    afterVersion = readInstalledVersion(packageDir);
+    if (!afterVersion) throw new Error("The package manager finished, but the installed ompgui version could not be verified.");
+  } catch (error) {
+    if (snapshot) {
+      stdout.write("Update failed; attempting to start the available ompgui installation (no rollback was performed)...\n");
+      try {
+        await startAndWait();
+        stdout.write("The available ompgui service is running again.\n");
+      } catch (recoveryError) {
+        throw new AggregateError([error, recoveryError], `${error.message} Recovery start also failed: ${recoveryError.message}`);
+      }
+    }
+    throw error;
+  }
+  if (snapshot) {
+    stdout.write("Starting the updated ompgui service...\n");
+    await startAndWait();
+    stdout.write("The ompgui service is ready.\n");
   }
   if (beforeVersion && afterVersion && beforeVersion === afterVersion) {
     stdout.write(`ompgui v${afterVersion} is already up to date.\n`);

package/bin/ompgui.js

@@ -10,16 +10,35 @@ const pkgDir = path.join(__dirname, "..");
 const options = parseLaunchOptions();
 if (options.help || options.version) process.exit(0);
 if (options.command) {
-  if (options.command !== "update" || options.extraPositionals.length) {
-    console.error(`Unknown ompgui command: ${[options.command, ...options.extraPositionals].join(" ")}`);
-    process.exit(1);
+  if (["service", "start", "stop", "restart", "status"].includes(options.command)) {
+    require("./ompgui-service").runServiceCli(options).catch((error) => {
+      console.error(error.message);
+      process.exitCode = 1;
+    });
+    return;
   }
-  const { updateOmpGui } = require("./ompgui-update");
-  updateOmpGui({ packageDir: pkgDir }).catch((error) => {
-    console.error(`Could not update ompgui: ${error.message}`);
-    process.exitCode = 1;
-  });
-  return;
+  if (options.command === "update") {
+    if (options.extraPositionals.length) {
+      console.error(`Unknown ompgui command: ${[options.command, ...options.extraPositionals].join(" ")}`);
+      process.exit(1);
+    }
+    const { updateOmpGui } = require("./ompgui-update");
+    updateOmpGui({ packageDir: pkgDir }).catch((error) => {
+      console.error(`Could not update ompgui: ${error.message}`);
+      process.exitCode = 1;
+    });
+    return;
+  }
+  if (options.command === "pair" || options.command === "devices") {
+    const { runRelayCli } = require("./ompgui-pair");
+    runRelayCli(options).catch((error) => {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exitCode = 1;
+    });
+    return;
+  }
+  console.error(`Unknown ompgui command: ${[options.command, ...options.extraPositionals].join(" ")}`);
+  process.exit(1);
 }
 const { isPortAvailable } = require("./port-availability");
 const { wireChildProcessLifecycle } = require("./process-lifecycle");
@@ -28,10 +47,10 @@ let nextBin;
 try { nextBin = require.resolve("next/dist/bin/next", { paths:[pkgDir] }); } catch { try { nextBin = path.join(path.dirname(require.resolve("next/package.json", {paths:[pkgDir]})), "dist", "bin", "next"); } catch { nextBin = path.join(pkgDir,"node_modules/next/dist/bin/next"); } }
 const { port, hostname, password, openBrowser } = options;
 if (password) { process.env.OMPGUI_PASSWORD = password; process.env.OMP_WEB_PASSWORD = password; }
-const loopback = new Set(["127.0.0.1","localhost","::1","[::1]"]);
+const loopback = new Set(["127.0.0.1","localhost","::1"]);
 if (!loopback.has(hostname) && !(typeof password === "string" && password.length)) { console.error(`Refusing to listen on ${hostname} without OMPGUI_PASSWORD (or --password). Set a strong password or bind to 127.0.0.1.`); process.exit(1); }
 if (!fs.existsSync(nextDir)) { console.error("Build artifacts not found. Please report this issue."); process.exit(1); }
-const url = `http://${hostname}:${port}`;
+const url = options.baseUrl;
 function openBrowserWindow(target) { const cmd = process.platform === "win32" ? "cmd.exe" : process.platform === "darwin" ? "open" : process.platform === "linux" && (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP) ? "wslview" : "xdg-open"; const args = process.platform === "win32" ? ["/c","start","",target] : [target]; try { const p=spawn(cmd,args,{stdio:"ignore",detached:true}); p.on("error",e=>console.warn(`Could not open browser automatically: ${e.message}`)); p.unref(); } catch(e) { console.warn(`Could not open browser automatically: ${e.message}`); } }
 async function main() {
   if (!await isPortAvailable(port, hostname)) { console.log(`ompgui is already running on ${hostname}:${port}.`); if (openBrowser) openBrowserWindow(url); return; }

package/next.config.ts

@@ -54,7 +54,9 @@ const nextConfig = (phase: string): NextConfig => {
       ];
       const headers = [
         {
-          source: "/:path*",
+          // File routes supply their own document policy. Applying the app's
+          // script-enabled CSP here overrides their inert SVG/DOCX responses.
+          source: "/:path((?!api/files(?:/|$)).*)",
           headers: securityHeaders,
         },
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ompgui",
-  "version": "0.6.5",
+  "version": "0.7.2",
   "description": "Web UI & Browser GUI for the oh-my-pi (omp) coding agent",
   "homepage": "https://github.com/dbc-hbin/ompgui#readme",
   "repository": {
@@ -22,6 +22,8 @@
   "files": [
     "bin/ompgui.js",
     "bin/ompgui-update.js",
+    "bin/ompgui-service.js",
+    "bin/ompgui-pair.js",
     "bin/omp-web.js",
     "bin/ompgui-options.js",
     "bin/omp-web-options.js",
@@ -43,7 +45,7 @@
     "dev": "next dev -H 127.0.0.1 -p 30178",
     "build": "next build --webpack",
     "start": "next start -H 127.0.0.1 -p 30177",
-    "test": "node --experimental-strip-types --test lib/*.test.mjs lib/omp/*.test.mjs components/*.test.mjs components/ui/*.test.mjs hooks/*.test.mjs bin/*.test.mjs",
+    "test": "node --experimental-strip-types --test lib/*.test.mjs lib/omp/*.test.mjs lib/relay/*.test.mjs components/*.test.mjs components/ui/*.test.mjs hooks/*.test.mjs bin/*.test.mjs",
     "typecheck": "tsc --noEmit",
     "lint": "eslint .",
     "prepack": "npm run build",
@@ -65,17 +67,18 @@
     "rehype-katex": "^7.0.1",
     "rehype-raw": "^7.0.0",
     "rehype-sanitize": "^6.0.0",
+    "rehype-stringify": "^10.0.1",
     "remark-gfm": "^4.0.1",
     "remark-math": "^6.0.0",
     "undici": "8.10.0",
+    "unified": "^11.0.5",
+    "uqr": "^0.1.3",
     "yaml": "^2"
   },
   "devDependencies": {
-    "@capacitor/android": "^8.5.0",
-    "@capacitor/cli": "^8.5.0",
-    "@capacitor/core": "^8.5.0",
     "@lobehub/icons": "^5.6.0",
     "@tailwindcss/postcss": "^4.2.2",
+    "@types/hast": "^3.0.4",
     "@types/node": "^25",
     "@types/react": "^19",
     "@types/react-dom": "^19",
@@ -84,6 +87,7 @@
     "eslint-config-next": "16.2.9",
     "jiti": "^2.7.0",
     "postcss": "^8",
+    "prismjs": "^1.30.0",
     "typescript": "^5"
   }
 }