@firstpick/pi-package-webui 0.2.0 → 0.2.2

package/README.md

@@ -1,115 +1,59 @@
 # @firstpick/pi-package-webui
 
-Local browser companion for [Pi coding agent](https://www.npmjs.com/package/@earendil-works/pi-coding-agent).
+Local browser UI for [Pi coding agent](https://www.npmjs.com/package/@earendil-works/pi-coding-agent).
 
 ![Pi Web UI main window showing multi-tab chat, controls, theme picker, and local status](https://unpkg.com/@firstpick/pi-package-webui/images/Main_Window_v0.1.7.png)
 
-This package provides:
+Pi Web UI gives you a local browser companion for Pi: multi-tab chat, streaming output, model controls, uploads, slash-command helpers, workspace navigation, and optional extension widgets.
 
-- `pi-webui`: a local HTTP/SSE server that starts `pi --mode rpc`, serves the static browser UI, and proxies browser actions to Pi RPC commands.
-- `/webui-start`: a Pi slash command that launches `pi-webui` for the current Pi working directory and opens the browser.
-- `/webui-status`: a Pi slash command that reports the Web UI URL, online state, network exposure, and optional detailed runtime info.
-- A no-build web app in `public/` with no runtime frontend dependencies.
-
-> **Security:** Pi Web UI has no authentication. It can control the spawned Pi session, including any tools Pi is allowed to run. It binds to `127.0.0.1` by default; do not expose it on untrusted networks.
+> **Security:** Pi Web UI has no authentication. It can control the spawned Pi session and run anything that session is allowed to run. It binds to `127.0.0.1` by default; only expose it on trusted networks.
 
 ## Requirements
 
 - Node.js `>=22.19.0`
-- Pi available through this package dependency or as `pi` on `PATH`
+- Pi installed and configured
 - A modern browser with Server-Sent Events support
 
-## Optional companion packages
-
-The Web UI declares its companion Pi packages as npm `optionalDependencies`. A normal npm/Pi install will install them, while minimal installs can skip them with npm's optional-dependency controls such as `npm install --omit=optional`.
-
-At startup, the browser checks loaded Pi capabilities directly through RPC-visible commands and live widget events; it does not inspect npm package folders. That means locally symlinked/dev packages and separately installed Pi packages work as long as their commands/widgets are loaded in the active Pi tab.
-
-The side panel shows each optional feature as enabled, disabled, or install-needed. Disabling a feature is Web UI-local and hides Web UI affordances/specialized renderers without uninstalling or unloading the underlying Pi package. Installing a missing feature is an explicit, warned action: the server runs npm install for the whitelisted package from localhost only, then prompts you to `/reload` the active Pi tab so newly installed resources can load.
-
-Optional companions:
-
-- `@firstpick/pi-prompts-git-pr` for the guided Git workflow's `/git-staged-msg` prompt.
-- `@firstpick/pi-extension-release-npm` and `@firstpick/pi-extension-release-aur` for Publish menu commands and live release widgets.
-- `@firstpick/pi-extension-todo-progress` for the specialized todo-progress widget.
-- `@firstpick/pi-extension-git-footer-status` and `@firstpick/pi-extension-stats` for richer Pi status/footer and stats commands.
-- `@firstpick/pi-themes-bundle` for theme resources used by the browser theme picker and Pi themes.
-
-## Quick start
+## Install
 
-Install the package from npm into Pi, then restart Pi so `/webui-start` and `/webui-status` are loaded:
+Install the package into Pi:
 
 ```bash
 pi install npm:@firstpick/pi-package-webui
 ```
 
-From inside terminal Pi:
-
-```text
-/webui-start
-```
+Restart Pi after installation so the Web UI commands are loaded.
 
-Open the printed URL, usually <http://127.0.0.1:31415/>. The command opens it automatically unless `--no-open` is passed. Check a running instance with `/webui-status` or `/webui-status detailed`.
+## Start from Pi
 
-For direct development from this package directory:
+Run this inside Pi:
 
-```bash
-node bin/pi-webui.mjs --cwd /path/to/project
+```text
+/webui-start
 ```
 
-Or use the helper script in dev mode. `--dev` bypasses any `pi-webui` on `PATH` and runs this checkout's `bin/pi-webui.mjs`:
-
-```bash
-./start-webui.sh --dev --cwd /path/to/project
-```
+Open the printed URL, usually <http://127.0.0.1:31415/>. The command opens your browser automatically unless you pass `--no-open`.
 
-After a global npm install:
+Check a running Web UI with:
 
-```bash
-npm install -g @firstpick/pi-package-webui
-pi-webui --cwd /path/to/project
+```text
+/webui-status
+/webui-status detailed
 ```
 
-## Features
-
-- Local browser chat over Pi RPC with isolated terminal tabs; each tab has its own `pi --mode rpc` subprocess, event stream, session state, prompt draft, cwd, and activity indicator.
-- Automatic tab naming from the first prompt on default-named tabs, plus `/name <title>` to manually sync the Pi session and browser tab name.
-- Live transcript with streamed assistant text/thinking, Markdown output, active-run status, tool/bash cards, queue/compaction events, jump-to-latest, sticky last-prompt navigation, and abort by button, Esc, or long press.
-- Prompt composer for prompts, steer/follow-up, busy-session behavior, model/thinking controls, manual compact/new session, uploads by button/drag/drop/paste, slash-command autocomplete, and `@` file/path references with live suggestions.
-- Browser-native selector dialogs for `/model`, `/settings`, `/theme`, `/fork`, `/clone`, `/resume`, `/tree`, and `/scoped-models`; `/login`/`/logout` show non-secret guidance instead of accepting credentials in the browser.
-- Native TUI parity tracking through `WEBUI_TUI_NATIVE_PARITY.json`, used as the source of truth for native command discovery and exposed at `GET /api/native-parity`.
-- Initial `/export` parity: `/export` creates an HTML browser download through a short-lived opaque token, while explicit new `.html`/`.jsonl` paths write server-side from localhost only.
-- Initial `!` / `!!` bash parity: leading `!cmd` runs queued RPC bash and includes output in the next LLM context; `!!cmd` runs with `excludeFromContext`; the active bash can be aborted from the Web UI.
-- Initial native shortcut parity for Ctrl/Cmd+L model selector, Ctrl/Cmd+P and Shift+Ctrl/Cmd+P model cycling, Shift+Tab thinking cycling, Ctrl/Cmd+T thinking visibility, Ctrl/Cmd+O tool/bash expansion, Alt+Enter follow-up, degraded Alt+Up queue restore, and Ctrl/Cmd+C prompt clear when no text is selected.
-- Session/workspace helpers for per-tab cwd changes, a clickable footer cwd picker with server-persisted fast picks, fork/clone/resume/tree navigation, and restart-safe restoration of currently open tabs.
-- Collapsible side-panel control deck for model/thinking/settings, optional features, Codex usage, session/queue/commands/events, local-network exposure, browser notifications, and Web UI themes/custom backgrounds.
-- Pi-style footer with token/cache/context/cost/speed telemetry, estimated Pi-context tokens, cwd/git/runtime/model/thinking metadata, and a scoped-model picker.
-- Optional companion management with capability-based enabled/disabled/install-needed status, localhost-only warned installs, Side-panel theme picker backed by optional `@firstpick/pi-themes-bundle` themes when loaded, guided Git commit/push workflow, NPM/AUR Publish menu, todo-progress rendering, and richer git/status/stats widgets.
-- Extension UI bridge for `notify`, `setStatus`, `setWidget`, `setTitle`, `set_editor_text`, `select`, `confirm`, `input`, and `editor`, with browser notifications when a tab needs an extension UI response and an optional side-panel toggle for agent-done notifications.
-- Feedback reactions (`👍`, `👎`, `?`) on final assistant output plus tool/bash action cards, with queued post-run submission that asks Pi to create/update a LEARNING.
-- Mobile/PWA support: installable app shell, service worker/icons, backend-offline recovery panel, touch-friendly composer/tabs/footer, and a static frontend with no bundler or frontend install step.
-
-## Mobile/PWA notes
-
-- The mobile composer starts as a one-line `Ask Pi…` input, grows with user-entered lines, and scrolls the transcript to the latest output when focused.
-- When Pi is idle, `Steer` and `Follow-up` live inside `Actions`; while a run is active, they move back into the main composer row for quick steering/follow-up.
-- PWA install support, blocked-tab browser notifications, and optional agent-done notifications require browser service-worker/notification support and usually HTTPS or `localhost`. Plain `http://<LAN-IP>` may show the app but may not offer install or notifications on Chrome/Safari.
-
-## Pi slash commands
+### `/webui-start` options
 
 ```text
 /webui-start [port] [options] [-- <pi args...>]
 ```
 
-Options:
-
 ```text
-  [port]             Positional port shortcut
+  [port]             Port shortcut
   --host <host>      HTTP bind host (default: 127.0.0.1)
   --port <port>      HTTP port (default: 31415)
   --no-open          Do not open the browser automatically
   --no-session       Start Pi RPC with --no-session
-  --name <name>      Initial Web UI tab display name
+  --name <name>      Initial Web UI tab name
   -- <pi args...>    Extra arguments forwarded to Pi RPC
 ```
 
@@ -122,33 +66,36 @@ Examples:
 /webui-start --name browser -- --model anthropic/claude-sonnet-4-5:high
 ```
 
-If a compatible Web UI is already running on the target URL, `/webui-start` captures its currently open terminal tabs, stops that instance, then starts a fresh server and reopens only those open tabs from their session files when available. Tabs you closed in the Web UI stay closed; use `/resume` if you want to reopen an older Pi session manually.
+Running `/webui-start` again on the same URL restarts the server and restores currently open Web UI tabs from their session files when possible.
 
-Status commands:
+### `/webui-status` options
 
 ```text
-/webui-status
-/webui-status detailed
-/webui-status detailed --port 31500
+/webui-status [detailed] [port] [--port N] [--host HOST]
 ```
 
-`/webui-status` reports the page URL, whether the server is online, and whether it is open to the local network. `detailed` adds Web UI/Pi PIDs, bind info, tabs, current session/model/thinking state, available providers, per-tab workspace/stats summaries, and recent backend events.
+`/webui-status` reports the URL, online state, and network exposure. `detailed` adds tabs, sessions, models/providers, and recent backend events.
 
-## CLI
+## Standalone CLI
+
+Use the CLI when you want to start the Web UI without first opening terminal Pi:
+
+```bash
+npm install -g @firstpick/pi-package-webui
+pi-webui --cwd ~/src/my-project
+```
 
 ```text
 pi-webui [options] [-- <pi args...>]
 ```
 
-Options:
-
 ```text
   --host <host>       HTTP bind host (default: 127.0.0.1)
   --port <port>       HTTP port (default: 31415)
   --cwd <path>        Default working directory for Pi tabs (default: current dir)
   --pi <command>      Pi executable to spawn (default: bundled dependency, then "pi")
   --no-session        Start Pi RPC with --no-session
-  --name <name>       Initial Web UI tab display name
+  --name <name>       Initial Web UI tab name
   -h, --help          Show help
   -v, --version       Print version
 ```
@@ -165,66 +112,63 @@ Environment variables:
 
 - `PI_WEBUI_HOST`
 - `PI_WEBUI_PORT`
-- `PI_WEBUI_PI_BIN` (same purpose as `--pi`)
+- `PI_WEBUI_PI_BIN`
 
-## Guided Git workflow
+## Main features
 
-The browser button runs a native local workflow in the Web UI server process:
+- Multi-tab Pi sessions with isolated processes, working directories, prompt drafts, and activity state.
+- Streaming chat transcript with Markdown, thinking output, tool/bash cards, queue and compaction events, and abort controls.
+- Prompt composer with uploads, drag/drop/paste, inline image support, slash-command autocomplete, and `@` file/path references.
+- Browser dialogs for common Pi selectors such as `/model`, `/settings`, `/theme`, `/fork`, `/clone`, `/resume`, `/tree`, and `/scoped-models`.
+- Model, thinking, session, workspace, theme, optional-feature, Codex usage, network, event, and notification controls in the side panel.
+- Per-tab cwd changes, a clickable footer cwd picker, saved path fast picks, and restart-safe restoration of open tabs.
+- Browser support for Pi extension UI prompts, widgets, status updates, and notifications.
+- Feedback reactions (`👍`, `👎`, `?`) on assistant output and action cards, which can ask Pi to create or update a LEARNING.
+- Mobile-friendly layout and PWA install support where the browser allows it.
 
-1. `git add .` in the active Pi working directory.
-2. Send `/git-staged-msg` to Pi.
-3. Read `dev/COMMIT/staged-commit-short.txt` and `dev/COMMIT/staged-commit-long.txt` from the git root.
-4. Commit with either the short message (`git commit -m ...`) or the long message (`git commit -F ...`).
-5. Run `git push`.
+## Optional companion features
 
-This workflow requires `/git-staged-msg` from `@firstpick/pi-prompts-git-pr`, which writes the two `dev/COMMIT/` files above. The Web UI enables the Git workflow button only when that command is loaded in the active Pi tab. If package resources are filtered or optional dependencies were omitted, make sure `/git-staged-msg` remains enabled. The workflow can be cancelled between steps; active native git commands are terminated on cancel where possible.
+A normal Pi/npm install includes the optional companion packages unless optional dependencies are disabled. If a feature is missing, the side panel shows it as install-needed. Installing from the side panel is localhost-only, limited to known packages, and requires reloading the active Pi tab after installation.
 
-## How it works
+Optional companions:
 
-`pi-webui` starts a Pi RPC subprocess for the initial browser terminal tab, and each additional Web UI tab starts another isolated subprocess:
+- `@firstpick/pi-prompts-git-pr` — guided Git commit/push workflow.
+- `@firstpick/pi-extension-release-npm` — NPM publish menu and release widgets.
+- `@firstpick/pi-extension-release-aur` — AUR publish menu and release widgets.
+- `@firstpick/pi-extension-todo-progress` — todo-progress rendering.
+- `@firstpick/pi-extension-git-footer-status` — richer git/footer status.
+- `@firstpick/pi-extension-stats` — stats commands and status data.
+- `@firstpick/pi-themes-bundle` — Web UI and Pi theme resources.
 
-```bash
-pi --mode rpc
-```
+## Guided Git workflow
 
-With options, each spawned command becomes:
+The Git workflow button runs local git commands in the active Pi working directory:
 
-```bash
-pi --mode rpc [--no-session] [...extra Pi args]
-```
+1. `git add .`
+2. Send `/git-staged-msg` to Pi
+3. Read the generated commit message files from `dev/COMMIT/`
+4. Commit with the selected message
+5. Run `git push`
 
-Web UI tab titles are stored in Web UI metadata instead of being forwarded as Pi CLI `--name` flags, so multiple tabs remain compatible with bundled Pi CLI versions that do not support session naming.
-
-The local server exposes:
-
-- static files from `public/`
-- `GET /api/tabs`, `POST /api/tabs`, `PATCH /api/tabs/:id`, and `DELETE /api/tabs/:id` for isolated Web UI terminal tabs and per-tab cwd changes; default-named tabs are auto-renamed from the first conversation prompt
-- `GET /api/directories?tab=<tabId>&path=<path>` for the browser cwd picker
-- `GET /api/path-suggestions?tab=<tabId>&query=<path>` for `@` file/path reference autocomplete in the prompt composer
-- `GET /api/path-fast-picks` and `POST /api/path-fast-picks` for cwd picker fast picks persisted across browser tabs, Pi terminal tabs, and Web UI server restarts
-- `POST /api/attachments` for browser-selected, pasted, or dropped files; files are stored under the OS temp directory and referenced in the prompt, while supported images can also be sent inline via RPC `images`
-- `GET /api/themes` for optional theme data from `@firstpick/pi-themes-bundle` when available
-- `GET /api/native-parity` for the machine-readable native TUI parity matrix that drives native command discovery
-- `GET /api/native-download/<token>` for short-lived opaque native command artifacts such as browser `/export` downloads
-- `GET /api/fork-messages`, `POST /api/fork`, `POST /api/clone`, `GET /api/sessions`, `POST /api/switch-session`, `GET /api/session-tree`, and `POST /api/tree-navigate` for browser-native native slash selectors
-- localhost-only `POST /api/optional-feature-install` for explicit, warned installation of whitelisted optional feature packages
-- `GET /api/network` and localhost-only `POST /api/network/open` for local-network exposure status/control
-- `GET /api/webui-status?detailed=1` for slash-command status reporting
-- `POST /api/shutdown` for localhost-only graceful restarts from `/webui-start`; restart captures detailed open-tab status first so currently open tabs can be restored with their session files
-- HTTP endpoints for prompt/session/model/thinking/compact/git actions; tab-scoped calls use `?tab=<tabId>`
-- `POST /api/bash?tab=<tabId>` and `POST /api/abort-bash?tab=<tabId>` for leading `!` / `!!` user bash parity with server-side one-active-per-tab FIFO queuing
-- `POST /api/model-cycle?tab=<tabId>` and `POST /api/thinking-cycle?tab=<tabId>` for native shortcut model/thinking cycling
-- `POST /api/action-feedback?tab=<tabId>` to turn queued action/final-output reactions into a Pi prompt that creates/updates a LEARNING after the run is idle
-- `/api/events?tab=<tabId>` as a per-tab Server-Sent Events stream for Pi RPC events
-- `/api/extension-ui-response?tab=<tabId>` for browser responses to extension UI prompts
-
-Pi stdout is read as JSONL and split only on `\n`, matching Pi RPC framing.
-
-## Network and safety notes
+This requires `/git-staged-msg` from `@firstpick/pi-prompts-git-pr`. Review the generated commit message before committing or pushing.
+
+## Mobile and PWA notes
+
+- The mobile composer starts as a compact `Ask Pi…` input and grows as you type.
+- Installable PWA support and notifications depend on browser support and usually require `localhost` or HTTPS.
+- Plain `http://<LAN-IP>` can show the app, but some browsers disable PWA install and notifications there.
+
+## Network safety
 
 - Default bind is localhost-only: `127.0.0.1:31415`.
-- The side-panel "Open to network" button rebinds the current server to `0.0.0.0`, shows LAN URLs when available, and toggles to "Close for network" to rebind back to localhost-only access.
-- `--host 0.0.0.0` also makes the UI reachable from the network and is unsafe unless the network is trusted.
-- The UI is intended as a local companion, not a hardened multi-user web service.
-- Browser actions can trigger Pi tools, shell commands, file edits, and git operations according to the spawned Pi session's permissions.
-- If the Web UI is exposed to a LAN, any connected browser client can use `!` / `!!` bash and the `/api/bash` endpoint to run shell commands as the Web UI process user.
+- The side-panel **Open to network** button rebinds the server to `0.0.0.0`, shows LAN URLs when available, and toggles to "Close for network".
+- `--host 0.0.0.0` also exposes the Web UI to the local network.
+- Any connected browser client can control Pi and run Web UI bash actions as the Web UI process user.
+- Treat Pi Web UI as a local companion, not a hardened multi-user web service.
+
+## Troubleshooting
+
+- **`/webui-start` is missing:** restart Pi after installing the package.
+- **Wrong port or existing server:** use `/webui-status detailed`, or start on another port with `/webui-start --port 31500`.
+- **Optional feature is disabled or missing:** check the side panel, install the companion package if needed, then run `/reload` in the active Pi tab.
+- **PWA install or notifications are unavailable:** use `localhost` or HTTPS; browser support varies on LAN HTTP URLs.

package/bin/pi-webui.mjs

@@ -17,6 +17,7 @@ const packageRoot = path.resolve(__dirname, "..");
 const publicDir = path.join(packageRoot, "public");
 const packageJson = JSON.parse(await readFile(path.join(packageRoot, "package.json"), "utf8"));
 const nativeParityMatrix = JSON.parse(await readFile(path.join(packageRoot, "WEBUI_TUI_NATIVE_PARITY.json"), "utf8"));
+const webuiDevServer = isTruthyEnv(process.env.PI_WEBUI_DEV) || isSourceCheckout(packageRoot);
 
 const DEFAULT_HOST = "127.0.0.1";
 const DEFAULT_PORT = 31415;
@@ -100,6 +101,15 @@ const MIME_TYPES = new Map([
   [".webmanifest", "application/manifest+json; charset=utf-8"],
 ]);
 
+function isTruthyEnv(value) {
+  return ["1", "true", "yes", "dev"].includes(String(value || "").trim().toLowerCase());
+}
+
+function isSourceCheckout(root) {
+  const normalized = String(root || "").replace(/\\/g, "/");
+  return normalized.includes("/npm-packages/") && !normalized.includes("/node_modules/");
+}
+
 function nativeParitySurfaces(matrix = nativeParityMatrix) {
   return Array.isArray(matrix?.surfaces) ? matrix.surfaces : [];
 }
@@ -2004,6 +2014,12 @@ if (options.version) {
   process.exit(0);
 }
 
+const startupDelayMs = Number.parseInt(process.env.PI_WEBUI_START_DELAY_MS || "", 10);
+delete process.env.PI_WEBUI_START_DELAY_MS;
+if (Number.isFinite(startupDelayMs) && startupDelayMs > 0) {
+  await delay(Math.min(startupDelayMs, 10_000));
+}
+
 const restoreTabs = readRestoreTabsFromEnv();
 
 function normalizedRestoreString(value, maxLength) {
@@ -2547,6 +2563,33 @@ function mergeRestorableTabDescriptors(...sources) {
     .slice(0, RESTORE_TAB_LIMIT);
 }
 
+async function restorableTabsForRestart() {
+  const liveDescriptors = await Promise.all([...tabs.values()].map(async (tab) => {
+    const state = await currentSessionState(tab).catch(() => tab.lastState || null);
+    return restorableTabDescriptor(tab, state);
+  }));
+  return mergeRestorableTabDescriptors(liveDescriptors, closedRestorableTabs);
+}
+
+function spawnRestartServer(restorableTabs) {
+  const env = {
+    ...process.env,
+    PI_WEBUI_RESTORE_TABS: JSON.stringify(restorableTabs || []),
+    PI_WEBUI_START_DELAY_MS: "1200",
+  };
+  if (webuiDevServer) env.PI_WEBUI_DEV = "1";
+  else delete env.PI_WEBUI_DEV;
+  const child = spawn(process.execPath, process.argv.slice(1), {
+    cwd: process.cwd(),
+    env,
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+  });
+  child.unref();
+  return child;
+}
+
 function rememberClosedRestorableTab(tab, state = null) {
   const descriptor = restorableTabDescriptor(tab, state);
   if (!descriptor) return;
@@ -3461,6 +3504,8 @@ async function webuiStatus({ detailed = false, eventLimit = 40 } = {}) {
   const data = {
     online: true,
     webuiVersion: packageJson.version,
+    webuiDev: webuiDevServer,
+    webuiMode: webuiDevServer ? "dev" : "production",
     webuiPid: process.pid,
     startedAt: serverStartedAt,
     cwd: options.cwd,
@@ -3537,6 +3582,8 @@ const server = createServer(async (req, res) => {
       sendSse(res, {
         type: "webui_connected",
         version: packageJson.version,
+        webuiDev: webuiDevServer,
+        webuiMode: webuiDevServer ? "dev" : "production",
         tabId: tab.id,
         tabTitle: tab.title,
         pid: tab.rpc.child?.pid,
@@ -3559,6 +3606,8 @@ const server = createServer(async (req, res) => {
       sendJson(res, 200, {
         ok: true,
         webuiVersion: status.webuiVersion,
+        webuiDev: status.webuiDev,
+        webuiMode: status.webuiMode,
         webuiPid: status.webuiPid,
         piPid: status.piPid,
         piRunning: status.piRunning,
@@ -3629,6 +3678,15 @@ const server = createServer(async (req, res) => {
       return;
     }
 
+    if (url.pathname === "/api/restart" && req.method === "POST") {
+      if (!isLocalAddress(req.socket.remoteAddress)) throw makeHttpError(403, "Restart is only allowed from localhost");
+      const restorableTabs = await restorableTabsForRestart();
+      const child = spawnRestartServer(restorableTabs);
+      sendJson(res, 200, { ok: true, message: "Pi Web UI restarting", webuiPid: process.pid, nextWebuiPid: child.pid, restorableTabCount: restorableTabs.length });
+      setTimeout(() => shutdown("api restart"), 20).unref();
+      return;
+    }
+
     if (url.pathname === "/api/shutdown" && req.method === "POST") {
       if (!isLocalAddress(req.socket.remoteAddress)) throw makeHttpError(403, "Shutdown is only allowed from localhost");
       sendJson(res, 200, { ok: true, message: "Pi Web UI shutting down", webuiPid: process.pid });
@@ -3879,7 +3937,15 @@ server.listen(options.port, currentHost, () => {
 
 function shutdown(signal) {
   console.log(`\n${signal}: shutting down Pi Web UI...`);
-  server.close(() => process.exit(0));
+  const forceCloseTimer = setTimeout(() => {
+    server.closeAllConnections?.();
+  }, NETWORK_REBIND_FORCE_CLOSE_MS);
+  forceCloseTimer.unref?.();
+  server.close(() => {
+    clearTimeout(forceCloseTimer);
+    process.exit(0);
+  });
+  server.closeIdleConnections?.();
   for (const tab of tabs.values()) tab.rpc.stop();
   setTimeout(() => process.exit(0), 4000).unref();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firstpick/pi-package-webui",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Pi Web UI companion package with a local browser UI CLI plus /webui-start and /webui-status commands.",
   "license": "MIT",
   "type": "module",