pi-extmgr 0.1.18 → 0.1.20

package/package.json

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

package/src/index.ts

@@ -17,7 +17,7 @@ import {
   stopAutoUpdateTimer,
   type ContextProvider,
 } from "./utils/auto-update.js";
-import { hydrateAutoUpdateConfig } from "./utils/settings.js";
+import { hydrateAutoUpdateConfig, getAutoUpdateConfig } from "./utils/settings.js";
 import {
   getExtensionsAutocompleteItems,
   resolveCommand,
@@ -72,8 +72,11 @@ export default function extensionsManager(pi: ExtensionAPI) {
 
     if (!ctx.hasUI) return;
 
-    const getCtx: ContextProvider = () => ctx;
-    startAutoUpdateTimer(pi, getCtx, createAutoUpdateNotificationHandler(ctx));
+    const config = getAutoUpdateConfig(ctx);
+    if (config.enabled && config.intervalMs > 0) {
+      const getCtx: ContextProvider = () => ctx;
+      startAutoUpdateTimer(pi, getCtx, createAutoUpdateNotificationHandler(ctx));
+    }
 
     setImmediate(() => {
       updateStatusBar(ctx).catch((err) => {

package/src/packages/discovery.ts

@@ -238,23 +238,28 @@ export function parseInstalledPackagesOutput(text: string): InstalledPackage[] {
 }
 
 /**
- * Check if a specific source is installed by running `pi list` and checking output.
- * Returns true if found, false if not found.
+ * Check whether a specific package source is installed.
+ * Matches on normalized package source and optional scope.
  */
 export async function isSourceInstalled(
   source: string,
   ctx: ExtensionCommandContext | ExtensionContext,
-  pi: ExtensionAPI
+  pi: ExtensionAPI,
+  options?: { scope?: "global" | "project" }
 ): Promise<boolean> {
   try {
     const res = await pi.exec("pi", ["list"], { timeout: TIMEOUTS.listPackages, cwd: ctx.cwd });
     if (res.code !== 0) return false;
 
-    const normalized = source.toLowerCase().replace(/\\/g, "/");
-    const stdout = res.stdout || "";
+    const installed = parseInstalledPackagesOutputAllScopes(res.stdout || "");
+    const expected = normalizeSourceIdentity(source);
 
-    // Check if the source appears in the output (case-insensitive, normalized paths)
-    return stdout.toLowerCase().replace(/\\/g, "/").includes(normalized);
+    return installed.some((pkg) => {
+      if (normalizeSourceIdentity(pkg.source) !== expected) {
+        return false;
+      }
+      return options?.scope ? pkg.scope === options.scope : true;
+    });
   } catch {
     return false;
   }

package/src/packages/extensions.ts

@@ -27,14 +27,24 @@ function normalizeSource(source: string): string {
     .trim();
 }
 
+function normalizePackageRootCandidate(candidate: string): string {
+  const resolved = resolve(candidate);
+
+  if (/(?:^|[\\/])package\.json$/i.test(resolved) || /\.(?:[cm]?[jt]s)$/i.test(resolved)) {
+    return dirname(resolved);
+  }
+
+  return resolved;
+}
+
 function toPackageRoot(pkg: InstalledPackage, cwd: string): string | undefined {
   if (pkg.resolvedPath) {
-    return resolve(pkg.resolvedPath);
+    return normalizePackageRootCandidate(pkg.resolvedPath);
   }
 
   if (pkg.source.startsWith("file://")) {
     try {
-      return resolve(fileURLToPath(pkg.source));
+      return normalizePackageRootCandidate(fileURLToPath(pkg.source));
     } catch {
       return undefined;
     }
@@ -45,7 +55,7 @@ function toPackageRoot(pkg: InstalledPackage, cwd: string): string | undefined {
     /^[a-zA-Z]:[\\/]/.test(pkg.source) ||
     pkg.source.startsWith("\\\\")
   ) {
-    return resolve(pkg.source);
+    return normalizePackageRootCandidate(pkg.source);
   }
 
   if (
@@ -54,11 +64,11 @@ function toPackageRoot(pkg: InstalledPackage, cwd: string): string | undefined {
     pkg.source.startsWith(".\\") ||
     pkg.source.startsWith("..\\")
   ) {
-    return resolve(cwd, pkg.source);
+    return normalizePackageRootCandidate(resolve(cwd, pkg.source));
   }
 
   if (pkg.source.startsWith("~/")) {
-    return resolve(join(homedir(), pkg.source.slice(2)));
+    return normalizePackageRootCandidate(join(homedir(), pkg.source.slice(2)));
   }
 
   return undefined;

package/src/packages/install.ts

@@ -1,11 +1,12 @@
 /**
  * Package installation logic
  */
-import { mkdir, rm, writeFile, access, cp } from "node:fs/promises";
+import { mkdir, rm, writeFile, cp, readFile } 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 { waitForCondition } from "../utils/retry.js";
 import { logPackageInstall } from "../utils/history.js";
@@ -67,6 +68,37 @@ function safeExtractGithubMatch(
   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;
+        }
+      }
+      return false;
+    }
+  } catch {
+    // Ignore invalid/missing manifest and fall back to conventional entrypoints.
+  }
+
+  return (
+    (await fileExists(join(packageRoot, "index.ts"))) ||
+    (await fileExists(join(packageRoot, "index.js")))
+  );
+}
+
 export async function installPackage(
   source: string,
   ctx: ExtensionCommandContext,
@@ -134,7 +166,7 @@ export async function installPackage(
   // This prevents a race condition where ctx.reload() runs before
   // settings.json or extension files are fully flushed to disk.
   notify(ctx, "Waiting for extension to be ready...", "info");
-  const isReady = await waitForCondition(() => isSourceInstalled(normalized, ctx, pi), {
+  const isReady = await waitForCondition(() => isSourceInstalled(normalized, ctx, pi, { scope }), {
     maxAttempts: 10,
     delayMs: 100,
     backoff: "exponential",
@@ -211,22 +243,6 @@ export async function installFromUrl(
   success(ctx, `Installed ${name} to:\n${destPath}`);
   clearUpdatesAvailable(pi, ctx);
 
-  // Wait for the extension file to be fully written and discoverable
-  notify(ctx, "Waiting for extension to be ready...", "info");
-  const isReady = await waitForCondition(() => isSourceInstalled(name, ctx, pi), {
-    maxAttempts: 10,
-    delayMs: 100,
-    backoff: "exponential",
-  });
-
-  if (!isReady) {
-    notify(
-      ctx,
-      "Extension may not be immediately available. Reload pi manually if needed.",
-      "warning"
-    );
-  }
-
   const reloaded = await confirmReload(ctx, "Extension installed.");
   if (!reloaded) {
     void updateExtmgrStatus(ctx, pi);
@@ -382,12 +398,11 @@ export async function installPackageLocally(
         throw new Error(`Extraction failed: ${extractRes.stderr || extractRes.stdout}`);
       }
 
-      // Verify index.ts exists
-      const indexPath = join(extractDir, "index.ts");
-      try {
-        await access(indexPath);
-      } catch {
-        throw new Error(`Package ${packageName} does not have an index.ts file`);
+      const hasEntrypoint = await hasStandaloneEntrypoint(extractDir);
+      if (!hasEntrypoint) {
+        throw new Error(
+          `Package ${packageName} does not contain a runnable extension entrypoint (pi.extensions, index.ts, or index.js)`
+        );
       }
 
       return true;
@@ -443,25 +458,9 @@ export async function installPackageLocally(
 
   clearSearchCache();
   logPackageInstall(pi, `npm:${packageName}`, packageName, version, scope, true);
-  success(ctx, `Installed ${packageName}@${version} locally to:\n${destResult}/index.ts`);
+  success(ctx, `Installed ${packageName}@${version} locally to:\n${destResult}`);
   clearUpdatesAvailable(pi, ctx);
 
-  // Wait for the extension to be discoverable before reloading
-  notify(ctx, "Waiting for extension to be ready...", "info");
-  const isReady = await waitForCondition(() => isSourceInstalled(`npm:${packageName}`, ctx, pi), {
-    maxAttempts: 10,
-    delayMs: 100,
-    backoff: "exponential",
-  });
-
-  if (!isReady) {
-    notify(
-      ctx,
-      "Extension may not be immediately available. Reload pi manually if needed.",
-      "warning"
-    );
-  }
-
   const reloaded = await confirmReload(ctx, "Extension installed.");
   if (!reloaded) {
     void updateExtmgrStatus(ctx, pi);

package/src/packages/management.ts

@@ -338,23 +338,25 @@ async function removePackageInternal(
     clearUpdatesAvailable(pi, ctx);
   }
 
-  // Wait for the extension to be fully removed from pi list before restarting.
-  // This prevents a race condition where the removal hasn't flushed to disk yet.
+  // Wait for selected targets to disappear from their target scopes before reloading.
   if (failures.length === 0 && targets.length > 0) {
     notify(ctx, "Waiting for removal to complete...", "info");
-    const mainTarget = targets[0];
-    if (mainTarget) {
-      const isRemoved = await waitForCondition(
-        async () => {
-          const stillInstalled = await isSourceInstalled(mainTarget.source, ctx, pi);
-          return !stillInstalled;
-        },
-        { maxAttempts: 10, delayMs: 100, backoff: "exponential" }
-      );
+    const isRemoved = await waitForCondition(
+      async () => {
+        const installedChecks = await Promise.all(
+          targets.map((target) =>
+            isSourceInstalled(target.source, ctx, pi, {
+              scope: target.scope,
+            })
+          )
+        );
+        return installedChecks.every((installedInScope) => !installedInScope);
+      },
+      { maxAttempts: 10, delayMs: 100, backoff: "exponential" }
+    );
 
-      if (!isRemoved) {
-        notify(ctx, "Extension may still be active. Restart pi manually if needed.", "warning");
-      }
+    if (!isRemoved) {
+      notify(ctx, "Extension may still be active. Restart pi manually if needed.", "warning");
     }
   }
 

package/src/utils/cache.ts

@@ -6,6 +6,7 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import type { NpmPackage, InstalledPackage } from "../types/index.js";
 import { CACHE_LIMITS } from "../constants.js";
+import { parseNpmSource } from "./format.js";
 
 const CACHE_DIR = process.env.PI_EXTMGR_CACHE_DIR
   ? process.env.PI_EXTMGR_CACHE_DIR
@@ -365,14 +366,12 @@ export async function getPackageDescriptions(
   const cache = await loadCache();
 
   for (const pkg of packages) {
-    if (pkg.source.startsWith("npm:")) {
-      const pkgName = pkg.source.slice(4).split("@")[0];
-      if (pkgName) {
-        const cached = cache.packages.get(pkgName);
-        if (cached?.description && isCacheValid(cached.timestamp)) {
-          descriptions.set(pkg.source, cached.description);
-        }
-      }
+    const npmSource = parseNpmSource(pkg.source);
+    if (!npmSource?.name) continue;
+
+    const cached = cache.packages.get(npmSource.name);
+    if (cached?.description && isCacheValid(cached.timestamp)) {
+      descriptions.set(pkg.source, cached.description);
     }
   }
 

package/src/utils/ui-helpers.ts

@@ -28,32 +28,6 @@ export async function confirmReload(
   return false;
 }
 
-/**
- * Confirm and trigger shutdown (for actions requiring full restart)
- * Returns true if shutdown was triggered
- */
-export async function confirmRestart(
-  ctx: ExtensionCommandContext,
-  reason: string
-): Promise<boolean> {
-  if (!ctx.hasUI) {
-    notify(ctx, `⚠️  ${reason}\nFull restart required to complete. Exit and restart pi manually.`);
-    return false;
-  }
-
-  const confirmed = await ctx.ui.confirm(
-    "Restart Required",
-    `${reason}\nPackage removed. Commands may still work until you restart pi. Exit now?`
-  );
-
-  if (confirmed) {
-    ctx.shutdown();
-    return true;
-  }
-
-  return false;
-}
-
 /**
  * Confirm action with timeout
  */