pi-extmgr 0.1.23 → 0.1.25

package/src/packages/extensions.ts

@@ -9,6 +9,7 @@ import { getAgentDir } from "@mariozechner/pi-coding-agent";
 import type { InstalledPackage, PackageExtensionEntry, Scope, State } from "../types/index.js";
 import { parseNpmSource } from "../utils/format.js";
 import { fileExists, readSummary } from "../utils/fs.js";
+import { resolveNpmCommand } from "../utils/npm-exec.js";
 
 interface PackageSettingsObject {
   source: string;
@@ -19,6 +20,14 @@ interface SettingsFile {
   packages?: (string | PackageSettingsObject)[];
 }
 
+export interface PackageManifest {
+  name?: string;
+  dependencies?: Record<string, string>;
+  pi?: {
+    extensions?: unknown;
+  };
+}
+
 const execFileAsync = promisify(execFile);
 let globalNpmRootCache: string | null | undefined;
 
@@ -50,7 +59,8 @@ async function getGlobalNpmRoot(): Promise<string | undefined> {
   }
 
   try {
-    const { stdout } = await execFileAsync("npm", ["root", "-g"], {
+    const npmCommand = resolveNpmCommand(["root", "-g"]);
+    const { stdout } = await execFileAsync(npmCommand.command, npmCommand.args, {
       timeout: 2_000,
       windowsHide: true,
     });
@@ -206,6 +216,125 @@ async function writeSettingsFile(path: string, settings: SettingsFile): Promise<
   }
 }
 
+function findPackageSettingsIndex(
+  packages: SettingsFile["packages"] extends infer T ? NonNullable<T> : never,
+  normalizedSource: string
+): number {
+  return packages.findIndex((pkg) => {
+    if (typeof pkg === "string") {
+      return normalizeSource(pkg) === normalizedSource;
+    }
+    return normalizeSource(pkg.source) === normalizedSource;
+  });
+}
+
+function toPackageSettingsObject(
+  existing: string | PackageSettingsObject | undefined,
+  packageSource: string
+): PackageSettingsObject {
+  if (typeof existing === "string") {
+    return { source: existing, extensions: [] };
+  }
+
+  if (existing && typeof existing.source === "string") {
+    return {
+      source: existing.source,
+      extensions: Array.isArray(existing.extensions) ? [...existing.extensions] : [],
+    };
+  }
+
+  return { source: packageSource, extensions: [] };
+}
+
+function updateExtensionMarkers(
+  existingTokens: string[] | undefined,
+  changes: ReadonlyMap<string, State>
+): string[] {
+  const nextTokens: string[] = [];
+
+  for (const token of existingTokens ?? []) {
+    if (typeof token !== "string") {
+      continue;
+    }
+
+    if (token[0] !== "+" && token[0] !== "-") {
+      nextTokens.push(token);
+      continue;
+    }
+
+    const tokenPath = normalizeRelativePath(token.slice(1));
+    if (!changes.has(tokenPath)) {
+      nextTokens.push(token);
+    }
+  }
+
+  for (const [extensionPath, target] of Array.from(changes.entries()).sort((a, b) =>
+    a[0].localeCompare(b[0])
+  )) {
+    nextTokens.push(`${target === "enabled" ? "+" : "-"}${extensionPath}`);
+  }
+
+  return nextTokens;
+}
+
+export async function validatePackageExtensionSettings(
+  scope: Scope,
+  cwd: string
+): Promise<{ ok: true } | { ok: false; error: string }> {
+  try {
+    await readSettingsFile(getSettingsPath(scope, cwd), { strict: true });
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+export async function applyPackageExtensionStateChanges(
+  packageSource: string,
+  scope: Scope,
+  changes: readonly { extensionPath: string; target: State }[],
+  cwd: string
+): Promise<{ ok: true } | { ok: false; error: string }> {
+  try {
+    if (changes.length === 0) {
+      return { ok: true };
+    }
+
+    const settingsPath = getSettingsPath(scope, cwd);
+    const settings = await readSettingsFile(settingsPath, { strict: true });
+    const normalizedSource = normalizeSource(packageSource);
+    const packages = [...(settings.packages ?? [])];
+    const index = findPackageSettingsIndex(packages, normalizedSource);
+    const packageEntry = toPackageSettingsObject(packages[index], packageSource);
+
+    const normalizedChanges = new Map<string, State>();
+    for (const change of changes) {
+      normalizedChanges.set(normalizeRelativePath(change.extensionPath), change.target);
+    }
+
+    packageEntry.extensions = updateExtensionMarkers(packageEntry.extensions, normalizedChanges);
+
+    if (index === -1) {
+      packages.push(packageEntry);
+    } else {
+      packages[index] = packageEntry;
+    }
+
+    settings.packages = packages;
+    await writeSettingsFile(settingsPath, settings);
+
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
 function safeMatchesGlob(targetPath: string, pattern: string): boolean {
   try {
     return matchesGlob(targetPath, pattern);
@@ -405,20 +534,29 @@ async function resolveManifestExtensionEntries(
   return Array.from(selected).sort((a, b) => a.localeCompare(b));
 }
 
-export async function resolveManifestExtensionEntrypoints(
+export async function readPackageManifest(
   packageRoot: string
-): Promise<string[] | undefined> {
+): Promise<PackageManifest | undefined> {
   const packageJsonPath = join(packageRoot, "package.json");
 
-  let parsed: { pi?: { extensions?: unknown } };
   try {
     const raw = await readFile(packageJsonPath, "utf8");
-    parsed = JSON.parse(raw) as { pi?: { extensions?: unknown } };
+    const parsed = JSON.parse(raw) as unknown;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return undefined;
+    }
+    return parsed as PackageManifest;
   } catch {
     return undefined;
   }
+}
 
-  const extensions = parsed.pi?.extensions;
+export async function resolveManifestExtensionEntrypoints(
+  packageRoot: string,
+  manifest?: PackageManifest
+): Promise<string[] | undefined> {
+  const parsed = manifest ?? (await readPackageManifest(packageRoot));
+  const extensions = parsed?.pi?.extensions;
   if (!Array.isArray(extensions)) {
     return undefined;
   }
@@ -427,12 +565,35 @@ export async function resolveManifestExtensionEntrypoints(
   return resolveManifestExtensionEntries(packageRoot, entries);
 }
 
-async function discoverEntrypoints(packageRoot: string): Promise<string[]> {
-  const manifestEntrypoints = await resolveManifestExtensionEntrypoints(packageRoot);
+async function resolveConventionExtensionEntrypoints(packageRoot: string): Promise<string[]> {
+  const extensionsDir = join(packageRoot, "extensions");
+  return collectExtensionFilesFromDir(packageRoot, extensionsDir);
+}
+
+export async function discoverPackageExtensionEntrypoints(
+  packageRoot: string,
+  options?: {
+    allowConventionDirectory?: boolean;
+    allowRootIndexFallback?: boolean;
+  }
+): Promise<string[]> {
+  const manifest = await readPackageManifest(packageRoot);
+  const manifestEntrypoints = await resolveManifestExtensionEntrypoints(packageRoot, manifest);
   if (manifestEntrypoints !== undefined) {
     return manifestEntrypoints;
   }
 
+  if (options?.allowConventionDirectory !== false) {
+    const conventionEntrypoints = await resolveConventionExtensionEntrypoints(packageRoot);
+    if (conventionEntrypoints.length > 0) {
+      return conventionEntrypoints.sort((a, b) => a.localeCompare(b));
+    }
+  }
+
+  if (options?.allowRootIndexFallback === false) {
+    return [];
+  }
+
   const indexTs = join(packageRoot, "index.ts");
   if (await fileExists(indexTs)) {
     return ["index.ts"];
@@ -456,7 +617,7 @@ export async function discoverPackageExtensions(
     const packageRoot = await toPackageRoot(pkg, cwd);
     if (!packageRoot) continue;
 
-    const extensionPaths = await discoverEntrypoints(packageRoot);
+    const extensionPaths = await discoverPackageExtensionEntrypoints(packageRoot);
     for (const extensionPath of extensionPaths) {
       const normalizedPath = normalizeRelativePath(extensionPath);
       const absolutePath = resolve(packageRoot, extensionPath);
@@ -490,58 +651,5 @@ export async function setPackageExtensionState(
   target: State,
   cwd: string
 ): Promise<{ ok: true } | { ok: false; error: string }> {
-  try {
-    const settingsPath = getSettingsPath(scope, cwd);
-    const settings = await readSettingsFile(settingsPath, { strict: true });
-
-    const normalizedSource = normalizeSource(packageSource);
-    const normalizedPath = normalizeRelativePath(extensionPath);
-    const marker = `${target === "enabled" ? "+" : "-"}${normalizedPath}`;
-
-    const packages = [...(settings.packages ?? [])];
-    let index = packages.findIndex((pkg) => {
-      if (typeof pkg === "string") {
-        return normalizeSource(pkg) === normalizedSource;
-      }
-      return normalizeSource(pkg.source) === normalizedSource;
-    });
-
-    let packageEntry: PackageSettingsObject;
-    if (index === -1) {
-      packageEntry = { source: packageSource, extensions: [marker] };
-      packages.push(packageEntry);
-      index = packages.length - 1;
-    } else {
-      const existing = packages[index];
-      if (typeof existing === "string") {
-        packageEntry = { source: existing, extensions: [] };
-      } else if (existing && typeof existing.source === "string") {
-        packageEntry = {
-          source: existing.source,
-          extensions: Array.isArray(existing.extensions) ? [...existing.extensions] : [],
-        };
-      } else {
-        packageEntry = { source: packageSource, extensions: [] };
-      }
-
-      packageEntry.extensions = (packageEntry.extensions ?? []).filter((token) => {
-        if (typeof token !== "string") return false;
-        if (token[0] !== "+" && token[0] !== "-") return true;
-        return normalizeRelativePath(token.slice(1)) !== normalizedPath;
-      });
-      packageEntry.extensions.push(marker);
-      packages[index] = packageEntry;
-    }
-
-    settings.packages = packages;
-
-    await writeSettingsFile(settingsPath, settings);
-
-    return { ok: true };
-  } catch (error) {
-    return {
-      ok: false,
-      error: error instanceof Error ? error.message : String(error),
-    };
-  }
+  return applyPackageExtensionStateChanges(packageSource, scope, [{ extensionPath, target }], cwd);
 }

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,8 @@ 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 { fetchWithTimeout } from "../utils/network.js";
 import { TIMEOUTS } from "../constants.js";
 
 export type InstallScope = "global" | "project";
@@ -72,20 +74,77 @@ function safeExtractGithubMatch(match: RegExpMatchArray | null): GithubUrlInfo |
   return { owner, repo, branch, filePath };
 }
 
+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 +209,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 +267,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 +290,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 +383,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 +417,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 +436,7 @@ export async function installPackageLocally(
     void updateExtmgrStatus(ctx, pi);
     return;
   }
-  const { tarballPath, tempDir } = extractResult;
+  const { tarballPath } = extractResult;
 
   // Extract
   const extractDir = join(
@@ -390,17 +465,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 +509,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 +528,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;