@firstpick/pi-package-webui 0.4.7 → 0.4.9

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.
+- 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. Running app runners expose line-oriented stdin in the widget for interactive scripts. 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

@@ -177,6 +177,7 @@ const APP_RUNNER_DETECTION_TIMEOUT_MS = 1_200;
 const APP_RUNNER_COMMAND_CACHE_TTL_MS = 30_000;
 const APP_RUNNER_OUTPUT_LINE_LIMIT = 1_000;
 const APP_RUNNER_OUTPUT_MAX_CHARS = 240_000;
+const APP_RUNNER_INPUT_MAX_CHARS = 16_000;
 const APP_RUNNER_STOP_GRACE_MS = 2_500;
 const APP_RUNNER_PYTHON_ENTRIES = ["Main.py", "main.py", "src/main.py", "src/Main.py", "app.py", "src/app.py"];
 const APP_RUNNER_JS_ENTRIES = ["main.js", "src/main.js", "index.js", "src/index.js", "server.js", "src/server.js", "app.js", "src/app.js"];
@@ -838,10 +839,18 @@ function safeDownloadFileName(name, fallback = "pi-export") {
   return (text || fallback).slice(0, 180);
 }
 
-function contentDispositionAttachment(fileName) {
+function contentDispositionHeader(fileName, disposition = "attachment") {
   const safeName = safeDownloadFileName(fileName);
   const asciiName = safeName.replace(/[^\x20-\x7e]/g, "_").replace(/["\\]/g, "_");
-  return `attachment; filename="${asciiName}"; filename*=UTF-8''${encodeURIComponent(safeName)}`;
+  return `${disposition}; filename="${asciiName}"; filename*=UTF-8''${encodeURIComponent(safeName)}`;
+}
+
+function contentDispositionAttachment(fileName) {
+  return contentDispositionHeader(fileName, "attachment");
+}
+
+function contentDispositionInline(fileName) {
+  return contentDispositionHeader(fileName, "inline");
 }
 
 function registerNativeDownload(filePath, { fileName, contentType, command = "native" } = {}) {
@@ -856,15 +865,17 @@ function registerNativeDownload(filePath, { fileName, contentType, command = "na
     expiresAt,
   };
   nativeDownloadTokens.set(token, record);
+  const url = `/api/native-download/${encodeURIComponent(token)}`;
   return {
-    url: `/api/native-download/${encodeURIComponent(token)}`,
+    url,
+    openUrl: record.contentType === MIME_TYPES.get(".html") ? `${url}?disposition=inline` : undefined,
     fileName: record.fileName,
     contentType: record.contentType,
     expiresAt: new Date(expiresAt).toISOString(),
   };
 }
 
-async function sendNativeDownload(res, token) {
+async function sendNativeDownload(res, token, { inline = false } = {}) {
   pruneNativeDownloadTokens();
   const item = nativeDownloadTokens.get(token);
   if (!item) throw makeHttpError(404, "Download token expired or not found");
@@ -873,10 +884,11 @@ async function sendNativeDownload(res, token) {
     nativeDownloadTokens.delete(token);
     throw makeHttpError(404, "Download file expired or not found");
   }
+  const canRenderInline = inline === true && item.contentType === MIME_TYPES.get(".html");
   res.writeHead(200, {
     "content-type": item.contentType,
     "content-length": String(fileStats.size),
-    "content-disposition": contentDispositionAttachment(item.fileName),
+    "content-disposition": canRenderInline ? contentDispositionInline(item.fileName) : contentDispositionAttachment(item.fileName),
     "cache-control": "no-store",
     "x-content-type-options": "nosniff",
   });
@@ -2274,6 +2286,11 @@ async function detectAppRunners(tab) {
     .map(publicAppRunner);
 }
 
+function appRunnerPendingLine(run) {
+  if (!run || run.status !== "running") return "";
+  return [run.stdoutRemainder, run.stderrRemainder].map((part) => String(part || "")).filter(Boolean).join("");
+}
+
 function publicAppRunnerState(run) {
   if (!run) return null;
   return {
@@ -2295,6 +2312,11 @@ function publicAppRunnerState(run) {
     truncated: run.truncated === true,
     lineCount: run.lineCount || run.lines?.length || 0,
     lines: Array.isArray(run.lines) ? [...run.lines] : [],
+    pendingLine: appRunnerPendingLine(run),
+    stdinClosed: run.stdinClosed === true,
+    stdinError: run.stdinError || "",
+    stdinWrites: run.stdinWrites || 0,
+    lastStdinAt: run.lastStdinAt || "",
   };
 }
 
@@ -2398,6 +2420,7 @@ function finishAppRunner(tab, run, patch = {}) {
   run.error = patch.error;
   run.status = patch.error ? "error" : patch.exitCode === 0 ? "done" : "failed";
   run.child = null;
+  run.stdinClosed = true;
   run.stopping = false;
   appendAppRunnerLine(run, `# ${appRunnerStatusLabel(run)} after ${Math.max(0, Math.round((Date.parse(run.endedAt) - Date.parse(run.startedAt)) / 1000))}s`);
   if (patch.error) appendAppRunnerLine(run, `# ${patch.error}`);
@@ -2407,6 +2430,45 @@ function finishAppRunner(tab, run, patch = {}) {
   broadcastAppRunnerState(tab);
 }
 
+function normalizeAppRunnerInputText(value) {
+  const text = String(value ?? "");
+  if (text.includes("\0")) throw makeHttpError(400, "App runner input cannot contain null bytes");
+  if (text.length > APP_RUNNER_INPUT_MAX_CHARS) throw makeHttpError(413, `App runner input is too long; limit is ${APP_RUNNER_INPUT_MAX_CHARS} characters`);
+  return text;
+}
+
+function sendAppRunnerInput(tab, value, { appendNewline = true, closeStdin = false } = {}) {
+  const run = tab?.appRunner;
+  if (!run || run.status !== "running") throw makeHttpError(409, "No app runner is running in this tab");
+  const stdin = run.child?.stdin;
+  if (!stdin || stdin.destroyed || stdin.writableEnded || run.stdinClosed === true) throw makeHttpError(409, "App runner stdin is closed");
+  const text = normalizeAppRunnerInputText(value);
+  const chunk = `${text}${appendNewline === false ? "" : "\n"}`;
+  if (!chunk && !closeStdin) throw makeHttpError(400, "App runner input is empty");
+  let buffered = false;
+  try {
+    if (closeStdin) {
+      if (chunk) stdin.end(chunk, "utf8");
+      else stdin.end();
+      run.stdinClosed = true;
+    } else {
+      buffered = stdin.write(chunk, "utf8") === false;
+    }
+  } catch (error) {
+    run.stdinClosed = true;
+    run.stdinError = sanitizeError(error);
+    throw makeHttpError(409, `App runner stdin write failed: ${run.stdinError}`);
+  }
+  run.stdinWrites = (run.stdinWrites || 0) + 1;
+  run.lastStdinAt = new Date().toISOString();
+  const closeSuffix = closeStdin ? " and closed" : "";
+  if (chunk) appendAppRunnerLine(run, text ? `# stdin sent (${text.length} char${text.length === 1 ? "" : "s"})${closeSuffix}` : `# stdin sent (Enter)${closeSuffix}`);
+  else appendAppRunnerLine(run, "# stdin closed (EOF)");
+  recordEvent({ type: "webui_app_runner_stdin", tabId: tab.id, tabTitle: tab.title, command: run.displayCommand, chars: text.length, newline: appendNewline !== false, closed: closeStdin === true });
+  scheduleAppRunnerBroadcast(tab);
+  return { cwd: tab.cwd, activeRun: publicAppRunnerState(run), inputBuffered: buffered };
+}
+
 async function startAppRunner(tab, runnerId) {
   if (tab.appRunner?.status === "running") throw makeHttpError(409, `App runner already running: ${tab.appRunner.displayCommand}`);
   const runners = await detectAppRunners(tab);
@@ -2427,12 +2489,14 @@ async function startAppRunner(tab, runnerId) {
     lines: [],
     lineCount: 0,
     outputChars: 0,
+    stdinClosed: false,
+    stdinWrites: 0,
   };
   appendAppRunnerLine(run, `$ ${run.displayCommand}`);
   const child = spawn(run.command, run.args, {
     cwd: run.cwd,
     env: process.env,
-    stdio: ["ignore", "pipe", "pipe"],
+    stdio: ["pipe", "pipe", "pipe"],
     windowsHide: true,
     detached: process.platform !== "win32",
   });
@@ -2440,6 +2504,18 @@ async function startAppRunner(tab, runnerId) {
   run.pid = child.pid;
   tab.appRunner = run;
 
+  child.stdin?.on("error", (error) => {
+    run.stdinClosed = true;
+    run.stdinError = sanitizeError(error);
+    if (run.status === "running") {
+      appendAppRunnerLine(run, `# stdin error: ${run.stdinError}`);
+      scheduleAppRunnerBroadcast(tab);
+    }
+  });
+  child.stdin?.on("close", () => {
+    run.stdinClosed = true;
+    if (run.status === "running") scheduleAppRunnerBroadcast(tab);
+  });
   child.stdout.on("data", (chunk) => appendAppRunnerChunk(tab, run, chunk, "stdout"));
   child.stderr.on("data", (chunk) => appendAppRunnerChunk(tab, run, chunk, "stderr"));
   child.on("error", (error) => finishAppRunner(tab, run, { error: sanitizeError(error) }));
@@ -3155,40 +3231,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 +3372,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 +4356,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 +5281,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 +5484,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 +5527,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 +5545,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"),
@@ -6537,7 +6620,7 @@ async function handleNativeExportCommand(tab, args, req) {
     return respondNative("export", {
       status: "succeeded",
       level: "info",
-      message: `Exported current session to HTML.\nDownload: ${download.fileName}\nLink expires: ${download.expiresAt}`,
+      message: `Exported current session to HTML.\nDownload: ${download.fileName}\nOpen it in your browser when prompted.\nOpen URL: ${download.openUrl || download.url}\nDownload URL: ${download.url}\nLink expires: ${download.expiresAt}`,
       download,
       result: response.data,
       refresh: ["state"],
@@ -7297,7 +7380,9 @@ const server = createServer(async (req, res) => {
     }
 
     if (url.pathname.startsWith("/api/native-download/") && req.method === "GET") {
-      await sendNativeDownload(res, decodeURIComponent(url.pathname.slice("/api/native-download/".length)));
+      await sendNativeDownload(res, decodeURIComponent(url.pathname.slice("/api/native-download/".length)), {
+        inline: url.searchParams.get("disposition") === "inline",
+      });
       return;
     }
 
@@ -7354,7 +7439,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;
@@ -7389,6 +7477,14 @@ const server = createServer(async (req, res) => {
       return;
     }
 
+    if (url.pathname === "/api/app-runner/input" && req.method === "POST") {
+      const body = await readJsonBody(req);
+      const tab = getRequestedTab(req, url, body);
+      const text = Object.prototype.hasOwnProperty.call(body, "text") ? body.text : body.input;
+      sendJson(res, 200, { ok: true, data: sendAppRunnerInput(tab, text, { appendNewline: body.newline !== false, closeStdin: body.closeStdin === true || body.close === true }) });
+      return;
+    }
+
     if (url.pathname === "/api/app-runner/stop" && req.method === "POST") {
       const body = await readJsonBody(req);
       const tab = getRequestedTab(req, url, body);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firstpick/pi-package-webui",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "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.7"
+    "@earendil-works/pi-coding-agent": "^0.79.8"
   },
   "optionalDependencies": {
     "@firstpick/pi-extension-btw": "^0.1.0",