pi-extmgr 0.1.21 → 0.1.23

package/src/ui/unified.ts

@@ -14,22 +14,14 @@ import {
   matchesKey,
   Key,
 } from "@mariozechner/pi-tui";
-import type {
-  UnifiedItem,
-  State,
-  UnifiedAction,
-  InstalledPackage,
-  PackageExtensionEntry,
-} from "../types/index.js";
+import type { UnifiedItem, State, UnifiedAction, InstalledPackage } from "../types/index.js";
 import {
   discoverExtensions,
   removeLocalExtension,
   setExtensionState,
 } from "../extensions/discovery.js";
 import { getInstalledPackages } from "../packages/discovery.js";
-import { discoverPackageExtensions, setPackageExtensionState } from "../packages/extensions.js";
 import {
-  showPackageActions,
   updatePackageWithOutcome,
   removePackageWithOutcome,
   updatePackagesWithOutcome,
@@ -51,6 +43,7 @@ import { updateExtmgrStatus } from "../utils/status.js";
 import { parseChoiceByLabel } from "../utils/command.js";
 import { getPackageSourceKind } from "../utils/package-source.js";
 import { UI } from "../constants.js";
+import { configurePackageExtensions } from "./package-config.js";
 
 // Type guard for SettingsList with selectedIndex
 interface SelectableList {
@@ -87,16 +80,15 @@ async function showInteractiveOnce(
   ctx: ExtensionCommandContext,
   pi: ExtensionAPI
 ): Promise<boolean> {
-  // Load local extensions and installed packages, then discover package entrypoints.
+  // Load local extensions and installed packages.
   const [localEntries, installedPackages] = await Promise.all([
     discoverExtensions(ctx.cwd),
     getInstalledPackages(ctx, pi),
   ]);
-  const packageExtensions = await discoverPackageExtensions(installedPackages, ctx.cwd);
 
-  // Build unified items list
+  // Build unified items list.
   const knownUpdates = getKnownUpdates(ctx);
-  const items = buildUnifiedItems(localEntries, installedPackages, packageExtensions, knownUpdates);
+  const items = buildUnifiedItems(localEntries, installedPackages, knownUpdates);
 
   // If nothing found, show quick actions
   if (items.length === 0) {
@@ -112,7 +104,7 @@ async function showInteractiveOnce(
     return true;
   }
 
-  // Staged changes tracking for toggleable rows (local + package extensions)
+  // Staged changes tracking for local extensions.
   const staged = new Map<string, State>();
   const byId = new Map(items.map((item) => [item.id, item]));
 
@@ -126,7 +118,7 @@ async function showInteractiveOnce(
       new Text(
         theme.fg(
           "muted",
-          `${items.length} item${items.length === 1 ? "" : "s"} • Space/Enter toggle extensions • Enter/A actions • u update pkg • x remove selected`
+          `${items.length} item${items.length === 1 ? "" : "s"} • Space/Enter toggle local • Enter/A actions • c configure pkg extensions • u update pkg • x remove selected`
         ),
         2,
         0
@@ -150,7 +142,7 @@ async function showInteractiveOnce(
       getSettingsListTheme(),
       (id: string, newValue: string) => {
         const item = byId.get(id);
-        if (!item || (item.type !== "local" && item.type !== "package-extension")) return;
+        if (!item || item.type !== "local") return;
 
         const state = newValue as State;
         staged.set(id, state);
@@ -236,6 +228,10 @@ async function showInteractiveOnce(
             done({ type: "action", itemId: selectedId, action: "details" });
             return;
           }
+          if (data === "c" || data === "C") {
+            done({ type: "action", itemId: selectedId, action: "configure" });
+            return;
+          }
         }
 
         if (selectedId && selectedItem?.type === "local") {
@@ -266,35 +262,25 @@ async function showInteractiveOnce(
   return await handleUnifiedAction(result, items, staged, byId, ctx, pi);
 }
 
+function normalizePathForDuplicateCheck(value: string): string {
+  const normalized = value.replace(/\\/g, "/");
+  const looksWindowsPath =
+    /^[a-zA-Z]:\//.test(normalized) || normalized.startsWith("//") || value.includes("\\");
+
+  return looksWindowsPath ? normalized.toLowerCase() : normalized;
+}
+
 export function buildUnifiedItems(
   localEntries: Awaited<ReturnType<typeof discoverExtensions>>,
   installedPackages: InstalledPackage[],
-  packageExtensions: PackageExtensionEntry[],
   knownUpdates: Set<string>
 ): UnifiedItem[] {
   const items: UnifiedItem[] = [];
   const localPaths = new Set<string>();
 
-  const packageExtensionGroups = new Map<string, PackageExtensionEntry[]>();
-  for (const entry of packageExtensions) {
-    const key = `${entry.packageScope}:${entry.packageSource.toLowerCase()}`;
-    const group = packageExtensionGroups.get(key) ?? [];
-    group.push(entry);
-    packageExtensionGroups.set(key, group);
-  }
-
-  const visiblePackageExtensions = packageExtensions.filter((entry) => {
-    const key = `${entry.packageScope}:${entry.packageSource.toLowerCase()}`;
-    const group = packageExtensionGroups.get(key) ?? [];
-
-    // Avoid duplicate-looking rows for packages that expose a single enabled extension entrypoint.
-    // Keep extension rows when there are multiple entrypoints, or when an entry is disabled so it can be re-enabled.
-    return group.length > 1 || entry.state === "disabled";
-  });
-
   // Add local extensions
   for (const entry of localEntries) {
-    localPaths.add(entry.activePath?.toLowerCase() ?? "");
+    localPaths.add(normalizePathForDuplicateCheck(entry.activePath));
     items.push({
       type: "local",
       id: entry.id,
@@ -308,39 +294,28 @@ export function buildUnifiedItems(
     });
   }
 
-  for (const entry of visiblePackageExtensions) {
-    items.push({
-      type: "package-extension",
-      id: entry.id,
-      displayName: entry.displayName,
-      summary: entry.summary,
-      scope: entry.packageScope,
-      state: entry.state,
-      originalState: entry.state,
-      packageSource: entry.packageSource,
-      extensionPath: entry.extensionPath,
-    });
-  }
-
   for (const pkg of installedPackages) {
-    const pkgSourceLower = pkg.source.toLowerCase();
-    const pkgResolvedLower = pkg.resolvedPath?.toLowerCase() ?? "";
+    const pkgSourceNormalized = normalizePathForDuplicateCheck(pkg.source);
+    const pkgResolvedNormalized = pkg.resolvedPath
+      ? normalizePathForDuplicateCheck(pkg.resolvedPath)
+      : "";
 
     let isDuplicate = false;
     for (const localPath of localPaths) {
-      if (pkgSourceLower === localPath || pkgResolvedLower === localPath) {
+      if (pkgSourceNormalized === localPath || pkgResolvedNormalized === localPath) {
         isDuplicate = true;
         break;
       }
       if (
-        pkgResolvedLower &&
-        (localPath.startsWith(pkgResolvedLower + "/") || pkgResolvedLower.startsWith(localPath))
+        pkgResolvedNormalized &&
+        (localPath.startsWith(`${pkgResolvedNormalized}/`) ||
+          pkgResolvedNormalized.startsWith(localPath))
       ) {
         isDuplicate = true;
         break;
       }
-      const localDir = localPath.replace(/\\/g, "/").split("/").slice(0, -1).join("/");
-      if (pkgResolvedLower && pkgResolvedLower.replace(/\\/g, "/") === localDir) {
+      const localDir = localPath.split("/").slice(0, -1).join("/");
+      if (pkgResolvedNormalized && pkgResolvedNormalized === localDir) {
         isDuplicate = true;
         break;
       }
@@ -365,8 +340,7 @@ export function buildUnifiedItems(
   items.sort((a, b) => {
     const rank = (type: UnifiedItem["type"]): number => {
       if (type === "local") return 0;
-      if (type === "package") return 1;
-      return 2;
+      return 1;
     };
 
     const diff = rank(a.type) - rank(b.type);
@@ -383,7 +357,7 @@ function buildSettingsItems(
   theme: Theme
 ): SettingItem[] {
   return items.map((item) => {
-    if (item.type === "local" || item.type === "package-extension") {
+    if (item.type === "local") {
       const currentState = staged.get(item.id) ?? item.state!;
       const changed = staged.has(item.id) && staged.get(item.id) !== item.originalState;
       return {
@@ -411,34 +385,19 @@ function formatUnifiedItemLabel(
 ): string {
   if (item.type === "local") {
     const statusIcon = getStatusIcon(theme, state === "enabled" ? "enabled" : "disabled");
-    const scopeIcon = getScopeIcon(theme, item.scope as "global" | "project");
+    const scopeIcon = getScopeIcon(theme, item.scope);
     const changeMarker = getChangeMarker(theme, changed);
     const name = theme.bold(item.displayName);
     const summary = theme.fg("dim", item.summary);
     return `${statusIcon} [${scopeIcon}] ${name} - ${summary}${changeMarker}`;
   }
 
-  if (item.type === "package-extension") {
-    const statusIcon = getStatusIcon(theme, state === "enabled" ? "enabled" : "disabled");
-    const scopeIcon = getScopeIcon(theme, item.scope as "global" | "project");
-    const sourceKind = getPackageSourceKind(item.packageSource ?? "");
-    const pkgIcon = getPackageIcon(
-      theme,
-      sourceKind === "npm" || sourceKind === "git" || sourceKind === "local" ? sourceKind : "local"
-    );
-    const sourceLabel = sourceKind === "unknown" ? "package" : `${sourceKind} package`;
-    const changeMarker = getChangeMarker(theme, changed);
-    const name = theme.bold(item.displayName);
-    const summary = theme.fg("dim", `${item.summary} • ${sourceLabel}`);
-    return `${statusIcon} ${pkgIcon} [${scopeIcon}] ${name} - ${summary}${changeMarker}`;
-  }
-
   const sourceKind = getPackageSourceKind(item.source ?? "");
   const pkgIcon = getPackageIcon(
     theme,
     sourceKind === "npm" || sourceKind === "git" || sourceKind === "local" ? sourceKind : "local"
   );
-  const scopeIcon = getScopeIcon(theme, item.scope as "global" | "project");
+  const scopeIcon = getScopeIcon(theme, item.scope);
   const name = theme.bold(item.displayName);
   const version = item.version ? theme.fg("dim", `@${item.version}`) : "";
   const updateBadge = item.updateAvailable ? ` ${theme.fg("warning", "[update]")}` : "";
@@ -468,7 +427,7 @@ function formatUnifiedItemLabel(
 }
 
 function getToggleItemsForApply(items: UnifiedItem[]): UnifiedItem[] {
-  return items.filter((item) => item.type === "local" || item.type === "package-extension");
+  return items.filter((item) => item.type === "local");
 }
 
 async function applyToggleChangesFromManager(
@@ -479,7 +438,7 @@ async function applyToggleChangesFromManager(
   options?: { promptReload?: boolean }
 ): Promise<{ changed: number; reloaded: boolean }> {
   const toggleItems = getToggleItemsForApply(items);
-  const apply = await applyStagedChanges(toggleItems, staged, pi, ctx.cwd);
+  const apply = await applyStagedChanges(toggleItems, staged, pi);
 
   if (apply.errors.length > 0) {
     ctx.ui.notify(
@@ -489,7 +448,7 @@ async function applyToggleChangesFromManager(
   } else if (apply.changed === 0) {
     ctx.ui.notify("No changes to apply.", "info");
   } else {
-    ctx.ui.notify(`Applied ${apply.changed} extension change(s).`, "info");
+    ctx.ui.notify(`Applied ${apply.changed} local extension change(s).`, "info");
   }
 
   if (apply.changed > 0) {
@@ -498,7 +457,7 @@ async function applyToggleChangesFromManager(
     if (shouldPromptReload) {
       const shouldReload = await ctx.ui.confirm(
         "Reload Required",
-        "Extensions changed. Reload pi now?"
+        "Local extensions changed. Reload pi now?"
       );
 
       if (shouldReload) {
@@ -570,6 +529,34 @@ const QUICK_DESTINATION_LABELS: Record<QuickDestination, string> = {
   help: "Help",
 };
 
+const PACKAGE_ACTION_OPTIONS = {
+  configure: "Configure extensions",
+  update: "Update package",
+  remove: "Remove package",
+  details: "View details",
+  back: "Back to manager",
+} as const;
+
+type PackageActionKey = keyof typeof PACKAGE_ACTION_OPTIONS;
+
+type PackageActionSelection = Exclude<PackageActionKey, "back"> | "cancel";
+
+async function promptPackageActionSelection(
+  pkg: InstalledPackage,
+  ctx: ExtensionCommandContext
+): Promise<PackageActionSelection> {
+  const selection = parseChoiceByLabel(
+    PACKAGE_ACTION_OPTIONS,
+    await ctx.ui.select(pkg.name, Object.values(PACKAGE_ACTION_OPTIONS))
+  );
+
+  if (!selection || selection === "back") {
+    return "cancel";
+  }
+
+  return selection;
+}
+
 async function navigateWithPendingGuard(
   destination: QuickDestination,
   items: UnifiedItem[],
@@ -754,20 +741,29 @@ async function handleUnifiedAction(
       return false;
     }
 
-    if (item.type === "package-extension") {
-      return false;
-    }
-
     const pkg: InstalledPackage = {
       source: item.source!,
       name: item.displayName,
       ...(item.version ? { version: item.version } : {}),
-      scope: item.scope as "global" | "project",
+      scope: item.scope,
       ...(item.description ? { description: item.description } : {}),
       ...(item.size !== undefined ? { size: item.size } : {}),
     };
 
-    switch (result.action) {
+    const selection =
+      !result.action || result.action === "menu"
+        ? await promptPackageActionSelection(pkg, ctx)
+        : result.action;
+
+    if (selection === "cancel") {
+      return false;
+    }
+
+    switch (selection) {
+      case "configure": {
+        const outcome = await configurePackageExtensions(pkg, ctx, pi);
+        return outcome.reloaded;
+      }
       case "update": {
         const outcome = await updatePackageWithOutcome(pkg.source, ctx, pi);
         return outcome.reloaded;
@@ -784,11 +780,6 @@ async function handleUnifiedAction(
         );
         return false;
       }
-      case "menu":
-      default: {
-        const exitManager = await showPackageActions(pkg, ctx, pi);
-        return exitManager;
-      }
     }
   }
 
@@ -799,37 +790,23 @@ async function handleUnifiedAction(
 async function applyStagedChanges(
   items: UnifiedItem[],
   staged: Map<string, State>,
-  pi: ExtensionAPI,
-  cwd: string
+  pi: ExtensionAPI
 ) {
   let changed = 0;
   const errors: string[] = [];
 
   for (const item of items) {
-    if ((item.type !== "local" && item.type !== "package-extension") || !item.originalState) {
+    if (item.type !== "local" || !item.originalState || !item.activePath || !item.disabledPath) {
       continue;
     }
 
     const target = staged.get(item.id) ?? item.originalState;
     if (target === item.originalState) continue;
 
-    let result: { ok: true } | { ok: false; error: string };
-    if (item.type === "local") {
-      if (!item.activePath || !item.disabledPath) continue;
-      result = await setExtensionState(
-        { activePath: item.activePath, disabledPath: item.disabledPath },
-        target
-      );
-    } else {
-      if (!item.packageSource || !item.extensionPath) continue;
-      result = await setPackageExtensionState(
-        item.packageSource,
-        item.extensionPath,
-        item.scope as "global" | "project",
-        target,
-        cwd
-      );
-    }
+    const result = await setExtensionState(
+      { activePath: item.activePath, disabledPath: item.disabledPath },
+      target
+    );
 
     if (result.ok) {
       changed++;

package/src/utils/auto-update.ts

@@ -18,6 +18,7 @@ import {
   type AutoUpdateConfig,
 } from "./settings.js";
 import { parseNpmSource } from "./format.js";
+import { execNpm } from "./npm-exec.js";
 import { TIMEOUTS } from "../constants.js";
 
 import { startTimer, stopTimer, isTimerRunning } from "./timer.js";
@@ -134,9 +135,8 @@ async function checkPackageUpdate(
   if (!pkgName) return false;
 
   try {
-    const res = await pi.exec("npm", ["view", pkgName, "version", "--json"], {
+    const res = await execNpm(pi, ["view", pkgName, "version", "--json"], ctx, {
       timeout: TIMEOUTS.npmView,
-      cwd: ctx.cwd,
     });
 
     if (res.code !== 0) return false;

package/src/utils/command.ts

@@ -3,7 +3,83 @@
  */
 
 export function tokenizeArgs(input: string): string[] {
-  return input.trim().split(/\s+/).filter(Boolean);
+  const tokens: string[] = [];
+  let current = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let tokenStarted = false;
+
+  const pushCurrent = () => {
+    if (tokenStarted) {
+      tokens.push(current);
+      current = "";
+      tokenStarted = false;
+    }
+  };
+
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i]!;
+    const next = input[i + 1];
+
+    if (inSingleQuote) {
+      if (char === "'") {
+        inSingleQuote = false;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+
+    if (inDoubleQuote) {
+      if (char === '"') {
+        inDoubleQuote = false;
+        continue;
+      }
+
+      if (char === "\\" && next === '"') {
+        current += next;
+        i++;
+        continue;
+      }
+
+      current += char;
+      continue;
+    }
+
+    if (/\s/.test(char)) {
+      pushCurrent();
+      continue;
+    }
+
+    if (char === "'") {
+      inSingleQuote = true;
+      tokenStarted = true;
+      continue;
+    }
+
+    if (char === '"') {
+      inDoubleQuote = true;
+      tokenStarted = true;
+      continue;
+    }
+
+    if (char === "\\" && (next === '"' || next === "'" || /\s/.test(next ?? ""))) {
+      tokenStarted = true;
+      if (next) {
+        current += next;
+        i++;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+
+    tokenStarted = true;
+    current += char;
+  }
+
+  pushCurrent();
+  return tokens;
 }
 
 export function splitCommandArgs(input: string): { subcommand: string; args: string[] } {

package/src/utils/format.ts

@@ -59,6 +59,9 @@ export function formatBytes(bytes: number): string {
 
 const GIT_PATTERNS = {
   gitPrefix: /^git:/,
+  gitPlusHttpPrefix: /^git\+https?:\/\//,
+  gitPlusSshPrefix: /^git\+ssh:\/\//,
+  gitPlusGitPrefix: /^git\+git:\/\//,
   httpPrefix: /^https?:\/\//,
   sshPrefix: /^ssh:\/\//,
   gitProtoPrefix: /^git:\/\//,
@@ -78,6 +81,9 @@ const LOCAL_PATH_PATTERNS = {
 function isGitLikeSource(source: string): boolean {
   return (
     GIT_PATTERNS.gitPrefix.test(source) ||
+    GIT_PATTERNS.gitPlusHttpPrefix.test(source) ||
+    GIT_PATTERNS.gitPlusSshPrefix.test(source) ||
+    GIT_PATTERNS.gitPlusGitPrefix.test(source) ||
     GIT_PATTERNS.httpPrefix.test(source) ||
     GIT_PATTERNS.sshPrefix.test(source) ||
     GIT_PATTERNS.gitProtoPrefix.test(source) ||
@@ -97,22 +103,36 @@ function isLocalPathSource(source: string): boolean {
   );
 }
 
+function unwrapQuotedSource(source: string): string {
+  const trimmed = source.trim();
+  if (trimmed.length < 2) return trimmed;
+
+  const first = trimmed[0];
+  const last = trimmed[trimmed.length - 1];
+
+  if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+    return trimmed.slice(1, -1).trim();
+  }
+
+  return trimmed;
+}
+
 export function isPackageSource(str: string): boolean {
-  const source = str.trim();
+  const source = unwrapQuotedSource(str);
   if (!source) return false;
 
   return source.startsWith("npm:") || isGitLikeSource(source) || isLocalPathSource(source);
 }
 
 export function normalizePackageSource(source: string): string {
-  const trimmed = source.trim();
+  const trimmed = unwrapQuotedSource(source);
   if (!trimmed) return trimmed;
 
   if (GIT_PATTERNS.gitSsh.test(trimmed)) {
     return `git:${trimmed}`;
   }
 
-  if (isPackageSource(trimmed)) {
+  if (trimmed.startsWith("npm:") || isGitLikeSource(trimmed) || isLocalPathSource(trimmed)) {
     return trimmed;
   }
 

package/src/utils/npm-exec.ts

@@ -0,0 +1,47 @@
+import path from "node:path";
+import { execPath, platform } from "node:process";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+interface NpmCommandResolutionOptions {
+  platform?: NodeJS.Platform;
+  nodeExecPath?: string;
+}
+
+interface NpmExecOptions {
+  timeout: number;
+}
+
+function getNpmCliPath(nodeExecPath: string, runtimePlatform: NodeJS.Platform): string {
+  const pathImpl = runtimePlatform === "win32" ? path.win32 : path;
+  return pathImpl.join(pathImpl.dirname(nodeExecPath), "node_modules", "npm", "bin", "npm-cli.js");
+}
+
+export function resolveNpmCommand(
+  npmArgs: string[],
+  options?: NpmCommandResolutionOptions
+): { command: string; args: string[] } {
+  const runtimePlatform = options?.platform ?? platform;
+
+  if (runtimePlatform === "win32") {
+    const nodeBinary = options?.nodeExecPath ?? execPath;
+    return {
+      command: nodeBinary,
+      args: [getNpmCliPath(nodeBinary, runtimePlatform), ...npmArgs],
+    };
+  }
+
+  return { command: "npm", args: npmArgs };
+}
+
+export async function execNpm(
+  pi: ExtensionAPI,
+  npmArgs: string[],
+  ctx: { cwd: string },
+  options: NpmExecOptions
+): Promise<{ code: number; stdout: string; stderr: string; killed: boolean }> {
+  const resolved = resolveNpmCommand(npmArgs);
+  return pi.exec(resolved.command, resolved.args, {
+    timeout: options.timeout,
+    cwd: ctx.cwd,
+  });
+}

package/src/utils/package-source.ts

@@ -18,6 +18,10 @@ export function getPackageSourceKind(source: string): PackageSourceKind {
 
   if (
     normalized.startsWith("git:") ||
+    normalized.startsWith("git+http://") ||
+    normalized.startsWith("git+https://") ||
+    normalized.startsWith("git+ssh://") ||
+    normalized.startsWith("git+git://") ||
     normalized.startsWith("http://") ||
     normalized.startsWith("https://") ||
     normalized.startsWith("ssh://") ||
@@ -43,6 +47,14 @@ export function getPackageSourceKind(source: string): PackageSourceKind {
   return "unknown";
 }
 
+export function normalizeLocalSourceIdentity(source: string): string {
+  const normalized = source.replace(/\\/g, "/");
+  const looksWindowsPath =
+    /^[a-zA-Z]:\//.test(normalized) || normalized.startsWith("//") || source.includes("\\");
+
+  return looksWindowsPath ? normalized.toLowerCase() : normalized;
+}
+
 export function splitGitRepoAndRef(gitSpec: string): { repo: string; ref?: string | undefined } {
   const lastAt = gitSpec.lastIndexOf("@");
   if (lastAt <= 0) {