pi-extmgr 0.1.23 → 0.1.24

package/src/packages/install.ts

@@ -8,7 +8,7 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-cod
 import { normalizePackageSource } from "../utils/format.js";
 import { fileExists } from "../utils/fs.js";
 import { clearSearchCache, isSourceInstalled } from "./discovery.js";
-import { resolveManifestExtensionEntrypoints } from "./extensions.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";
@@ -17,6 +17,7 @@ import { confirmAction, confirmReload, showProgress } from "../utils/ui-helpers.
 import { tryOperation } from "../utils/mode.js";
 import { updateExtmgrStatus } from "../utils/status.js";
 import { execNpm } from "../utils/npm-exec.js";
+import { normalizePackageIdentity } from "../utils/package-source.js";
 import { TIMEOUTS } from "../constants.js";
 
 export type InstallScope = "global" | "project";
@@ -72,20 +73,93 @@ function safeExtractGithubMatch(match: RegExpMatchArray | null): GithubUrlInfo |
   return { owner, repo, branch, filePath };
 }
 
+async function fetchWithTimeout(url: string, timeoutMs: number): Promise<Response> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    return await fetch(url, { signal: controller.signal });
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Download timed out after ${Math.ceil(timeoutMs / 1000)}s`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function ensureTarAvailable(
+  pi: ExtensionAPI,
+  ctx: ExtensionCommandContext
+): Promise<{ ok: true } | { ok: false; error: string }> {
+  const result = await pi.exec("tar", ["--version"], {
+    timeout: 5_000,
+    cwd: ctx.cwd,
+  });
+
+  if (result.code === 0) {
+    return { ok: true };
+  }
+
+  return {
+    ok: false,
+    error:
+      "Standalone local installs require the `tar` command on PATH. Install tar or use managed package install instead.",
+  };
+}
+
 async function hasStandaloneEntrypoint(packageRoot: string): Promise<boolean> {
-  const declared = await resolveManifestExtensionEntrypoints(packageRoot);
-  if (declared !== undefined) {
-    for (const path of declared) {
-      if (await fileExists(join(packageRoot, path))) {
-        return true;
-      }
+  const entrypoints = await discoverPackageExtensionEntrypoints(packageRoot, {
+    allowConventionDirectory: false,
+  });
+
+  for (const path of entrypoints) {
+    if (await fileExists(join(packageRoot, path))) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+async function getStandaloneDependencyError(packageRoot: string): Promise<string | undefined> {
+  const manifest = await readPackageManifest(packageRoot);
+  const dependencies = manifest?.dependencies;
+  if (!dependencies || typeof dependencies !== "object") {
+    return undefined;
+  }
+
+  const missingDependencies: string[] = [];
+  for (const dependencyName of Object.keys(dependencies)) {
+    const dependencyPath = join(packageRoot, "node_modules", dependencyName);
+    if (!(await fileExists(dependencyPath))) {
+      missingDependencies.push(dependencyName);
     }
-    return false;
   }
 
-  return (
-    (await fileExists(join(packageRoot, "index.ts"))) ||
-    (await fileExists(join(packageRoot, "index.js")))
+  if (missingDependencies.length === 0) {
+    return undefined;
+  }
+
+  const packageName = manifest?.name ?? "This package";
+  return `${packageName} declares runtime dependencies that are not bundled for standalone install: ${missingDependencies.join(", ")}. Use managed install instead, or bundle dependencies in the package tarball.`;
+}
+
+async function cleanupStandaloneTempArtifacts(tempDir: string, extractDir?: string): Promise<void> {
+  const paths = [extractDir, tempDir].filter((path): path is string => Boolean(path));
+
+  await Promise.allSettled(
+    paths.map(async (path) => {
+      try {
+        await rm(path, { recursive: true, force: true });
+      } catch (error) {
+        console.warn(
+          `[extmgr] Failed to remove temporary standalone install artifact at ${path}:`,
+          error
+        );
+      }
+    })
   );
 }
 
@@ -150,7 +224,7 @@ export async function installPackage(
   clearSearchCache();
   logPackageInstall(pi, normalized, normalized, undefined, scope, true);
   success(ctx, `Installed ${normalized} (${scope})`);
-  clearUpdatesAvailable(pi, ctx);
+  clearUpdatesAvailable(pi, ctx, [normalizePackageIdentity(normalized)]);
 
   // Wait for the extension to be discoverable before reloading.
   // This prevents a race condition where ctx.reload() runs before
@@ -208,7 +282,7 @@ export async function installFromUrl(
       await mkdir(extensionDir, { recursive: true });
       notify(ctx, `Downloading ${fileName}...`, "info");
 
-      const response = await fetch(url);
+      const response = await fetchWithTimeout(url, TIMEOUTS.packageInstall);
       if (!response.ok) {
         throw new Error(`Download failed: ${response.status} ${response.statusText}`);
       }
@@ -231,7 +305,6 @@ export async function installFromUrl(
   const { fileName: name, destPath } = result;
   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) {
@@ -325,17 +398,33 @@ export async function installPackageLocally(
   }
   const { version, tarballUrl } = result;
 
+  const tarAvailability = await ensureTarAvailable(pi, ctx);
+  if (!tarAvailability.ok) {
+    notifyError(ctx, tarAvailability.error);
+    logPackageInstall(
+      pi,
+      `npm:${packageName}`,
+      packageName,
+      version,
+      scope,
+      false,
+      tarAvailability.error
+    );
+    void updateExtmgrStatus(ctx, pi);
+    return;
+  }
+
   // Download and extract
+  const tempDir = join(extensionDir, ".temp");
   const extractResult = await tryOperation(
     ctx,
     async () => {
-      const tempDir = join(extensionDir, ".temp");
       await mkdir(tempDir, { recursive: true });
       const tarballPath = join(tempDir, `${packageName.replace(/[@/]/g, "-")}-${version}.tgz`);
 
       showProgress(ctx, "Downloading", `${packageName}@${version}`);
 
-      const response = await fetch(tarballUrl);
+      const response = await fetchWithTimeout(tarballUrl, TIMEOUTS.packageInstall);
       if (!response.ok) {
         throw new Error(`Download failed: ${response.status} ${response.statusText}`);
       }
@@ -343,12 +432,13 @@ export async function installPackageLocally(
       const buffer = await response.arrayBuffer();
       await writeFile(tarballPath, new Uint8Array(buffer));
 
-      return { tarballPath, tempDir };
+      return { tarballPath };
     },
     "Download failed"
   );
 
   if (!extractResult) {
+    await cleanupStandaloneTempArtifacts(tempDir);
     logPackageInstall(
       pi,
       `npm:${packageName}`,
@@ -361,7 +451,7 @@ export async function installPackageLocally(
     void updateExtmgrStatus(ctx, pi);
     return;
   }
-  const { tarballPath, tempDir } = extractResult;
+  const { tarballPath } = extractResult;
 
   // Extract
   const extractDir = join(
@@ -390,17 +480,22 @@ export async function installPackageLocally(
       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)`
+          `Package ${packageName} does not contain a runnable standalone extension entrypoint (manifest-declared entrypoint, index.ts, or index.js)`
         );
       }
 
+      const dependencyError = await getStandaloneDependencyError(extractDir);
+      if (dependencyError) {
+        throw new Error(dependencyError);
+      }
+
       return true;
     },
     "Extraction failed"
   );
 
   if (!extractSuccess) {
-    await rm(extractDir, { recursive: true, force: true });
+    await cleanupStandaloneTempArtifacts(tempDir, extractDir);
     logPackageInstall(
       pi,
       `npm:${packageName}`,
@@ -429,7 +524,7 @@ export async function installPackageLocally(
     "Failed to copy extension"
   );
 
-  await rm(extractDir, { recursive: true, force: true });
+  await cleanupStandaloneTempArtifacts(tempDir, extractDir);
 
   if (!destResult) {
     logPackageInstall(
@@ -448,7 +543,6 @@ export async function installPackageLocally(
   clearSearchCache();
   logPackageInstall(pi, `npm:${packageName}`, packageName, version, scope, true);
   success(ctx, `Installed ${packageName}@${version} locally to:\n${destResult}`);
-  clearUpdatesAvailable(pi, ctx);
 
   const reloaded = await confirmReload(ctx, "Extension installed.");
   if (!reloaded) {

package/src/packages/management.ts

@@ -10,12 +10,8 @@ import {
   isSourceInstalled,
 } from "./discovery.js";
 import { waitForCondition } from "../utils/retry.js";
-import { formatInstalledPackageLabel, parseNpmSource } from "../utils/format.js";
-import {
-  getPackageSourceKind,
-  normalizeLocalSourceIdentity,
-  splitGitRepoAndRef,
-} from "../utils/package-source.js";
+import { formatInstalledPackageLabel } from "../utils/format.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";
@@ -70,18 +66,19 @@ async function updatePackageInternal(
     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);
+    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);
+  clearUpdatesAvailable(pi, ctx, [updateIdentity]);
 
   const reloaded = await confirmReload(ctx, "Package updated.");
   if (!reloaded) {
@@ -156,29 +153,8 @@ export async function updatePackagesWithOutcome(
   return updatePackagesInternal(ctx, pi);
 }
 
-function packageIdentity(source: string, fallbackName?: string): string {
-  const npm = parseNpmSource(source);
-  if (npm?.name) {
-    return `npm:${npm.name}`;
-  }
-
-  const sourceKind = getPackageSourceKind(source);
-
-  if (sourceKind === "git") {
-    const gitSpec = source.startsWith("git:") ? source.slice(4) : source;
-    const { repo } = splitGitRepoAndRef(gitSpec);
-    return `git:${repo}`;
-  }
-
-  if (sourceKind === "local") {
-    return `src:${normalizeLocalSourceIdentity(source)}`;
-  }
-
-  if (fallbackName) {
-    return `name:${fallbackName}`;
-  }
-
-  return `src:${source}`;
+function packageIdentity(source: string): string {
+  return normalizePackageIdentity(source);
 }
 
 async function getInstalledPackagesAllScopes(
@@ -325,9 +301,8 @@ async function removePackageInternal(
   pi: ExtensionAPI
 ): Promise<PackageMutationOutcome> {
   const installed = await getInstalledPackagesAllScopes(ctx, pi);
-  const direct = installed.find((p) => p.source === source);
-  const identity = packageIdentity(source, direct?.name);
-  const matching = installed.filter((p) => packageIdentity(p.source, p.name) === identity);
+  const identity = packageIdentity(source);
+  const matching = installed.filter((p) => packageIdentity(p.source) === identity);
 
   const hasBothScopes =
     matching.some((pkg) => pkg.scope === "global") &&
@@ -369,12 +344,12 @@ async function removePackageInternal(
     .map((result) => result.target);
 
   const remaining = (await getInstalledPackagesAllScopes(ctx, pi)).filter(
-    (p) => packageIdentity(p.source, p.name) === identity
+    (p) => packageIdentity(p.source) === identity
   );
   notifyRemovalSummary(source, remaining, failures, ctx);
 
-  if (failures.length === 0) {
-    clearUpdatesAvailable(pi, ctx);
+  if (failures.length === 0 && remaining.length === 0) {
+    clearUpdatesAvailable(pi, ctx, [identity]);
   }
 
   const successfulRemovalCount = successfulTargets.length;

package/src/ui/package-config.ts

@@ -13,19 +13,20 @@ import {
   type SettingItem,
 } from "@mariozechner/pi-tui";
 import type { InstalledPackage, PackageExtensionEntry, State } from "../types/index.js";
-import { discoverPackageExtensions, setPackageExtensionState } from "../packages/extensions.js";
+import {
+  applyPackageExtensionStateChanges,
+  discoverPackageExtensions,
+  validatePackageExtensionSettings,
+} from "../packages/extensions.js";
 import { notify } from "../utils/notify.js";
 import { logExtensionToggle } from "../utils/history.js";
+import { requireCustomUI, runCustomUI } from "../utils/mode.js";
 import { getPackageSourceKind } from "../utils/package-source.js";
+import { getSettingsListSelectedIndex } from "../utils/settings-list.js";
 import { fileExists } from "../utils/fs.js";
 import { UI } from "../constants.js";
 import { getChangeMarker, getPackageIcon, getScopeIcon, getStatusIcon } from "./theme.js";
 
-interface SelectableList {
-  selectedIndex?: number;
-  handleInput?(data: string): void;
-}
-
 export interface PackageConfigRow {
   id: string;
   extensionPath: string;
@@ -36,16 +37,6 @@ export interface PackageConfigRow {
 
 type ConfigurePanelAction = { type: "cancel" } | { type: "save" };
 
-function getSelectedIndex(settingsList: unknown): number | undefined {
-  if (settingsList && typeof settingsList === "object") {
-    const selectable = settingsList as SelectableList;
-    if (typeof selectable.selectedIndex === "number") {
-      return selectable.selectedIndex;
-    }
-  }
-  return undefined;
-}
-
 export async function buildPackageConfigRows(
   entries: PackageExtensionEntry[]
 ): Promise<PackageConfigRow[]> {
@@ -130,99 +121,116 @@ async function showConfigurePanel(
   rows: PackageConfigRow[],
   staged: Map<string, State>,
   ctx: ExtensionCommandContext
-): Promise<ConfigurePanelAction> {
-  return ctx.ui.custom<ConfigurePanelAction>((tui, theme, _keybindings, done) => {
-    const container = new Container();
-
-    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
-    container.addChild(
-      new Text(theme.fg("accent", theme.bold(`Configure extensions: ${pkg.name}`)), 2, 0)
-    );
-    container.addChild(
-      new Text(
-        theme.fg(
-          "muted",
-          `${rows.length} extension path${rows.length === 1 ? "" : "s"} • Space/Enter toggle • S save • Esc cancel`
-        ),
-        2,
-        0
-      )
-    );
-    container.addChild(new Spacer(1));
-
-    const settingsItems = buildSettingItems(rows, staged, pkg, theme);
-    const rowById = new Map(rows.map((row) => [row.id, row]));
-
-    const settingsList = new SettingsList(
-      settingsItems,
-      Math.min(rows.length + 2, UI.maxListHeight),
-      getSettingsListTheme(),
-      (id: string, newValue: string) => {
-        const row = rowById.get(id);
-        if (!row || !row.available) return;
-
-        const state = newValue as State;
-        staged.set(id, state);
-
-        const settingsItem = settingsItems.find((item) => item.id === id);
-        if (settingsItem) {
+): Promise<ConfigurePanelAction | undefined> {
+  return runCustomUI(ctx, "Package extension configuration", () =>
+    ctx.ui.custom<ConfigurePanelAction>((tui, theme, _keybindings, done) => {
+      const container = new Container();
+      const titleText = new Text("", 2, 0);
+      const subtitleText = new Text("", 2, 0);
+      const footerText = new Text("", 2, 0);
+
+      container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+      container.addChild(titleText);
+      container.addChild(subtitleText);
+      container.addChild(new Spacer(1));
+
+      const settingsItems = buildSettingItems(rows, staged, pkg, theme);
+      const rowById = new Map(rows.map((row) => [row.id, row]));
+      const syncThemedContent = (): void => {
+        titleText.setText(theme.fg("accent", theme.bold(`Configure extensions: ${pkg.name}`)));
+        subtitleText.setText(
+          theme.fg(
+            "muted",
+            `${rows.length} extension path${rows.length === 1 ? "" : "s"} • Space/Enter toggle • S save • Esc cancel`
+          )
+        );
+        footerText.setText(theme.fg("dim", "↑↓ Navigate | Space/Enter Toggle | S Save | Esc Back"));
+
+        for (const settingsItem of settingsItems) {
+          const row = rowById.get(settingsItem.id);
+          if (!row) continue;
+          const currentState = staged.get(row.id) ?? row.originalState;
           settingsItem.label = formatConfigRowLabel(
             row,
-            state,
+            currentState,
             pkg,
             theme,
-            state !== row.originalState
-          );
-        }
-
-        tui.requestRender();
-      },
-      () => done({ type: "cancel" }),
-      { enableSearch: rows.length > UI.searchThreshold }
-    );
-
-    container.addChild(settingsList);
-    container.addChild(new Spacer(1));
-    container.addChild(
-      new Text(theme.fg("dim", "↑↓ Navigate | Space/Enter Toggle | S Save | Esc Back"), 2, 0)
-    );
-    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
-
-    return {
-      render(width: number) {
-        return container.render(width);
-      },
-      invalidate() {
-        container.invalidate();
-      },
-      handleInput(data: string) {
-        if (matchesKey(data, Key.ctrl("s")) || data === "s" || data === "S") {
-          done({ type: "save" });
-          return;
-        }
-
-        const selectedIndex = getSelectedIndex(settingsList) ?? 0;
-        const selectedId = settingsItems[selectedIndex]?.id ?? settingsItems[0]?.id;
-        const selectedRow = selectedId ? rowById.get(selectedId) : undefined;
-
-        if (
-          selectedRow &&
-          !selectedRow.available &&
-          (data === " " || data === "\r" || data === "\n")
-        ) {
-          notify(
-            ctx,
-            `${selectedRow.extensionPath} is missing on disk and cannot be toggled.`,
-            "warning"
+            currentState !== row.originalState
           );
-          return;
         }
+      };
+      syncThemedContent();
+
+      const settingsList = new SettingsList(
+        settingsItems,
+        Math.min(rows.length + 2, UI.maxListHeight),
+        getSettingsListTheme(),
+        (id: string, newValue: string) => {
+          const row = rowById.get(id);
+          if (!row || !row.available) return;
+
+          const state = newValue as State;
+          staged.set(id, state);
+
+          const settingsItem = settingsItems.find((item) => item.id === id);
+          if (settingsItem) {
+            settingsItem.label = formatConfigRowLabel(
+              row,
+              state,
+              pkg,
+              theme,
+              state !== row.originalState
+            );
+          }
+
+          tui.requestRender();
+        },
+        () => done({ type: "cancel" }),
+        { enableSearch: rows.length > UI.searchThreshold }
+      );
 
-        settingsList.handleInput?.(data);
-        tui.requestRender();
-      },
-    };
-  });
+      container.addChild(settingsList);
+      container.addChild(new Spacer(1));
+      container.addChild(footerText);
+      container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+
+      return {
+        render(width: number) {
+          return container.render(width);
+        },
+        invalidate() {
+          container.invalidate();
+          syncThemedContent();
+        },
+        handleInput(data: string) {
+          if (matchesKey(data, Key.ctrl("s")) || data === "s" || data === "S") {
+            done({ type: "save" });
+            return;
+          }
+
+          const selectedIndex = getSettingsListSelectedIndex(settingsList) ?? 0;
+          const selectedId = settingsItems[selectedIndex]?.id ?? settingsItems[0]?.id;
+          const selectedRow = selectedId ? rowById.get(selectedId) : undefined;
+
+          if (
+            selectedRow &&
+            !selectedRow.available &&
+            (data === " " || data === "\r" || data === "\n")
+          ) {
+            notify(
+              ctx,
+              `${selectedRow.extensionPath} is missing on disk and cannot be toggled.`,
+              "warning"
+            );
+            return;
+          }
+
+          settingsList.handleInput?.(data);
+          tui.requestRender();
+        },
+      };
+    })
+  );
 }
 
 export async function applyPackageExtensionChanges(
@@ -232,40 +240,50 @@ export async function applyPackageExtensionChanges(
   cwd: string,
   pi: ExtensionAPI
 ): Promise<{ changed: number; errors: string[] }> {
-  let changed = 0;
   const errors: string[] = [];
+  const changedRows = [...rows]
+    .sort((a, b) => a.extensionPath.localeCompare(b.extensionPath))
+    .flatMap((row) => {
+      const target = staged.get(row.id) ?? row.originalState;
+      if (target === row.originalState) {
+        return [];
+      }
 
-  const sortedRows = [...rows].sort((a, b) => a.extensionPath.localeCompare(b.extensionPath));
+      if (!row.available) {
+        const error = `${row.extensionPath}: extension entrypoint is missing on disk`;
+        errors.push(error);
+        logExtensionToggle(pi, row.id, row.originalState, target, false, error);
+        return [];
+      }
 
-  for (const row of sortedRows) {
-    const target = staged.get(row.id) ?? row.originalState;
-    if (target === row.originalState) continue;
+      return [{ row, target }];
+    });
 
-    if (!row.available) {
-      const error = `${row.extensionPath}: extension entrypoint is missing on disk`;
-      errors.push(error);
-      logExtensionToggle(pi, row.id, row.originalState, target, false, error);
-      continue;
-    }
+  if (changedRows.length === 0) {
+    return { changed: 0, errors };
+  }
 
-    const result = await setPackageExtensionState(
-      pkg.source,
-      row.extensionPath,
-      pkg.scope,
-      target,
-      cwd
-    );
+  const result = await applyPackageExtensionStateChanges(
+    pkg.source,
+    pkg.scope,
+    changedRows.map(({ row, target }) => ({ extensionPath: row.extensionPath, target })),
+    cwd
+  );
 
-    if (result.ok) {
-      changed += 1;
-      logExtensionToggle(pi, row.id, row.originalState, target, true);
-    } else {
-      errors.push(`${row.extensionPath}: ${result.error}`);
+  if (!result.ok) {
+    for (const { row, target } of changedRows) {
+      const error = `${row.extensionPath}: ${result.error}`;
+      errors.push(error);
       logExtensionToggle(pi, row.id, row.originalState, target, false, result.error);
     }
+    return { changed: 0, errors };
+  }
+
+  for (const { row, target } of changedRows) {
+    logExtensionToggle(pi, row.id, row.originalState, target, true);
   }
 
-  return { changed, errors };
+  return { changed: changedRows.length, errors };
 }
 
 async function promptRestartForPackageConfig(ctx: ExtensionCommandContext): Promise<boolean> {
@@ -302,6 +320,16 @@ export async function configurePackageExtensions(
   ctx: ExtensionCommandContext,
   pi: ExtensionAPI
 ): Promise<{ changed: number; reloaded: boolean }> {
+  if (!requireCustomUI(ctx, "Package extension configuration")) {
+    return { changed: 0, reloaded: false };
+  }
+
+  const validation = await validatePackageExtensionSettings(pkg.scope, ctx.cwd);
+  if (!validation.ok) {
+    notify(ctx, validation.error, "error");
+    return { changed: 0, reloaded: false };
+  }
+
   const discovered = await discoverPackageExtensions([pkg], ctx.cwd);
   const rows = await buildPackageConfigRows(discovered);
 
@@ -314,6 +342,9 @@ export async function configurePackageExtensions(
 
   while (true) {
     const action = await showConfigurePanel(pkg, rows, staged, ctx);
+    if (!action) {
+      return { changed: 0, reloaded: false };
+    }
 
     if (action.type === "cancel") {
       const pending = getPendingChangeCount(rows, staged);