pi-extmgr 0.1.26 → 0.1.27

package/src/ui/remote.ts

@@ -18,6 +18,7 @@ import { installPackage, installPackageLocally } from "../packages/install.js";
 import { execNpm } from "../utils/npm-exec.js";
 import { notify } from "../utils/notify.js";
 import { requireCustomUI, runCustomUI } from "../utils/mode.js";
+import { runTaskWithLoader } from "./async-task.js";
 
 interface PackageInfoCacheEntry {
   timestamp: number;
@@ -109,25 +110,44 @@ const PACKAGE_DETAILS_CHOICES = {
   back: "Back to results",
 } as const;
 
+function createAbortError(): Error {
+  const error = new Error("Operation cancelled");
+  error.name = "AbortError";
+  return error;
+}
+
+function throwIfAborted(signal?: AbortSignal): void {
+  if (signal?.aborted) {
+    throw createAbortError();
+  }
+}
+
 function formatCount(value: number | undefined): string {
   if (typeof value !== "number" || !Number.isFinite(value)) return "unknown";
   return new Intl.NumberFormat().format(value);
 }
 
-async function fetchWeeklyDownloads(packageName: string): Promise<number | undefined> {
+async function fetchWeeklyDownloads(
+  packageName: string,
+  signal?: AbortSignal
+): Promise<number | undefined> {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), TIMEOUTS.weeklyDownloads);
+  const combinedSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
 
   try {
     const encoded = encodeURIComponent(packageName);
     const res = await fetch(`https://api.npmjs.org/downloads/point/last-week/${encoded}`, {
-      signal: controller.signal,
+      signal: combinedSignal,
     });
 
     if (!res.ok) return undefined;
     const data = (await res.json()) as NpmDownloadsPoint;
     return typeof data.downloads === "number" ? data.downloads : undefined;
-  } catch {
+  } catch (error) {
+    if (signal?.aborted && error instanceof Error && error.name === "AbortError") {
+      throw error;
+    }
     return undefined;
   } finally {
     clearTimeout(timer);
@@ -137,7 +157,8 @@ async function fetchWeeklyDownloads(packageName: string): Promise<number | undef
 async function buildPackageInfoText(
   packageName: string,
   ctx: ExtensionCommandContext,
-  pi: ExtensionAPI
+  pi: ExtensionAPI,
+  signal?: AbortSignal
 ): Promise<string> {
   // Check cache first
   const cached = packageInfoCache.get(packageName);
@@ -148,10 +169,13 @@ async function buildPackageInfoText(
   const [infoRes, weeklyDownloads] = await Promise.all([
     execNpm(pi, ["view", packageName, "--json"], ctx, {
       timeout: TIMEOUTS.npmView,
+      ...(signal ? { signal } : {}),
     }),
-    fetchWeeklyDownloads(packageName),
+    fetchWeeklyDownloads(packageName, signal),
   ]);
 
+  throwIfAborted(signal);
+
   if (infoRes.code !== 0) {
     throw new Error(infoRes.stderr || infoRes.stdout || `npm view failed (exit ${infoRes.code})`);
   }
@@ -179,7 +203,7 @@ async function buildPackageInfoText(
 
   const text = lines.join("\n");
 
-  // Store in LRU cache
+  throwIfAborted(signal);
   packageInfoCache.set(packageName, { text });
 
   return text;
@@ -346,20 +370,34 @@ export async function browseRemotePackages(
     return;
   }
 
-  // Check cache first
-  let allPackages: NpmPackage[] = [];
+  let allPackages: NpmPackage[] | undefined;
 
-  if (isCacheValid(query) && offset > 0) {
+  if (isCacheValid(query)) {
     const cache = getSearchCache();
-    if (cache) allPackages = cache.results;
-  } else {
-    // Show searching notification
-    ctx.ui.notify(`Searching npm for: ${truncate(query, 40)}...`, "info");
+    if (cache) {
+      allPackages = cache.results;
+    }
+  }
+
+  if (!allPackages) {
+    const results = await runTaskWithLoader(
+      ctx,
+      {
+        title: "Remote Packages",
+        message: `Searching npm for ${truncate(query, 40)}...`,
+      },
+      async ({ signal, setMessage }) => {
+        setMessage(`Searching npm for ${truncate(query, 40)}...`);
+        return searchNpmPackages(query, ctx, { signal });
+      }
+    );
 
-    // Perform search
-    allPackages = await searchNpmPackages(query, ctx, pi);
+    if (!results) {
+      notify(ctx, "Remote package search was cancelled.", "info");
+      return;
+    }
 
-    // Cache results for pagination
+    allPackages = results;
     setSearchCache({
       query,
       results: allPackages,
@@ -451,7 +489,21 @@ async function showPackageDetails(
       return;
     case "viewInfo":
       try {
-        const text = await buildPackageInfoText(packageName, ctx, pi);
+        const text = await runTaskWithLoader(
+          ctx,
+          {
+            title: packageName,
+            message: `Fetching package details for ${packageName}...`,
+          },
+          ({ signal }) => buildPackageInfoText(packageName, ctx, pi, signal)
+        );
+
+        if (!text) {
+          notify(ctx, `Loading ${packageName} details was cancelled.`, "info");
+          await showPackageDetails(packageName, ctx, pi, previousQuery, previousOffset);
+          return;
+        }
+
         ctx.ui.notify(text, "info");
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);

package/src/ui/unified.ts

@@ -29,6 +29,7 @@ import {
 } from "../packages/management.js";
 import { showRemote } from "./remote.js";
 import { showHelp } from "./help.js";
+import { runTaskWithLoader } from "./async-task.js";
 import { formatEntry as formatExtEntry, dynamicTruncate, formatBytes } from "../utils/format.js";
 import {
   getStatusIcon,
@@ -43,6 +44,7 @@ import { getKnownUpdates, promptAutoUpdateWizard } from "../utils/auto-update.js
 import { updateExtmgrStatus } from "../utils/status.js";
 import { parseChoiceByLabel } from "../utils/command.js";
 import { notify } from "../utils/notify.js";
+import { confirmReload } from "../utils/ui-helpers.js";
 import { getPackageSourceKind, normalizePackageIdentity } from "../utils/package-source.js";
 import { hasCustomUI, runCustomUI } from "../utils/mode.js";
 import { getSettingsListSelectedIndex } from "../utils/settings-list.js";
@@ -82,11 +84,46 @@ async function showInteractiveOnce(
   ctx: ExtensionCommandContext,
   pi: ExtensionAPI
 ): Promise<boolean> {
-  // Load local extensions and installed packages.
-  const [localEntries, installedPackages] = await Promise.all([
-    discoverExtensions(ctx.cwd),
-    getInstalledPackages(ctx, pi),
-  ]);
+  const initialData = await runTaskWithLoader(
+    ctx,
+    {
+      title: "Extensions Manager",
+      message: "Loading extensions and packages...",
+    },
+    async ({ signal, setMessage }) => {
+      const localEntriesPromise = discoverExtensions(ctx.cwd);
+      const installedPackagesPromise = getInstalledPackages(
+        ctx,
+        pi,
+        (current, total) => {
+          if (total <= 0) {
+            return;
+          }
+          setMessage(`Loading package metadata... ${current}/${total}`);
+        },
+        signal
+      );
+
+      const [localEntries, installedPackages] = await Promise.all([
+        localEntriesPromise,
+        installedPackagesPromise,
+      ]);
+
+      return { localEntries, installedPackages };
+    }
+  );
+
+  if (!initialData) {
+    notify(
+      ctx,
+      "The unified extensions manager requires the full interactive TUI. Showing read-only local and installed package lists instead.",
+      "warning"
+    );
+    await showInteractiveFallback(ctx, pi);
+    return true;
+  }
+
+  const { localEntries, installedPackages } = initialData;
 
   // Build unified items list.
   const knownUpdates = getKnownUpdates(ctx);
@@ -498,7 +535,7 @@ async function applyToggleChangesFromManager(
       );
 
       if (shouldReload) {
-        await (ctx as ExtensionCommandContext & { reload: () => Promise<void> }).reload();
+        await ctx.reload();
         return { changed: apply.changed, reloaded: true };
       }
     } else {
@@ -768,12 +805,8 @@ async function handleUnifiedAction(
         "info"
       );
 
-      const shouldReload = await ctx.ui.confirm(
-        "Reload Recommended",
-        "Extension removed. Reload pi now?"
-      );
-      if (shouldReload) {
-        await (ctx as ExtensionCommandContext & { reload: () => Promise<void> }).reload();
+      const reloaded = await confirmReload(ctx, "Extension removed.");
+      if (reloaded) {
         return true;
       }
 

package/src/utils/auto-update.ts

@@ -6,8 +6,7 @@ import type {
   ExtensionCommandContext,
   ExtensionContext,
 } from "@mariozechner/pi-coding-agent";
-import type { InstalledPackage } from "../types/index.js";
-import { getInstalledPackages } from "../packages/discovery.js";
+import { getPackageCatalog } from "../packages/catalog.js";
 import { notify } from "./notify.js";
 import {
   getAutoUpdateConfig,
@@ -17,21 +16,14 @@ import {
   parseDuration,
   type AutoUpdateConfig,
 } from "./settings.js";
-import { parseNpmSource } from "./format.js";
-import { execNpm } from "./npm-exec.js";
 import { normalizePackageIdentity } from "./package-source.js";
 import { logAutoUpdateConfig } from "./history.js";
-import { TIMEOUTS } from "../constants.js";
 
 import { startTimer, stopTimer, isTimerRunning } from "./timer.js";
 
 // Context provider for safe session handling
 export type ContextProvider = () => (ExtensionCommandContext | ExtensionContext) | undefined;
 
-function getUpdateIdentity(pkg: InstalledPackage): string {
-  return normalizePackageIdentity(pkg.source);
-}
-
 /**
  * Start auto-update background checker
  * Uses a context provider to avoid stale context issues when sessions switch
@@ -67,7 +59,10 @@ export function startAutoUpdateTimer(
         stopAutoUpdateTimer();
         return;
       }
-      void checkForUpdates(pi, checkCtx, onUpdateAvailable);
+
+      void checkForUpdates(pi, checkCtx, onUpdateAvailable).catch((error) => {
+        console.warn("[extmgr] Auto-update check failed:", error);
+      });
     },
     { initialDelayMs }
   );
@@ -96,19 +91,9 @@ export async function checkForUpdates(
   ctx: ExtensionCommandContext | ExtensionContext,
   onUpdateAvailable?: (packages: string[]) => void
 ): Promise<string[]> {
-  const packages = await getInstalledPackages(ctx, pi);
-  const npmPackages = packages.filter((p) => p.source.startsWith("npm:"));
-
-  const updatesAvailable: string[] = [];
-  const updatedPackageNames: string[] = [];
-
-  for (const pkg of npmPackages) {
-    const hasUpdate = await checkPackageUpdate(pkg, ctx, pi);
-    if (hasUpdate) {
-      updatesAvailable.push(getUpdateIdentity(pkg));
-      updatedPackageNames.push(pkg.name);
-    }
-  }
+  const updates = await getPackageCatalog(ctx.cwd).checkForAvailableUpdates();
+  const updatesAvailable = updates.map((update) => normalizePackageIdentity(update.source));
+  const updatedPackageNames = updates.map((update) => update.displayName);
 
   const checkedAt = Date.now();
   const config = getAutoUpdateConfig(ctx);
@@ -126,37 +111,6 @@ export async function checkForUpdates(
   return updatedPackageNames;
 }
 
-/**
- * Check if a specific package has updates available
- */
-async function checkPackageUpdate(
-  pkg: InstalledPackage,
-  ctx: ExtensionCommandContext | ExtensionContext,
-  pi: ExtensionAPI
-): Promise<boolean> {
-  const parsed = parseNpmSource(pkg.source);
-  const pkgName = parsed?.name;
-  if (!pkgName) return false;
-
-  try {
-    const res = await execNpm(pi, ["view", pkgName, "version", "--json"], ctx, {
-      timeout: TIMEOUTS.npmView,
-    });
-
-    if (res.code !== 0) return false;
-
-    const latestVersion = JSON.parse(res.stdout) as string;
-    const currentVersion = pkg.version;
-
-    if (!currentVersion) return false;
-
-    // Simple version comparison (assumes semver)
-    return latestVersion !== currentVersion;
-  } catch {
-    return false;
-  }
-}
-
 /**
  * Get status text for display
  */

package/src/utils/network.ts

@@ -1,11 +1,19 @@
-export async function fetchWithTimeout(url: string, timeoutMs: number): Promise<Response> {
+export async function fetchWithTimeout(
+  url: string,
+  timeoutMs: number,
+  signal?: AbortSignal
+): Promise<Response> {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const combinedSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
 
   try {
-    return await fetch(url, { signal: controller.signal });
+    return await fetch(url, { signal: combinedSignal });
   } catch (error) {
     if (error instanceof Error && error.name === "AbortError") {
+      if (signal?.aborted) {
+        throw error;
+      }
       throw new Error(`Request timed out after ${Math.ceil(timeoutMs / 1000)}s`);
     }
     throw error;

package/src/utils/npm-exec.ts

@@ -9,6 +9,7 @@ interface NpmCommandResolutionOptions {
 
 interface NpmExecOptions {
   timeout: number;
+  signal?: AbortSignal;
 }
 
 function getNpmCliPath(nodeExecPath: string, runtimePlatform: NodeJS.Platform): string {
@@ -43,5 +44,6 @@ export async function execNpm(
   return pi.exec(resolved.command, resolved.args, {
     timeout: options.timeout,
     cwd: ctx.cwd,
+    ...(options.signal ? { signal: options.signal } : {}),
   });
 }

package/src/utils/package-source.ts

@@ -100,3 +100,54 @@ export function splitGitRepoAndRef(gitSpec: string): { repo: string; ref?: strin
 
   return { repo: gitSpec.slice(0, lastAt), ref: tail };
 }
+
+function extractGitPackageName(repoSpec: string): string {
+  if (repoSpec.startsWith("git@")) {
+    const afterColon = repoSpec.split(":").slice(1).join(":");
+    if (afterColon) {
+      const last = afterColon.split("/").pop() || afterColon;
+      return last.replace(/\.git$/i, "") || repoSpec;
+    }
+  }
+
+  try {
+    const url = new URL(repoSpec);
+    const last = url.pathname.split("/").filter(Boolean).pop();
+    if (last) {
+      return last.replace(/\.git$/i, "") || repoSpec;
+    }
+  } catch {
+    // Fall back to generic path splitting below.
+  }
+
+  const last = repoSpec.split(/[/:]/).filter(Boolean).pop();
+  return (last ? last.replace(/\.git$/i, "") : repoSpec) || repoSpec;
+}
+
+export function parsePackageNameAndVersion(fullSource: string): {
+  name: string;
+  version?: string | undefined;
+} {
+  const parsedNpm = parseNpmSource(fullSource);
+  if (parsedNpm) {
+    return parsedNpm;
+  }
+
+  const sourceKind = getPackageSourceKind(fullSource);
+  if (sourceKind === "git") {
+    const gitSpec = stripGitSourcePrefix(fullSource);
+    const { repo } = splitGitRepoAndRef(gitSpec);
+    return { name: extractGitPackageName(repo) };
+  }
+
+  if (fullSource.includes("node_modules/")) {
+    const nmMatch = fullSource.match(/node_modules\/(.+)$/);
+    if (nmMatch?.[1]) {
+      return { name: nmMatch[1] };
+    }
+  }
+
+  const pathParts = fullSource.split(/[\\/]/);
+  const fileName = pathParts[pathParts.length - 1];
+  return { name: fileName || fullSource };
+}

package/src/utils/status.ts

@@ -6,14 +6,16 @@ import type {
   ExtensionCommandContext,
   ExtensionContext,
 } from "@mariozechner/pi-coding-agent";
-import { getInstalledPackages } from "../packages/discovery.js";
+import { getPackageCatalog, type PackageCatalog } from "../packages/catalog.js";
 import { getAutoUpdateStatus } from "./auto-update.js";
 import { normalizePackageIdentity } from "./package-source.js";
 import { getAutoUpdateConfigAsync, saveAutoUpdateConfig } from "./settings.js";
 
+type CatalogInstalledPackages = Awaited<ReturnType<PackageCatalog["listInstalledPackages"]>>;
+
 function filterStaleUpdates(
   knownUpdates: string[],
-  installedPackages: Awaited<ReturnType<typeof getInstalledPackages>>
+  installedPackages: CatalogInstalledPackages
 ): string[] {
   const installedIdentities = new Set(
     installedPackages.map((pkg) =>
@@ -34,7 +36,7 @@ export async function updateExtmgrStatus(
 
   try {
     const [packages, autoUpdateConfig] = await Promise.all([
-      getInstalledPackages(ctx, pi),
+      getPackageCatalog(ctx.cwd).listInstalledPackages(),
       getAutoUpdateConfigAsync(ctx),
     ]);
     const statusParts: string[] = [];

package/src/utils/ui-helpers.ts

@@ -21,7 +21,7 @@ export async function confirmReload(
   const confirmed = await ctx.ui.confirm("Reload Required", `${reason}\nReload pi now?`);
 
   if (confirmed) {
-    await (ctx as ExtensionCommandContext & { reload: () => Promise<void> }).reload();
+    await ctx.reload();
     return true;
   }