pi-extmgr 0.1.23 → 0.1.25

package/README.md

@@ -26,6 +26,7 @@ Requires Node.js `>=22.5.0`.
   - Scope indicators (global/project), status indicators, update badges
 - **Package extension configuration panel**
   - Configure individual extension entrypoints inside an installed package (`c` on package row)
+  - Works with manifest-declared entrypoints and conventional `extensions/` package layouts
   - Persists to package filters in `settings.json` (no manual JSON editing)
 - **Safe staged local extension toggles**
   - Toggle with `Space/Enter`, apply with `S`
@@ -36,15 +37,16 @@ Requires Node.js `>=22.5.0`.
 - **Remote discovery and install**
   - npm search/browse with pagination
   - Install by source (`npm:`, `git:`, `https://`, `ssh://`, `git@...`, local path)
-  - Supports direct GitHub `.ts` installs and local standalone install mode
+  - Supports direct GitHub `.ts` installs and standalone local install for self-contained packages
 - **Auto-update**
   - Interactive wizard (`t` in manager, or `/extensions auto-update`)
   - Persistent schedule restored on startup and session switch
-  - Background checks + status bar updates
+  - Background checks + status bar updates for installed npm packages
 - **Operational visibility**
   - Session history (`/extensions history`)
-  - Cache controls (`/extensions clear-cache`)
+  - Cache controls (`/extensions clear-cache` clears persistent + runtime extmgr caches)
   - Status line summary (`pkg count • auto-update • known updates`)
+  - History now records local extension deletions and auto-update configuration changes
 - **Interactive + non-interactive support**
   - Works in TUI and non-UI modes
   - Non-interactive commands for list/install/remove/update/auto-update
@@ -91,9 +93,9 @@ Open the manager:
 /extensions remove [source]      # Remove package
 /extensions uninstall [source]   # Alias: remove
 /extensions update [source]      # Update one package (or all when omitted)
-/extensions auto-update [every]  # No arg opens wizard in UI; accepts 1d, 1w, never, etc.
+/extensions auto-update [every]  # No arg opens wizard in UI; accepts 1d, 1w, 1mo, never, etc.
 /extensions history [options]    # View change history (supports filters)
-/extensions clear-cache          # Clear metadata cache
+/extensions clear-cache          # Clear persistent + runtime extmgr caches
 ```
 
 ### Non-interactive mode
@@ -107,23 +109,33 @@ When Pi is running without UI, extmgr still supports command-driven workflows:
 - `/extensions update [source]`
 - `/extensions history [options]`
 - `/extensions auto-update <duration>`
+  - Use `1mo` for monthly schedules (`/extensions history --since <duration>` also accepts `1mo`; `30m`/`24h` are just lookback examples)
 
-Remote browsing/search menus require interactive mode.
+Remote browsing/search menus require the full interactive TUI.
+
+### RPC / limited-UI mode
+
+In RPC mode, dialog-based commands still work, but the custom TUI panels do not:
+
+- `/extensions` falls back to read-only local/package lists
+- `/extensions installed` lists packages directly
+- remote browsing/search panels require the full interactive TUI
+- package extension configuration requires the full interactive TUI
 
 History options (works in non-interactive mode too):
 
 - `--limit <n>`
-- `--action <extension_toggle|package_install|package_update|package_remove|cache_clear>`
+- `--action <extension_toggle|extension_delete|package_install|package_update|package_remove|cache_clear|auto_update_config>`
 - `--success` / `--failed`
 - `--package <query>`
-- `--since <duration>` (e.g. `30m`, `24h`, `7d`, `1mo`)
-- `--global` (non-interactive mode only; reads all persisted sessions)
+- `--since <duration>` (e.g. `30m`, `24h`, `7d`, `1mo`; `1mo` is supported for monthly lookbacks)
+- `--global` (non-interactive mode only; reads all persisted sessions under `~/.pi/agent/sessions`)
 
 Examples:
 
 - `/extensions history --failed --limit 50`
 - `/extensions history --action package_update --since 7d`
-- `/extensions history --global --package extmgr --since 24h`
+- `/extensions history --global --package extmgr --since 1mo`
 
 ### Install sources
 
@@ -144,9 +156,10 @@ Examples:
 - **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
+  - **Managed** (npm): Auto-updates with `pi update`, stored in pi's package cache, supports Pi package manifest/convention loading
+  - **Local** (standalone): Copies to `~/.pi/agent/extensions/{package}/`, so it only accepts runnable standalone layouts (manifest-declared/root entrypoints), requires `tar` on `PATH`, and rejects packages whose runtime `dependencies` are not already bundled with the package contents
 - **Auto-update schedule is persistent**: `/extensions auto-update 1d` stays active across future Pi sessions and is restored when switching sessions.
+- **Auto-update coverage is npm-only today**: extmgr checks update availability for managed npm packages; git/local installs are not included in the background update badge yet.
 - **Settings/cache writes are hardened**: extmgr serializes writes and uses safe file replacement to reduce JSON corruption issues.
 - **Invalid JSON is handled safely**: malformed `auto-update.json` / metadata cache files are backed up and reset; invalid `.pi/settings.json` is not overwritten during package-extension toggles.
 - **Reload is built-in**: When extmgr asks to reload, it calls `ctx.reload()` directly.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-extmgr",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "Enhanced UX for managing local Pi extensions and community packages",
   "keywords": [
     "pi-package",

package/src/commands/auto-update.ts

@@ -54,7 +54,7 @@ export async function handleAutoUpdateSubcommand(
       "  3d      - Check every 3 days",
       "  1w      - Check weekly",
       "  2w      - Check every 2 weeks",
-      "  1m      - Check monthly",
+      "  1mo     - Check monthly (1m also works)",
       "  daily   - Check daily (alias)",
       "  weekly  - Check weekly (alias)",
     ];

package/src/commands/cache.ts

@@ -1,4 +1,6 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { clearSearchCache } from "../packages/discovery.js";
+import { clearRemotePackageInfoCache } from "../ui/remote.js";
 import { clearCache } from "../utils/cache.js";
 import { logCacheClear } from "../utils/history.js";
 import { notify } from "../utils/notify.js";
@@ -10,8 +12,10 @@ export async function clearMetadataCacheCommand(
 ): Promise<void> {
   try {
     await clearCache();
+    clearSearchCache();
+    clearRemotePackageInfoCache();
     logCacheClear(pi, true);
-    notify(ctx, "Metadata cache cleared.", "info");
+    notify(ctx, "Metadata and in-memory extmgr caches cleared.", "info");
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     logCacheClear(pi, false, message);

package/src/commands/history.ts

@@ -11,10 +11,12 @@ import { formatListOutput } from "../utils/ui-helpers.js";
 
 const HISTORY_ACTIONS: ChangeAction[] = [
   "extension_toggle",
+  "extension_delete",
   "package_install",
   "package_update",
   "package_remove",
   "cache_clear",
+  "auto_update_config",
 ];
 
 interface ParsedHistoryArgs {
@@ -187,12 +189,12 @@ function showHistoryHelp(ctx: ExtensionCommandContext): void {
     "Options:",
     "  --limit <n>      Maximum entries to show (default: 20)",
     "  --action <type>  Filter by action",
-    "                   extension_toggle | package_install | package_update | package_remove | cache_clear",
+    `                   ${HISTORY_ACTIONS.join(" | ")}`,
     "  --success        Show only successful entries",
     "  --failed         Show only failed entries",
     "  --package <q>    Filter by package/source/extension id",
     "  --since <d>      Show only entries newer than duration (e.g. 30m, 24h, 7d, 1mo)",
-    "  --global         Read all persisted sessions (non-interactive mode only)",
+    "  --global         Read all persisted sessions from ~/.pi/agent/sessions (non-interactive mode only)",
     "",
     "Examples:",
     "  /extensions history --failed --limit 50",

package/src/commands/registry.ts

@@ -34,7 +34,7 @@ function showNonInteractiveHelp(ctx: ExtensionCommandContext): void {
     "  /extensions remove <source>  - Remove a package",
     "  /extensions update [source]  - Update one package or all packages",
     "  /extensions history [opts]   - Show history (supports filters)",
-    "  /extensions auto-update <d>  - Configure auto-update (e.g. 1d, 1w, never)",
+    "  /extensions auto-update <d>  - Configure auto-update (e.g. 1d, 1w, 1mo, never)",
     "",
     "History examples:",
     "  /extensions history --failed --limit 50",

package/src/packages/discovery.ts

@@ -14,10 +14,30 @@ import { readSummary } from "../utils/fs.js";
 import { parseNpmSource } from "../utils/format.js";
 import {
   getPackageSourceKind,
-  normalizeLocalSourceIdentity,
+  normalizePackageIdentity,
   splitGitRepoAndRef,
+  stripGitSourcePrefix,
 } from "../utils/package-source.js";
 import { execNpm } from "../utils/npm-exec.js";
+import { fetchWithTimeout } from "../utils/network.js";
+
+const NPM_SEARCH_API = "https://registry.npmjs.org/-/v1/search";
+const NPM_SEARCH_PAGE_SIZE = 250;
+
+interface NpmSearchResultObject {
+  package?: {
+    name?: string;
+    version?: string;
+    description?: string;
+    keywords?: string[];
+    date?: string;
+  };
+}
+
+interface NpmSearchResponse {
+  total?: number;
+  objects?: NpmSearchResultObject[];
+}
 
 let searchCache: SearchCache | null = null;
 
@@ -50,15 +70,86 @@ import {
   setCachedPackageSize,
 } from "../utils/cache.js";
 
+function toNpmPackage(entry: NpmSearchResultObject): NpmPackage | undefined {
+  const pkg = entry.package;
+  if (!pkg) return undefined;
+
+  const name = pkg.name?.trim();
+  if (!name) return undefined;
+
+  return {
+    name,
+    version: pkg.version,
+    description: pkg.description,
+    keywords: Array.isArray(pkg.keywords) ? pkg.keywords : undefined,
+    date: pkg.date,
+  };
+}
+
+async function fetchNpmSearchPage(
+  query: string,
+  from: number
+): Promise<{
+  total: number;
+  resultCount: number;
+  packages: NpmPackage[];
+}> {
+  const params = new URLSearchParams({
+    text: query,
+    size: String(NPM_SEARCH_PAGE_SIZE),
+    from: String(from),
+  });
+  const response = await fetchWithTimeout(
+    `${NPM_SEARCH_API}?${params.toString()}`,
+    TIMEOUTS.npmSearch
+  );
+
+  if (!response.ok) {
+    throw new Error(`npm registry search failed: HTTP ${response.status}`);
+  }
+
+  const data = (await response.json()) as NpmSearchResponse;
+  const objects = data.objects ?? [];
+  const packages = objects.map(toNpmPackage).filter((pkg): pkg is NpmPackage => !!pkg);
+
+  return {
+    total:
+      typeof data.total === "number" && Number.isFinite(data.total) ? data.total : packages.length,
+    resultCount: objects.length,
+    packages,
+  };
+}
+
+export async function fetchNpmRegistrySearchResults(query: string): Promise<NpmPackage[]> {
+  const packagesByName = new Map<string, NpmPackage>();
+  let from = 0;
+  let total = Infinity;
+
+  while (from < total) {
+    const page = await fetchNpmSearchPage(query, from);
+    total = page.total;
+
+    if (page.resultCount === 0) {
+      break;
+    }
+
+    for (const pkg of page.packages) {
+      if (!packagesByName.has(pkg.name)) {
+        packagesByName.set(pkg.name, pkg);
+      }
+    }
+
+    from += page.resultCount;
+  }
+
+  return [...packagesByName.values()];
+}
+
 export async function searchNpmPackages(
   query: string,
   ctx: ExtensionCommandContext,
-  pi: ExtensionAPI
+  _pi: ExtensionAPI
 ): Promise<NpmPackage[]> {
-  // Pull more results so browse mode has meaningful pagination.
-  // npm search can still cap server-side, but this improves coverage.
-  const searchLimit = 250;
-
   // Check persistent cache first
   const cached = await getCachedSearch(query);
   if (cached && cached.length > 0) {
@@ -72,25 +163,12 @@ export async function searchNpmPackages(
     ctx.ui.notify(`Searching npm for "${query}"...`, "info");
   }
 
-  const res = await execNpm(pi, ["search", "--json", `--searchlimit=${searchLimit}`, query], ctx, {
-    timeout: TIMEOUTS.npmSearch,
-  });
+  const packages = await fetchNpmRegistrySearchResults(query);
 
-  if (res.code !== 0) {
-    throw new Error(`npm search failed: ${res.stderr || res.stdout || `exit ${res.code}`}`);
-  }
+  // Cache the results
+  await setCachedSearch(query, packages);
 
-  try {
-    const parsed = JSON.parse(res.stdout || "[]") as NpmPackage[];
-    const filtered = parsed.filter((p) => !!p?.name);
-
-    // Cache the results
-    await setCachedSearch(query, filtered);
-
-    return filtered;
-  } catch {
-    throw new Error("Failed to parse npm search output");
-  }
+  return packages;
 }
 
 export async function getInstalledPackages(
@@ -121,15 +199,11 @@ function sanitizeListSourceSuffix(source: string): string {
     .trim();
 }
 
-function normalizeSourceIdentity(source: string): string {
-  const sanitized = sanitizeListSourceSuffix(source);
-  const kind = getPackageSourceKind(sanitized);
-
-  if (kind === "local") {
-    return normalizeLocalSourceIdentity(sanitized);
-  }
-
-  return sanitized.replace(/\\/g, "/").toLowerCase();
+function getInstalledPackageIdentity(pkg: InstalledPackage): string {
+  return normalizePackageIdentity(
+    pkg.source,
+    pkg.resolvedPath ? { resolvedPath: pkg.resolvedPath } : undefined
+  );
 }
 
 function isScopeHeader(lowerTrimmed: string, scope: "global" | "project"): boolean {
@@ -181,12 +255,8 @@ function parseResolvedPathLine(line: string): string | undefined {
   return undefined;
 }
 
-function parseInstalledPackagesOutputInternal(
-  text: string,
-  options?: { dedupeBySource?: boolean }
-): InstalledPackage[] {
+function parseInstalledPackagesOutputInternal(text: string): InstalledPackage[] {
   const packages: InstalledPackage[] = [];
-  const seenSources = new Set<string>();
 
   const lines = text.split("\n");
   let currentScope: "global" | "project" = "global";
@@ -222,15 +292,6 @@ function parseInstalledPackagesOutputInternal(
     if (!looksLikePackageSource(candidate)) continue;
 
     const source = sanitizeListSourceSuffix(candidate);
-    if (options?.dedupeBySource !== false) {
-      const sourceIdentity = normalizeSourceIdentity(source);
-      if (seenSources.has(sourceIdentity)) {
-        currentPackage = undefined;
-        continue;
-      }
-      seenSources.add(sourceIdentity);
-    }
-
     const { name, version } = parsePackageNameAndVersion(source);
 
     const pkg: InstalledPackage = { source, name, scope: currentScope };
@@ -244,8 +305,34 @@ function parseInstalledPackagesOutputInternal(
   return packages;
 }
 
+function shouldReplaceInstalledPackage(
+  current: InstalledPackage | undefined,
+  candidate: InstalledPackage
+): boolean {
+  if (!current) {
+    return true;
+  }
+
+  if (current.scope !== candidate.scope) {
+    return candidate.scope === "project";
+  }
+
+  return false;
+}
+
 export function parseInstalledPackagesOutput(text: string): InstalledPackage[] {
-  return parseInstalledPackagesOutputInternal(text, { dedupeBySource: true });
+  const parsed = parseInstalledPackagesOutputInternal(text);
+  const deduped = new Map<string, InstalledPackage>();
+
+  for (const pkg of parsed) {
+    const identity = getInstalledPackageIdentity(pkg);
+    const current = deduped.get(identity);
+    if (shouldReplaceInstalledPackage(current, pkg)) {
+      deduped.set(identity, pkg);
+    }
+  }
+
+  return Array.from(deduped.values());
 }
 
 /**
@@ -263,10 +350,10 @@ export async function isSourceInstalled(
     if (res.code !== 0) return false;
 
     const installed = parseInstalledPackagesOutputAllScopes(res.stdout || "");
-    const expected = normalizeSourceIdentity(source);
+    const expected = normalizePackageIdentity(source);
 
     return installed.some((pkg) => {
-      if (normalizeSourceIdentity(pkg.source) !== expected) {
+      if (getInstalledPackageIdentity(pkg) !== expected) {
         return false;
       }
       return options?.scope ? pkg.scope === options.scope : true;
@@ -276,8 +363,14 @@ export async function isSourceInstalled(
   }
 }
 
+/**
+ * parseInstalledPackagesOutputAllScopes returns the raw parsed entries from
+ * parseInstalledPackagesOutputInternal without deduplication or scope merging.
+ * Prefer parseInstalledPackagesOutput for user-facing lists, since it applies
+ * deduplication and normalized scope selection.
+ */
 export function parseInstalledPackagesOutputAllScopes(text: string): InstalledPackage[] {
-  return parseInstalledPackagesOutputInternal(text, { dedupeBySource: false });
+  return parseInstalledPackagesOutputInternal(text);
 }
 
 function extractGitPackageName(repoSpec: string): string {
@@ -316,7 +409,7 @@ function parsePackageNameAndVersion(fullSource: string): {
 
   const sourceKind = getPackageSourceKind(fullSource);
   if (sourceKind === "git") {
-    const gitSpec = fullSource.startsWith("git:") ? fullSource.slice(4) : fullSource;
+    const gitSpec = stripGitSourcePrefix(fullSource);
     const { repo } = splitGitRepoAndRef(gitSpec);
     return { name: extractGitPackageName(repo) };
   }