pi-extmgr 0.1.17 → 0.1.19

package/README.md

@@ -142,7 +142,6 @@ Examples:
 - **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.
-- **Remove requires restart**: After removing a package, you need to fully restart Pi (not just a reload) for it to be completely unloaded.
 
 ## License
 

package/package.json

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

package/src/packages/discovery.ts

@@ -237,6 +237,34 @@ export function parseInstalledPackagesOutput(text: string): InstalledPackage[] {
   return parseInstalledPackagesOutputInternal(text, { dedupeBySource: true });
 }
 
+/**
+ * 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,
+  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 installed = parseInstalledPackagesOutputAllScopes(res.stdout || "");
+    const expected = normalizeSourceIdentity(source);
+
+    return installed.some((pkg) => {
+      if (normalizeSourceIdentity(pkg.source) !== expected) {
+        return false;
+      }
+      return options?.scope ? pkg.scope === options.scope : true;
+    });
+  } catch {
+    return false;
+  }
+}
+
 export function parseInstalledPackagesOutputAllScopes(text: string): InstalledPackage[] {
   return parseInstalledPackagesOutputInternal(text, { dedupeBySource: 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,12 +1,14 @@
 /**
  * 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 { clearSearchCache } from "./discovery.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";
 import { clearUpdatesAvailable } from "../utils/settings.js";
 import { notify, error as notifyError, success } from "../utils/notify.js";
@@ -66,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,
@@ -129,6 +162,24 @@ export async function installPackage(
   success(ctx, `Installed ${normalized} (${scope})`);
   clearUpdatesAvailable(pi, ctx);
 
+  // Wait for the extension to be discoverable before reloading.
+  // 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, { scope }), {
+    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, "Package installed.");
   if (!reloaded) {
     void updateExtmgrStatus(ctx, pi);
@@ -191,6 +242,7 @@ export async function installFromUrl(
   logPackageInstall(pi, url, name, undefined, scope, true);
   success(ctx, `Installed ${name} to:\n${destPath}`);
   clearUpdatesAvailable(pi, ctx);
+
   const reloaded = await confirmReload(ctx, "Extension installed.");
   if (!reloaded) {
     void updateExtmgrStatus(ctx, pi);
@@ -346,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;
@@ -407,8 +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);
+
   const reloaded = await confirmReload(ctx, "Extension installed.");
   if (!reloaded) {
     void updateExtmgrStatus(ctx, pi);

package/src/packages/management.ts

@@ -7,7 +7,9 @@ import {
   getInstalledPackages,
   clearSearchCache,
   parseInstalledPackagesOutputAllScopes,
+  isSourceInstalled,
 } from "./discovery.js";
+import { waitForCondition } from "../utils/retry.js";
 import { formatInstalledPackageLabel, formatBytes, parseNpmSource } from "../utils/format.js";
 import { getPackageSourceKind, splitGitRepoAndRef } from "../utils/package-source.js";
 import { logPackageUpdate, logPackageRemove } from "../utils/history.js";
@@ -16,7 +18,6 @@ import { notify, error as notifyError, success } from "../utils/notify.js";
 import {
   confirmAction,
   confirmReload,
-  confirmRestart,
   showProgress,
   formatListOutput,
 } from "../utils/ui-helpers.js";
@@ -26,12 +27,10 @@ import { TIMEOUTS, UI } from "../constants.js";
 
 export interface PackageMutationOutcome {
   reloaded: boolean;
-  restartRequested: boolean;
 }
 
 const NO_PACKAGE_MUTATION_OUTCOME: PackageMutationOutcome = {
   reloaded: false,
-  restartRequested: false,
 };
 
 function packageMutationOutcome(
@@ -339,15 +338,34 @@ async function removePackageInternal(
     clearUpdatesAvailable(pi, ctx);
   }
 
-  const restartRequested = await confirmRestart(
-    ctx,
-    `Removal complete.\n\n⚠️  Extensions/prompts/skills/themes from removed packages are fully unloaded after restarting pi.`
-  );
-  if (!restartRequested) {
+  // 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 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");
+    }
+  }
+
+  const reloaded = await confirmReload(ctx, "Removal complete.");
+  if (!reloaded) {
     void updateExtmgrStatus(ctx, pi);
   }
 
-  return packageMutationOutcome({ restartRequested });
+  return packageMutationOutcome({ reloaded });
 }
 
 export async function removePackage(
@@ -425,11 +443,11 @@ export async function showPackageActions(
   switch (action) {
     case "remove": {
       const outcome = await removePackageWithOutcome(pkg.source, ctx, pi);
-      return outcome.reloaded || outcome.restartRequested;
+      return outcome.reloaded;
     }
     case "update": {
       const outcome = await updatePackageWithOutcome(pkg.source, ctx, pi);
-      return outcome.reloaded || outcome.restartRequested;
+      return outcome.reloaded;
     }
     case "details": {
       const sizeStr = pkg.size !== undefined ? `\nSize: ${formatBytes(pkg.size)}` : "";

package/src/ui/unified.ts

@@ -650,7 +650,7 @@ async function navigateWithPendingGuard(
       return "done";
     case "update-all": {
       const outcome = await updatePackagesWithOutcome(ctx, pi);
-      return outcome.reloaded || outcome.restartRequested ? "exit" : "done";
+      return outcome.reloaded ? "exit" : "done";
     }
     case "auto-update":
       await promptAutoUpdateWizard(pi, ctx, (packages) => {
@@ -819,11 +819,11 @@ async function handleUnifiedAction(
     switch (result.action) {
       case "update": {
         const outcome = await updatePackageWithOutcome(pkg.source, ctx, pi);
-        return outcome.reloaded || outcome.restartRequested;
+        return outcome.reloaded;
       }
       case "remove": {
         const outcome = await removePackageWithOutcome(pkg.source, ctx, pi);
-        return outcome.reloaded || outcome.restartRequested;
+        return outcome.reloaded;
       }
       case "details": {
         const sizeStr = pkg.size !== undefined ? `\nSize: ${formatBytes(pkg.size)}` : "";

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/retry.ts

@@ -0,0 +1,49 @@
+/**
+ * Retry utilities for async operations
+ */
+
+export interface RetryOptions {
+  maxAttempts?: number;
+  delayMs?: number;
+  backoff?: "fixed" | "linear" | "exponential";
+}
+
+export async function retryWithBackoff<T>(
+  operation: () => Promise<T | undefined>,
+  options: RetryOptions = {}
+): Promise<T | undefined> {
+  const { maxAttempts = 5, delayMs = 100, backoff = "exponential" } = options;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const result = await operation();
+    if (result !== undefined) {
+      return result;
+    }
+
+    if (attempt < maxAttempts) {
+      const delay =
+        backoff === "exponential"
+          ? delayMs * Math.pow(2, attempt - 1)
+          : backoff === "linear"
+            ? delayMs * attempt
+            : delayMs;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Wait for a condition to be true with timeout
+ */
+export async function waitForCondition(
+  condition: () => Promise<boolean> | boolean,
+  options: RetryOptions = {}
+): Promise<boolean> {
+  const result = await retryWithBackoff(async () => {
+    const value = await condition();
+    return value ? true : undefined;
+  }, options);
+  return result === true;
+}

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
  */