@firstpick/pi-package-webui 0.3.5 → 0.3.7

package/README.md

@@ -125,11 +125,12 @@ Environment variables:
 - Streaming chat transcript with Markdown, thinking output, tool/bash cards, queue and compaction events, and abort controls.
 - Prompt composer with uploads, drag/drop/paste, inline image support, slash-command autocomplete, and `@` file/path references 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, event, and notification controls in the side panel.
+- Model, thinking, session, workspace, theme, optional-feature, Codex usage, network, update/restart, event, and notification controls in the side panel.
 - 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, browser notifications when a tab needs an extension UI response and an optional side-panel toggle for agent-done notifications.
+- Localhost-only Pi update checks with a top-right update notification and a confirmed **Update & restart** action that runs `pi update`, then restarts the Web UI server.
 - 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.
 
@@ -138,6 +139,7 @@ Useful browser endpoints exposed by the local server include:
 - `GET /api/path-suggestions?tab=<tabId>&query=<path>` for `@` file/path references with live suggestions.
 - `POST /api/action-feedback?tab=<tabId>` for feedback on final assistant output and action cards.
 - `POST /api/optional-feature-install` for installing 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` followed by a Web UI server restart.
 
 For local development, run the checkout helper directly, for example:
 
@@ -191,6 +193,7 @@ This requires `/git-staged-msg` and `/pr` from `@firstpick/pi-prompts-git-pr`; b
 - The side-panel **Open to network** button rebinds the server to `0.0.0.0`, shows LAN URLs when available, and toggles to "Close for network".
 - `--host 0.0.0.0` also exposes the Web UI to the local network.
 - Any connected browser client can control Pi and run Web UI bash actions as the Web UI process user.
+- The Web UI update endpoint is restricted to localhost, because it runs `pi update` and restarts the server.
 - Treat Pi Web UI as a local companion, not a hardened multi-user web service.
 
 ## Troubleshooting

package/bin/pi-webui.mjs

@@ -19,6 +19,13 @@ const webuiHelperExtensionPath = path.join(packageRoot, "webui-rpc-helper.mjs");
 const agentDir = process.env.PI_CODING_AGENT_DIR || path.join(homedir(), ".pi", "agent");
 const OPTIONAL_FEATURE_INSTALL_ROOT_ENV = "PI_WEBUI_OPTIONAL_FEATURE_INSTALL_ROOT";
 const packageJson = JSON.parse(await readFile(path.join(packageRoot, "package.json"), "utf8"));
+let piPackageJson = {};
+try {
+  const piPackageJsonPath = require.resolve("@earendil-works/pi-coding-agent/package.json", { paths: [packageRoot] });
+  piPackageJson = JSON.parse(await readFile(piPackageJsonPath, "utf8"));
+} catch {
+  piPackageJson = {};
+}
 const nativeParityMatrix = JSON.parse(await readFile(path.join(packageRoot, "WEBUI_TUI_NATIVE_PARITY.json"), "utf8"));
 const webuiDevServer = isTruthyEnv(process.env.PI_WEBUI_DEV) || isSourceCheckout(packageRoot);
 
@@ -28,6 +35,14 @@ const REQUEST_TIMEOUT_MS = 5 * 60 * 1000;
 const WEBUI_HELPER_TIMEOUT_MS = 8 * 1000;
 const WEBUI_HELPER_COMMAND = "webui-helper";
 const WEBUI_HELPER_RESPONSE_PREFIX = "__PI_WEBUI_HELPER_RESPONSE__:";
+const PI_CODING_AGENT_PACKAGE = "@earendil-works/pi-coding-agent";
+const WEBUI_PACKAGE = packageJson.name || "@firstpick/pi-package-webui";
+const PI_LATEST_VERSION_URL = process.env.PI_WEBUI_PI_LATEST_VERSION_URL || "https://pi.dev/api/latest-version";
+const NPM_REGISTRY_URL = (process.env.PI_WEBUI_NPM_REGISTRY_URL || "https://registry.npmjs.org").replace(/\/+$/, "");
+const UPDATE_STATUS_CACHE_MS = 10 * 60 * 1000;
+const UPDATE_STATUS_TIMEOUT_MS = 10 * 1000;
+const PI_UPDATE_TIMEOUT_MS = 15 * 60 * 1000;
+const PI_UPDATE_OUTPUT_MAX_CHARS = 120_000;
 const CODEX_USAGE_TIMEOUT_MS = 15 * 1000;
 const CODEX_TOKEN_REFRESH_SKEW_MS = 5 * 60 * 1000;
 const OPENAI_CODEX_PROVIDER_ID = "openai-codex";
@@ -363,6 +378,51 @@ function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function truncateLongText(value, maxLength = 8000) {
+  const text = String(value || "");
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, Math.max(0, maxLength - 1))}…`;
+}
+
+function parsePackageVersion(version) {
+  const match = String(version || "").trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+.*)?$/);
+  if (!match) return undefined;
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10),
+    patch: Number.parseInt(match[3], 10),
+    prerelease: match[4],
+  };
+}
+
+function comparePackageVersions(leftVersion, rightVersion) {
+  const left = parsePackageVersion(leftVersion);
+  const right = parsePackageVersion(rightVersion);
+  if (!left || !right) return undefined;
+  if (left.major !== right.major) return left.major - right.major;
+  if (left.minor !== right.minor) return left.minor - right.minor;
+  if (left.patch !== right.patch) return left.patch - right.patch;
+  if (left.prerelease === right.prerelease) return 0;
+  if (!left.prerelease) return 1;
+  if (!right.prerelease) return -1;
+  return left.prerelease.localeCompare(right.prerelease);
+}
+
+function isNewerPackageVersion(candidateVersion, currentVersion) {
+  const comparison = comparePackageVersions(candidateVersion, currentVersion);
+  if (comparison !== undefined) return comparison > 0;
+  return String(candidateVersion || "").trim() !== String(currentVersion || "").trim();
+}
+
+async function fetchJsonWithTimeout(url, { timeoutMs = UPDATE_STATUS_TIMEOUT_MS, headers = {} } = {}) {
+  const response = await fetch(url, {
+    headers,
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  if (!response.ok) throw new Error(`${response.status}${response.statusText ? ` ${response.statusText}` : ""}`);
+  return response.json();
+}
+
 class PiRpcProcess {
   constructor({ command, args, displayCommand, cwd }) {
     this.command = command;
@@ -2694,6 +2754,8 @@ async function getWorkspaceInfo(cwd, startedAt) {
 }
 
 let activeGitWorkflowProcess = null;
+const GIT_CHANGES_COMMAND_TIMEOUT_MS = 5000;
+const GIT_CHANGES_DIFF_MAX_OUTPUT = 500_000;
 
 async function getGitRoot(cwd) {
   const result = await runCommand("git", ["rev-parse", "--show-toplevel"], { cwd, timeoutMs: 2000 });
@@ -2703,6 +2765,120 @@ async function getGitRoot(cwd) {
   return path.resolve(result.stdout.trim());
 }
 
+async function runGitReadCommand(root, args, { timeoutMs = GIT_CHANGES_COMMAND_TIMEOUT_MS, maxOutputLength = GIT_CHANGES_DIFF_MAX_OUTPUT } = {}) {
+  const result = await runCommand("git", args, { cwd: root, timeoutMs, maxOutputLength });
+  if (result.exitCode === 0 && !result.timedOut && !result.error) return result.stdout;
+  const command = formatGitCommand(args);
+  const message = result.timedOut
+    ? `${command} timed out`
+    : (result.stderr || result.stdout || result.error || `${command} failed with exit code ${result.exitCode ?? "unknown"}`);
+  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 summarizeGitShortStatus(statusText) {
+  const summary = { staged: 0, unstaged: 0, untracked: 0, conflicted: 0 };
+  for (const line of String(statusText || "").split(/\r?\n/)) {
+    if (!line || line.startsWith("## ")) continue;
+    const x = line[0] || " ";
+    const y = line[1] || " ";
+    if (x === "?" && y === "?") {
+      summary.untracked += 1;
+      continue;
+    }
+    if (x === "U" || y === "U" || (x === "A" && y === "A") || (x === "D" && y === "D")) {
+      summary.conflicted += 1;
+      continue;
+    }
+    if (x && x !== " ") summary.staged += 1;
+    if (y && y !== " ") summary.unstaged += 1;
+  }
+  return summary;
+}
+
+function resolveGitRelativePath(root, relativePath) {
+  const normalized = String(relativePath || "").trim();
+  if (!normalized || normalized.includes("\0")) throw new Error("Invalid git path");
+  const resolved = path.resolve(root, normalized);
+  if (resolved !== root && !resolved.startsWith(`${root}${path.sep}`)) throw new Error(`Git path escapes repository: ${normalized}`);
+  return resolved;
+}
+
+function isLikelyBinaryBuffer(buffer) {
+  return Buffer.isBuffer(buffer) && buffer.includes(0);
+}
+
+function normalizeGitRelativePath(root, relativePath) {
+  const resolved = resolveGitRelativePath(root, relativePath);
+  return path.relative(root, resolved).split(path.sep).join("/");
+}
+
+async function readGitUntrackedEntry(root, file) {
+  const normalized = normalizeGitRelativePath(root, file);
+  const filePath = resolveGitRelativePath(root, normalized);
+  const info = await stat(filePath);
+  if (!info.isFile()) return { path: normalized, size: info.size, binary: false, content: "", error: "Not a regular file" };
+  const buffer = await readFile(filePath);
+  const binary = isLikelyBinaryBuffer(buffer);
+  return {
+    path: normalized,
+    size: info.size,
+    binary,
+    content: binary ? "" : buffer.toString("utf8"),
+  };
+}
+
+async function readGitUntrackedEntries(root, files) {
+  const entries = [];
+  for (const file of files) {
+    try {
+      entries.push(await readGitUntrackedEntry(root, file));
+    } catch (error) {
+      entries.push({ path: file, size: 0, binary: false, content: "", error: sanitizeError(error) });
+    }
+  }
+  return entries;
+}
+
+async function readGitUntrackedFile(cwd, requestedPath) {
+  const root = await getGitRoot(cwd);
+  const normalized = normalizeGitRelativePath(root, requestedPath);
+  const listed = await runGitReadCommand(root, ["ls-files", "--others", "--exclude-standard", "--", normalized], { maxOutputLength: 120_000 });
+  const files = listed.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (!files.includes(normalized)) throw new Error(`Not an untracked file: ${normalized}`);
+  return readGitUntrackedEntry(root, normalized);
+}
+
+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([
+    runGitReadCommand(root, ["status", "--short", "--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, ["ls-files", "--others", "--exclude-standard"], { maxOutputLength: 120_000 }),
+  ]);
+  const untrackedFiles = untrackedText.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const untracked = await readGitUntrackedEntries(root, untrackedFiles);
+  return {
+    cwd,
+    root,
+    branch: gitBranchFromStatus(statusText),
+    generatedAt: new Date().toISOString(),
+    summary: summarizeGitShortStatus(statusText),
+    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() },
+    ],
+    untracked,
+  };
+}
+
 function commitMessagePaths(root) {
   return {
     shortPath: path.join(root, "dev", "COMMIT", "staged-commit-short.txt"),
@@ -2769,6 +2945,68 @@ async function currentGitBranch(root) {
   return branch;
 }
 
+async function currentGitBranchForPicker(root) {
+  try {
+    return (await runGitReadCommand(root, ["branch", "--show-current"], { timeoutMs: 5000, maxOutputLength: 10_000 })).trim();
+  } catch {
+    return "";
+  }
+}
+
+function normalizeGitBranchList(branchText, current = "") {
+  const seen = new Set();
+  const branches = [];
+  for (const line of String(branchText || "").split(/\r?\n/)) {
+    const name = line.trim();
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    branches.push({ name, current: !!current && name === current });
+  }
+  return branches.sort((left, right) => {
+    if (left.current !== right.current) return left.current ? -1 : 1;
+    return left.name.localeCompare(right.name);
+  });
+}
+
+async function readGitBranches(cwd) {
+  const root = await getGitRoot(cwd);
+  const [current, branchText] = await Promise.all([
+    currentGitBranchForPicker(root),
+    runGitReadCommand(root, ["branch", "--format=%(refname:short)"], { timeoutMs: 5000, maxOutputLength: 120_000 }),
+  ]);
+  return {
+    cwd,
+    root,
+    current,
+    generatedAt: new Date().toISOString(),
+    branches: normalizeGitBranchList(branchText, current),
+  };
+}
+
+async function switchGitBranch(cwd, branch, { create = false } = {}) {
+  const root = await getGitRoot(cwd);
+  const targetBranch = cleanGitBranchName(branch);
+  await validateGitBranchName(root, targetBranch);
+  const branches = await readGitBranches(cwd);
+  const branchExists = branches.branches.some((item) => item.name === targetBranch);
+  if (create && branchExists) throw new Error(`Local git branch already exists: ${targetBranch}`);
+  if (!create && !branchExists) throw new Error(`Unknown local git branch: ${targetBranch}`);
+  if (!create && branches.current === targetBranch) {
+    return { ok: true, data: { command: `git switch ${targetBranch}`, stdout: "", stderr: "", exitCode: 0, branch: targetBranch, root, switched: false, created: false } };
+  }
+  const args = create ? ["switch", "-c", targetBranch] : ["switch", targetBranch];
+  const payload = gitWorkflowCommandPayload(await runGitWorkflowCommand(args, { cwd: root, timeoutMs: 10 * 60 * 1000 }));
+  if (payload.ok) {
+    payload.data.branch = targetBranch;
+    payload.data.root = root;
+    payload.data.switched = true;
+    payload.data.created = create;
+  } else {
+    payload.error = (payload.data?.stderr || payload.data?.stdout || payload.error || `Failed to ${create ? "create and switch to" : "switch to"} ${targetBranch}`).trim();
+  }
+  return payload;
+}
+
 async function defaultGitRemote(root) {
   const result = await runGitWorkflowCommand(["remote"], { cwd: root, timeoutMs: 5000 });
   if (result.exitCode !== 0) throw new Error((result.stderr || result.stdout || "Cannot list git remotes").trim());
@@ -3912,6 +4150,173 @@ function spawnRestartServer(restorableTabs) {
   return child;
 }
 
+let updateStatusCache = null;
+let updateStatusCacheAt = 0;
+let piUpdateInProgress = false;
+
+function updateChecksSkippedReason() {
+  if (process.env.PI_OFFLINE) return "PI_OFFLINE is set";
+  if (process.env.PI_SKIP_VERSION_CHECK) return "PI_SKIP_VERSION_CHECK is set";
+  return "";
+}
+
+function basePackageUpdateStatus(packageName, currentVersion) {
+  return {
+    packageName,
+    currentVersion: String(currentVersion || ""),
+    latestVersion: null,
+    updateAvailable: false,
+    checked: false,
+    skipped: false,
+    skippedReason: "",
+    error: "",
+  };
+}
+
+async function checkLatestPiReleaseStatus() {
+  const status = basePackageUpdateStatus(PI_CODING_AGENT_PACKAGE, piPackageJson.version);
+  const skippedReason = updateChecksSkippedReason();
+  if (skippedReason) {
+    status.skipped = true;
+    status.skippedReason = skippedReason;
+    return status;
+  }
+  try {
+    const data = await fetchJsonWithTimeout(PI_LATEST_VERSION_URL, {
+      headers: {
+        "User-Agent": `pi-webui/${packageJson.version} pi/${piPackageJson.version || "unknown"}`,
+        accept: "application/json",
+      },
+    });
+    const latestVersion = typeof data.version === "string" ? data.version.trim() : "";
+    if (!latestVersion) throw new Error("latest-version response did not include a version");
+    status.latestVersion = latestVersion;
+    status.packageName = typeof data.packageName === "string" && data.packageName.trim() ? data.packageName.trim() : PI_CODING_AGENT_PACKAGE;
+    status.note = typeof data.note === "string" && data.note.trim() ? data.note.trim() : "";
+    status.updateAvailable = status.currentVersion ? isNewerPackageVersion(latestVersion, status.currentVersion) : false;
+    status.checked = true;
+  } catch (error) {
+    status.error = sanitizeError(error);
+  }
+  return status;
+}
+
+function npmLatestPackageUrl(packageName) {
+  return `${NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}/latest`;
+}
+
+async function checkLatestNpmPackageStatus(packageName, currentVersion) {
+  const status = basePackageUpdateStatus(packageName, currentVersion);
+  const skippedReason = updateChecksSkippedReason();
+  if (skippedReason) {
+    status.skipped = true;
+    status.skippedReason = skippedReason;
+    return status;
+  }
+  try {
+    const data = await fetchJsonWithTimeout(npmLatestPackageUrl(packageName), {
+      headers: {
+        "User-Agent": `pi-webui/${packageJson.version}`,
+        accept: "application/json",
+      },
+    });
+    const latestVersion = typeof data.version === "string" ? data.version.trim() : "";
+    if (!latestVersion) throw new Error(`${packageName} latest metadata did not include a version`);
+    status.latestVersion = latestVersion;
+    status.updateAvailable = status.currentVersion ? isNewerPackageVersion(latestVersion, status.currentVersion) : false;
+    status.checked = true;
+  } catch (error) {
+    status.error = sanitizeError(error);
+  }
+  return status;
+}
+
+function updateStatusForRequest(status, req) {
+  return {
+    ...status,
+    canRunUpdate: isLocalAddress(req?.socket?.remoteAddress),
+    updateInProgress: piUpdateInProgress,
+  };
+}
+
+async function getUpdateStatus({ force = false } = {}) {
+  const now = Date.now();
+  if (!force && updateStatusCache && now - updateStatusCacheAt < UPDATE_STATUS_CACHE_MS) return updateStatusCache;
+  const [piStatus, webuiStatus] = await Promise.all([
+    checkLatestPiReleaseStatus(),
+    checkLatestNpmPackageStatus(WEBUI_PACKAGE, packageJson.version),
+  ]);
+  const updateAvailable = !!(piStatus.updateAvailable || webuiStatus.updateAvailable);
+  updateStatusCache = {
+    checkedAt: new Date(now).toISOString(),
+    updateAvailable,
+    restartRequired: true,
+    command: "pi update",
+    webuiDev: webuiDevServer,
+    pi: piStatus,
+    webui: webuiStatus,
+    packages: {
+      checked: false,
+      note: "pi update will also update configured unpinned Pi packages.",
+    },
+  };
+  updateStatusCacheAt = now;
+  return updateStatusCache;
+}
+
+async function resolvePiUpdateCommand() {
+  if (options.piBinExplicit) {
+    return { command: options.piBin, args: ["update"], displayCommand: formatCommandForDisplay(options.piBin, ["update"]) };
+  }
+
+  const pathPi = await runCommand(options.piBin, ["--version"], { timeoutMs: 3000, maxOutputLength: 4000 });
+  if (pathPi.exitCode === 0 && !pathPi.timedOut && !pathPi.error) {
+    return { command: options.piBin, args: ["update"], displayCommand: formatCommandForDisplay(options.piBin, ["update"]) };
+  }
+
+  return resolvePiCommand(["update"]);
+}
+
+async function runPiUpdateAndPrepareRestart() {
+  if (piUpdateInProgress) throw makeHttpError(409, "A Pi update is already running.");
+  piUpdateInProgress = true;
+  let restartPrepared = false;
+  try {
+    const restorableTabs = await restorableTabsForRestart();
+    const piCommand = await resolvePiUpdateCommand();
+    const command = piCommand.displayCommand || formatCommandForDisplay(piCommand.command, piCommand.args || []);
+    recordEvent({ type: "webui_update_started", command, restorableTabCount: restorableTabs.length });
+    const result = await runCommand(piCommand.command, piCommand.args || [], {
+      cwd: process.cwd(),
+      timeoutMs: PI_UPDATE_TIMEOUT_MS,
+      maxOutputLength: PI_UPDATE_OUTPUT_MAX_CHARS,
+    });
+    const ok = result.exitCode === 0 && !result.timedOut && !result.error;
+    if (!ok) {
+      const details = [result.error, result.timedOut ? "timed out" : undefined, result.stderr?.trim(), result.stdout?.trim()].filter(Boolean).join("\n");
+      recordEvent({ type: "webui_update_failed", command, error: truncateStatusText(details || `exit code ${result.exitCode ?? "unknown"}`) });
+      throw makeHttpError(500, truncateLongText(`Pi update failed: ${command}${details ? `\n${details}` : ""}`));
+    }
+
+    updateStatusCache = null;
+    updateStatusCacheAt = 0;
+    const child = spawnRestartServer(restorableTabs);
+    restartPrepared = true;
+    recordEvent({ type: "webui_update_restarting", command, nextWebuiPid: child.pid, restorableTabCount: restorableTabs.length });
+    return {
+      message: "Pi update completed. Pi Web UI is restarting.",
+      command,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      webuiPid: process.pid,
+      nextWebuiPid: child.pid,
+      restorableTabCount: restorableTabs.length,
+    };
+  } finally {
+    if (!restartPrepared) piUpdateInProgress = false;
+  }
+}
+
 function rememberClosedRestorableTab(tab, state = null) {
   const descriptor = restorableTabDescriptor(tab, state);
   if (!descriptor) return;
@@ -5517,6 +5922,13 @@ const server = createServer(async (req, res) => {
       return;
     }
 
+    if (url.pathname === "/api/update-status" && req.method === "GET") {
+      const force = ["1", "true", "yes", "refresh"].includes(String(url.searchParams.get("refresh") || "").toLowerCase());
+      const status = await getUpdateStatus({ force });
+      sendJson(res, 200, { ok: true, data: updateStatusForRequest(status, req) });
+      return;
+    }
+
     if (url.pathname === "/api/native-parity" && req.method === "GET") {
       sendJson(res, 200, { ok: true, data: nativeParityMatrix });
       return;
@@ -5577,6 +5989,14 @@ const server = createServer(async (req, res) => {
       return;
     }
 
+    if (url.pathname === "/api/update" && req.method === "POST") {
+      if (!isLocalAddress(req.socket.remoteAddress)) throw makeHttpError(403, "Updating Pi from the Web UI is only allowed from localhost");
+      const data = await runPiUpdateAndPrepareRestart();
+      sendJson(res, 200, { ok: true, data });
+      setTimeout(() => shutdown("api update"), 20).unref();
+      return;
+    }
+
     if (url.pathname === "/api/shutdown" && req.method === "POST") {
       if (!isLocalAddress(req.socket.remoteAddress)) throw makeHttpError(403, "Shutdown is only allowed from localhost");
       sendJson(res, 200, { ok: true, message: "Pi Web UI shutting down", webuiPid: process.pid });
@@ -5855,6 +6275,47 @@ const server = createServer(async (req, res) => {
       return;
     }
 
+    if (url.pathname === "/api/git-changes" && req.method === "GET") {
+      const tab = getRequestedTab(req, url);
+      try {
+        sendJson(res, 200, { ok: true, data: await readGitChanges(tab.cwd) });
+      } catch (error) {
+        sendJson(res, 200, { ok: false, error: sanitizeError(error) });
+      }
+      return;
+    }
+
+    if (url.pathname === "/api/git-changes/untracked-file" && req.method === "GET") {
+      const tab = getRequestedTab(req, url);
+      try {
+        sendJson(res, 200, { ok: true, data: await readGitUntrackedFile(tab.cwd, url.searchParams.get("path") || "") });
+      } 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 {
+        sendJson(res, 200, { ok: true, data: await readGitBranches(tab.cwd) });
+      } catch (error) {
+        sendJson(res, 200, { ok: false, error: sanitizeError(error) });
+      }
+      return;
+    }
+
+    if (url.pathname === "/api/git-branch" && req.method === "POST") {
+      const body = await readJsonBody(req);
+      const tab = getRequestedTab(req, url, body);
+      try {
+        sendJson(res, 200, await switchGitBranch(tab.cwd, body.branch, { create: body.create === true }));
+      } catch (error) {
+        sendJson(res, 200, { ok: false, error: sanitizeError(error) });
+      }
+      return;
+    }
+
     if (url.pathname.startsWith("/api/git-workflow/")) {
       const body = req.method === "POST" ? await readJsonBody(req) : {};
       const tab = getRequestedTab(req, url, body);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firstpick/pi-package-webui",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "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",