pi-extmgr 0.1.21 → 0.1.23

package/README.md

@@ -17,11 +17,16 @@ pi install npm:pi-extmgr
 
 Then reload Pi.
 
+Requires Node.js `>=22.5.0`.
+
 ## Features
 
 - **Unified manager UI**
   - Local extensions (`~/.pi/agent/extensions`, `.pi/extensions`) and installed packages in one list
   - Scope indicators (global/project), status indicators, update badges
+- **Package extension configuration panel**
+  - Configure individual extension entrypoints inside an installed package (`c` on package row)
+  - Persists to package filters in `settings.json` (no manual JSON editing)
 - **Safe staged local extension toggles**
   - Toggle with `Space/Enter`, apply with `S`
   - Unsaved-change guard when leaving (save/discard/stay)
@@ -54,22 +59,23 @@ Open the manager:
 
 ### In the manager
 
-| Key           | Action                                           |
-| ------------- | ------------------------------------------------ |
-| `↑↓`          | Navigate                                         |
-| `Space/Enter` | Toggle local/package extension on/off            |
-| `S`           | Save changes                                     |
-| `Enter` / `A` | Actions on selected package (update/remove/view) |
-| `u`           | Update selected package directly                 |
-| `X`           | Remove selected item (package/local extension)   |
-| `i`           | Quick install by source                          |
-| `f`           | Quick search                                     |
-| `U`           | Update all packages                              |
-| `t`           | Auto-update wizard                               |
-| `P` / `M`     | Quick actions palette                            |
-| `R`           | Browse remote packages                           |
-| `?` / `H`     | Help                                             |
-| `Esc`         | Exit                                             |
+| Key           | Action                                                |
+| ------------- | ----------------------------------------------------- |
+| `↑↓`          | Navigate                                              |
+| `Space/Enter` | Toggle local extension on/off                         |
+| `S`           | Save local extension changes                          |
+| `Enter` / `A` | Actions on selected package (configure/update/remove) |
+| `c`           | Configure selected package extensions                 |
+| `u`           | Update selected package directly                      |
+| `X`           | Remove selected item (package/local extension)        |
+| `i`           | Quick install by source                               |
+| `f`           | Quick search                                          |
+| `U`           | Update all packages                                   |
+| `t`           | Auto-update wizard                                    |
+| `P` / `M`     | Quick actions palette                                 |
+| `R`           | Browse remote packages                                |
+| `?` / `H`     | Help                                                  |
+| `Esc`         | Exit                                                  |
 
 ### Commands
 
@@ -134,7 +140,9 @@ Examples:
 
 ## Tips
 
-- **Staged changes**: Toggle extensions on/off, then press `S` to apply all at once. A `*` shows pending changes.
+- **Staged local changes**: Toggle local extensions on/off, then press `S` to apply all at once.
+- **Package extension config**: Select a package and press `c` (or Enter/A → Configure) to enable/disable individual package entrypoints.
+  - After saving package extension config, restart pi to fully apply changes.
 - **Two install modes**:
   - **Managed** (npm): Auto-updates with `pi update`, stored in pi's package cache
   - **Local** (standalone): Copies to `~/.pi/agent/extensions/{package}/`, supports multi-file extensions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-extmgr",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "Enhanced UX for managing local Pi extensions and community packages",
   "keywords": [
     "pi-package",
@@ -57,7 +57,7 @@
   "author": "ayagmar",
   "license": "MIT",
   "engines": {
-    "node": ">=22"
+    "node": ">=22.5.0"
   },
   "repository": {
     "type": "git",

package/src/index.ts

@@ -70,12 +70,17 @@ export default function extensionsManager(pi: ExtensionAPI) {
     // Restore persisted auto-update config into session entries so sync lookups are valid.
     await hydrateAutoUpdateConfig(pi, ctx);
 
-    if (!ctx.hasUI) return;
+    if (!ctx.hasUI) {
+      stopAutoUpdateTimer();
+      return;
+    }
 
     const config = getAutoUpdateConfig(ctx);
     if (config.enabled && config.intervalMs > 0) {
       const getCtx: ContextProvider = () => ctx;
       startAutoUpdateTimer(pi, getCtx, createAutoUpdateNotificationHandler(ctx));
+    } else {
+      stopAutoUpdateTimer();
     }
 
     setImmediate(() => {

package/src/packages/discovery.ts

@@ -12,7 +12,12 @@ import type { InstalledPackage, NpmPackage, SearchCache } from "../types/index.j
 import { CACHE_TTL, TIMEOUTS } from "../constants.js";
 import { readSummary } from "../utils/fs.js";
 import { parseNpmSource } from "../utils/format.js";
-import { getPackageSourceKind, splitGitRepoAndRef } from "../utils/package-source.js";
+import {
+  getPackageSourceKind,
+  normalizeLocalSourceIdentity,
+  splitGitRepoAndRef,
+} from "../utils/package-source.js";
+import { execNpm } from "../utils/npm-exec.js";
 
 let searchCache: SearchCache | null = null;
 
@@ -67,9 +72,8 @@ export async function searchNpmPackages(
     ctx.ui.notify(`Searching npm for "${query}"...`, "info");
   }
 
-  const res = await pi.exec("npm", ["search", "--json", `--searchlimit=${searchLimit}`, query], {
+  const res = await execNpm(pi, ["search", "--json", `--searchlimit=${searchLimit}`, query], ctx, {
     timeout: TIMEOUTS.npmSearch,
-    cwd: ctx.cwd,
   });
 
   if (res.code !== 0) {
@@ -118,7 +122,14 @@ function sanitizeListSourceSuffix(source: string): string {
 }
 
 function normalizeSourceIdentity(source: string): string {
-  return sanitizeListSourceSuffix(source).replace(/\\/g, "/").toLowerCase();
+  const sanitized = sanitizeListSourceSuffix(source);
+  const kind = getPackageSourceKind(sanitized);
+
+  if (kind === "local") {
+    return normalizeLocalSourceIdentity(sanitized);
+  }
+
+  return sanitized.replace(/\\/g, "/").toLowerCase();
 }
 
 function isScopeHeader(lowerTrimmed: string, scope: "global" | "project"): boolean {
@@ -375,9 +386,8 @@ async function fetchPackageSize(
 
   try {
     // Try to get unpacked size from npm view
-    const res = await pi.exec("npm", ["view", pkgName, "dist.unpackedSize", "--json"], {
+    const res = await execNpm(pi, ["view", pkgName, "dist.unpackedSize", "--json"], ctx, {
       timeout: TIMEOUTS.npmView,
-      cwd: ctx.cwd,
     });
     if (res.code === 0) {
       try {
@@ -441,9 +451,8 @@ async function addPackageMetadata(
                 if (cached?.description) {
                   pkg.description = cached.description;
                 } else {
-                  const res = await pi.exec("npm", ["view", pkgName, "description", "--json"], {
+                  const res = await execNpm(pi, ["view", pkgName, "description", "--json"], ctx, {
                     timeout: TIMEOUTS.npmView,
-                    cwd: ctx.cwd,
                   });
                   if (res.code === 0) {
                     try {

package/src/packages/extensions.ts

@@ -1,9 +1,13 @@
-import { mkdir, readFile, writeFile, rename, rm } from "node:fs/promises";
-import { dirname, join, relative, resolve } from "node:path";
+import { mkdir, readFile, writeFile, rename, rm, readdir } from "node:fs/promises";
+import type { Dirent } from "node:fs";
+import { dirname, join, matchesGlob, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { getAgentDir } from "@mariozechner/pi-coding-agent";
 import type { InstalledPackage, PackageExtensionEntry, Scope, State } from "../types/index.js";
+import { parseNpmSource } from "../utils/format.js";
 import { fileExists, readSummary } from "../utils/fs.js";
 
 interface PackageSettingsObject {
@@ -15,6 +19,9 @@ interface SettingsFile {
   packages?: (string | PackageSettingsObject)[];
 }
 
+const execFileAsync = promisify(execFile);
+let globalNpmRootCache: string | null | undefined;
+
 function normalizeRelativePath(value: string): string {
   const normalized = value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
   return normalized;
@@ -37,11 +44,69 @@ function normalizePackageRootCandidate(candidate: string): string {
   return resolved;
 }
 
-function toPackageRoot(pkg: InstalledPackage, cwd: string): string | undefined {
+async function getGlobalNpmRoot(): Promise<string | undefined> {
+  if (globalNpmRootCache !== undefined) {
+    return globalNpmRootCache ?? undefined;
+  }
+
+  try {
+    const { stdout } = await execFileAsync("npm", ["root", "-g"], {
+      timeout: 2_000,
+      windowsHide: true,
+    });
+    const root = stdout.trim();
+    globalNpmRootCache = root || null;
+  } catch {
+    globalNpmRootCache = null;
+  }
+
+  return globalNpmRootCache ?? undefined;
+}
+
+async function resolveNpmPackageRoot(
+  pkg: InstalledPackage,
+  cwd: string
+): Promise<string | undefined> {
+  const parsed = parseNpmSource(pkg.source);
+  if (!parsed?.name) {
+    return undefined;
+  }
+
+  const packageName = parsed.name;
+  const projectCandidates = [
+    join(cwd, ".pi", "npm", "node_modules", packageName),
+    join(cwd, "node_modules", packageName),
+  ];
+
+  const packageDir = process.env.PI_PACKAGE_DIR || join(homedir(), ".pi", "agent");
+  const globalCandidates = [join(packageDir, "npm", "node_modules", packageName)];
+
+  const npmGlobalRoot = await getGlobalNpmRoot();
+  if (npmGlobalRoot) {
+    globalCandidates.unshift(join(npmGlobalRoot, packageName));
+  }
+
+  const candidates =
+    pkg.scope === "project" ? projectCandidates : [...globalCandidates, ...projectCandidates];
+
+  for (const candidate of candidates) {
+    if (await fileExists(join(candidate, "package.json"))) {
+      return candidate;
+    }
+  }
+
+  return undefined;
+}
+
+async function toPackageRoot(pkg: InstalledPackage, cwd: string): Promise<string | undefined> {
   if (pkg.resolvedPath) {
     return normalizePackageRootCandidate(pkg.resolvedPath);
   }
 
+  if (pkg.source.startsWith("npm:")) {
+    return resolveNpmPackageRoot(pkg, cwd);
+  }
+
   if (pkg.source.startsWith("file://")) {
     try {
       return normalizePackageRootCandidate(fileURLToPath(pkg.source));
@@ -141,23 +206,79 @@ async function writeSettingsFile(path: string, settings: SettingsFile): Promise<
   }
 }
 
+function safeMatchesGlob(targetPath: string, pattern: string): boolean {
+  try {
+    return matchesGlob(targetPath, pattern);
+  } catch {
+    return false;
+  }
+}
+
+function matchesFilterPattern(targetPath: string, pattern: string): boolean {
+  const normalizedPattern = normalizeRelativePath(pattern.trim());
+  if (!normalizedPattern) return false;
+  if (targetPath === normalizedPattern) return true;
+
+  return safeMatchesGlob(targetPath, normalizedPattern);
+}
+
 function getPackageFilterState(filters: string[] | undefined, extensionPath: string): State {
-  if (!filters || filters.length === 0) {
+  // Omitted key => all enabled (pi default).
+  if (filters === undefined) {
     return "enabled";
   }
 
+  // Explicit empty array => load none.
+  if (filters.length === 0) {
+    return "disabled";
+  }
+
   const normalizedTarget = normalizeRelativePath(extensionPath);
-  let state: State = "enabled";
+  const includePatterns: string[] = [];
+  const excludePatterns: string[] = [];
+  let markerOverride: State | undefined;
+
+  for (const rawToken of filters) {
+    const token = rawToken.trim();
+    if (!token) continue;
+
+    const prefix = token[0];
+
+    if (prefix === "+" || prefix === "-") {
+      const markerPath = normalizeRelativePath(token.slice(1));
+      if (markerPath === normalizedTarget) {
+        markerOverride = prefix === "+" ? "enabled" : "disabled";
+      }
+      continue;
+    }
+
+    if (prefix === "!") {
+      const pattern = normalizeRelativePath(token.slice(1));
+      if (pattern) {
+        excludePatterns.push(pattern);
+      }
+      continue;
+    }
+
+    const include = normalizeRelativePath(token);
+    if (include) {
+      includePatterns.push(include);
+    }
+  }
+
+  let enabled =
+    includePatterns.length === 0 ||
+    includePatterns.some((p) => matchesFilterPattern(normalizedTarget, p));
+
+  if (enabled && excludePatterns.some((p) => matchesFilterPattern(normalizedTarget, p))) {
+    enabled = false;
+  }
 
-  for (const token of filters) {
-    if (!token || (token[0] !== "+" && token[0] !== "-")) continue;
-    const sign = token[0];
-    const path = normalizeRelativePath(token.slice(1));
-    if (path !== normalizedTarget) continue;
-    state = sign === "+" ? "enabled" : "disabled";
+  if (markerOverride !== undefined) {
+    enabled = markerOverride === "enabled";
   }
 
-  return state;
+  return enabled ? "enabled" : "disabled";
 }
 
 async function getPackageExtensionState(
@@ -185,26 +306,131 @@ async function getPackageExtensionState(
   return getPackageFilterState(entry.extensions, extensionPath);
 }
 
-async function discoverEntrypoints(packageRoot: string): Promise<string[]> {
+function isExtensionEntrypointPath(path: string): boolean {
+  return /\.(ts|js)$/i.test(path);
+}
+
+function hasGlobMagic(path: string): boolean {
+  return /[*?{}[\]]/.test(path);
+}
+
+function isSafeRelativePath(path: string): boolean {
+  return path !== "" && path !== ".." && !path.startsWith("../") && !path.includes("/../");
+}
+
+function selectDirectoryFiles(allFiles: string[], directoryPath: string): string[] {
+  const prefix = `${directoryPath}/`;
+  return allFiles.filter((file) => file.startsWith(prefix));
+}
+
+function applySelection(selected: Set<string>, files: Iterable<string>, exclude: boolean): void {
+  for (const file of files) {
+    if (exclude) {
+      selected.delete(file);
+    } else {
+      selected.add(file);
+    }
+  }
+}
+
+async function collectExtensionFilesFromDir(
+  packageRoot: string,
+  startDir: string
+): Promise<string[]> {
+  const collected: string[] = [];
+
+  let entries: Dirent[];
+  try {
+    entries = await readdir(startDir, { withFileTypes: true });
+  } catch {
+    return collected;
+  }
+
+  for (const entry of entries) {
+    const absolutePath = join(startDir, entry.name);
+
+    if (entry.isDirectory()) {
+      collected.push(...(await collectExtensionFilesFromDir(packageRoot, absolutePath)));
+      continue;
+    }
+
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    const relativePath = normalizeRelativePath(relative(packageRoot, absolutePath));
+    if (isExtensionEntrypointPath(relativePath)) {
+      collected.push(relativePath);
+    }
+  }
+
+  return collected;
+}
+
+async function resolveManifestExtensionEntries(
+  packageRoot: string,
+  entries: string[]
+): Promise<string[]> {
+  const selected = new Set<string>();
+  const allFiles = await collectExtensionFilesFromDir(packageRoot, packageRoot);
+
+  for (const rawToken of entries) {
+    const token = rawToken.trim();
+    if (!token) continue;
+
+    const exclude = token.startsWith("!");
+    const normalizedToken = normalizeRelativePath(exclude ? token.slice(1) : token);
+    const pattern = normalizedToken.replace(/[\\/]+$/g, "");
+    if (!isSafeRelativePath(pattern)) {
+      continue;
+    }
+
+    if (hasGlobMagic(pattern)) {
+      const matchedFiles = allFiles.filter((file) => matchesFilterPattern(file, pattern));
+      applySelection(selected, matchedFiles, exclude);
+      continue;
+    }
+
+    const directoryFiles = selectDirectoryFiles(allFiles, pattern);
+    if (directoryFiles.length > 0) {
+      applySelection(selected, directoryFiles, exclude);
+      continue;
+    }
+
+    if (isExtensionEntrypointPath(pattern)) {
+      applySelection(selected, [pattern], exclude);
+    }
+  }
+
+  return Array.from(selected).sort((a, b) => a.localeCompare(b));
+}
+
+export async function resolveManifestExtensionEntrypoints(
+  packageRoot: string
+): Promise<string[] | undefined> {
   const packageJsonPath = join(packageRoot, "package.json");
-  let manifestExtensions: string[] | undefined;
 
+  let parsed: { pi?: { extensions?: unknown } };
   try {
     const raw = await readFile(packageJsonPath, "utf8");
-    const parsed = JSON.parse(raw) as { pi?: { extensions?: unknown } };
-    const ext = parsed.pi?.extensions;
-    if (Array.isArray(ext)) {
-      const entries = ext.filter((value): value is string => typeof value === "string");
-      if (entries.length > 0) {
-        manifestExtensions = entries;
-      }
-    }
+    parsed = JSON.parse(raw) as { pi?: { extensions?: unknown } };
   } catch {
-    // Ignore invalid/missing package.json and fall back.
+    return undefined;
+  }
+
+  const extensions = parsed.pi?.extensions;
+  if (!Array.isArray(extensions)) {
+    return undefined;
   }
 
-  if (manifestExtensions && manifestExtensions.length > 0) {
-    return manifestExtensions.map((entry) => normalizeRelativePath(entry));
+  const entries = extensions.filter((value): value is string => typeof value === "string");
+  return resolveManifestExtensionEntries(packageRoot, entries);
+}
+
+async function discoverEntrypoints(packageRoot: string): Promise<string[]> {
+  const manifestEntrypoints = await resolveManifestExtensionEntrypoints(packageRoot);
+  if (manifestEntrypoints !== undefined) {
+    return manifestEntrypoints;
   }
 
   const indexTs = join(packageRoot, "index.ts");
@@ -227,7 +453,7 @@ export async function discoverPackageExtensions(
   const entries: PackageExtensionEntry[] = [];
 
   for (const pkg of packages) {
-    const packageRoot = toPackageRoot(pkg, cwd);
+    const packageRoot = await toPackageRoot(pkg, cwd);
     if (!packageRoot) continue;
 
     const extensionPaths = await discoverEntrypoints(packageRoot);
@@ -319,8 +545,3 @@ export async function setPackageExtensionState(
     };
   }
 }
-
-export function toProjectRelativePath(path: string, cwd: string): string {
-  const rel = relative(cwd, path);
-  return rel.startsWith("..") ? path : normalizeRelativePath(rel);
-}

package/src/packages/install.ts

@@ -1,13 +1,14 @@
 /**
  * Package installation logic
  */
-import { mkdir, rm, writeFile, cp, readFile } from "node:fs/promises";
+import { mkdir, rm, writeFile, cp } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
 import { normalizePackageSource } from "../utils/format.js";
 import { fileExists } from "../utils/fs.js";
 import { clearSearchCache, isSourceInstalled } from "./discovery.js";
+import { resolveManifestExtensionEntrypoints } from "./extensions.js";
 import { waitForCondition } from "../utils/retry.js";
 import { logPackageInstall } from "../utils/history.js";
 import { clearUpdatesAvailable } from "../utils/settings.js";
@@ -15,6 +16,7 @@ import { notify, error as notifyError, success } from "../utils/notify.js";
 import { confirmAction, confirmReload, showProgress } from "../utils/ui-helpers.js";
 import { tryOperation } from "../utils/mode.js";
 import { updateExtmgrStatus } from "../utils/status.js";
+import { execNpm } from "../utils/npm-exec.js";
 import { TIMEOUTS } from "../constants.js";
 
 export type InstallScope = "global" | "project";
@@ -70,29 +72,15 @@ function safeExtractGithubMatch(match: RegExpMatchArray | null): GithubUrlInfo |
   return { owner, repo, branch, filePath };
 }
 
-function normalizeRelativePath(value: string): string {
-  return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
-}
-
 async function hasStandaloneEntrypoint(packageRoot: string): Promise<boolean> {
-  try {
-    const manifestPath = join(packageRoot, "package.json");
-    const raw = await readFile(manifestPath, "utf8");
-    const parsed = JSON.parse(raw) as { pi?: { extensions?: unknown } };
-    const declared = parsed.pi?.extensions;
-
-    if (Array.isArray(declared) && declared.length > 0) {
-      for (const entry of declared) {
-        if (typeof entry !== "string" || !entry.trim()) continue;
-        const candidate = join(packageRoot, normalizeRelativePath(entry));
-        if (await fileExists(candidate)) {
-          return true;
-        }
+  const declared = await resolveManifestExtensionEntrypoints(packageRoot);
+  if (declared !== undefined) {
+    for (const path of declared) {
+      if (await fileExists(join(packageRoot, path))) {
+        return true;
       }
-      return false;
     }
-  } catch {
-    // Ignore invalid/missing manifest and fall back to conventional entrypoints.
+    return false;
   }
 
   return (
@@ -304,9 +292,8 @@ export async function installPackageLocally(
       await mkdir(extensionDir, { recursive: true });
       showProgress(ctx, "Fetching", packageName);
 
-      const viewRes = await pi.exec("npm", ["view", packageName, "--json"], {
+      const viewRes = await execNpm(pi, ["view", packageName, "--json"], ctx, {
         timeout: TIMEOUTS.fetchPackageInfo,
-        cwd: ctx.cwd,
       });
 
       if (viewRes.code !== 0) {