pi-extmgr 0.1.17 → 0.1.18

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.18",
   "description": "Enhanced UX for managing local Pi extensions and community packages",
   "keywords": [
     "pi-package",

package/src/packages/discovery.ts

@@ -237,6 +237,29 @@ export function parseInstalledPackagesOutput(text: string): InstalledPackage[] {
   return parseInstalledPackagesOutputInternal(text, { dedupeBySource: true });
 }
 
+/**
+ * Check if a specific source is installed by running `pi list` and checking output.
+ * Returns true if found, false if not found.
+ */
+export async function isSourceInstalled(
+  source: string,
+  ctx: ExtensionCommandContext | ExtensionContext,
+  pi: ExtensionAPI
+): 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 || "";
+
+    // Check if the source appears in the output (case-insensitive, normalized paths)
+    return stdout.toLowerCase().replace(/\\/g, "/").includes(normalized);
+  } catch {
+    return false;
+  }
+}
+
 export function parseInstalledPackagesOutputAllScopes(text: string): InstalledPackage[] {
   return parseInstalledPackagesOutputInternal(text, { dedupeBySource: false });
 }

package/src/packages/install.ts

@@ -6,7 +6,8 @@ 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 { 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";
@@ -129,6 +130,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), {
+    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 +210,23 @@ export async function installFromUrl(
   logPackageInstall(pi, url, name, undefined, scope, true);
   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);
@@ -409,6 +445,23 @@ export async function installPackageLocally(
   logPackageInstall(pi, `npm:${packageName}`, packageName, version, scope, true);
   success(ctx, `Installed ${packageName}@${version} locally to:\n${destResult}/index.ts`);
   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

@@ -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,32 @@ 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 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.
+  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" }
+      );
+
+      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 +441,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/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;
+}