@opentig/cli 0.1.4 → 0.1.5

package/README.md

@@ -1,37 +1,93 @@
 # OpenTig CLI
 
-Run the same authenticated OpenTig server, runtime, protocol, and production web client used by the Windows desktop application.
+**A focused workspace for reviewing code changes, in your browser.**
 
-OpenTig is local-first: it works with existing Git repositories on the machine running the server. Node.js 24 or later and Git are required.
+Browse files, inspect diffs, edit, stage, and commit on your computer or a remote server. The CLI serves the same UI as the OpenTig desktop app, without Electron.
 
-## Local use
+[Source](https://github.com/jorgefl8/opentig) · [Documentation](https://github.com/jorgefl8/opentig/blob/main/docs/README.md) · [Report a bug](https://github.com/jorgefl8/opentig/issues)
 
-Pin an exact version for repeatable use:
+![OpenTig reviewing a TypeScript split diff in a demo repository](https://raw.githubusercontent.com/jorgefl8/opentig/main/docs/images/workspace.png)
+
+*The browser UI in the Dev build, reviewing a small demo repository.*
+
+> **Early development.** I'm building OpenTig for my own daily workflow and sharing it as it takes shape. Expect bugs, rough edges, and changes. Keep important work backed up and review Git and file operations before confirming them.
+
+## Start locally
+
+Works on **macOS, Linux, and Windows** with **Node.js 24+** and **Git** installed.
+
+```bash
+npx --yes @opentig/cli@latest
+```
+
+This starts OpenTig at `127.0.0.1:6767` and opens a one-use browser pairing link. Choose an existing repository in the visual folder picker and start reviewing. Repositories are managed in the UI; you do not need to start a separate server for each one.
+
+Prefer Bun's package runner?
+
+```bash
+bunx @opentig/cli@latest
+```
+
+Plain `bunx` launches the Node-shebang executable. **Node.js 24+ is still required**; running OpenTig under the Bun runtime itself is not supported.
+
+Or install globally:
 
 ```bash
-npx --yes @opentig/cli@0.1.0
-npx --yes @opentig/cli@0.1.0 serve
-bunx @opentig/cli@0.1.0 serve
+npm install -g @opentig/cli@latest
+opentig
 ```
 
-Plain `bunx` installs and launches the Node-shebang executable. Running OpenTig under the Bun runtime itself is not supported.
+## What you can do
 
-Run `opentig help` or `opentig --help` for commands, examples, pairing/tunnel guidance, service management, environment variables, and shutdown behavior.
+| | |
+| --- | --- |
+| **Review changes** | Split or unified diffs, staged and unstaged files, and merge-conflict resolution. [Details](https://github.com/jorgefl8/opentig/blob/main/docs/features.md#changes-diffs-and-commits) |
+| **Browse and edit** | File tree, tabs, quick edits, find and replace, repository search, and Markdown, image, HTML, and SVG previews. [Details](https://github.com/jorgefl8/opentig/blob/main/docs/features.md#files-and-editing) |
+| **Work with Git** | Stage files, commit, pull and push, inspect history, and switch branches and worktrees. [Details](https://github.com/jorgefl8/opentig/blob/main/docs/features.md#safe-pull-and-push) |
+| **Organize repositories** | Recent repositories, project groups, and manual relocation without moving files. [Details](https://github.com/jorgefl8/opentig/blob/main/docs/features.md#repositories-and-projects) |
+| **Review GitHub PRs** | Browse pull requests, inspect changes, and prepare new PRs through your authenticated `gh` CLI. [Details](https://github.com/jorgefl8/opentig/blob/main/docs/features.md#github-pull-requests) |
+| **Use a remote server** | Pair a browser on your laptop or phone and work with repositories on the server. [Details](https://github.com/jorgefl8/opentig/blob/main/docs/web-access.md) |
 
-`opentig` and `opentig start` open the pairing link in the system browser. `opentig serve` keeps browser launch disabled and prints a terminal QR. Use `--no-browser` to suppress presentation in start mode. The CLI starts one project-independent server; add, open, and switch repositories exclusively from the web UI using paths on the server.
+**AI is optional.** Normal Git work needs no AI account or OpenTig account. If you choose to use AI assistance, a supported CLI installed and authenticated on the host can draft commit messages and pull-request descriptions for you to review. The selected CLI may send the supplied context to its provider. OpenTig does not run an autonomous coding agent or create commits on its own. See the [feature guide](https://github.com/jorgefl8/opentig/blob/main/docs/features.md) and [privacy details](https://github.com/jorgefl8/opentig/blob/main/docs/security-and-privacy.md).
+
+## Run on a remote server
+
+Start without opening a browser:
+
+```bash
+npx --yes @opentig/cli@latest serve
+```
+
+Server mode is designed for personal access through **Cloudflare Tunnel**, a **private network such as Tailscale**, or an SSH tunnel. The default listener stays on `127.0.0.1:6767`, which a tunnel or HTTPS reverse proxy on the same machine can reach. For direct private-network access, bind to its interface with `--host`; alternatively, keep loopback and use a private HTTPS proxy such as Tailscale Serve. Tunnel and VPN setup are managed separately from OpenTig.
+
+Pair your browser with the one-use code printed on the server. The visual folder picker selects **folders on the server**, not on your laptop or phone.
+
+After a global installation, run `opentig pair` as the same OS user to generate a fresh five-minute pairing code for the running instance. If you use a custom data directory, pass the same `--home` value.
+
+Paired browsers have the host user's filesystem, Git, and configured CLI authority. Keep access private and do not expose the raw HTTP port publicly. See [remote access and pairing](https://github.com/jorgefl8/opentig/blob/main/docs/web-access.md) for SSH and reverse-proxy examples.
+
+## Keep a background server running
+
+After installing globally, opt into a background service on Linux, macOS, or Windows:
+
+```bash
+opentig service install --host 127.0.0.1 --port 6767
+opentig service status
+opentig service restart
+```
 
-The default listener is `127.0.0.1:6767`. If the configured port is busy, OpenTig fails instead of silently changing a reverse-proxy target. Configuration precedence is command line, `OPENTIG_HOST` / `OPENTIG_PORT` / `OPENTIG_HOME`, then defaults. Data lives under `~/.opentig` unless `--home` is supplied. Settings, hash-only sessions, AI history, credential-free runtime identity, a private same-host admin credential, and rotating logs are kept there.
+The service uses a persistent runtime outside the temporary package cache and starts independently of any repository. Running `npx` or `bunx` alone never installs a background service. Use `opentig service uninstall` to remove it. Linux uses systemd with lingering and starts at boot. macOS uses a user LaunchAgent and Windows uses a Task Scheduler task for the current user; these start at login and stop at logout. Keep the machine awake for remote access. This service is independent of the desktop app.
 
-Run `opentig pair --home <same-home>` as the same OS user to mint a new five-minute, one-use code and link for a running server. Open `/pair` on the local, LAN, or tunnel domain, paste the code, and confirm or edit the suggested device name. SIGINT and SIGTERM close clients, watchers, owned Git/AI processes, persistence, and logs; a second signal forces exit.
+Managed services on all three platforms can **download updates and restart from the browser UI**. Those updates replace the service's runtime, without changing the global npm package. For foreground instances, stop the process and start the desired package version. Pin an exact version instead of `latest` for repeatable deployments. See [installation, services, and updates](https://github.com/jorgefl8/opentig/blob/main/docs/getting-started.md).
 
-`npx` and `bunx` never install background persistence. Linux/systemd users can opt in with `opentig service install`, inspect it with `opentig service status`, and remove it with `opentig service uninstall`. The installer stages the exact package outside the temporary npx cache, uses the private OpenTig home as its stable working directory, and enables user lingering. It is never scoped to a repository. Other platforms should use their preferred service manager for now.
+## Configuration and scope
 
-A non-loopback listener grants authenticated owner sessions the filesystem, Git, GitHub CLI, and configured AI CLI authority of the operating-system account running OpenTig. Use a trusted LAN/VPN, HTTPS reverse proxy, or SSH tunnel with a restrictive firewall. Never expose the raw HTTP port to the public Internet or use unencrypted non-loopback HTTP on an untrusted network.
+Run `opentig --help` for commands and options. Configure `--host`, `--port`, and `--home`, or their `OPENTIG_HOST`, `OPENTIG_PORT`, and `OPENTIG_HOME` environment equivalents. Data is stored under `~/.opentig` by default. An occupied port fails clearly instead of silently changing the address.
 
-Pin versions for production. Upgrade or roll back by stopping the process and running a different immutable version. Docker, built-in TLS, Tailscale/SSH automation, multi-user roles, and self-update are not included.
+OpenTig opens existing repositories. Cloning and initial remote setup remain Git CLI tasks. Built-in TLS, multi-user roles, and automatic SSH or tunnel setup are not included.
 
-Source, documentation, and security guidance: <https://github.com/jorgefl8/opentig>
+The separate [desktop installer](https://github.com/jorgefl8/opentig/releases/latest) is currently available for Windows x64 only. **macOS and Linux users can use this CLI and the browser UI today.**
 
 ## License
 
-MIT. Bundled third-party assets retain their own licences; see `THIRD_PARTY_NOTICES.md`.
+[MIT](https://github.com/jorgefl8/opentig/blob/main/LICENSE). Bundled third-party assets retain their own licences; see [third-party notices](https://github.com/jorgefl8/opentig/blob/main/THIRD_PARTY_NOTICES.md).

package/dist/bin.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import process$1 from "node:process";
-import { p as parseCliArguments, C as CliUsageError, r as runCli } from "./chunks/cli-B3AR8LUd.mjs";
+import { p as parseCliArguments, C as CliUsageError, O as OPEN_TIG_APP_VERSION, r as runCli } from "./chunks/cli-D_aggpu2.mjs";
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 import { realpath } from "node:fs/promises";
 import path from "node:path";
-import { r as readInstallation, n as newerVersion, p as packageDirectory, O as OPEN_TIG_APP_VERSION } from "./chunks/cli-service-B939lTxw.mjs";
+import { r as readInstallation, n as newerVersion, p as packageDirectory } from "./chunks/service-manager-DkpSHxsP.mjs";
 import "./server.mjs";
 import "node:crypto";
 import "node:string_decoder";

package/dist/chunks/{cli-B3AR8LUd.mjs → cli-D_aggpu2.mjs}

@@ -3,10 +3,11 @@ import process$1 from "node:process";
 import { w as writeFileAtomically, r as redactSensitiveText, n as normalizeRuntimePlatform, a as applicationName, runOpenTigServer } from "../server.mjs";
 import os from "node:os";
 import path from "node:path";
-import { r as readInstallation, s as systemctl, S as SERVICE_NAME, a as serviceUnitPath, p as packageDirectory, n as newerVersion, b as atomicWrite, e as execute, c as stableVersion, O as OPEN_TIG_APP_VERSION, m as manageCliService } from "./cli-service-B939lTxw.mjs";
-import { randomUUID, createHash, randomBytes } from "node:crypto";
-import { realpath, readFile, mkdir, rm, mkdtemp, writeFile, rename, chmod, appendFile, stat } from "node:fs/promises";
+import { realpath, access, mkdir, rm, readFile, cp, rename, mkdtemp, writeFile, chmod, appendFile, stat } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { e as execute, c as createServiceManager, r as readInstallation, n as newerVersion, a as assertManager, p as packageDirectory, s as saveInstallation, b as atomicWrite, d as stableVersion } from "./service-manager-DkpSHxsP.mjs";
+import { createHash, randomBytes } from "node:crypto";
 var QrCodeDataType = /* @__PURE__ */ ((QrCodeDataType2) => {
   QrCodeDataType2[QrCodeDataType2["Border"] = -1] = "Border";
   QrCodeDataType2[QrCodeDataType2["Data"] = 0] = "Data";
@@ -65,14 +66,14 @@ class QrCode {
   // error correction level, data codeword bytes, and mask number.
   // This is a low-level API that most users should not use directly.
   // A mid-level API is the encodeSegments() function.
-  constructor(version, ecc, dataCodewords, msk) {
-    this.version = version;
+  constructor(version2, ecc, dataCodewords, msk) {
+    this.version = version2;
     this.ecc = ecc;
-    if (version < MIN_VERSION || version > MAX_VERSION)
+    if (version2 < MIN_VERSION || version2 > MAX_VERSION)
       throw new RangeError("Version value out of range");
     if (msk < -1 || msk > 7)
       throw new RangeError("Mask value out of range");
-    this.size = version * 4 + 17;
+    this.size = version2 * 4 + 17;
     const row = Array.from({ length: this.size }).fill(false);
     for (let i = 0; i < this.size; i++) {
       this.modules.push(row.slice());
@@ -490,10 +491,10 @@ function isNumeric(text) {
 function isAlphanumeric(text) {
   return ALPHANUMERIC_REGEX.test(text);
 }
-function getTotalBits(segs, version) {
+function getTotalBits(segs, version2) {
   let result = 0;
   for (const seg of segs) {
-    const ccbits = numCharCountBits(seg.mode, version);
+    const ccbits = numCharCountBits(seg.mode, version2);
     if (seg.numChars >= 1 << ccbits)
       return Number.POSITIVE_INFINITY;
     result += 4 + ccbits + seg.bitData.length;
@@ -569,37 +570,37 @@ function encodeSegments(segs, ecl, minVersion = 1, maxVersion = 40, mask = -1, b
   if (!(MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= MAX_VERSION) || mask < -1 || mask > 7) {
     throw new RangeError("Invalid value");
   }
-  let version;
+  let version2;
   let dataUsedBits;
-  for (version = minVersion; ; version++) {
-    const dataCapacityBits2 = getNumDataCodewords(version, ecl) * 8;
-    const usedBits = getTotalBits(segs, version);
+  for (version2 = minVersion; ; version2++) {
+    const dataCapacityBits2 = getNumDataCodewords(version2, ecl) * 8;
+    const usedBits = getTotalBits(segs, version2);
     if (usedBits <= dataCapacityBits2) {
       dataUsedBits = usedBits;
       break;
     }
-    if (version >= maxVersion)
+    if (version2 >= maxVersion)
       throw new RangeError("Data too long");
   }
   for (const newEcl of [MEDIUM, QUARTILE, HIGH]) {
-    if (boostEcl && dataUsedBits <= getNumDataCodewords(version, newEcl) * 8)
+    if (boostEcl && dataUsedBits <= getNumDataCodewords(version2, newEcl) * 8)
       ecl = newEcl;
   }
   const bb = [];
   for (const seg of segs) {
     appendBits(seg.mode[0], 4, bb);
-    appendBits(seg.numChars, numCharCountBits(seg.mode, version), bb);
+    appendBits(seg.numChars, numCharCountBits(seg.mode, version2), bb);
     for (const b of seg.getData())
       bb.push(b);
   }
-  const dataCapacityBits = getNumDataCodewords(version, ecl) * 8;
+  const dataCapacityBits = getNumDataCodewords(version2, ecl) * 8;
   appendBits(0, Math.min(4, dataCapacityBits - bb.length), bb);
   appendBits(0, (8 - bb.length % 8) % 8, bb);
   for (let padByte = 236; bb.length < dataCapacityBits; padByte ^= 236 ^ 17)
     appendBits(padByte, 8, bb);
   const dataCodewords = Array.from({ length: Math.ceil(bb.length / 8) }, () => 0);
   bb.forEach((b, i) => dataCodewords[i >>> 3] |= b << 7 - (i & 7));
-  return new QrCode(version, ecl, dataCodewords, mask);
+  return new QrCode(version2, ecl, dataCodewords, mask);
 }
 function encode(data, options) {
   const {
@@ -780,7 +781,7 @@ function parseCliArguments(args, environment = process.env, currentDirectory = p
   if (command === "pair" && (hostValue !== void 0 || portValue !== void 0 || noBrowser)) {
     throw new CliUsageError("The pair command only accepts --home.");
   }
-  if (command === "service" && serviceAction === null) throw new CliUsageError("The service command requires install, status, or uninstall.");
+  if (command === "service" && serviceAction === null) throw new CliUsageError("The service command requires install, status, restart, or uninstall.");
   if (command === "service" && serviceAction !== "install" && (hostValue !== void 0 || portValue !== void 0 || noBrowser)) {
     throw new CliUsageError(`The service ${serviceAction} command only accepts --home.`);
   }
@@ -807,15 +808,15 @@ function parseCliArguments(args, environment = process.env, currentDirectory = p
     openBrowser: command === "start" && !noBrowser
   };
 }
-function cliHelp(version) {
-  return `OpenTig ${version}
+function cliHelp(version2) {
+  return `OpenTig ${version2}
 
 Usage:
   opentig [options]
   opentig start [options]
   opentig serve [options]
   opentig pair [--home <path>]
-  opentig service <install|status|uninstall> [options]
+  opentig service <install|status|restart|uninstall> [options]
   opentig help
   opentig version
 
@@ -823,7 +824,7 @@ Commands:
   start       Start OpenTig and open the one-use pairing link (default)
   serve       Start OpenTig without opening a browser; ideal for servers
   pair        Print a fresh five-minute code/link for a running server
-  service     Explicitly manage startup at boot (Linux/systemd only)
+  service     Manage a background server (Linux, macOS, Windows)
   help        Show this help
   version     Show the OpenTig version
 
@@ -858,7 +859,8 @@ Runtime behavior:
   The configured port is never changed silently. If it is occupied, OpenTig
   exits and asks you to stop that process or choose another --port. SIGINT and
   SIGTERM shut the server down cleanly. npx and bunx never install a service;
-  service installation is an explicit Linux/systemd action.
+  service installation is explicit. Linux uses systemd with lingering; macOS
+  and Windows start at login and stop at logout.
 
 Requirements: Node.js 24 or later and Git. Plain bunx launches the Node shebang;
 running OpenTig with the Bun runtime itself is not supported.`;
@@ -881,7 +883,7 @@ function isCommand(value) {
   return value === "start" || value === "serve" || value === "pair" || value === "service" || value === "help" || value === "version";
 }
 function isServiceAction(value) {
-  return value === "install" || value === "status" || value === "uninstall";
+  return value === "install" || value === "status" || value === "restart" || value === "uninstall";
 }
 function validateHost(value) {
   const normalized = value.trim();
@@ -898,22 +900,197 @@ function resolvePath(value, currentDirectory, label) {
   if (!value || value.includes("\0")) throw new CliUsageError(`Invalid ${label}.`);
   return path.resolve(currentDirectory, value);
 }
+const version = "0.1.5";
+const packageMetadata = {
+  version
+};
+const OPEN_TIG_APP_VERSION = packageMetadata.version;
+async function runServiceNpm(args, cwd) {
+  const candidates = [
+    process.env.npm_execpath,
+    path.join(path.dirname(process.execPath), "node_modules/npm/bin/npm-cli.js"),
+    path.resolve(path.dirname(process.execPath), "../lib/node_modules/npm/bin/npm-cli.js")
+  ];
+  for (const directory of (process.env.PATH ?? "").split(path.delimiter)) {
+    if (!directory) continue;
+    candidates.push(path.join(directory, "node_modules/npm/bin/npm-cli.js"));
+    if (process.platform !== "win32") {
+      try {
+        candidates.push(await realpath(path.join(directory, "npm")));
+      } catch {
+      }
+    }
+  }
+  for (const candidate of candidates) {
+    if (!candidate || path.basename(candidate) !== "npm-cli.js") continue;
+    try {
+      await access(candidate);
+    } catch {
+      continue;
+    }
+    await execute(process.execPath, [candidate, ...args], { cwd, timeout: 18e4, maxBuffer: 2e6, windowsHide: true });
+    return;
+  }
+  throw new Error("npm could not be located. Install Node.js with npm and run service install from that terminal.");
+}
+async function manageCliService(config, io, managerOverride) {
+  const manager = await createServiceManager(config.home);
+  const action = config.serviceAction;
+  if (!action) throw new Error("A service action is required.");
+  const installed = await readInstallation(config.home);
+  if (action !== "status" && installed && newerVersion(installed.version, OPEN_TIG_APP_VERSION)) throw new Error("A newer managed service is installed. Use its CLI to administer it; downgrades are not automatic.");
+  const definition = await manager.read();
+  if (definition && !manager.owns(definition)) throw new Error("Another OpenTig home owns this service. Use its --home before changing or removing it.");
+  if (installed) assertManager(installed, manager.kind);
+  if (action === "status") {
+    if (!definition) {
+      io.out("OpenTig service is not installed.");
+      return 1;
+    }
+    const state = await manager.status();
+    io.out(`OpenTig service: ${state.running ? "running" : "stopped"} (${state.enabled ? "enabled" : "disabled"}).`);
+    io.out(manager.location);
+    io.out(manager.startup);
+    return state.running && state.enabled ? 0 : 1;
+  }
+  if (action === "uninstall" && !definition && !installed) {
+    io.out("OpenTig service is not installed.");
+    return 0;
+  }
+  await mkdir(path.join(config.home, "service"), { recursive: true, mode: 448 });
+  const lock = path.join(config.home, "service/update-lock");
+  try {
+    await mkdir(lock, { mode: 448 });
+  } catch (error) {
+    if (error.code === "EEXIST") throw new Error("A service installation or update is already in progress.", { cause: error });
+    throw error;
+  }
+  try {
+    if (action === "restart") {
+      if (!definition || !installed) throw new Error("OpenTig service is not installed.");
+      await manager.restart();
+      await waitServiceReady(config.home, installed, manager);
+      io.out("OpenTig service restarted.");
+      return 0;
+    }
+    if (action === "uninstall") {
+      if (definition) {
+        await manager.stop();
+        await manager.remove();
+      }
+      await rm(path.join(config.home, "service"), { recursive: true, force: true });
+      io.out("OpenTig service removed. Repository settings and paired sessions were kept.");
+      return 0;
+    }
+    await manager.preflight();
+    return await installService(config, manager, installed, definition, io);
+  } finally {
+    await rm(lock, { recursive: true, force: true });
+  }
+}
+async function installService(config, manager, installed, previousDefinition, io) {
+  const packageRoot = await findPackageRoot(fileURLToPath(import.meta.url));
+  await assertPackageBuild(packageRoot);
+  const serviceRoot = path.join(config.home, "service");
+  const reuse = installed?.version === OPEN_TIG_APP_VERSION;
+  const target = reuse ? packageDirectory(config.home, installed) : path.join(serviceRoot, `app-${OPEN_TIG_APP_VERSION}`);
+  const temporary = path.join(serviceRoot, `.install-${process.pid}-${Date.now()}`);
+  try {
+    if (!reuse) {
+      await mkdir(temporary, { recursive: true, mode: 448 });
+      await cp(path.join(packageRoot, "dist"), path.join(temporary, "dist"), { recursive: true });
+      for (const name of ["package.json", "README.md", "LICENSE", "THIRD_PARTY_NOTICES.md"]) await cp(path.join(packageRoot, name), path.join(temporary, name));
+      await runServiceNpm(["install", "--omit=dev", "--ignore-scripts", "--no-audit", "--no-fund"], temporary);
+      await rm(target, { recursive: true, force: true });
+      await rename(temporary, target);
+    }
+  } finally {
+    await rm(temporary, { recursive: true, force: true });
+  }
+  await assertPackageBuild(target);
+  const next = { schema: 1, manager: manager.kind, version: OPEN_TIG_APP_VERSION, layout: reuse ? installed.layout : "flat", host: config.host, port: config.port, node: process.execPath, environmentPath: process.env.PATH };
+  const definition = manager.render({ nodeExecutable: next.node, cliEntrypoint: path.join(target, "dist/bin.mjs"), home: config.home, host: next.host, port: next.port, environmentPath: next.environmentPath });
+  try {
+    await manager.write(definition);
+    await saveInstallation(config.home, next);
+    await manager.restart();
+    await waitServiceReady(config.home, next, manager);
+  } catch (error) {
+    if (previousDefinition) {
+      await manager.write(previousDefinition);
+      if (installed) await saveInstallation(config.home, installed);
+      else await rm(path.join(serviceRoot, "installation.json"), { force: true });
+      await manager.restart();
+    } else {
+      await manager.stop();
+      await manager.remove();
+      await rm(path.join(serviceRoot, "installation.json"), { force: true });
+    }
+    throw error;
+  }
+  io.out(`OpenTig service installed and started on ${config.host}:${config.port}.`);
+  io.out(manager.location);
+  io.out(manager.startup);
+  io.out(`Pair another browser with: opentig pair --home ${JSON.stringify(config.home)}`);
+  return 0;
+}
+async function waitServiceReady(home, installation, manager) {
+  const host = ["0.0.0.0", "::"].includes(installation.host) ? installation.host === "::" ? "[::1]" : "127.0.0.1" : installation.host.includes(":") ? `[${installation.host}]` : installation.host;
+  for (let i = 0; i < 30; i++) {
+    try {
+      const state = await manager.status();
+      const runtime = JSON.parse(await readFile(path.join(home, "runtime.json"), "utf8"));
+      const response = await fetch(`http://${host}:${installation.port}/readyz`, { signal: AbortSignal.timeout(1e3) });
+      const value = await response.json();
+      if (state.running && (!state.pid || state.pid === runtime.pid) && runtime.appVersion === installation.version && response.ok && value.status === "ready" && value.appVersion === installation.version) return;
+    } catch {
+    }
+    await setTimeout$1(1e3);
+  }
+  throw new Error("The managed service did not become ready. Inspect service status and logs; check Git, Node.js, and the configured port.");
+}
+async function assertPackageBuild(packageRoot) {
+  await Promise.all([
+    access(path.join(packageRoot, "dist", "bin.mjs")),
+    access(path.join(packageRoot, "dist", "client", "index.html")),
+    readFile(path.join(packageRoot, "package.json"), "utf8")
+  ]).catch(() => {
+    throw new Error("The OpenTig package is incomplete and cannot be installed as a service.");
+  });
+}
+async function findPackageRoot(modulePath) {
+  let directory = path.dirname(modulePath);
+  for (let depth = 0; depth < 4; depth += 1) {
+    try {
+      await Promise.all([
+        access(path.join(directory, "package.json")),
+        access(path.join(directory, "dist", "bin.mjs"))
+      ]);
+      return directory;
+    } catch {
+    }
+    const parent = path.dirname(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+  throw new Error("Could not locate the installed OpenTig package.");
+}
 const DESKTOP_UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 const REPOSITORY = "jorgefl8/opentig";
 const REGISTRY = "https://registry.npmjs.org";
 const MAX_PACKAGE_BYTES = 100 * 1024 * 1024;
 class ServiceUpdater {
-  constructor(version, backend, failedUpdate = false) {
+  constructor(version2, backend, failedUpdate = false) {
     this.backend = backend;
     this.status = {
       phase: backend ? failedUpdate ? "error" : "idle" : "unavailable",
-      currentVersion: version,
+      currentVersion: version2,
       availableVersion: null,
       progress: null,
       checkedAt: null,
       releaseUrl: null,
       releaseNotes: null,
-      message: backend ? failedUpdate ? "The new server could not start. The previous version was restored. Check for updates to retry." : null : "Browser updates require an OpenTig Linux service. Install with opentig service install; temporary CLI and Dev instances are updated from the terminal."
+      message: backend ? failedUpdate ? "The new server could not start. The previous version was restored. Check for updates to retry." : null : "Browser updates require a managed OpenTig CLI service. Install with opentig service install; temporary CLI and Dev instances are updated from the terminal."
     };
   }
   backend;
@@ -992,18 +1169,18 @@ async function json(url) {
 async function latestCliRelease() {
   const release = await json(`https://api.github.com/repos/${REPOSITORY}/releases/latest`);
   if (!release || release.draft || release.prerelease || typeof release.tag_name !== "string") return null;
-  const version = release.tag_name.replace(/^v/, "");
-  if (!stableVersion(version) || release.tag_name !== `v${version}`) return null;
-  const pkg = await json(`${REGISTRY}/@opentig%2fcli/${version}`);
+  const version2 = release.tag_name.replace(/^v/, "");
+  if (!stableVersion(version2) || release.tag_name !== `v${version2}`) return null;
+  const pkg = await json(`${REGISTRY}/@opentig%2fcli/${version2}`);
   if (!pkg) return null;
   const dist = pkg.dist;
-  const tarball = `${REGISTRY}/@opentig/cli/-/cli-${version}.tgz`;
-  if (pkg.name !== "@opentig/cli" || pkg.version !== version || dist?.tarball !== tarball || typeof dist.integrity !== "string" || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(dist.integrity)) throw new Error("Invalid CLI release metadata.");
+  const tarball = `${REGISTRY}/@opentig/cli/-/cli-${version2}.tgz`;
+  if (pkg.name !== "@opentig/cli" || pkg.version !== version2 || dist?.tarball !== tarball || typeof dist.integrity !== "string" || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(dist.integrity)) throw new Error("Invalid CLI release metadata.");
   return {
-    version,
+    version: version2,
     tarball,
     integrity: dist.integrity,
-    url: `https://github.com/${REPOSITORY}/releases/tag/v${version}`,
+    url: `https://github.com/${REPOSITORY}/releases/tag/v${version2}`,
     notes: typeof release.body === "string" ? release.body.slice(0, 64e3) : null
   };
 }
@@ -1041,7 +1218,7 @@ async function stageCliRelease(home, release, progress) {
     await writeFile(tarball, bytes, { mode: 384 });
     const target = path.join(temporary, "app");
     await mkdir(target);
-    await execute("npm", ["install", "--prefix", target, "--ignore-scripts", "--omit=dev", "--no-audit", "--no-fund", "--registry", REGISTRY, tarball], { timeout: 18e4, maxBuffer: 2e6 });
+    await runServiceNpm(["install", "--prefix", target, "--ignore-scripts", "--omit=dev", "--no-audit", "--no-fund", "--registry", REGISTRY, tarball]);
     const pkgRoot = path.join(target, "node_modules/@opentig/cli");
     const pkg = JSON.parse(await readFile(path.join(pkgRoot, "package.json"), "utf8"));
     if (pkg.name !== "@opentig/cli" || pkg.version !== release.version) throw new Error("Installed CLI identity mismatch.");
@@ -1060,53 +1237,50 @@ async function stageCliRelease(home, release, progress) {
     await rm(temporary, { recursive: true, force: true });
   }
 }
-async function createServiceUpdater(home, version, profile, address) {
+async function createServiceUpdater(home, version2, profile, address) {
   let installation = null;
+  let manager = null;
   try {
-    if (profile === "production" && process.platform === "linux" && process.env.INVOCATION_ID) {
+    if (profile === "production") {
+      manager = await createServiceManager(home);
       installation = await readInstallation(home);
-      if (!installation || installation.version !== version || installation.host !== address.host || installation.port !== address.port || await systemctl("show", SERVICE_NAME, "--property=FragmentPath", "--value") !== serviceUnitPath() || await realpath(process.argv[1]) !== await realpath(path.join(packageDirectory(home, installation), "dist/bin.mjs")) || await systemctl("show", SERVICE_NAME, "--property=MainPID", "--value") !== String(process.pid)) installation = null;
+      if (installation) assertManager(installation, manager.kind);
+      const definition = await manager.read();
+      if (!installation || !definition || !manager.owns(definition) || installation.version !== version2 || installation.host !== address.host || installation.port !== address.port || await realpath(process.argv[1]) !== await realpath(path.join(packageDirectory(home, installation), "dist/bin.mjs")) || !await manager.ownsProcess()) installation = null;
     }
   } catch {
     installation = null;
   }
-  if (!installation) return new ServiceUpdater(version, null);
+  if (!installation || !manager) return new ServiceUpdater(version2, null);
+  const supervisor = manager;
   const current = installation;
   let failedUpdate = false;
   try {
     const result = JSON.parse(await readFile(path.join(home, "service/update-result.json"), "utf8"));
-    failedUpdate = result.success === false && result.version === version;
+    failedUpdate = result.success === false && result.version === version2;
   } catch {
   }
-  const updater = new ServiceUpdater(version, {
+  const updater = new ServiceUpdater(version2, {
     release: latestCliRelease,
     stage: (release, progress) => stageCliRelease(home, release, progress),
     install: async (release) => {
       const lock = path.join(home, "service/update-lock");
       await mkdir(lock, { mode: 448 });
-      const unit = `opentig-update-${randomUUID()}`;
+      let worker;
       try {
-        const next = { ...current, version: release.version, layout: "npm" };
-        const previousUnit = await readFile(serviceUnitPath(), "utf8");
+        const next = { ...current, manager: supervisor.kind, version: release.version, layout: "npm", environmentPath: process.env.PATH ?? current.environmentPath };
+        const previousUnit = await supervisor.read();
+        if (!previousUnit || !supervisor.owns(previousUnit)) throw new Error("Managed service definition changed.");
         await atomicWrite(path.join(lock, "plan.json"), JSON.stringify({ home, current, next, previousUnit, integrity: release.integrity }));
-        await execute("systemd-run", [
-          "--user",
-          "--collect",
-          "--unit",
-          unit,
-          "--property=Type=exec",
-          process.execPath,
-          path.join(packageDirectory(home, current), "dist/service-update.mjs"),
-          home
-        ], { timeout: 15e3 });
+        worker = await supervisor.launchWorker(process.execPath, path.join(packageDirectory(home, current), "dist/service-update.mjs"));
       } catch (error) {
         await rm(lock, { recursive: true, force: true });
         throw error;
       }
       for (let attempt = 0; attempt < 120; attempt++) {
         await setTimeout$1(1e3);
-        const state = await systemctl("show", unit, "--property=ActiveState", "--value").catch(() => "inactive");
-        if (!["active", "activating", "deactivating"].includes(state)) {
+        if (!await worker.running()) {
+          await worker.cleanup();
           await rm(lock, { recursive: true, force: true });
           throw new Error("Update worker exited without replacing the server.");
         }
@@ -1466,6 +1640,7 @@ function assertGitAvailable() {
 }
 export {
   CliUsageError as C,
+  OPEN_TIG_APP_VERSION as O,
   parseCliArguments as p,
   runCli as r
 };