pi-extmgr 0.1.24 → 0.1.25

package/package.json

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

package/src/packages/discovery.ts

@@ -19,6 +19,25 @@ import {
   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;
 
@@ -51,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) {
@@ -73,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}`}`);
-  }
-
-  try {
-    const parsed = JSON.parse(res.stdout || "[]") as NpmPackage[];
-    const filtered = parsed.filter((p) => !!p?.name);
+  // Cache the results
+  await setCachedSearch(query, packages);
 
-    // 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(

package/src/packages/install.ts

@@ -18,6 +18,7 @@ import { tryOperation } from "../utils/mode.js";
 import { updateExtmgrStatus } from "../utils/status.js";
 import { execNpm } from "../utils/npm-exec.js";
 import { normalizePackageIdentity } from "../utils/package-source.js";
+import { fetchWithTimeout } from "../utils/network.js";
 import { TIMEOUTS } from "../constants.js";
 
 export type InstallScope = "global" | "project";
@@ -73,22 +74,6 @@ function safeExtractGithubMatch(match: RegExpMatchArray | null): GithubUrlInfo |
   return { owner, repo, branch, filePath };
 }
 
-async function fetchWithTimeout(url: string, timeoutMs: number): Promise<Response> {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-
-  try {
-    return await fetch(url, { signal: controller.signal });
-  } catch (error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error(`Download timed out after ${Math.ceil(timeoutMs / 1000)}s`);
-    }
-    throw error;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
 async function ensureTarAvailable(
   pi: ExtensionAPI,
   ctx: ExtensionCommandContext

package/src/utils/cache.ts

@@ -12,6 +12,7 @@ const CACHE_DIR = process.env.PI_EXTMGR_CACHE_DIR
   ? process.env.PI_EXTMGR_CACHE_DIR
   : join(homedir(), ".pi", "agent", ".extmgr-cache");
 const CACHE_FILE = join(CACHE_DIR, "metadata.json");
+const CURRENT_SEARCH_CACHE_STRATEGY = "npm-registry-v1-paginated";
 
 interface CachedPackageData {
   name: string;
@@ -29,6 +30,7 @@ interface CacheData {
         query: string;
         results: string[];
         timestamp: number;
+        strategy: string;
       }
     | undefined;
 }
@@ -92,12 +94,15 @@ function normalizeCacheFromDisk(input: unknown): CacheData {
     const query = input.lastSearch.query;
     const timestamp = input.lastSearch.timestamp;
     const results = input.lastSearch.results;
+    const strategy = input.lastSearch.strategy;
 
     if (
       typeof query === "string" &&
       typeof timestamp === "number" &&
       Number.isFinite(timestamp) &&
-      Array.isArray(results)
+      Array.isArray(results) &&
+      typeof strategy === "string" &&
+      strategy.trim()
     ) {
       const normalizedResults = results.filter(
         (value): value is string => typeof value === "string"
@@ -106,6 +111,7 @@ function normalizeCacheFromDisk(input: unknown): CacheData {
         query,
         timestamp,
         results: normalizedResults,
+        strategy: strategy.trim(),
       };
     }
   }
@@ -194,7 +200,9 @@ async function saveCache(): Promise<void> {
   const data: {
     version: number;
     packages: Record<string, CachedPackageData>;
-    lastSearch?: { query: string; results: string[]; timestamp: number } | undefined;
+    lastSearch?:
+      | { query: string; results: string[]; timestamp: number; strategy: string }
+      | undefined;
   } = {
     version: memoryCache.version,
     packages: Object.fromEntries(memoryCache.packages),
@@ -276,6 +284,10 @@ export async function getCachedSearch(query: string): Promise<NpmPackage[] | nul
     return null;
   }
 
+  if (cache.lastSearch.strategy !== CURRENT_SEARCH_CACHE_STRATEGY) {
+    return null;
+  }
+
   // Reconstruct packages from cached names
   const packages: NpmPackage[] = [];
   for (const name of cache.lastSearch.results) {
@@ -313,6 +325,7 @@ export async function setCachedSearch(query: string, packages: NpmPackage[]): Pr
     query,
     results: packages.map((p) => p.name),
     timestamp: Date.now(),
+    strategy: CURRENT_SEARCH_CACHE_STRATEGY,
   };
 
   await enqueueCacheSave();

package/src/utils/network.ts

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