@firstpick/pi-package-webui 0.4.7 → 0.4.8

package/README.md

@@ -6,7 +6,7 @@ Local browser UI for [Pi coding agent](https://www.npmjs.com/package/@earendil-w
 
 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.
 
-> **Security:** Pi Web UI can control the spawned Pi session and run anything that session is allowed to run. It binds to `127.0.0.1` by default. Remote PIN authentication is off by default on first use; enabling it in **Controls → Network → Remote PIN auth** persists that preference for later Web UI starts.
+> **Security:** Pi Web UI can control the spawned Pi session and run anything that session is allowed to run. It binds to `127.0.0.1` by default. Trusted-LAN opening/closing and Remote PIN auth controls are owned by the optional `@firstpick/pi-package-remote-webui` companion; when enabled, Remote PIN auth persists for later Web UI starts.
 
 ## Requirements
 
@@ -134,13 +134,13 @@ Environment variables:
 - Streaming chat transcript with Markdown, thinking output, tool/bash cards, queue and compaction events, edit-and-retry from user prompts, and guarded abort controls that require holding Esc or the Abort button for 3 seconds.
 - Prompt composer with uploads, drag/drop/paste, inline image support, slash-command autocomplete, and `@` file/path references with live suggestions.
 - Browser dialogs for common Pi selectors such as `/model`, `/settings`, `/theme`, `/fork`, `/clone`, `/resume`, `/tree`, `/scoped-models`, `/tools`, and `/skills`.
-- Model, thinking, session, workspace, theme, optional-feature, Codex usage, network, update/restart, event, and notification controls in the side panel.
+- Model, thinking, session, workspace, theme, optional-feature, Codex usage, optional Remote WebUI, update/restart, event, and notification controls in the side panel.
 - Persistent context-window meter with manual compact and auto-compaction controls near the composer.
 - Side-panel theme picker backed by optional `@firstpick/pi-themes-bundle` themes when loaded.
 - Per-tab cwd changes, a clickable footer cwd picker, saved path fast picks, server-persisted fast picks, and restart-safe restoration of open tabs.
 - Detected app runner dropdown for the active tab cwd, including Cargo, Bun, npm/npx/pnpm, Python/uv, Go/Golang, Zig, C/C++, Docker Compose, root/dev/scripts shell scripts, and other common project runners with live output pinned at the top of the terminal. Projects can add browseable custom runners in `.pi-webui-runners.json` with a command (default `./`) plus a relative path to the file to run.
 - Browser support for Pi extension UI prompts, widgets, status updates, `/btw` side-question output widgets with optional context transfer/live steering, browser notifications when a tab needs an extension UI response, and an optional side-panel toggle for agent-done notifications.
-- Localhost-only Pi/Web UI update checks with a top-right update notification and a confirmed **Update & restart** action that runs `pi update` plus all detected local/global Web UI and Pi package-manager updates, then restarts the Web UI server.
+- Localhost-only Pi/Web UI update checks with a top-right update notification and confirmed restart actions: **Update Pi & restart** runs `pi update` for Pi-only updates, while **Update Pi + Packages & Restart** runs `pi update --all` for Pi plus configured packages.
 - Feedback reactions (`👍`, `👎`, `?`) on final assistant output plus tool/bash action cards, which can ask Pi to create or update a LEARNING.
 - Mobile-friendly layout and PWA install support where the browser allows it.
 
@@ -150,7 +150,7 @@ Useful browser endpoints exposed by the local server include:
 - `POST /api/action-feedback?tab=<tabId>` for feedback on final assistant output and action cards.
 - `GET /api/optional-features` for optional companion package install/update status.
 - `POST /api/optional-feature-install` for installing or updating known optional companion packages from the side panel.
-- `GET /api/update-status` and localhost-only `POST /api/update` for checking Pi/Web UI updates and running `pi update` plus all detected local/global Web UI and Pi package-manager updates followed by a Web UI server restart.
+- `GET /api/update-status` and localhost-only `POST /api/update` for checking Pi/Web UI updates and running `pi update` followed by a Web UI server restart. Use `POST /api/update?all=1` to run `pi update --all` for Pi plus configured packages.
 - `GET /api/remote-auth`, `POST /api/remote-auth`, and localhost-only `POST /api/remote-auth/settings` for optional 4-digit PIN authentication when serving non-local browser clients.
 
 For local development, run the checkout helper directly, for example:
@@ -178,7 +178,7 @@ Optional companions:
 - `@firstpick/pi-extension-setup-skills` — TUI `/skills` setup command alongside WebUI-native skill toggles.
 - `@firstpick/pi-extension-todo-progress` — todo-progress rendering.
 - `@firstpick/pi-extension-tools` — TUI `/tools` active-tool manager alongside WebUI-native tool toggles.
-- `@firstpick/pi-package-remote-webui` — `/remote` trusted-LAN QR helper for connecting mobile browsers to Web UI.
+- `@firstpick/pi-package-remote-webui` — `/remote` trusted-LAN QR helper plus the optional browser controls for opening/closing LAN access and Remote PIN auth.
 - `@firstpick/pi-extension-git-footer-status` — richer extension-owned git/footer status, including the structured Web UI footer payload.
 - `@firstpick/pi-extension-stats` — stats commands and status data.
 - `@firstpick/pi-themes-bundle` — Web UI and Pi theme resources.
@@ -208,9 +208,9 @@ This requires `/git-staged-msg` and `/pr` from `@firstpick/pi-prompts-git-pr`; b
 ## Network safety
 
 - Default bind is localhost-only: `127.0.0.1:31415`.
-- 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".
-- The side-panel **Remote PIN auth** toggle is off by default on first use. When enabled, the server saves that preference, generates a fresh random 4-digit PIN for each server start, shows it in Controls and `/webui-status`, and requires it from non-local browser clients.
-- Localhost clients stay frictionless and can toggle Remote PIN auth; changing the toggle persists the preference and disconnects existing event streams so remote clients must re-authenticate after enablement.
+- When `@firstpick/pi-package-remote-webui` is loaded and enabled, the side-panel **Remote WebUI** controls dispatch through `/remote`: opening rebinds the server to `0.0.0.0`, shows LAN URLs when available, and toggles to "Close for network".
+- The optional **Remote PIN auth** toggle is off by default on first use. When enabled through `/remote auth on` or the Remote WebUI controls, the server saves that preference, generates a fresh random 4-digit PIN for each server start, shows it in the Remote WebUI controls and `/webui-status`, and requires it from non-local browser clients.
+- Localhost clients stay frictionless and can toggle Remote PIN auth through the remote companion; changing the toggle persists the preference and disconnects existing event streams so remote clients must re-authenticate after enablement.
 - `--host 0.0.0.0` also exposes the Web UI to the local network; pass `--remote-auth` to start with PIN auth already enabled.
 - Any connected browser client with access (and the PIN, if enabled) can control Pi and run Web UI bash actions as the Web UI process user.
 - Remote PIN auth is a simple trusted-LAN HTTP gate, not hardened multi-user authentication; do not expose it to untrusted networks.
@@ -222,5 +222,5 @@ This requires `/git-staged-msg` and `/pr` from `@firstpick/pi-prompts-git-pr`; b
 - **`/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.
-- **Remote browser asks for a PIN:** read it from **Controls → Network → Remote PIN auth**, `/webui-status`, or the local Web UI server log. Disable the toggle from localhost to remove the PIN gate.
+- **Remote browser asks for a PIN:** read it from the optional **Remote WebUI** side-panel controls, `/webui-status`, `/remote status`, or the local Web UI server log. Disable the toggle from localhost to remove the PIN gate.
 - **PWA install or notifications are unavailable:** use `localhost` or HTTPS; browser support varies on LAN HTTP URLs.

package/bin/pi-webui.mjs

@@ -3155,40 +3155,43 @@ async function runGitReadCommand(root, args, { timeoutMs = GIT_CHANGES_COMMAND_T
   throw new Error(String(message).trim());
 }
 
-function gitBranchFromStatus(statusText) {
-  const branchLine = String(statusText || "").split(/\r?\n/).find((line) => line.startsWith("## ")) || "";
-  return branchLine.slice(3).trim().replace(/\.\.\..*$/, "") || "detached";
+function gitBranchFromPorcelainStatus(statusText) {
+  for (const line of String(statusText || "").split(/\r?\n/)) {
+    if (!line.startsWith("# branch.head ")) continue;
+    const branch = line.slice("# branch.head ".length).trim();
+    return branch && branch !== "(detached)" ? branch : "detached";
+  }
+  return "detached";
 }
 
-function gitDivergenceFromBranchStatus(line) {
-  const details = String(line || "").match(/\[(.+)\]\s*$/)?.[1] || "";
-  const ahead = Number.parseInt(details.match(/ahead\s+(\d+)/i)?.[1] || "0", 10) || 0;
-  const behind = Number.parseInt(details.match(/behind\s+(\d+)/i)?.[1] || "0", 10) || 0;
-  return { ahead, behind };
+function addGitPorcelainTrackedSummary(summary, xy) {
+  const x = xy?.[0] || ".";
+  const y = xy?.[1] || ".";
+  if (x !== ".") summary.staged += 1;
+  if (y !== ".") summary.unstaged += 1;
 }
 
-function summarizeGitShortStatus(statusText) {
+function summarizeGitPorcelainStatus(statusText) {
   const summary = { staged: 0, unstaged: 0, untracked: 0, conflicted: 0, ahead: 0, behind: 0 };
   for (const line of String(statusText || "").split(/\r?\n/)) {
     if (!line) continue;
-    if (line.startsWith("## ")) {
-      const divergence = gitDivergenceFromBranchStatus(line);
-      summary.ahead = divergence.ahead;
-      summary.behind = divergence.behind;
+    if (line.startsWith("# branch.ab ")) {
+      const match = line.match(/\+(\d+)\s+-(\d+)/);
+      if (match) {
+        summary.ahead = Number.parseInt(match[1] || "0", 10) || 0;
+        summary.behind = Number.parseInt(match[2] || "0", 10) || 0;
+      }
       continue;
     }
-    const x = line[0] || " ";
-    const y = line[1] || " ";
-    if (x === "?" && y === "?") {
-      summary.untracked += 1;
+    if (line.startsWith("1 ") || line.startsWith("2 ")) {
+      addGitPorcelainTrackedSummary(summary, line.split(" ")[1] || "..");
       continue;
     }
-    if (x === "U" || y === "U" || (x === "A" && y === "A") || (x === "D" && y === "D")) {
+    if (line.startsWith("u ")) {
       summary.conflicted += 1;
       continue;
     }
-    if (x && x !== " ") summary.staged += 1;
-    if (y && y !== " ") summary.unstaged += 1;
+    if (line.startsWith("? ")) summary.untracked += 1;
   }
   return summary;
 }
@@ -3293,20 +3296,21 @@ async function pullGitChanges(cwd) {
 async function readGitChanges(cwd) {
   const root = await getGitRoot(cwd);
   const diffArgs = ["diff", "--no-ext-diff", "--no-color", "--find-renames", "--unified=0", "--src-prefix=a/", "--dst-prefix=b/"];
-  const [statusText, unstagedDiff, stagedDiff, untrackedText] = await Promise.all([
+  const [statusText, porcelainStatusText, unstagedDiff, stagedDiff, untrackedText] = await Promise.all([
     runGitReadCommand(root, ["status", "--short", "--branch", "--untracked-files=all"], { maxOutputLength: 120_000 }),
+    runGitReadCommand(root, ["status", "--porcelain=2", "--branch", "--untracked-files=all"], { maxOutputLength: 120_000 }),
     runGitReadCommand(root, diffArgs),
     runGitReadCommand(root, ["diff", "--cached", "--no-ext-diff", "--no-color", "--find-renames", "--unified=0", "--src-prefix=a/", "--dst-prefix=b/"]),
     runGitReadCommand(root, ["ls-files", "--others", "--exclude-standard"], { maxOutputLength: 120_000 }),
   ]);
-  const summary = summarizeGitShortStatus(statusText);
+  const summary = summarizeGitPorcelainStatus(porcelainStatusText);
   const incoming = await readGitIncomingChanges(root, summary);
   const untrackedFiles = untrackedText.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
   const untracked = await readGitUntrackedEntries(root, untrackedFiles);
   return {
     cwd,
     root,
-    branch: gitBranchFromStatus(statusText),
+    branch: gitBranchFromPorcelainStatus(porcelainStatusText),
     generatedAt: new Date().toISOString(),
     summary,
     remote: incoming.remote,
@@ -4276,6 +4280,9 @@ try {
   process.exit(2);
 }
 
+process.env.PI_WEBUI_HOST = options.host;
+process.env.PI_WEBUI_PORT = String(options.port);
+
 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) {
@@ -5198,32 +5205,35 @@ async function getUpdateStatus({ force = false } = {}) {
     checkedAt: new Date(now).toISOString(),
     updateAvailable,
     restartRequired: true,
-    command: "pi update + Web UI/Pi package-manager updates",
+    command: "pi update",
+    allCommand: "pi update --all",
     webuiDev: webuiDevServer,
     pi: piStatus,
     webui: webuiStatus,
     packages: {
       checked: false,
-      note: "Update runs pi update plus all detected local, Pi-agent, npm-global, and Bun-global Web UI/Pi package roots."
+      note: "Default update runs pi update for Pi only. Use update all to run pi update --all for Pi and configured packages."
     },
   };
   updateStatusCacheAt = now;
   return updateStatusCache;
 }
 
-async function resolvePiUpdateCommand() {
+async function resolvePiUpdateCommand({ all = false } = {}) {
+  const updateArgs = all ? ["update", "--all"] : ["update"];
+  const label = all ? "Pi CLI and configured packages" : "Pi CLI";
   if (options.piBinExplicit) {
-    const command = await resolvePiCommand(["update"]);
-    return { ...command, label: "Pi CLI and configured packages" };
+    const command = await resolvePiCommand(updateArgs);
+    return { ...command, label, timeoutMs: PI_UPDATE_TIMEOUT_MS, maxOutputLength: PI_UPDATE_OUTPUT_MAX_CHARS };
   }
 
   const pathPi = await runCommand(options.piBin, ["--version"], { timeoutMs: 3000, maxOutputLength: 4000 });
   if (pathPi.exitCode === 0 && !pathPi.timedOut && !pathPi.error) {
-    return { label: "Pi CLI and configured packages", command: options.piBin, args: ["update"], displayCommand: formatCommandForDisplay(options.piBin, ["update"]) };
+    return { label, command: options.piBin, args: updateArgs, displayCommand: formatCommandForDisplay(options.piBin, updateArgs), timeoutMs: PI_UPDATE_TIMEOUT_MS, maxOutputLength: PI_UPDATE_OUTPUT_MAX_CHARS };
   }
 
-  const fallback = await resolvePiCommand(["update"]);
-  return { ...fallback, label: "bundled Pi CLI and configured packages" };
+  const fallback = await resolvePiCommand(updateArgs);
+  return { ...fallback, label: `bundled ${label}`, timeoutMs: PI_UPDATE_TIMEOUT_MS, maxOutputLength: PI_UPDATE_OUTPUT_MAX_CHARS };
 }
 
 function packageNodeModulesPath(nodeModulesRoot, packageName) {
@@ -5398,13 +5408,9 @@ function uniqueUpdateTasks(tasks) {
   return unique;
 }
 
-async function resolveUpdateTasks() {
+async function resolveUpdateTasks({ all = false } = {}) {
   return uniqueUpdateTasks([
-    await resolvePiUpdateCommand(),
-    await currentWebuiPackageUpdateTask(),
-    await agentPackageRootUpdateTask(),
-    await npmGlobalPackageRootUpdateTask(),
-    await bunGlobalPackageRootUpdateTask(),
+    await resolvePiUpdateCommand({ all }),
   ]);
 }
 
@@ -5445,16 +5451,17 @@ function combinedUpdateOutput(results, field) {
     .join("\n\n");
 }
 
-async function runPiUpdateAndPrepareRestart() {
+async function runPiUpdateAndPrepareRestart({ all = false } = {}) {
   if (piUpdateInProgress) throw makeHttpError(409, "A Pi update is already running.");
   piUpdateInProgress = true;
   let restartPrepared = false;
   try {
     const restorableTabs = await restorableTabsForRestart();
-    const updateTasks = await resolveUpdateTasks();
-    if (!updateTasks.length) throw makeHttpError(500, "No Pi/Web UI update commands could be resolved.");
+    const updateTasks = await resolveUpdateTasks({ all });
+    if (!updateTasks.length) throw makeHttpError(500, "No Pi update command could be resolved.");
     const command = updateTasks.map(updateTaskDisplay).join(" && ");
-    recordEvent({ type: "webui_update_started", command, restorableTabCount: restorableTabs.length });
+    const updateLabel = all ? "Pi and package updates" : "Pi update";
+    recordEvent({ type: "webui_update_started", command, updateAll: all, restorableTabCount: restorableTabs.length });
     const results = [];
     for (const task of updateTasks) results.push(await runUpdateTask(task));
 
@@ -5462,9 +5469,9 @@ async function runPiUpdateAndPrepareRestart() {
     updateStatusCacheAt = 0;
     const child = spawnRestartServer(restorableTabs);
     restartPrepared = true;
-    recordEvent({ type: "webui_update_restarting", command, nextWebuiPid: child.pid, restorableTabCount: restorableTabs.length });
+    recordEvent({ type: "webui_update_restarting", command, updateAll: all, nextWebuiPid: child.pid, restorableTabCount: restorableTabs.length });
     return {
-      message: "Pi/Web UI package updates completed. Pi Web UI is restarting.",
+      message: `${updateLabel} completed. Pi Web UI is restarting.`,
       command,
       commands: results.map((result) => ({ label: result.label, command: result.command })),
       stdout: combinedUpdateOutput(results, "stdout"),
@@ -7354,7 +7361,10 @@ const server = createServer(async (req, res) => {
 
     if (url.pathname === "/api/update" && req.method === "POST") {
       requireLocalhostRoute(req, url.pathname);
-      const data = await runPiUpdateAndPrepareRestart();
+      const body = await readJsonBody(req);
+      const queryAll = ["1", "true", "yes", "all"].includes(String(url.searchParams.get("all") || "").toLowerCase());
+      const bodyAll = body?.all === true || String(body?.mode || "").toLowerCase() === "all";
+      const data = await runPiUpdateAndPrepareRestart({ all: queryAll || bodyAll });
       sendJson(res, 200, { ok: true, data });
       setTimeout(() => shutdown("api update"), 20).unref();
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firstpick/pi-package-webui",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "description": "Pi Web UI companion package with a local browser UI CLI plus /webui-start and /webui-status commands.",
   "license": "MIT",
   "homepage": "https://github.com/Firstp1ck/npm-packages/tree/main/pi-package-webui#readme",

package/public/app.js

@@ -24,6 +24,7 @@ const elements = {
   updateNotificationMessage: $("#updateNotificationMessage"),
   updateNotificationDetail: $("#updateNotificationDetail"),
   updateNotificationUpdateButton: $("#updateNotificationUpdateButton"),
+  updateNotificationUpdateAllButton: $("#updateNotificationUpdateAllButton"),
   updateNotificationDismissButton: $("#updateNotificationDismissButton"),
   serverOfflineCommand: $("#serverOfflineCommand"),
   serverOfflineSlashCommand: $("#serverOfflineSlashCommand"),
@@ -129,6 +130,7 @@ const elements = {
   backgroundChooseButton: $("#backgroundChooseButton"),
   backgroundClearButton: $("#backgroundClearButton"),
   backgroundStatus: $("#backgroundStatus"),
+  networkControlField: $("#networkControlField"),
   networkStatus: $("#networkStatus"),
   remoteAuthToggle: $("#remoteAuthToggle"),
   remoteAuthStatus: $("#remoteAuthStatus"),
@@ -436,6 +438,9 @@ const GIT_INIT_STACK_STORAGE_KEY = "pi-webui-git-init-stack";
 const STATS_WEBUI_STATUS_KEY = "stats-webui";
 const STATS_WEBUI_PAYLOAD_TYPE = "firstpick.pi-extension-stats.overlay";
 const STATS_WEBUI_PAYLOAD_VERSION = 1;
+const REMOTE_WEBUI_CONTROLS_STATUS_KEY = "pi-remote-webui:controls";
+const REMOTE_WEBUI_CONTROLS_PAYLOAD_TYPE = "firstpick.pi-package-remote-webui.controls";
+const REMOTE_WEBUI_CONTROLS_PAYLOAD_VERSION = 1;
 const BTW_WEBUI_STATUS_KEY = "btw-webui";
 const BTW_OUTPUT_WIDGET_KEY = "btw:output";
 const BTW_FOOTER_WIDGET_KEY = "btw:footer";
@@ -2825,22 +2830,34 @@ function renderUpdateNotification(status = latestUpdateStatus, { force = false }
   }
 
   const canRunUpdate = latestUpdateStatus.canRunUpdate !== false;
+  const hasPiUpdate = !!latestUpdateStatus.pi?.updateAvailable;
+  const hasPackageUpdate = !!latestUpdateStatus.webui?.updateAvailable;
   if (elements.updateNotificationTitle) elements.updateNotificationTitle.textContent = items.length === 1 ? `${items[0]} available` : "Pi updates available";
   if (elements.updateNotificationMessage) {
-    elements.updateNotificationMessage.textContent = canRunUpdate
-      ? "Run Pi and Web UI package updates now, then restart this Web UI server automatically."
-      : "Updates are available. Direct Web UI updates are only enabled from localhost on the host machine.";
+    let message = "Updates are available. Direct Web UI updates are only enabled from localhost on the host machine.";
+    if (canRunUpdate) {
+      if (hasPiUpdate && hasPackageUpdate) message = "Run pi update for Pi only, or pi update --all to include Web UI/package updates, then restart this Web UI server automatically.";
+      else if (hasPackageUpdate) message = "Run pi update --all to update Web UI/package entries, then restart this Web UI server automatically.";
+      else message = "Run pi update for Pi only, then restart this Web UI server automatically.";
+    }
+    elements.updateNotificationMessage.textContent = message;
   }
   const details = [
     items.join(" · "),
-    latestUpdateStatus.webuiDev && latestUpdateStatus.webui?.updateAvailable ? "The current Web UI is a dev checkout; update also refreshes this checkout's Web UI/Pi package dependencies when possible." : "",
+    latestUpdateStatus.webuiDev && latestUpdateStatus.webui?.updateAvailable ? "The current Web UI is a dev checkout; pi update --all refreshes configured package dependencies when possible." : "",
     latestUpdateStatus.packages?.note || "",
   ].filter(Boolean).join(" ");
   if (elements.updateNotificationDetail) elements.updateNotificationDetail.textContent = details;
   if (elements.updateNotificationUpdateButton) {
-    elements.updateNotificationUpdateButton.hidden = !canRunUpdate;
+    elements.updateNotificationUpdateButton.hidden = !canRunUpdate || !hasPiUpdate;
     elements.updateNotificationUpdateButton.disabled = updateRequestInProgress || latestUpdateStatus.updateInProgress;
-    elements.updateNotificationUpdateButton.textContent = latestUpdateStatus.updateInProgress ? "Updating…" : "Update & restart";
+    elements.updateNotificationUpdateButton.textContent = latestUpdateStatus.updateInProgress ? "Updating…" : "Update Pi & restart";
+  }
+  if (elements.updateNotificationUpdateAllButton) {
+    elements.updateNotificationUpdateAllButton.hidden = !canRunUpdate || !hasPackageUpdate;
+    elements.updateNotificationUpdateAllButton.disabled = updateRequestInProgress || latestUpdateStatus.updateInProgress;
+    elements.updateNotificationUpdateAllButton.classList.toggle("primary", !hasPiUpdate);
+    elements.updateNotificationUpdateAllButton.textContent = latestUpdateStatus.updateInProgress ? "Updating…" : "Update all & restart";
   }
   clearTimeout(updateNotificationHideTimer);
   panel.hidden = false;
@@ -2871,30 +2888,33 @@ function initializeUpdateNotifications() {
   }, UPDATE_STATUS_INITIAL_DELAY_MS);
 }
 
-function piUpdateConfirmationText() {
+function piUpdateConfirmationText({ all = false } = {}) {
   const items = updateNotificationItems();
   const workingWarning = hasWorkingTab() ? "\n\nOne or more Pi tabs look busy or blocked. Finish or abort in-flight work before updating if you need to preserve it." : "";
   const versionText = items.length ? `\n\nDetected update: ${items.join(" · ")}.` : "";
-  return `Run Pi/Web UI package updates now?${versionText}\n\nThis will run \"pi update\" plus detected local and global Web UI/Pi package-manager updates on the Web UI host. After it finishes, Pi Web UI will restart itself. Browser clients will briefly disconnect, and managed Pi tabs/RPC processes will be restarted from saved session state when possible.${workingWarning}`;
+  const command = all ? "pi update --all" : "pi update";
+  const scope = all ? "Pi and configured package updates" : "Pi only";
+  return `Run ${scope} now?${versionText}\n\nThis will run \"${command}\" on the Web UI host. After it finishes, Pi Web UI will restart itself. Browser clients will briefly disconnect, and managed Pi tabs/RPC processes will be restarted from saved session state when possible.${workingWarning}`;
 }
 
-async function runPiUpdateAndRestart() {
+async function runPiUpdateAndRestart({ all = false } = {}) {
   if (updateRequestInProgress) return;
   if (latestUpdateStatus?.canRunUpdate === false) {
-    addEvent("Pi/Web UI package updates can only be started from localhost on the Web UI host", "warn");
+    addEvent("Pi updates can only be started from localhost on the Web UI host", "warn");
     renderUpdateNotification(latestUpdateStatus, { force: true });
     return;
   }
-  if (!confirm(piUpdateConfirmationText())) return;
+  if (!confirm(piUpdateConfirmationText({ all }))) return;
 
+  const updateLabel = all ? "Pi and package updates" : "Pi update";
   updateRequestInProgress = true;
   hideUpdateNotification();
   setServerActionBusy("Updating…");
-  setServerActionStatus("Running Pi/Web UI package updates. The server will restart after the update completes…", "warn");
-  setServerRestartOverlay(true, "Running Pi/Web UI package updates. The server will restart after the update completes…");
+  setServerActionStatus(`Running ${updateLabel}. The server will restart after the update completes…`, "warn");
+  setServerRestartOverlay(true, `Running ${updateLabel}. The server will restart after the update completes…`);
   try {
-    await api("/api/update", { method: "POST", scoped: false });
-    addEvent("Pi/Web UI package updates completed; Pi Web UI server restart requested", "warn");
+    await api(all ? "/api/update?all=1" : "/api/update", { method: "POST", scoped: false });
+    addEvent(`${updateLabel} completed; Pi Web UI server restart requested`, "warn");
   } catch (error) {
     if (!error?.backendOffline) {
       updateRequestInProgress = false;
@@ -3811,6 +3831,11 @@ function setOptionalFeatureDisabled(featureId, disabled) {
     btwWidgetComposerOpen = false;
     btwWidgetInputDraft = "";
   }
+  if (featureId === "remoteWebui") {
+    statusEntries.delete(REMOTE_WEBUI_CONTROLS_STATUS_KEY);
+    statusEntries.delete("pi-remote-webui");
+    widgets.delete("pi-remote-webui");
+  }
   storeDisabledOptionalFeatures();
   renderOptionalFeatureDependentDisplays();
   const tabContext = activeTabContext();
@@ -5978,6 +6003,57 @@ function parseGitFooterWebuiPayloadRaw(raw) {
   }
 }
 
+function parseRemoteWebuiControlsPayloadRaw(raw) {
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || parsed.type !== REMOTE_WEBUI_CONTROLS_PAYLOAD_TYPE || parsed.version !== REMOTE_WEBUI_CONTROLS_PAYLOAD_VERSION) return null;
+    if (parsed.featureId !== "remoteWebui") return null;
+    const commands = parsed.commands && typeof parsed.commands === "object" ? parsed.commands : {};
+    return {
+      title: cleanFooterPayloadText(parsed.title, "Remote WebUI", 80),
+      description: cleanFooterPayloadText(parsed.description, "Trusted-LAN browser access controlled by the Remote WebUI package.", 240),
+      commands: {
+        open: typeof commands.open === "string" ? commands.open : "/remote",
+        close: typeof commands.close === "string" ? commands.close : "/remote close",
+        refresh: typeof commands.refresh === "string" ? commands.refresh : "/remote refresh",
+        status: typeof commands.status === "string" ? commands.status : "/remote status",
+        authOn: typeof commands.authOn === "string" ? commands.authOn : "/remote auth on",
+        authOff: typeof commands.authOff === "string" ? commands.authOff : "/remote auth off",
+      },
+    };
+  } catch {
+    return null;
+  }
+}
+
+function remoteWebuiControlsPayload() {
+  if (isOptionalFeatureDisabled("remoteWebui")) return null;
+  return parseRemoteWebuiControlsPayloadRaw(statusEntries.get(REMOTE_WEBUI_CONTROLS_STATUS_KEY));
+}
+
+function remoteWebuiDefaultPortArg() {
+  const port = Number.parseInt(String(latestNetwork?.port || DEFAULT_WEBUI_PORT), 10);
+  return Number.isFinite(port) && port > 0 && port <= 65535 && String(port) !== DEFAULT_WEBUI_PORT ? ` --port ${port}` : "";
+}
+
+function remoteWebuiFallbackCommand(name, fallback) {
+  const portArg = remoteWebuiDefaultPortArg();
+  const commands = {
+    open: `/remote${portArg}`,
+    close: `/remote close${portArg}`,
+    refresh: `/remote refresh${portArg}`,
+    status: `/remote status${portArg}`,
+    authOn: `/remote auth on${portArg}`,
+    authOff: `/remote auth off${portArg}`,
+  };
+  return commands[name] || fallback;
+}
+
+function remoteWebuiCommand(name, fallback) {
+  return remoteWebuiControlsPayload()?.commands?.[name] || remoteWebuiFallbackCommand(name, fallback);
+}
+
 function readCachedGitFooterWebuiPayloadRaw() {
   try {
     const cached = JSON.parse(localStorage.getItem(GIT_FOOTER_WEBUI_PAYLOAD_CACHE_KEY) || "null");
@@ -14475,7 +14551,7 @@ function updateOptionalFeatureAvailability() {
   optionalFeatureAvailability.tuiSkillsCommand = hasLoadedRpcCommand("skills");
   optionalFeatureAvailability.todoProgressWidget = hasAvailableCommand("todo-progress-status") || optionalFeatureAvailability.todoProgressWidget || widgets.has("todo-progress");
   optionalFeatureAvailability.tuiToolsCommand = hasLoadedRpcCommand("tools");
-  optionalFeatureAvailability.remoteWebui = hasAvailableCommand("remote") || optionalFeatureAvailability.remoteWebui || statusEntries.has("pi-remote-webui") || widgets.has("pi-remote-webui");
+  optionalFeatureAvailability.remoteWebui = hasAvailableCommand("remote") || optionalFeatureAvailability.remoteWebui || statusEntries.has("pi-remote-webui") || statusEntries.has(REMOTE_WEBUI_CONTROLS_STATUS_KEY) || widgets.has("pi-remote-webui");
   optionalFeatureAvailability.themeBundle = availableThemes.length > 0;
   requestGitFooterWebuiPayload();
   renderOptionalFeatureControls();
@@ -14633,6 +14709,14 @@ function renderOptionalFeatureControls() {
       optionalFeatureUnavailableMessage("remoteWebui"),
     );
   }
+  if (elements.networkControlField) {
+    elements.networkControlField.hidden = !hasRemoteWebuiCommand;
+    elements.networkControlField.classList.toggle("feature-unavailable", !hasRemoteWebuiCommand);
+    const label = elements.networkControlField.querySelector("label");
+    const payload = remoteWebuiControlsPayload();
+    if (label) label.textContent = payload?.title || "Remote WebUI";
+    elements.networkControlField.title = hasRemoteWebuiCommand ? payload?.description || "Remote WebUI controls are provided by @firstpick/pi-package-remote-webui." : optionalFeatureUnavailableMessage("remoteWebui");
+  }
 
   renderOptionalFeaturePanel();
 }
@@ -16064,21 +16148,25 @@ async function refreshNetworkStatus() {
   renderNetworkStatus();
 }
 
-async function toggleRemoteAuth() {
-  const enable = !latestNetwork?.auth?.enabled;
-  const message = enable
-    ? "Enable remote PIN authentication?\n\nA random 4-digit PIN will be required for non-local browser clients. The PIN is shown in Controls."
-    : "Disable remote PIN authentication?\n\nNon-local browser clients will no longer need a PIN while the network listener is open.";
-  if (!confirm(message)) {
-    renderNetworkStatus();
-    return;
+async function runRemoteWebuiCommand(command) {
+  const commandName = String(command || "").replace(/^\//, "").split(/\s+/, 1)[0] || "remote";
+  if (!isOptionalFeatureEnabled("remoteWebui") || !hasAvailableCommand(commandName)) {
+    const message = commandUnavailableMessage(commandName);
+    addEvent(message, "warn");
+    refreshCommands(activeTabContext()).catch((error) => addEvent(error.message || String(error), "error"));
+    return false;
   }
+  await runNativeCommandMenu(command);
+  return true;
+}
 
+async function toggleRemoteAuth() {
+  const enable = !latestNetwork?.auth?.enabled;
   elements.remoteAuthToggle.disabled = true;
   try {
-    const response = await api("/api/remote-auth/settings", { method: "POST", body: { enabled: enable }, scoped: false });
-    latestNetwork = response.data?.network || { ...(latestNetwork || {}), auth: response.data?.auth };
-    addEvent(enable ? "remote PIN auth enabled" : "remote PIN auth disabled", enable ? "warn" : "info");
+    await runRemoteWebuiCommand(remoteWebuiCommand(enable ? "authOn" : "authOff", enable ? "/remote auth on" : "/remote auth off"));
+    await delay(250);
+    await refreshNetworkStatus();
   } catch (error) {
     addEvent(error.message || String(error), "error");
   } finally {
@@ -16896,35 +16984,15 @@ function scheduleForegroundReconcile(reason = "resume", delay = FOREGROUND_RECON
 }
 
 async function openToNetwork() {
-  if (latestNetwork?.open) {
-    await closeNetworkAccess();
-    return;
-  }
-  if (!confirm(`Open Pi Web UI to your local network?\n\nRemote PIN auth is ${latestNetwork?.auth?.enabled ? "ON" : "OFF"}. The Web UI can control Pi/tools, so only do this on a trusted LAN.`)) return;
-
+  const open = !!latestNetwork?.open;
   elements.openNetworkButton.disabled = true;
-  elements.openNetworkButton.textContent = "Opening…";
+  elements.openNetworkButton.textContent = open ? "Closing…" : "Opening…";
   try {
-    await api("/api/network/open", { method: "POST", scoped: false });
-    latestNetwork = { ...(latestNetwork || {}), opening: true, closing: false };
-    renderNetworkStatus();
-    addEvent("opening webui to local network", "warn");
-    for (let attempt = 0; attempt < 20; attempt++) {
-      await delay(350);
-      try {
-        await refreshNetworkStatus();
-        if (latestNetwork?.open && !latestNetwork?.opening) {
-          const url = latestNetwork.networkUrls?.[0];
-          addEvent(`webui open to local network${url ? `: ${url}` : ""}`, "warn");
-          return;
-        }
-      } catch {
-        // The listener briefly drops while rebinding; retry.
-      }
-    }
+    await runRemoteWebuiCommand(remoteWebuiCommand(open ? "close" : "open", open ? "/remote close" : "/remote"));
+    await delay(350);
     await refreshNetworkStatus();
   } catch (error) {
-    addEvent(error.message, "error");
+    addEvent(error.message || String(error), "error");
   } finally {
     renderNetworkStatus();
   }
@@ -16932,41 +17000,7 @@ async function openToNetwork() {
 
 async function closeNetworkAccess() {
   if (!latestNetwork?.open) return;
-  if (!confirm("Close Pi Web UI network access?\n\nThe local browser can keep using the UI, but LAN clients will disconnect.")) return;
-
-  elements.openNetworkButton.disabled = true;
-  elements.openNetworkButton.textContent = "Closing…";
-  try {
-    await api("/api/network/close", { method: "POST", scoped: false });
-    latestNetwork = { ...(latestNetwork || {}), opening: false, closing: true };
-    renderNetworkStatus();
-    addEvent("closing webui network access", "warn");
-    let refreshFailed = false;
-    for (let attempt = 0; attempt < 20; attempt++) {
-      await delay(350);
-      try {
-        await refreshNetworkStatus();
-        if (!latestNetwork?.open && !latestNetwork?.closing) {
-          addEvent("webui closed to local-only access", "warn");
-          return;
-        }
-      } catch {
-        refreshFailed = true;
-        // Remote tabs will lose access after the listener returns to localhost.
-      }
-    }
-    if (refreshFailed) {
-      latestNetwork = { ...(latestNetwork || {}), open: false, opening: false, closing: false, networkUrls: [] };
-      renderNetworkStatus();
-      addEvent("webui network access closed; reconnect from this machine if this tab loses access", "warn");
-      return;
-    }
-    addEvent("network close requested, but the server still reports network access open", "warn");
-  } catch (error) {
-    addEvent(error.message, "error");
-  } finally {
-    renderNetworkStatus();
-  }
+  await openToNetwork();
 }
 
 function setServerActionStatus(message = "", level = "info") {
@@ -16982,10 +17016,11 @@ function updateServerActionButton() {
   const button = elements.runServerActionButton;
   if (!button) return;
   button.disabled = !action;
-  button.textContent = action === "restart" ? "Restart" : action === "update" ? "Update" : action === "stop" ? "Stop" : "Run";
+  button.textContent = action === "restart" ? "Restart" : action === "update" || action === "update-all" ? "Update" : action === "stop" ? "Stop" : "Run";
   button.classList.toggle("danger", action === "stop");
   if (action === "restart") setServerActionStatus("Ready to restart the Web UI server.", "info");
-  else if (action === "update") setServerActionStatus("Ready to run pi update, then restart the Web UI server.", "info");
+  else if (action === "update") setServerActionStatus("Ready to run pi update for Pi only, then restart the Web UI server.", "info");
+  else if (action === "update-all") setServerActionStatus("Ready to run pi update --all for Pi and configured packages, then restart the Web UI server.", "info");
   else if (action === "stop") setServerActionStatus("Ready to stop the Web UI server.", "info");
   else setServerActionStatus();
 }
@@ -17093,6 +17128,7 @@ async function runSelectedServerAction() {
   const action = elements.serverActionSelect?.value || "";
   if (action === "restart") await restartServer();
   else if (action === "update") await runPiUpdateAndRestart();
+  else if (action === "update-all") await runPiUpdateAndRestart({ all: true });
   else if (action === "stop") await stopServer();
 }
 
@@ -18477,6 +18513,7 @@ elements.openNetworkButton.addEventListener("click", openToNetwork);
 elements.serverActionSelect.addEventListener("change", updateServerActionButton);
 elements.runServerActionButton.addEventListener("click", () => runSelectedServerAction().catch((error) => addEvent(error.message || String(error), "error")));
 elements.updateNotificationUpdateButton?.addEventListener("click", () => runPiUpdateAndRestart().catch((error) => addEvent(error.message || String(error), "error")));
+elements.updateNotificationUpdateAllButton?.addEventListener("click", () => runPiUpdateAndRestart({ all: true }).catch((error) => addEvent(error.message || String(error), "error")));
 elements.updateNotificationDismissButton?.addEventListener("click", () => hideUpdateNotification({ remember: true }));
 updateServerActionButton();
 elements.agentDoneNotificationsToggle.addEventListener("change", () => {

package/public/index.html

@@ -52,7 +52,8 @@
         <p id="updateNotificationMessage">A newer Pi version is available.</p>
         <p id="updateNotificationDetail" class="update-notification-detail muted"></p>
         <div class="update-notification-actions">
-          <button id="updateNotificationUpdateButton" class="primary" type="button">Update &amp; restart</button>
+          <button id="updateNotificationUpdateButton" class="primary" type="button">Update Pi &amp; restart</button>
+          <button id="updateNotificationUpdateAllButton" type="button">Update all &amp; restart</button>
           <button id="updateNotificationDismissButton" type="button">Later</button>
         </div>
       </div>
@@ -379,8 +380,8 @@
                   </div>
                   <div id="backgroundStatus" class="background-status muted">Theme default</div>
                 </div>
-                <div class="control-field network-control-field">
-                  <label>Network</label>
+                <div id="networkControlField" class="control-field network-control-field" hidden>
+                  <label>Remote WebUI</label>
                   <div id="networkStatus" class="network-status closed">Local only</div>
                   <label class="toggle-control remote-auth-toggle" for="remoteAuthToggle">
                     <input id="remoteAuthToggle" type="checkbox" />
@@ -398,6 +399,7 @@
                       <option value="" selected>Choose action…</option>
                       <option value="restart">Restart Server</option>
                       <option value="update">Update Pi &amp; Restart</option>
+                      <option value="update-all">Update Pi + Packages &amp; Restart</option>
                       <option value="stop">Stop Server</option>
                     </select>
                     <button id="runServerActionButton" type="button" disabled>Run</button>

package/tests/http-endpoints-harness.test.mjs

@@ -37,6 +37,22 @@ async function request(host, pathname, { method = "GET", body, timeoutMs = 5_000
   return { status: response.status, body: payload };
 }
 
+function runGitFixture(args, cwd, message) {
+  const result = spawnSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: "Pi WebUI Test",
+      GIT_AUTHOR_EMAIL: "pi-webui-test@example.invalid",
+      GIT_COMMITTER_NAME: "Pi WebUI Test",
+      GIT_COMMITTER_EMAIL: "pi-webui-test@example.invalid",
+    },
+  });
+  assert.equal(result.status, 0, `${message}\n$ git ${args.join(" ")}\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`);
+  return result.stdout.trim();
+}
+
 const cwd = await mkdtemp(path.join(tmpdir(), "pi-webui-http-harness-"));
 const settingsFile = path.join(cwd, "webui-settings.json");
 await chmod(fakePi, 0o755);
@@ -152,6 +168,47 @@ try {
     assert.equal(gitMain.status, 200);
     assert.equal(gitMain.body?.ok, true, "main branch endpoint should rename the branch");
 
+    const remoteFixtureRoot = await mkdtemp(path.join(tmpdir(), "pi-webui-git-remote-"));
+    const remoteBare = path.join(remoteFixtureRoot, "origin.git");
+    const localRepo = path.join(remoteFixtureRoot, "local");
+    const remoteWork = path.join(remoteFixtureRoot, "remote-work");
+    runGitFixture(["init", "--bare", remoteBare], remoteFixtureRoot, "remote fixture should initialize a bare origin");
+    runGitFixture(["init", localRepo], remoteFixtureRoot, "remote fixture should initialize a local repo");
+    runGitFixture(["config", "user.name", "Pi WebUI Test"], localRepo, "local repo should set a user name");
+    runGitFixture(["config", "user.email", "pi-webui-test@example.invalid"], localRepo, "local repo should set a user email");
+    await writeFile(path.join(localRepo, "incoming.txt"), "base\n");
+    runGitFixture(["add", "incoming.txt"], localRepo, "local repo should stage base content");
+    runGitFixture(["commit", "-m", "base"], localRepo, "local repo should commit base content");
+    runGitFixture(["branch", "-M", "main"], localRepo, "local repo should rename main branch");
+    runGitFixture(["remote", "add", "origin", remoteBare], localRepo, "local repo should add bare origin");
+    runGitFixture(["push", "-u", "origin", "main"], localRepo, "local repo should push main to bare origin");
+    runGitFixture(["symbolic-ref", "HEAD", "refs/heads/main"], remoteBare, "bare origin should advertise main as HEAD");
+    runGitFixture(["clone", remoteBare, remoteWork], remoteFixtureRoot, "remote worktree should clone bare origin");
+    runGitFixture(["config", "user.name", "Pi WebUI Test"], remoteWork, "remote worktree should set a user name");
+    runGitFixture(["config", "user.email", "pi-webui-test@example.invalid"], remoteWork, "remote worktree should set a user email");
+    await writeFile(path.join(remoteWork, "incoming.txt"), "base\nremote one\n");
+    runGitFixture(["commit", "-am", "remote one"], remoteWork, "remote worktree should commit first incoming change");
+    await writeFile(path.join(remoteWork, "incoming.txt"), "base\nremote one\nremote two\n");
+    runGitFixture(["commit", "-am", "remote two"], remoteWork, "remote worktree should commit second incoming change");
+    runGitFixture(["push", "origin", "main"], remoteWork, "remote worktree should push incoming commits");
+    runGitFixture(["fetch", "origin"], localRepo, "local repo should fetch incoming commits");
+
+    const remoteTab = await request("127.0.0.1", "/api/tabs", { method: "POST", body: { cwd: localRepo, title: "remote-behind-fixture" } });
+    assert.equal(remoteTab.status, 201);
+    const remoteTabId = remoteTab.body?.data?.tab?.id;
+    assert.ok(remoteTabId, "remote fixture tab should have an id");
+    const incomingChanges = await request("127.0.0.1", `/api/git-changes?tab=${encodeURIComponent(remoteTabId)}`);
+    assert.equal(incomingChanges.status, 200);
+    assert.equal(incomingChanges.body?.ok, true, "git changes endpoint should load a fetched-behind repo");
+    assert.equal(incomingChanges.body?.data?.summary?.behind, 2, "git changes endpoint should report two fetched commits behind");
+    assert.equal(incomingChanges.body?.data?.remote?.canPull, true, "git changes endpoint should mark fetched commits as pullable");
+    assert.ok(incomingChanges.body?.data?.sections?.some((section) => section.key === "incoming"), "git changes endpoint should include an incoming diff section");
+
+    const pullIncoming = await request("127.0.0.1", "/api/git-changes/pull", { method: "POST", body: { tab: remoteTabId }, timeoutMs: 20_000 });
+    assert.equal(pullIncoming.status, 200);
+    assert.equal(pullIncoming.body?.ok, true, "pull endpoint should fast-forward fetched incoming commits");
+    assert.equal(pullIncoming.body?.data?.changes?.summary?.behind, 0, "pull endpoint should refresh changes with no remote commits left behind");
+
     const gitRemote = await request("127.0.0.1", "/api/git-workflow/remote", { method: "POST", body: { username: "Firstp1ck", repoName: "pi-webui-http-harness", tab: tabId } });
     assert.equal(gitRemote.status, 200);
     assert.equal(gitRemote.body?.ok, true, "remote endpoint should add origin without pushing");

package/tests/mobile-static.test.mjs

@@ -357,6 +357,7 @@ assert.match(app, /function updateGitChangesCurrentFileHeader\(\)[\s\S]*?querySe
 assert.match(server, /async function readGitUntrackedEntry\(root, file\)[\s\S]*?content: binary \? "" : buffer\.toString\("utf8"\)/, "server should include complete text contents for untracked files");
 assert.match(server, /url\.pathname === "\/api\/git-changes\/untracked-file" && req\.method === "GET"/, "server should expose a focused untracked-file content endpoint for stale path-only payload fallbacks");
 assert.match(server, /async function readGitChanges\(cwd\)[\s\S]*?const diffArgs = \["diff", "--no-ext-diff"[\s\S]*?"--unified=0"[\s\S]*?\["diff", "--cached"/, "server should collect compact staged and unstaged git diffs for the changes modal");
+assert.match(server, /\["status", "--porcelain=2", "--branch", "--untracked-files=all"\][\s\S]*?summarizeGitPorcelainStatus\(porcelainStatusText\)/, "server should derive behind/ahead from locale-independent porcelain status so the Pull button activates after fetch");
 assert.match(server, /async function readGitIncomingChanges\(root, summary\)[\s\S]*?"HEAD\.\.@\{upstream\}"/, "server should collect incoming upstream diffs when remote commits are behind");
 assert.match(server, /url\.pathname === "\/api\/git-changes" && req\.method === "GET"/, "server should expose GET /api/git-changes for the changes modal");
 assert.match(server, /url\.pathname === "\/api\/git-changes\/pull" && req\.method === "POST"[\s\S]*?pullGitChanges\(tab\.cwd\)/, "server should expose POST /api/git-changes/pull for the changes modal Pull button");
@@ -432,8 +433,9 @@ assert.match(app, /initializeCustomBackground\(\)\.catch/, "startup should resto
 assert.match(app, /Restart Web UI to load themes/, "frontend should explain when a stale server cannot serve the themes endpoint");
 assert.match(app, /themeSelect\.addEventListener\("change"/, "side-panel theme selector should switch themes immediately");
 assert.match(app, /open \? "Close for network" : "Open to network"/, "network button should toggle from open to close action");
-assert.match(app, /remoteAuthToggle: \$\("#remoteAuthToggle"\)/, "Controls should expose the remote PIN auth toggle");
-assert.match(app, /api\("\/api\/remote-auth\/settings", \{ method: "POST"/, "remote PIN auth toggle should call the settings endpoint");
+assert.match(app, /remoteAuthToggle: \$\("#remoteAuthToggle"\)/, "Remote WebUI controls should bind the remote PIN auth toggle");
+assert.match(html, /id="networkControlField"[^>]*hidden/, "Remote WebUI browser controls should be hidden until the optional package is loaded and enabled");
+assert.match(app, /remoteWebuiCommand\(enable \? "authOn" : "authOff"/, "remote PIN auth toggle should dispatch through the Remote WebUI package command");
 assert.match(server, /function webuiSettingsFile\(\)[\s\S]*pi-webui[\s\S]*settings\.json/, "server should persist Web UI settings under a pi-webui settings file");
 assert.match(server, /let persistedRemoteAuthEnabled = await readPersistedRemoteAuthEnabled\(\)/, "server should load the saved Remote PIN auth preference before startup");
 assert.match(server, /if \(remoteAuthStartupEnabled\(\)\) enableRemoteAuth\(remoteAuthStartupReason\(\)\)/, "saved Remote PIN auth preference should enable auth on startup");
@@ -441,7 +443,7 @@ assert.match(server, /await saveRemoteAuthPreference\(true\)/, "enabling Remote
 assert.match(server, /await saveRemoteAuthPreference\(false\)/, "disabling Remote PIN auth should persist the off preference");
 assert.match(server, /function pinFromHash\(\)[\s\S]*new URLSearchParams\(String\(window\.location\.hash \|\| ""\)\.replace\(\/\^#\/, ""\)\)/, "remote auth page should read QR-provided PINs from the URL fragment");
 assert.match(server, /window\.history\.replaceState\(null, "", window\.location\.pathname \+ \(window\.location\.search \|\| ""\)\)/, "remote auth page should scrub fragment PINs from the address bar before authenticating");
-assert.match(app, /api\("\/api\/network\/close", \{ method: "POST"/, "network close action should call the close endpoint");
+assert.match(app, /remoteWebuiCommand\(open \? "close" : "open"/, "network open\/close button should dispatch through the Remote WebUI package command");
 assert.match(app, /webuiVersionBadge: \$\("#webuiVersionBadge"\)/, "frontend should bind the Control Deck version badge");
 assert.match(app, /webuiDevBadge: \$\("#webuiDevBadge"\)/, "frontend should bind the Control Deck dev badge");
 assert.match(app, /function refreshWebuiVersion\(\)[\s\S]*api\("\/api\/health", \{ scoped: false \}\)[\s\S]*setWebuiVersion\(health\.webuiVersion\)[\s\S]*setWebuiDevServer\(isWebuiDevMetadata\(health\)\)/, "frontend should load Web UI version and dev mode from health metadata");
@@ -456,7 +458,7 @@ assert.match(server, /cwdExplicit: false/, "server should track whether startup
 assert.match(server, /return options\.cwdExplicit \? \[await createTab\(\)\] : \[\]/, "server should wait for UI cwd selection when no --cwd is supplied");
 assert.match(server, /async function resolvedPiCliScript\(\)[\s\S]*require\.resolve\.paths\(PI_CODING_AGENT_PACKAGE\)[\s\S]*nodeModulesRoot[\s\S]*dist[\s\S]*cli\.js/, "server should resolve the bundled Pi CLI through Node resolution roots so hoisted global installs can spawn RPC tabs");
 assert.match(server, /const bundledCli = await resolvedPiCliScript\(\)/, "standalone server should prefer the resolved Pi CLI script before falling back to PATH pi");
-assert.match(server, /if \(options\.piBinExplicit\) \{\n\s+const command = await resolvePiCommand\(\["update"\]\)/, "explicit --pi JavaScript launchers should also work for update commands");
+assert.match(server, /if \(options\.piBinExplicit\) \{\n\s+const command = await resolvePiCommand\(updateArgs\)/, "explicit --pi JavaScript launchers should also work for update commands");
 assert.match(app, /serverActionSelect\.addEventListener\("change", updateServerActionButton\)/, "Server action dropdown should control the guarded run button");
 assert.match(app, /runServerActionButton\.addEventListener\("click"[\s\S]*runSelectedServerAction/, "Server action run button should execute the selected action");
 assert.match(app, /api\("\/api\/restart", \{ method: "POST", scoped: false \}\)/, "Restart Server action should call the unscoped restart endpoint");
@@ -466,10 +468,12 @@ assert.match(app, /api\("\/api\/shutdown", \{ method: "POST", scoped: false \}\)
 assert.match(server, /url\.pathname === "\/api\/restart" && req\.method === "POST"/, "server should expose restart endpoint");
 assert.match(server, /PI_WEBUI_RESTORE_TABS: JSON\.stringify\(restorableTabs \|\| \[\]\)/, "server restart should preserve restorable tab metadata");
 assert.match(server, /if \(webuiDevServer\) env\.PI_WEBUI_DEV = "1";/, "server restart should explicitly preserve dev mode");
-assert.match(server, /async function resolveUpdateTasks\(\)[\s\S]*currentWebuiPackageUpdateTask\(\)[\s\S]*agentPackageRootUpdateTask\(\)[\s\S]*npmGlobalPackageRootUpdateTask\(\)[\s\S]*bunGlobalPackageRootUpdateTask\(\)/, "server update should include current, Pi-agent, npm-global, and Bun-global Web UI/Pi package roots");
-assert.match(server, /function packageInstallSpecs\(packageNames\)[\s\S]*`\$\{packageName\}@latest`/, "server package update tasks should force latest Web UI/Pi package specs instead of staying inside stale semver ranges");
-assert.match(app, /Run Pi\/Web UI package updates now\?/, "frontend update confirmation should describe the broader package update set");
-assert.match(readme, /detected local\/global Web UI and Pi package-manager updates/, "README should document that update refreshes local and global Web UI\/Pi package roots");
+assert.match(server, /const updateArgs = all \? \["update", "--all"\] : \["update"\]/, "server update should use pi update by default and pi update --all for package-inclusive updates");
+assert.match(server, /async function resolveUpdateTasks\(\{ all = false \} = \{\}\)[\s\S]*await resolvePiUpdateCommand\(\{ all \}\)/, "server update should resolve a single Pi update command with the selected all mode");
+assert.match(app, /const command = all \? "pi update --all" : "pi update"/, "frontend update confirmation should describe self-only and all update commands");
+assert.match(app, /api\(all \? "\/api\/update\?all=1" : "\/api\/update"/, "frontend all update should call the explicit all-mode endpoint");
+assert.match(html, /<option value="update-all">Update Pi \+ Packages &amp; Restart<\/option>/, "side panel should expose pi update --all as a separate server action");
+assert.match(readme, /`pi update` for Pi-only updates[\s\S]*`pi update --all` for Pi plus configured packages/, "README should document self-only and all update modes");
 assert.match(server, /async function closeNetworkAccess\(\)/, "server should expose a local-only rebind helper for closing network access");
 assert.match(server, /url\.pathname === "\/api\/network\/close" && req\.method === "POST"/, "server should route network close requests");
 assert.match(server, /server\.closeAllConnections\?\.\(\)/, "network rebind should force-close long-lived clients so close-to-localhost can complete");
@@ -626,8 +630,9 @@ assert.match(app, /id: "tuiSkillsCommand"[\s\S]*?@firstpick\/pi-extension-setup-
 assert.match(app, /id: "tuiToolsCommand"[\s\S]*?@firstpick\/pi-extension-tools/, "optional features should include the TUI tools command companion");
 assert.match(app, /id: "remoteWebui"[\s\S]*?@firstpick\/pi-package-remote-webui/, "optional features should include the Remote WebUI companion");
 assert.match(app, /function updateOptionalFeatureAvailability\(\)[\s\S]*hasAvailableCommand\("git-staged-msg"\)[\s\S]*hasAvailableCommand\("release-npm"\)[\s\S]*hasAvailableCommand\("release-aur"\)[\s\S]*hasAvailableCommand\("safety-guard"\)[\s\S]*hasLoadedRpcCommand\("skills"\)[\s\S]*hasAvailableCommand\("todo-progress-status"\)[\s\S]*hasLoadedRpcCommand\("tools"\)[\s\S]*hasAvailableCommand\("remote"\)/, "optional feature detection should call RPC-visible commands directly and distinguish native resource selectors from TUI companions");
-assert.match(app, /hasRemoteWebuiCommand = isOptionalFeatureEnabled\("remoteWebui"\) && hasAvailableCommand\("remote"\)[\s\S]*optionsRemoteButton\.hidden = !hasRemoteWebuiCommand/, "Options menu should show Open Remote only when /remote is loaded and enabled");
+assert.match(app, /hasRemoteWebuiCommand = isOptionalFeatureEnabled\("remoteWebui"\) && hasAvailableCommand\("remote"\)[\s\S]*optionsRemoteButton\.hidden = !hasRemoteWebuiCommand[\s\S]*networkControlField\.hidden = !hasRemoteWebuiCommand/, "Options menu and browser controls should show Remote WebUI only when /remote is loaded and enabled");
 assert.match(app, /if \(key === "pi-remote-webui"\) return "remoteWebui"/, "optional feature handling should recognize Remote WebUI widget events without rendering them as overlays");
+assert.match(app, /REMOTE_WEBUI_CONTROLS_PAYLOAD_TYPE = "firstpick\.pi-package-remote-webui\.controls"/, "Remote WebUI package should announce browser controls through a package-owned status payload");
 assert.match(app, /function combineIdenticalDuplicateCommands\(commands\)[\s\S]*duplicateGroups[\s\S]*duplicateCount: group\.length/, "identical duplicate RPC commands should be combined into one visible command entry");
 assert.match(app, /if \(kind === "prompt" && attachments\.length === 0\) message = resolveRpcSlashCommandMessage\(message\)/, "manual slash prompts should resolve combined duplicate command aliases before reaching Pi RPC");
 assert.match(app, /if \(!isOptionalFeatureEnabled\("todoProgressWidget"\)\) return String\(text \|\| ""\)/, "todo progress line stripping should only run when the todo feature is detected and enabled");