pi-extmgr 0.1.26 → 0.1.27

package/src/packages/install.ts

@@ -4,17 +4,22 @@
 import { mkdir, rm, writeFile, cp } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir } from "node:os";
-import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ProgressEvent,
+} from "@mariozechner/pi-coding-agent";
 import { normalizePackageSource } from "../utils/format.js";
 import { fileExists } from "../utils/fs.js";
-import { clearSearchCache, isSourceInstalled } from "./discovery.js";
+import { clearSearchCache } from "./discovery.js";
+import { getPackageCatalog } from "./catalog.js";
 import { discoverPackageExtensionEntrypoints, readPackageManifest } from "./extensions.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";
 import { confirmAction, confirmReload, showProgress } from "../utils/ui-helpers.js";
 import { tryOperation } from "../utils/mode.js";
+import { runTaskWithLoader } from "../ui/async-task.js";
 import { updateExtmgrStatus } from "../utils/status.js";
 import { execNpm } from "../utils/npm-exec.js";
 import { normalizePackageIdentity } from "../utils/package-source.js";
@@ -27,6 +32,10 @@ export interface InstallOptions {
   scope?: InstallScope;
 }
 
+function getProgressMessage(event: ProgressEvent, fallback: string): string {
+  return event.message?.trim() || fallback;
+}
+
 async function resolveInstallScope(
   ctx: ExtensionCommandContext,
   explicitScope?: InstallScope
@@ -195,11 +204,24 @@ export async function installPackage(
 
   showProgress(ctx, "Installing", normalized);
 
-  const args = ["install", ...(scope === "project" ? ["-l"] : []), normalized];
-  const res = await pi.exec("pi", args, { timeout: TIMEOUTS.packageInstall, cwd: ctx.cwd });
-
-  if (res.code !== 0) {
-    const errorMsg = `Install failed:\n${res.stderr || res.stdout || `exit ${res.code}`}`;
+  try {
+    await runTaskWithLoader(
+      ctx,
+      {
+        title: "Install Package",
+        message: `Installing ${normalized}...`,
+        cancellable: false,
+      },
+      async ({ setMessage }) => {
+        await getPackageCatalog(ctx.cwd).install(normalized, scope, (event) => {
+          setMessage(getProgressMessage(event, `Installing ${normalized}...`));
+        });
+        return undefined;
+      }
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const errorMsg = `Install failed:\n${message}`;
     logPackageInstall(pi, normalized, normalized, undefined, scope, false, errorMsg);
     notifyError(ctx, errorMsg);
     void updateExtmgrStatus(ctx, pi);
@@ -211,24 +233,6 @@ export async function installPackage(
   success(ctx, `Installed ${normalized} (${scope})`);
   clearUpdatesAvailable(pi, ctx, [normalizePackageIdentity(normalized)]);
 
-  // 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);

package/src/packages/management.ts

@@ -1,15 +1,18 @@
 /**
  * Package management (update, remove)
  */
-import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ProgressEvent,
+} from "@mariozechner/pi-coding-agent";
 import type { InstalledPackage } from "../types/index.js";
 import {
   getInstalledPackages,
+  getInstalledPackagesAllScopes,
   clearSearchCache,
-  parseInstalledPackagesOutputAllScopes,
-  isSourceInstalled,
 } from "./discovery.js";
-import { waitForCondition } from "../utils/retry.js";
+import { getPackageCatalog } from "./catalog.js";
 import { formatInstalledPackageLabel } from "../utils/format.js";
 import { normalizePackageIdentity } from "../utils/package-source.js";
 import { logPackageUpdate, logPackageRemove } from "../utils/history.js";
@@ -22,8 +25,9 @@ import {
   formatListOutput,
 } from "../utils/ui-helpers.js";
 import { requireUI } from "../utils/mode.js";
+import { runTaskWithLoader } from "../ui/async-task.js";
 import { updateExtmgrStatus } from "../utils/status.js";
-import { TIMEOUTS, UI } from "../constants.js";
+import { UI } from "../constants.js";
 
 export interface PackageMutationOutcome {
   reloaded: boolean;
@@ -41,9 +45,8 @@ function packageMutationOutcome(
   return { ...NO_PACKAGE_MUTATION_OUTCOME, ...overrides };
 }
 
-function isUpToDateOutput(stdout: string): boolean {
-  const pinnedAsStatus = /^\s*pinned\b(?!\s+dependency\b)(?:\s*$|\s*[:(-])/im.test(stdout);
-  return /already\s+up\s+to\s+date/i.test(stdout) || pinnedAsStatus;
+function getProgressMessage(event: ProgressEvent, fallback: string): string {
+  return event.message?.trim() || fallback;
 }
 
 async function updatePackageInternal(
@@ -53,29 +56,45 @@ async function updatePackageInternal(
 ): Promise<PackageMutationOutcome> {
   showProgress(ctx, "Updating", source);
 
-  const res = await pi.exec("pi", ["update", source], {
-    timeout: TIMEOUTS.packageUpdate,
-    cwd: ctx.cwd,
-  });
+  const updateIdentity = normalizePackageIdentity(source);
+
+  try {
+    const updates = await getPackageCatalog(ctx.cwd).checkForAvailableUpdates();
+    const hasUpdate = updates.some(
+      (update) => normalizePackageIdentity(update.source) === updateIdentity
+    );
 
-  if (res.code !== 0) {
-    const errorMsg = `Update failed: ${res.stderr || res.stdout || `exit ${res.code}`}`;
+    if (!hasUpdate) {
+      notify(ctx, `${source} is already up to date (or pinned).`, "info");
+      logPackageUpdate(pi, source, source, undefined, true);
+      clearUpdatesAvailable(pi, ctx, [updateIdentity]);
+      void updateExtmgrStatus(ctx, pi);
+      return NO_PACKAGE_MUTATION_OUTCOME;
+    }
+
+    await runTaskWithLoader(
+      ctx,
+      {
+        title: "Update Package",
+        message: `Updating ${source}...`,
+        cancellable: false,
+      },
+      async ({ setMessage }) => {
+        await getPackageCatalog(ctx.cwd).update(source, (event) => {
+          setMessage(getProgressMessage(event, `Updating ${source}...`));
+        });
+        return undefined;
+      }
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const errorMsg = `Update failed: ${message}`;
     logPackageUpdate(pi, source, source, undefined, false, errorMsg);
     notifyError(ctx, errorMsg);
     void updateExtmgrStatus(ctx, pi);
     return NO_PACKAGE_MUTATION_OUTCOME;
   }
 
-  const updateIdentity = normalizePackageIdentity(source);
-  const stdout = res.stdout || "";
-  if (isUpToDateOutput(stdout)) {
-    notify(ctx, `${source} is already up to date (or pinned).`, "info");
-    logPackageUpdate(pi, source, source, undefined, true);
-    clearUpdatesAvailable(pi, ctx, [updateIdentity]);
-    void updateExtmgrStatus(ctx, pi);
-    return NO_PACKAGE_MUTATION_OUTCOME;
-  }
-
   logPackageUpdate(pi, source, source, undefined, true);
   success(ctx, `Updated ${source}`);
   clearUpdatesAvailable(pi, ctx, [updateIdentity]);
@@ -93,25 +112,39 @@ async function updatePackagesInternal(
 ): Promise<PackageMutationOutcome> {
   showProgress(ctx, "Updating", "all packages");
 
-  const res = await pi.exec("pi", ["update"], { timeout: TIMEOUTS.packageUpdateAll, cwd: ctx.cwd });
+  try {
+    const updates = await getPackageCatalog(ctx.cwd).checkForAvailableUpdates();
+    if (updates.length === 0) {
+      notify(ctx, "All packages are already up to date.", "info");
+      logPackageUpdate(pi, BULK_UPDATE_LABEL, BULK_UPDATE_LABEL, undefined, true);
+      clearUpdatesAvailable(pi, ctx);
+      void updateExtmgrStatus(ctx, pi);
+      return NO_PACKAGE_MUTATION_OUTCOME;
+    }
 
-  if (res.code !== 0) {
-    const errorMsg = `Update failed: ${res.stderr || res.stdout || `exit ${res.code}`}`;
+    await runTaskWithLoader(
+      ctx,
+      {
+        title: "Update Packages",
+        message: "Updating all packages...",
+        cancellable: false,
+      },
+      async ({ setMessage }) => {
+        await getPackageCatalog(ctx.cwd).update(undefined, (event) => {
+          setMessage(getProgressMessage(event, "Updating all packages..."));
+        });
+        return undefined;
+      }
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const errorMsg = `Update failed: ${message}`;
     logPackageUpdate(pi, BULK_UPDATE_LABEL, BULK_UPDATE_LABEL, undefined, false, errorMsg);
     notifyError(ctx, errorMsg);
     void updateExtmgrStatus(ctx, pi);
     return NO_PACKAGE_MUTATION_OUTCOME;
   }
 
-  const stdout = res.stdout || "";
-  if (isUpToDateOutput(stdout) || stdout.trim() === "") {
-    notify(ctx, "All packages are already up to date.", "info");
-    logPackageUpdate(pi, BULK_UPDATE_LABEL, BULK_UPDATE_LABEL, undefined, true);
-    clearUpdatesAvailable(pi, ctx);
-    void updateExtmgrStatus(ctx, pi);
-    return NO_PACKAGE_MUTATION_OUTCOME;
-  }
-
   logPackageUpdate(pi, BULK_UPDATE_LABEL, BULK_UPDATE_LABEL, undefined, true);
   success(ctx, "Packages updated");
   clearUpdatesAvailable(pi, ctx);
@@ -157,13 +190,10 @@ function packageIdentity(source: string): string {
   return normalizePackageIdentity(source);
 }
 
-async function getInstalledPackagesAllScopes(
-  ctx: ExtensionCommandContext,
-  pi: ExtensionAPI
+async function getInstalledPackagesAllScopesForRemoval(
+  ctx: ExtensionCommandContext
 ): Promise<InstalledPackage[]> {
-  const res = await pi.exec("pi", ["list"], { timeout: TIMEOUTS.listPackages, cwd: ctx.cwd });
-  if (res.code !== 0) return [];
-  return parseInstalledPackagesOutputAllScopes(res.stdout || "");
+  return getInstalledPackagesAllScopes(ctx);
 }
 
 type RemovalScopeChoice = "both" | "global" | "project" | "cancel";
@@ -197,14 +227,9 @@ async function selectRemovalScope(ctx: ExtensionCommandContext): Promise<Removal
 
 function buildRemovalTargets(
   matching: InstalledPackage[],
-  source: string,
   hasUI: boolean,
   scopeChoice: RemovalScopeChoice
 ): RemovalTarget[] {
-  if (matching.length === 0) {
-    return [{ scope: "global", source, name: source }];
-  }
-
   const byScope = new Map(matching.map((pkg) => [pkg.scope, pkg] as const));
   const addTarget = (scope: "global" | "project") => {
     const pkg = byScope.get(scope);
@@ -253,18 +278,30 @@ async function executeRemovalTargets(
   for (const target of targets) {
     showProgress(ctx, "Removing", `${target.source} (${target.scope})`);
 
-    const args = ["remove", ...(target.scope === "project" ? ["-l"] : []), target.source];
-    const res = await pi.exec("pi", args, { timeout: TIMEOUTS.packageRemove, cwd: ctx.cwd });
-
-    if (res.code !== 0) {
-      const errorMsg = `Remove failed (${target.scope}): ${res.stderr || res.stdout || `exit ${res.code}`}`;
+    try {
+      await runTaskWithLoader(
+        ctx,
+        {
+          title: "Remove Package",
+          message: `Removing ${target.source}...`,
+          cancellable: false,
+        },
+        async ({ setMessage }) => {
+          await getPackageCatalog(ctx.cwd).remove(target.source, target.scope, (event) => {
+            setMessage(getProgressMessage(event, `Removing ${target.source}...`));
+          });
+          return undefined;
+        }
+      );
+
+      logPackageRemove(pi, target.source, target.name, true);
+      results.push({ target, success: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const errorMsg = `Remove failed (${target.scope}): ${message}`;
       logPackageRemove(pi, target.source, target.name, false, errorMsg);
       results.push({ target, success: false, error: errorMsg });
-      continue;
     }
-
-    logPackageRemove(pi, target.source, target.name, true);
-    results.push({ target, success: true });
   }
 
   return results;
@@ -300,7 +337,7 @@ async function removePackageInternal(
   ctx: ExtensionCommandContext,
   pi: ExtensionAPI
 ): Promise<PackageMutationOutcome> {
-  const installed = await getInstalledPackagesAllScopes(ctx, pi);
+  const installed = await getInstalledPackagesAllScopesForRemoval(ctx);
   const identity = packageIdentity(source);
   const matching = installed.filter((p) => packageIdentity(p.source) === identity);
 
@@ -314,7 +351,12 @@ async function removePackageInternal(
     return NO_PACKAGE_MUTATION_OUTCOME;
   }
 
-  const targets = buildRemovalTargets(matching, source, ctx.hasUI, scopeChoice);
+  if (matching.length === 0) {
+    notify(ctx, `${source} is not installed.`, "info");
+    return NO_PACKAGE_MUTATION_OUTCOME;
+  }
+
+  const targets = buildRemovalTargets(matching, ctx.hasUI, scopeChoice);
   if (targets.length === 0) {
     notify(ctx, "Nothing to remove.", "info");
     return NO_PACKAGE_MUTATION_OUTCOME;
@@ -343,7 +385,7 @@ async function removePackageInternal(
     .filter((result) => result.success)
     .map((result) => result.target);
 
-  const remaining = (await getInstalledPackagesAllScopes(ctx, pi)).filter(
+  const remaining = (await getInstalledPackagesAllScopesForRemoval(ctx)).filter(
     (p) => packageIdentity(p.source) === identity
   );
   notifyRemovalSummary(source, remaining, failures, ctx);
@@ -354,28 +396,6 @@ async function removePackageInternal(
 
   const successfulRemovalCount = successfulTargets.length;
 
-  // Wait for successfully removed targets to disappear from their target scopes before reloading.
-  if (successfulTargets.length > 0) {
-    notify(ctx, "Waiting for removal to complete...", "info");
-    const isRemoved = await waitForCondition(
-      async () => {
-        const installedChecks = await Promise.all(
-          successfulTargets.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 (successfulRemovalCount === 0) {
     void updateExtmgrStatus(ctx, pi);
     return NO_PACKAGE_MUTATION_OUTCOME;
@@ -431,9 +451,9 @@ export async function promptRemove(ctx: ExtensionCommandContext, pi: ExtensionAP
 
 export async function showInstalledPackagesList(
   ctx: ExtensionCommandContext,
-  pi: ExtensionAPI
+  _pi: ExtensionAPI
 ): Promise<void> {
-  const packages = await getInstalledPackages(ctx, pi);
+  const packages = await getInstalledPackagesAllScopes(ctx);
 
   if (packages.length === 0) {
     notify(ctx, "No packages installed.", "info");

package/src/ui/async-task.ts

@@ -0,0 +1,158 @@
+import type {
+  ExtensionCommandContext,
+  ExtensionContext,
+  Theme,
+} from "@mariozechner/pi-coding-agent";
+import { DynamicBorder } from "@mariozechner/pi-coding-agent";
+import { CancellableLoader, Container, Loader, Spacer, Text, type TUI } from "@mariozechner/pi-tui";
+import { hasCustomUI } from "../utils/mode.js";
+
+type AnyContext = ExtensionCommandContext | ExtensionContext;
+
+const TASK_ABORTED = Symbol("task-aborted");
+const TASK_FAILED = Symbol("task-failed");
+
+export interface TaskControls {
+  signal: AbortSignal;
+  setMessage: (message: string) => void;
+}
+
+interface LoaderConfig {
+  title: string;
+  message: string;
+  cancellable?: boolean;
+}
+
+function createLoaderComponent(
+  tui: TUI,
+  theme: Theme,
+  title: string,
+  message: string,
+  cancellable: boolean,
+  onCancel: () => void
+): {
+  container: Container;
+  loader: Loader | CancellableLoader;
+  signal: AbortSignal;
+} {
+  const container = new Container();
+  const borderColor = (text: string) => theme.fg("accent", text);
+  const loader = cancellable
+    ? new CancellableLoader(
+        tui,
+        (text) => theme.fg("accent", text),
+        (text) => theme.fg("muted", text),
+        message
+      )
+    : new Loader(
+        tui,
+        (text) => theme.fg("accent", text),
+        (text) => theme.fg("muted", text),
+        message
+      );
+
+  container.addChild(new DynamicBorder(borderColor));
+  container.addChild(new Text(theme.fg("accent", theme.bold(title)), 1, 0));
+  container.addChild(loader);
+
+  if (cancellable) {
+    (loader as CancellableLoader).onAbort = onCancel;
+    container.addChild(new Spacer(1));
+    container.addChild(new Text(theme.fg("dim", "Esc cancel"), 1, 0));
+  }
+
+  container.addChild(new Spacer(1));
+  container.addChild(new DynamicBorder(borderColor));
+
+  const signal = cancellable ? (loader as CancellableLoader).signal : new AbortController().signal;
+
+  return { container, loader, signal };
+}
+
+export async function runTaskWithLoader<T>(
+  ctx: AnyContext,
+  config: LoaderConfig,
+  task: (controls: TaskControls) => Promise<T>
+): Promise<T | undefined> {
+  if (!hasCustomUI(ctx)) {
+    return task({
+      signal: new AbortController().signal,
+      setMessage: () => undefined,
+    });
+  }
+
+  let taskError: unknown;
+
+  const result = await ctx.ui.custom<T | typeof TASK_ABORTED | typeof TASK_FAILED>(
+    (tui, theme, _keybindings, done) => {
+      let finished = false;
+      const finish = (value: T | typeof TASK_ABORTED | typeof TASK_FAILED): void => {
+        if (finished) {
+          return;
+        }
+        finished = true;
+        done(value);
+      };
+
+      const { container, loader, signal } = createLoaderComponent(
+        tui,
+        theme,
+        config.title,
+        config.message,
+        config.cancellable ?? true,
+        () => finish(TASK_ABORTED)
+      );
+
+      void task({
+        signal,
+        setMessage: (message) => {
+          loader.setMessage(message);
+          tui.requestRender();
+        },
+      })
+        .then((value) => finish(value))
+        .catch((error) => {
+          if (signal.aborted) {
+            finish(TASK_ABORTED);
+            return;
+          }
+
+          taskError = error;
+          finish(TASK_FAILED);
+        });
+
+      return {
+        render(width: number) {
+          return container.render(width);
+        },
+        invalidate() {
+          container.invalidate();
+        },
+        handleInput(data: string) {
+          if (loader instanceof CancellableLoader) {
+            loader.handleInput(data);
+            tui.requestRender();
+          }
+        },
+        dispose() {
+          if (loader instanceof CancellableLoader) {
+            loader.dispose();
+            return;
+          }
+
+          loader.stop();
+        },
+      };
+    }
+  );
+
+  if (result === TASK_ABORTED) {
+    return undefined;
+  }
+
+  if (result === TASK_FAILED) {
+    throw taskError;
+  }
+
+  return result;
+}

package/src/ui/package-config.ts

@@ -21,6 +21,7 @@ import {
 import { notify } from "../utils/notify.js";
 import { logExtensionToggle } from "../utils/history.js";
 import { requireCustomUI, runCustomUI } from "../utils/mode.js";
+import { runTaskWithLoader } from "./async-task.js";
 import { getPackageSourceKind } from "../utils/package-source.js";
 import { getSettingsListSelectedIndex } from "../utils/settings-list.js";
 import { fileExists } from "../utils/fs.js";
@@ -329,8 +330,32 @@ export async function configurePackageExtensions(
     return { changed: 0, reloaded: false };
   }
 
-  const discovered = await discoverPackageExtensions([pkg], ctx.cwd);
-  const rows = await buildPackageConfigRows(discovered);
+  let initialData: { rows: PackageConfigRow[] } | undefined;
+  try {
+    initialData = await runTaskWithLoader(
+      ctx,
+      {
+        title: `Configure ${pkg.name}`,
+        message: "Discovering package extensions...",
+        cancellable: false,
+      },
+      async () => {
+        const discovered = await discoverPackageExtensions([pkg], ctx.cwd);
+        const rows = await buildPackageConfigRows(discovered);
+        return { rows };
+      }
+    );
+  } catch (error) {
+    notify(ctx, error instanceof Error ? error.message : String(error), "error");
+    return { changed: 0, reloaded: false };
+  }
+
+  if (!initialData) {
+    notify(ctx, "Package extension configuration requires the full interactive TUI.", "warning");
+    return { changed: 0, reloaded: false };
+  }
+
+  const { rows } = initialData;
 
   if (rows.length === 0) {
     notify(ctx, "No configurable extensions discovered for this package.", "info");