@firstpick/pi-package-webui 0.4.0 → 0.4.1

package/README.md

@@ -120,12 +120,14 @@ Environment variables:
 ## Main features
 
 - Pathless `pi-webui` startup: the server opens first, then the browser prompts for the first terminal CWD.
-- Multi-tab Pi sessions with isolated processes, working directories, prompt drafts, and activity state.
+- Multi-tab Pi sessions with isolated processes, working directories, prompt drafts, activity state, and a workspace dashboard for common actions.
+- Unified command palette (`Ctrl/Cmd+K`) for commands, tabs, models, sessions, settings, and frequent Web UI actions.
 - Automatic tab naming from the first prompt, with `--name <name>` still available for an explicit initial tab name.
-- Streaming chat transcript with Markdown, thinking output, tool/bash cards, queue and compaction events, and abort controls.
+- Streaming chat transcript with Markdown, thinking output, tool/bash cards, queue and compaction events, edit-and-retry from user prompts, 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, 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.
@@ -138,7 +140,8 @@ 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/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.
 
 For local development, run the checkout helper directly, for example:
@@ -151,9 +154,9 @@ Run `../dev/scripts/sync-pi-package-symlinks.sh` first when developing companion
 
 ## Optional companion packages
 
-A normal Pi/npm install includes the optional companion packages unless optional dependencies are disabled. Each Web UI tab curates Pi resources from the Web UI package that started the server, while preserving unrelated user/project resources; separately installed Web UI companion packages are ignored to avoid loading two copies. Startup checks loaded Pi capabilities directly through RPC-visible commands and live widget events, then the side panel shows each optional feature as enabled, disabled, or install-needed. Installing a missing feature is an explicit, warned action; it is localhost-only, limited to known packages, and requires reloading the active Pi tab after installation.
+A normal Pi/npm install includes the optional companion packages unless optional dependencies are disabled. Each Web UI tab curates Pi resources from the Web UI package that started the server, while preserving unrelated user/project resources. Companion packages installed as global/npm-prefix siblings of the started Web UI package are reused when the Web UI package does not have its own nested optional dependency copy, avoiding duplicate loads while keeping global `pi-webui` launches working. Startup checks loaded Pi capabilities directly through RPC-visible commands and live widget events, then the side panel shows each optional feature as enabled, disabled, installed-but-not-loaded, update-available, or install-needed. Installing or updating a feature is an explicit, warned action with running/failure feedback in the row and activity log; it is localhost-only, limited to known packages, and requires reloading the active Pi tab after installation.
 
-When the standalone global `pi-webui` launcher is used, optional companion installs should target the Pi agent npm root instead of the global npm prefix. Override the target explicitly with `PI_WEBUI_OPTIONAL_FEATURE_INSTALL_ROOT=/path/to/package-root` when needed.
+When the standalone global `pi-webui` launcher is used, optional companion installs target the npm prefix containing the Web UI package when that prefix is safe, otherwise the Pi agent npm root if it contains Web UI. Override the target explicitly with `PI_WEBUI_OPTIONAL_FEATURE_INSTALL_ROOT=/path/to/package-root` when needed.
 
 Optional companions:
 

package/bin/pi-webui.mjs

@@ -933,6 +933,10 @@ async function installRootDeclaresPackage(root, packageName) {
   return declaredDependencySpec(pkg, packageName) !== undefined;
 }
 
+async function installRootContainsPackage(root, packageName) {
+  return directoryExists(packageNodeModulesPath(path.join(root, "node_modules"), packageName));
+}
+
 function configuredAgentNpmRoot() {
   const root = process.env.PI_CODING_AGENT_DIR ? path.resolve(expandUserPath(process.env.PI_CODING_AGENT_DIR)) : agentDir;
   return path.join(root, "npm");
@@ -943,10 +947,10 @@ async function optionalDependencyInstallRoot() {
   if (configuredRoot) return path.resolve(expandUserPath(configuredRoot));
 
   const installRoot = nodeModulesParentForPackageRoot(packageRoot);
-  if (await installRootDeclaresPackage(installRoot, "@firstpick/pi-package-webui")) return installRoot;
+  if (await installRootDeclaresPackage(installRoot, "@firstpick/pi-package-webui") || await installRootContainsPackage(installRoot, "@firstpick/pi-package-webui")) return installRoot;
 
   const agentNpmRoot = configuredAgentNpmRoot();
-  if (installRoot !== agentNpmRoot && await installRootDeclaresPackage(agentNpmRoot, "@firstpick/pi-package-webui")) return agentNpmRoot;
+  if (installRoot !== agentNpmRoot && (await installRootDeclaresPackage(agentNpmRoot, "@firstpick/pi-package-webui") || await installRootContainsPackage(agentNpmRoot, "@firstpick/pi-package-webui"))) return agentNpmRoot;
 
   if (webuiDevServer) return installRoot;
 
@@ -956,13 +960,102 @@ async function optionalDependencyInstallRoot() {
   );
 }
 
+function minimumPackageVersionFromSpec(spec) {
+  const match = String(spec || "").match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/);
+  return match?.[0] || "";
+}
+
+function packageVersionBelowSpec(currentVersion, spec) {
+  const minimum = minimumPackageVersionFromSpec(spec);
+  return !!(currentVersion && minimum && isNewerPackageVersion(minimum, currentVersion));
+}
+
 function formatCommandForDisplay(command, args) {
   return [command, ...args].map((part) => (/\s/.test(part) ? JSON.stringify(part) : part)).join(" ");
 }
 
-async function installOptionalFeaturePackage(featureId) {
+let optionalPackageNodeModulesRootsCache = null;
+async function optionalPackageNodeModulesRoots() {
+  if (optionalPackageNodeModulesRootsCache) return optionalPackageNodeModulesRootsCache;
+  const roots = [];
+  const seen = new Set();
+  const add = (root) => {
+    if (!root) return;
+    const normalized = path.resolve(root);
+    if (seen.has(normalized)) return;
+    seen.add(normalized);
+    roots.push(normalized);
+  };
+  const configuredRoot = process.env[OPTIONAL_FEATURE_INSTALL_ROOT_ENV];
+  if (configuredRoot) add(path.join(path.resolve(expandUserPath(configuredRoot)), "node_modules"));
+  add(path.join(packageRoot, "node_modules"));
+  add(path.join(nodeModulesParentForPackageRoot(packageRoot), "node_modules"));
+  add(path.join(configuredAgentNpmRoot(), "node_modules"));
+  const npmGlobalRoot = await npmGlobalNodeModulesRoot();
+  if (npmGlobalRoot) add(npmGlobalRoot);
+  for (const bunRoot of await bunGlobalNodeModulesRoots()) add(bunRoot);
+  optionalPackageNodeModulesRootsCache = roots;
+  return roots;
+}
+
+async function optionalPackageCandidateRoots(packageName) {
+  return (await optionalPackageNodeModulesRoots()).map((root) => packageNodeModulesPath(root, packageName));
+}
+
+async function resolveInstalledPackageRoot(packageName) {
+  const workspaceRoot = await workspacePackageRootForName(packageName);
+  if (workspaceRoot) return workspaceRoot;
+  for (const candidate of await optionalPackageCandidateRoots(packageName)) {
+    if (await directoryExists(candidate)) return candidate;
+  }
+  return null;
+}
+
+async function resolveInstalledPackageSubpath(packageName, subpath = "") {
+  const root = await resolveInstalledPackageRoot(packageName);
+  if (!root) return null;
+  const candidate = path.join(root, subpath || "");
+  try {
+    await access(candidate);
+    return candidate;
+  } catch {
+    return null;
+  }
+}
+
+function optionalFeatureDeclaredSpec(packageName) {
+  return declaredDependencySpec(packageJson, packageName) || "";
+}
+
+async function optionalFeaturePackageStatus(featureId) {
   const packageName = OPTIONAL_FEATURE_PACKAGES.get(featureId);
   if (!packageName) throw makeHttpError(400, `Unknown optional feature: ${featureId}`);
+  const declaredSpec = optionalFeatureDeclaredSpec(packageName);
+  const installedRoot = await resolveInstalledPackageRoot(packageName);
+  const manifest = installedRoot ? await readJsonFileIfExists(path.join(installedRoot, "package.json")) : null;
+  const installedVersion = typeof manifest?.version === "string" ? manifest.version : "";
+  const updateAvailable = !!(installedVersion && packageVersionBelowSpec(installedVersion, declaredSpec));
+  return {
+    featureId,
+    packageName,
+    declaredSpec,
+    installed: !!installedRoot,
+    installedVersion,
+    installedRoot,
+    updateAvailable,
+    updateReason: updateAvailable ? `installed ${installedVersion} is older than Web UI expects (${declaredSpec})` : "",
+  };
+}
+
+async function optionalFeaturePackageStatuses() {
+  const features = [];
+  for (const featureId of OPTIONAL_FEATURE_PACKAGES.keys()) features.push(await optionalFeaturePackageStatus(featureId));
+  return { features };
+}
+
+async function installOptionalFeaturePackage(featureId) {
+  const beforeStatus = await optionalFeaturePackageStatus(featureId);
+  const packageName = beforeStatus.packageName;
 
   const installRoot = await optionalDependencyInstallRoot();
   const npmCommand = process.env.PI_WEBUI_NPM_BIN || "npm";
@@ -978,6 +1071,8 @@ async function installOptionalFeaturePackage(featureId) {
     const details = [result.error, result.timedOut ? "timed out" : undefined, result.stderr?.trim(), result.stdout?.trim()].filter(Boolean).join("\n");
     throw makeHttpError(500, `Optional feature install failed: ${command}${details ? `\n${details}` : ""}`);
   }
+  const afterStatus = await optionalFeaturePackageStatus(featureId);
+  const operation = beforeStatus.installed ? "Updated" : "Installed";
   return {
     featureId,
     packageName,
@@ -985,7 +1080,8 @@ async function installOptionalFeaturePackage(featureId) {
     command,
     stdout: result.stdout,
     stderr: result.stderr,
-    message: `Installed optional feature package ${packageName}. Reload the active Pi tab to load new resources.`,
+    status: afterStatus,
+    message: `${operation} optional feature package ${packageName}${afterStatus.installedVersion ? ` to ${afterStatus.installedVersion}` : ""}. Reload the active Pi tab to load new resources.`,
   };
 }
 
@@ -2955,6 +3051,58 @@ function cleanGitCommitMessageInput(value) {
   return message;
 }
 
+function parseGitPorcelainZEntries(text) {
+  const fields = String(text || "").split("\0").filter(Boolean);
+  const entries = [];
+  for (let index = 0; index < fields.length; index++) {
+    const field = fields[index];
+    if (field.length < 4) {
+      entries.push({ x: "", y: "", path: field, unsupported: true });
+      continue;
+    }
+    const x = field[0] || " ";
+    const y = field[1] || " ";
+    const filePath = field.slice(3);
+    const entry = { x, y, path: filePath };
+    if ((x === "R" || x === "C") && index + 1 < fields.length) entry.oldPath = fields[++index];
+    entries.push(entry);
+  }
+  return entries;
+}
+
+function gitWorkflowDefaultCommitAction(entry) {
+  if (!entry || entry.y !== " ") return "";
+  if (entry.x === "A") return "created";
+  if (entry.x === "M" || entry.x === "T") return "updated";
+  if (entry.x === "D") return "deleted";
+  return "";
+}
+
+function formatGitWorkflowDefaultCommitPath(filePath) {
+  return String(filePath || "").replace(/[\0\r\n\t]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 4000);
+}
+
+async function readGitWorkflowDefaultCommitMessage(cwd) {
+  const root = await getGitRoot(cwd);
+  const statusText = await runGitReadCommand(root, ["status", "--porcelain=v1", "-z", "--untracked-files=all"], { maxOutputLength: 120_000 });
+  const entries = parseGitPorcelainZEntries(statusText);
+  const empty = (reason, extra = {}) => ({ root, message: "", reason, ...extra });
+  if (entries.length === 0) return empty("No changed files are ready for a default commit message.");
+  if (entries.length !== 1) return empty(`Expected exactly one changed file for a default commit message; found ${entries.length}.`);
+  const [entry] = entries;
+  const action = gitWorkflowDefaultCommitAction(entry);
+  const displayPath = formatGitWorkflowDefaultCommitPath(entry.path);
+  if (!action || !displayPath) {
+    return empty("The only changed file is not a staged created, updated, or deleted file.", { path: entry.path || "" });
+  }
+  return {
+    root,
+    message: `${action} ${displayPath}`,
+    action,
+    path: entry.path,
+  };
+}
+
 function cleanGitHubUsername(value) {
   const username = String(value || "").trim().replace(/^@+/, "");
   if (!username) throw new Error("GitHub username is required");
@@ -3300,6 +3448,8 @@ async function handleGitWorkflowRequest(pathname, body = {}, cwd = options.cwd)
     switch (pathname) {
       case "/api/git-workflow/message":
         return { ok: true, data: await readGitWorkflowMessages(cwd) };
+      case "/api/git-workflow/default-commit-message":
+        return { ok: true, data: await readGitWorkflowDefaultCommitMessage(cwd) };
       case "/api/git-workflow/branch-name":
         return { ok: true, data: await readGitWorkflowBranchName(cwd) };
       case "/api/git-workflow/pr-description":
@@ -3917,16 +4067,8 @@ function parseNodeModulesPackageRef(manifestEntry) {
 async function resolveStartedWebuiManifestResource(manifestEntry) {
   const nodeModulesRef = parseNodeModulesPackageRef(manifestEntry);
   if (nodeModulesRef && WEBUI_CONTROLLED_PACKAGES.has(nodeModulesRef.packageName)) {
-    const workspaceRoot = await workspacePackageRootForName(nodeModulesRef.packageName);
-    if (workspaceRoot) {
-      const devCandidate = path.join(workspaceRoot, nodeModulesRef.subpath);
-      try {
-        await access(devCandidate);
-        return devCandidate;
-      } catch {
-        // Fall back to the started package's node_modules copy below.
-      }
-    }
+    const installedCandidate = await resolveInstalledPackageSubpath(nodeModulesRef.packageName, nodeModulesRef.subpath);
+    if (installedCandidate) return installedCandidate;
   }
 
   const candidate = path.resolve(packageRoot, manifestEntry);
@@ -6964,6 +7106,11 @@ const server = createServer(async (req, res) => {
       return;
     }
 
+    if (url.pathname === "/api/optional-features" && req.method === "GET") {
+      sendJson(res, 200, { ok: true, data: await optionalFeaturePackageStatuses() });
+      return;
+    }
+
     if (url.pathname === "/api/optional-feature-install" && req.method === "POST") {
       requireLocalhostRoute(req, url.pathname);
       const body = await readJsonBody(req);

package/package.json

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