@firstpick/pi-package-webui 0.4.6 → 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

@@ -640,7 +640,8 @@ function makeHttpError(statusCode, message) {
 }
 
 function sendError(res, statusCode, error) {
-  sendJson(res, statusCode, { ok: false, error: sanitizeError(error) });
+  const message = statusCode >= 500 ? sanitizeError(error) : formatCliError(error);
+  sendJson(res, statusCode, { ok: false, error: message });
 }
 
 function formatBytes(bytes) {
@@ -1627,22 +1628,85 @@ function normalizeCustomRunnerDefinition(raw, projectRoot, { strict = false } =
   return { id, label, command, path: filePath, args };
 }
 
-async function readAppRunnerConfig(projectRoot) {
+function customAppRunnerDiagnostic(severity, message, runner = {}) {
+  const source = runner && typeof runner === "object" ? runner : {};
+  return {
+    severity,
+    message,
+    runnerId: source.id || "",
+    runnerLabel: source.label || "",
+    path: source.path || source.projectFile || "",
+  };
+}
+
+function directCustomRunnerUnavailableReason(filePath, stats) {
+  if (process.platform !== "win32" && stats && (stats.mode & 0o111) === 0) {
+    return `Path is not executable: ${filePath}. Run chmod +x ${filePath} or set Command to bash, python3, node, etc.`;
+  }
+  return "";
+}
+
+async function customAppRunnerUnavailableReason(projectRoot, runner) {
+  const filePath = runner.path;
+  let stats;
+  try {
+    stats = await fileStatsIfExists(resolveProjectRelativePath(projectRoot, filePath));
+  } catch (error) {
+    return `Cannot access path ${filePath}: ${formatCliError(error)}`;
+  }
+  if (!stats?.isFile()) return `Path to file does not exist: ${filePath}`;
+  const command = cleanCustomRunnerCommand(runner.command);
+  const directReason = command === "./" ? directCustomRunnerUnavailableReason(filePath, stats) : "";
+  if (directReason) return directReason;
+  const commandParts = customRunnerCommandParts(command);
+  if (command !== "./" && !await appRunnerCommandAvailable(commandParts[0], projectRoot)) return `Command is not available: ${commandParts[0]}`;
+  return "";
+}
+
+async function readAppRunnerConfig(projectRoot, { strictRead = false } = {}) {
   const configPath = path.join(projectRoot, APP_RUNNER_CONFIG_FILE);
-  const parsed = await readJsonFileIfExists(configPath);
-  const source = parsed && typeof parsed === "object" ? parsed : {};
+  let source = {};
+  const diagnostics = [];
+  try {
+    const parsed = JSON.parse(await readFile(configPath, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      source = parsed;
+    } else {
+      const message = `${APP_RUNNER_CONFIG_FILE} must contain a JSON object`;
+      if (strictRead) throw makeHttpError(400, message);
+      diagnostics.push(customAppRunnerDiagnostic("error", message));
+    }
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      const message = `Cannot read ${APP_RUNNER_CONFIG_FILE}: ${formatCliError(error)}`;
+      if (strictRead) throw makeHttpError(400, message);
+      diagnostics.push(customAppRunnerDiagnostic("error", message));
+      console.warn(`failed to read custom app runner config ${configPath}: ${sanitizeError(error)}`);
+    }
+  }
+  if (source.runners !== undefined && !Array.isArray(source.runners)) {
+    const message = `${APP_RUNNER_CONFIG_FILE} runners must be an array`;
+    if (strictRead) throw makeHttpError(400, message);
+    diagnostics.push(customAppRunnerDiagnostic("error", message));
+  }
   const rawRunners = Array.isArray(source.runners) ? source.runners : [];
   const runners = [];
   for (const raw of rawRunners) {
     try {
       const runner = normalizeCustomRunnerDefinition(raw, projectRoot);
-      if (!runners.some((item) => item.id === runner.id)) runners.push(runner);
+      if (runners.some((item) => item.id === runner.id)) {
+        diagnostics.push(customAppRunnerDiagnostic("warning", `Duplicate custom runner ignored: ${runner.label || runner.path || runner.id}`, runner));
+      } else {
+        runners.push(runner);
+      }
     } catch (error) {
+      const message = `Invalid custom runner ignored: ${formatCliError(error)}`;
+      diagnostics.push(customAppRunnerDiagnostic("error", message, raw));
       console.warn(`skipping invalid custom app runner in ${configPath}: ${sanitizeError(error)}`);
     }
     if (runners.length >= APP_RUNNER_CUSTOM_LIMIT) break;
   }
-  return { projectRoot, configPath, runners };
+  return { projectRoot, configPath, runners, diagnostics };
 }
 
 async function writeAppRunnerConfig(projectRoot, runners) {
@@ -1660,15 +1724,12 @@ async function writeAppRunnerConfig(projectRoot, runners) {
 
 async function customAppRunnerCandidate(projectRoot, configPath, runner) {
   const filePath = runner.path;
-  const absolutePath = resolveProjectRelativePath(projectRoot, filePath);
-  const stats = await fileStatsIfExists(absolutePath);
-  if (!stats?.isFile()) return null;
+  if (await customAppRunnerUnavailableReason(projectRoot, runner)) return null;
   const command = cleanCustomRunnerCommand(runner.command);
   const args = parseCustomRunnerArgs(runner.args);
   const commandParts = customRunnerCommandParts(command);
   const effectiveCommand = command === "./" ? `./${filePath}` : commandParts[0];
   const effectiveArgs = command === "./" ? args : [...commandParts.slice(1), filePath, ...args];
-  if (command !== "./" && !await appRunnerCommandAvailable(commandParts[0], projectRoot)) return null;
   return appRunnerCandidate({
     id: appRunnerId("custom", runner.id),
     label: runner.label || path.basename(filePath),
@@ -1696,24 +1757,32 @@ async function addCustomAppRunners(runners, cwd) {
 async function getCustomAppRunnerConfigData(tab) {
   const projectRoot = await findAppRunnerProjectRoot(tab?.cwd || options.cwd);
   const config = await readAppRunnerConfig(projectRoot);
+  const runners = [];
+  for (const runner of config.runners) {
+    const unavailableReason = await customAppRunnerUnavailableReason(projectRoot, runner);
+    runners.push({
+      ...publicCustomRunnerDefinition(runner),
+      available: !unavailableReason,
+      unavailableReason,
+    });
+  }
   return {
     projectRoot,
     displayProjectRoot: displayPath(projectRoot),
     configFile: config.configPath,
     displayConfigFile: displayPath(config.configPath),
     relativeConfigFile: APP_RUNNER_CONFIG_FILE,
-    runners: config.runners.map(publicCustomRunnerDefinition),
+    runners,
+    diagnostics: config.diagnostics,
   };
 }
 
 async function saveCustomAppRunner(tab, rawRunner) {
   const projectRoot = await findAppRunnerProjectRoot(tab?.cwd || options.cwd);
-  const config = await readAppRunnerConfig(projectRoot);
+  const config = await readAppRunnerConfig(projectRoot, { strictRead: true });
   const normalized = normalizeCustomRunnerDefinition(rawRunner, projectRoot, { strict: true });
-  const stats = await fileStatsIfExists(resolveProjectRelativePath(projectRoot, normalized.path));
-  if (!stats?.isFile()) throw makeHttpError(400, `Path to file does not exist: ${normalized.path}`);
-  const commandParts = customRunnerCommandParts(normalized.command);
-  if (normalized.command !== "./" && !await appRunnerCommandAvailable(commandParts[0], projectRoot)) throw makeHttpError(400, `Command is not available: ${commandParts[0]}`);
+  const unavailableReason = await customAppRunnerUnavailableReason(projectRoot, normalized);
+  if (unavailableReason) throw makeHttpError(400, unavailableReason);
   const runners = config.runners.filter((runner) => runner.id !== normalized.id);
   if (runners.length >= APP_RUNNER_CUSTOM_LIMIT) throw makeHttpError(400, `Custom runner limit reached (${APP_RUNNER_CUSTOM_LIMIT})`);
   runners.push(normalized);
@@ -3066,6 +3135,7 @@ async function getWorkspaceInfo(cwd, startedAt) {
 let activeGitWorkflowProcess = null;
 const GIT_CHANGES_COMMAND_TIMEOUT_MS = 5000;
 const GIT_CHANGES_DIFF_MAX_OUTPUT = 500_000;
+const GIT_PULL_TIMEOUT_MS = 15 * 60 * 1000;
 
 async function getGitRoot(cwd) {
   const result = await runCommand("git", ["rev-parse", "--show-toplevel"], { cwd, timeoutMs: 2000 });
@@ -3085,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;
 }
@@ -3176,28 +3249,77 @@ async function readGitUntrackedFile(cwd, requestedPath) {
   return readGitUntrackedEntry(root, normalized);
 }
 
+async function gitUpstreamRef(root) {
+  try {
+    const upstream = await runGitReadCommand(root, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"], { timeoutMs: 5000, maxOutputLength: 10_000 });
+    return upstream.trim();
+  } catch {
+    return "";
+  }
+}
+
+async function readGitIncomingChanges(root, summary) {
+  const upstream = await gitUpstreamRef(root);
+  const remote = {
+    upstream,
+    behind: Number(summary?.behind || 0) || 0,
+    canPull: !!upstream && (Number(summary?.behind || 0) || 0) > 0,
+  };
+  if (!remote.canPull) return { remote, section: null };
+
+  const diffArgs = ["diff", "--no-ext-diff", "--no-color", "--find-renames", "--unified=0", "--src-prefix=a/", "--dst-prefix=b/", "HEAD..@{upstream}"];
+  try {
+    const diff = await runGitReadCommand(root, diffArgs);
+    return {
+      remote,
+      section: {
+        key: "incoming",
+        label: `Incoming from ${upstream}`,
+        command: `git diff --unified=0 HEAD..${upstream}`,
+        diff: diff.trimEnd(),
+      },
+    };
+  } catch (error) {
+    return { remote: { ...remote, error: sanitizeError(error) }, section: null };
+  }
+}
+
+async function pullGitChanges(cwd) {
+  const root = await getGitRoot(cwd);
+  const payload = gitWorkflowCommandPayload(await runGitWorkflowCommand(["pull", "--ff-only"], { cwd: root, timeoutMs: GIT_PULL_TIMEOUT_MS }));
+  if (payload.data) payload.data.root = root;
+  if (payload.ok) payload.data.changes = await readGitChanges(root);
+  else payload.error = (payload.data?.stderr || payload.data?.stdout || payload.error || "git pull --ff-only failed").trim();
+  return payload;
+}
+
 async function readGitChanges(cwd) {
   const root = await getGitRoot(cwd);
-  const diffArgs = ["diff", "--no-ext-diff", "--no-color", "--find-renames", "--src-prefix=a/", "--dst-prefix=b/"];
-  const [statusText, unstagedDiff, stagedDiff, untrackedText] = await Promise.all([
+  const diffArgs = ["diff", "--no-ext-diff", "--no-color", "--find-renames", "--unified=0", "--src-prefix=a/", "--dst-prefix=b/"];
+  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", "--src-prefix=a/", "--dst-prefix=b/"]),
+    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 = 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: summarizeGitShortStatus(statusText),
+    summary,
+    remote: incoming.remote,
     status: statusText.trimEnd(),
     sections: [
-      { key: "staged", label: "Staged", command: "git diff --cached", diff: stagedDiff.trimEnd() },
-      { key: "unstaged", label: "Unstaged", command: "git diff", diff: unstagedDiff.trimEnd() },
-    ],
+      incoming.section,
+      { key: "staged", label: "Staged", command: "git diff --cached --unified=0", diff: stagedDiff.trimEnd() },
+      { key: "unstaged", label: "Unstaged", command: "git diff --unified=0", diff: unstagedDiff.trimEnd() },
+    ].filter(Boolean),
     untracked,
   };
 }
@@ -4158,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) {
@@ -5080,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) {
@@ -5280,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 }),
   ]);
 }
 
@@ -5327,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));
 
@@ -5344,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"),
@@ -7236,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;
@@ -7572,6 +7700,17 @@ const server = createServer(async (req, res) => {
       return;
     }
 
+    if (url.pathname === "/api/git-changes/pull" && req.method === "POST") {
+      const body = await readJsonBody(req);
+      const tab = getRequestedTab(req, url, body);
+      try {
+        sendJson(res, 200, await pullGitChanges(tab.cwd));
+      } catch (error) {
+        sendJson(res, 200, { ok: false, error: sanitizeError(error) });
+      }
+      return;
+    }
+
     if (url.pathname === "/api/git-branches" && req.method === "GET") {
       const tab = getRequestedTab(req, url);
       try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firstpick/pi-package-webui",
-  "version": "0.4.6",
+  "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",
@@ -53,7 +53,7 @@
     "test": "node tests/run-all.mjs"
   },
   "dependencies": {
-    "@earendil-works/pi-coding-agent": "^0.79.5"
+    "@earendil-works/pi-coding-agent": "^0.79.7"
   },
   "optionalDependencies": {
     "@firstpick/pi-extension-btw": "^0.1.0",
@@ -66,7 +66,7 @@
     "@firstpick/pi-extension-todo-progress": "^0.2.4",
     "@firstpick/pi-extension-tools": "^0.1.6",
     "@firstpick/pi-extension-workflows": "^0.1.0",
-    "@firstpick/pi-package-remote-webui": "^0.1.0",
+    "@firstpick/pi-package-remote-webui": "^0.1.2",
     "@firstpick/pi-prompts-git-pr": "^0.1.2",
     "@firstpick/pi-themes-bundle": "^0.1.4"
   },
@@ -84,5 +84,12 @@
   ],
   "engines": {
     "node": ">=22.19.0"
+  },
+  "overrides": {
+    "@earendil-works/pi-coding-agent": {
+      "protobufjs": "7.6.3",
+      "undici": "8.5.0",
+      "ws": "8.21.0"
+    }
   }
 }