pi-extmgr 0.1.26 → 0.1.28

package/src/packages/management.ts

@@ -1,29 +1,34 @@
 /**
  * Package management (update, remove)
  */
-import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
-import type { InstalledPackage } from "../types/index.js";
 import {
-  getInstalledPackages,
-  clearSearchCache,
-  parseInstalledPackagesOutputAllScopes,
-  isSourceInstalled,
-} from "./discovery.js";
-import { waitForCondition } from "../utils/retry.js";
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+  getAgentDir,
+  type ProgressEvent,
+} from "@mariozechner/pi-coding-agent";
+import { UI } from "../constants.js";
+import { type InstalledPackage } from "../types/index.js";
+import { runTaskWithLoader } from "../ui/async-task.js";
 import { formatInstalledPackageLabel } from "../utils/format.js";
+import { logPackageRemove, logPackageUpdate } from "../utils/history.js";
+import { requireUI } from "../utils/mode.js";
+import { notify, error as notifyError, success } from "../utils/notify.js";
 import { normalizePackageIdentity } from "../utils/package-source.js";
-import { logPackageUpdate, logPackageRemove } from "../utils/history.js";
 import { clearUpdatesAvailable } from "../utils/settings.js";
-import { notify, error as notifyError, success } from "../utils/notify.js";
+import { updateExtmgrStatus } from "../utils/status.js";
 import {
   confirmAction,
   confirmReload,
-  showProgress,
   formatListOutput,
+  showProgress,
 } from "../utils/ui-helpers.js";
-import { requireUI } from "../utils/mode.js";
-import { updateExtmgrStatus } from "../utils/status.js";
-import { TIMEOUTS, UI } from "../constants.js";
+import { getPackageCatalog } from "./catalog.js";
+import {
+  clearSearchCache,
+  getInstalledPackages,
+  getInstalledPackagesAllScopes,
+} from "./discovery.js";
 
 export interface PackageMutationOutcome {
   reloaded: boolean;
@@ -41,9 +46,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 +57,46 @@ 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, { cwd: ctx.cwd });
+
+  try {
+    const updates = await getPackageCatalog(ctx.cwd).checkForAvailableUpdates();
+    const hasUpdate = updates.some(
+      (update) => normalizePackageIdentity(update.source) === updateIdentity
+    );
+
+    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;
+    }
 
-  if (res.code !== 0) {
-    const errorMsg = `Update failed: ${res.stderr || res.stdout || `exit ${res.code}`}`;
+    await runTaskWithLoader(
+      ctx,
+      {
+        title: "Update Package",
+        message: `Updating ${source}...`,
+        cancellable: false,
+        fallbackWithoutLoader: true,
+      },
+      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 +114,40 @@ 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,
+        fallbackWithoutLoader: true,
+      },
+      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);
@@ -153,17 +189,37 @@ export async function updatePackagesWithOutcome(
   return updatePackagesInternal(ctx, pi);
 }
 
-function packageIdentity(source: string): string {
-  return normalizePackageIdentity(source);
+function packageIdentity(
+  source: string,
+  options?: { resolvedPath?: string; cwd?: string }
+): string {
+  return normalizePackageIdentity(source, options);
 }
 
-async function getInstalledPackagesAllScopes(
-  ctx: ExtensionCommandContext,
-  pi: ExtensionAPI
+function packageSourceIdentities(source: string, ctx: ExtensionCommandContext): Set<string> {
+  return new Set([
+    packageIdentity(source, { cwd: ctx.cwd }),
+    packageIdentity(source, { cwd: getAgentDir() }),
+  ]);
+}
+
+function installedPackageMatchesSource(
+  pkg: InstalledPackage,
+  identities: Set<string>,
+  ctx: ExtensionCommandContext
+): boolean {
+  return identities.has(
+    packageIdentity(pkg.source, {
+      ...(pkg.resolvedPath ? { resolvedPath: pkg.resolvedPath } : {}),
+      cwd: pkg.scope === "project" ? ctx.cwd : getAgentDir(),
+    })
+  );
+}
+
+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 +253,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);
@@ -219,7 +270,6 @@ function buildRemovalTargets(
         return addTarget("global");
       case "project":
         return addTarget("project");
-      case "cancel":
       default:
         return [];
     }
@@ -253,18 +303,31 @@ 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,
+          fallbackWithoutLoader: true,
+        },
+        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,9 +363,9 @@ async function removePackageInternal(
   ctx: ExtensionCommandContext,
   pi: ExtensionAPI
 ): Promise<PackageMutationOutcome> {
-  const installed = await getInstalledPackagesAllScopes(ctx, pi);
-  const identity = packageIdentity(source);
-  const matching = installed.filter((p) => packageIdentity(p.source) === identity);
+  const installed = await getInstalledPackagesAllScopesForRemoval(ctx);
+  const identities = packageSourceIdentities(source, ctx);
+  const matching = installed.filter((pkg) => installedPackageMatchesSource(pkg, identities, ctx));
 
   const hasBothScopes =
     matching.some((pkg) => pkg.scope === "global") &&
@@ -314,7 +377,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,39 +411,17 @@ async function removePackageInternal(
     .filter((result) => result.success)
     .map((result) => result.target);
 
-  const remaining = (await getInstalledPackagesAllScopes(ctx, pi)).filter(
-    (p) => packageIdentity(p.source) === identity
+  const remaining = (await getInstalledPackagesAllScopesForRemoval(ctx)).filter((pkg) =>
+    installedPackageMatchesSource(pkg, identities, ctx)
   );
   notifyRemovalSummary(source, remaining, failures, ctx);
 
   if (failures.length === 0 && remaining.length === 0) {
-    clearUpdatesAvailable(pi, ctx, [identity]);
+    clearUpdatesAvailable(pi, ctx, identities);
   }
 
   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 +477,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/types/index.ts

@@ -46,25 +46,32 @@ export interface PackageExtensionEntry {
   state: State;
 }
 
-export interface UnifiedItem {
-  type: "local" | "package";
+export interface LocalUnifiedItem {
+  type: "local";
   id: string;
   displayName: string;
   summary: string;
   scope: Scope;
-  // Local extension fields
-  state?: State | undefined;
-  activePath?: string | undefined;
-  disabledPath?: string | undefined;
-  originalState?: State | undefined;
-  // Package fields
-  source?: string | undefined;
+  state: State;
+  activePath: string;
+  disabledPath: string;
+  originalState: State;
+}
+
+export interface PackageUnifiedItem {
+  type: "package";
+  id: string;
+  displayName: string;
+  scope: Scope;
+  source: string;
   version?: string | undefined;
   description?: string | undefined;
   size?: number | undefined; // Package size in bytes
   updateAvailable?: boolean | undefined;
 }
 
+export type UnifiedItem = LocalUnifiedItem | PackageUnifiedItem;
+
 export interface SearchCache {
   query: string;
   results: NpmPackage[];

package/src/ui/async-task.ts

@@ -0,0 +1,194 @@
+import {
+  DynamicBorder,
+  type ExtensionCommandContext,
+  type ExtensionContext,
+  type Theme,
+} 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");
+
+type TaskSuccess<T> = { type: "ok"; value: T };
+
+export interface TaskControls {
+  signal: AbortSignal;
+  setMessage: (message: string) => void;
+}
+
+interface LoaderConfig {
+  title: string;
+  message: string;
+  cancellable?: boolean;
+  fallbackWithoutLoader?: 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 };
+}
+
+function runTaskWithoutLoader<T>(task: (controls: TaskControls) => Promise<T>): Promise<T> {
+  return Promise.resolve().then(() =>
+    task({
+      signal: new AbortController().signal,
+      setMessage: () => undefined,
+    })
+  );
+}
+
+export async function runTaskWithLoader<T>(
+  ctx: AnyContext,
+  config: LoaderConfig,
+  task: (controls: TaskControls) => Promise<T>
+): Promise<T | undefined> {
+  if (!hasCustomUI(ctx)) {
+    return runTaskWithoutLoader(task);
+  }
+
+  let taskError: unknown;
+  let startedTask: Promise<T> | undefined;
+  let cleanupStartedTaskUI: (() => void) | undefined;
+
+  const result = await ctx.ui.custom<
+    TaskSuccess<T> | typeof TASK_ABORTED | typeof TASK_FAILED | undefined
+  >((tui, theme, _keybindings, done) => {
+    let finished = false;
+    const finish = (
+      value: TaskSuccess<T> | typeof TASK_ABORTED | typeof TASK_FAILED | undefined
+    ): 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)
+    );
+
+    cleanupStartedTaskUI = () => {
+      if (loader instanceof CancellableLoader) {
+        loader.dispose();
+        return;
+      }
+
+      loader.stop();
+    };
+
+    startedTask = Promise.resolve().then(() =>
+      task({
+        signal,
+        setMessage: (message) => {
+          loader.setMessage(message);
+          tui.requestRender();
+        },
+      })
+    );
+
+    void startedTask
+      .then((value) => finish({ type: "ok", 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 === undefined) {
+    if (startedTask) {
+      return startedTask.finally(() => cleanupStartedTaskUI?.());
+    }
+    if (config.fallbackWithoutLoader) {
+      return runTaskWithoutLoader(task);
+    }
+    return undefined;
+  }
+
+  if (result === TASK_ABORTED) {
+    return undefined;
+  }
+
+  if (result === TASK_FAILED) {
+    throw taskError;
+  }
+
+  return result.value;
+}

package/src/ui/footer.ts

@@ -1,10 +1,9 @@
 /**
  * Footer helpers for the unified extension manager UI
  */
-import type { UnifiedItem, State } from "../types/index.js";
+import { type State, type UnifiedItem } from "../types/index.js";
 
 export interface FooterState {
-  hasToggleRows: boolean;
   hasLocals: boolean;
   hasPackages: boolean;
 }
@@ -13,11 +12,8 @@ export interface FooterState {
  * Build footer state from visible items.
  */
 export function buildFooterState(items: UnifiedItem[]): FooterState {
-  const hasLocals = items.some((i) => i.type === "local");
-
   return {
-    hasToggleRows: hasLocals,
-    hasLocals,
+    hasLocals: items.some((i) => i.type === "local"),
     hasPackages: items.some((i) => i.type === "package"),
   };
 }
@@ -47,8 +43,8 @@ export function buildFooterShortcuts(state: FooterState): string {
   const parts: string[] = [];
   parts.push("↑↓ Navigate");
 
-  if (state.hasToggleRows) parts.push("Space/Enter Toggle");
-  if (state.hasToggleRows) parts.push("S Save");
+  if (state.hasLocals) parts.push("Space/Enter Toggle");
+  if (state.hasLocals) parts.push("S Save");
   if (state.hasPackages) parts.push("Enter/A Actions");
   if (state.hasPackages) parts.push("c Configure");
   if (state.hasPackages) parts.push("u Update");

package/src/ui/help.ts

@@ -1,7 +1,7 @@
 /**
  * Help display
  */
-import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { type ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
 
 export function showHelp(ctx: ExtensionCommandContext): void {
   const lines = [
@@ -17,7 +17,7 @@ export function showHelp(ctx: ExtensionCommandContext): void {
     "  Space/Enter  Toggle local extension enabled/disabled",
     "  S            Save changes to local extensions",
     "  Enter/A      Open actions for selected package",
-    "  c            Configure selected package extensions (restart required after save)",
+    "  c            Configure selected package extensions (reload after save)",
     "  u            Update selected package",
     "  X            Remove selected item (package or local extension)",
     "  i            Quick install by source",