pi-extmgr 0.1.22 → 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";
@@ -16,6 +16,8 @@ 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 { 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";
@@ -71,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
+        );
+      }
+    })
   );
 }
 
@@ -149,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
@@ -207,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}`);
       }
@@ -230,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) {
@@ -291,9 +365,8 @@ export async function installPackageLocally(
       await mkdir(extensionDir, { recursive: true });
       showProgress(ctx, "Fetching", packageName);
 
-      const viewRes = await pi.exec("npm", ["view", packageName, "--json"], {
+      const viewRes = await execNpm(pi, ["view", packageName, "--json"], ctx, {
         timeout: TIMEOUTS.fetchPackageInfo,
-        cwd: ctx.cwd,
       });
 
       if (viewRes.code !== 0) {
@@ -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,8 +10,8 @@ import {
   isSourceInstalled,
 } from "./discovery.js";
 import { waitForCondition } from "../utils/retry.js";
-import { formatInstalledPackageLabel, parseNpmSource } from "../utils/format.js";
-import { getPackageSourceKind, 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";
@@ -33,12 +33,19 @@ const NO_PACKAGE_MUTATION_OUTCOME: PackageMutationOutcome = {
   reloaded: false,
 };
 
+const BULK_UPDATE_LABEL = "all packages";
+
 function packageMutationOutcome(
   overrides: Partial<PackageMutationOutcome>
 ): 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;
+}
+
 async function updatePackageInternal(
   source: string,
   ctx: ExtensionCommandContext,
@@ -59,17 +66,19 @@ async function updatePackageInternal(
     return NO_PACKAGE_MUTATION_OUTCOME;
   }
 
+  const updateIdentity = normalizePackageIdentity(source);
   const stdout = res.stdout || "";
-  if (stdout.includes("already up to date") || stdout.includes("pinned")) {
+  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);
+  clearUpdatesAvailable(pi, ctx, [updateIdentity]);
 
   const reloaded = await confirmReload(ctx, "Package updated.");
   if (!reloaded) {
@@ -87,18 +96,23 @@ async function updatePackagesInternal(
   const res = await pi.exec("pi", ["update"], { timeout: TIMEOUTS.packageUpdateAll, cwd: ctx.cwd });
 
   if (res.code !== 0) {
-    notifyError(ctx, `Update failed: ${res.stderr || res.stdout || `exit ${res.code}`}`);
+    const errorMsg = `Update failed: ${res.stderr || res.stdout || `exit ${res.code}`}`;
+    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 (stdout.includes("already up to date") || stdout.trim() === "") {
+  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);
 
@@ -139,23 +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}`;
-  }
-
-  if (getPackageSourceKind(source) === "git") {
-    const gitSpec = source.startsWith("git:") ? source.slice(4) : source;
-    const { repo } = splitGitRepoAndRef(gitSpec);
-    return `git:${repo}`;
-  }
-
-  if (fallbackName) {
-    return `name:${fallbackName}`;
-  }
-
-  return `src:${source}`;
+function packageIdentity(source: string): string {
+  return normalizePackageIdentity(source);
 }
 
 async function getInstalledPackagesAllScopes(
@@ -238,12 +237,18 @@ function formatRemovalTargets(targets: RemovalTarget[]): string {
   return targets.map((t) => `${t.scope}: ${t.source}`).join("\n");
 }
 
+interface RemovalExecutionResult {
+  target: RemovalTarget;
+  success: boolean;
+  error?: string;
+}
+
 async function executeRemovalTargets(
   targets: RemovalTarget[],
   ctx: ExtensionCommandContext,
   pi: ExtensionAPI
-): Promise<string[]> {
-  const failures: string[] = [];
+): Promise<RemovalExecutionResult[]> {
+  const results: RemovalExecutionResult[] = [];
 
   for (const target of targets) {
     showProgress(ctx, "Removing", `${target.source} (${target.scope})`);
@@ -254,14 +259,15 @@ async function executeRemovalTargets(
     if (res.code !== 0) {
       const errorMsg = `Remove failed (${target.scope}): ${res.stderr || res.stdout || `exit ${res.code}`}`;
       logPackageRemove(pi, target.source, target.name, false, errorMsg);
-      failures.push(errorMsg);
+      results.push({ target, success: false, error: errorMsg });
       continue;
     }
 
     logPackageRemove(pi, target.source, target.name, true);
+    results.push({ target, success: true });
   }
 
-  return failures;
+  return results;
 }
 
 function notifyRemovalSummary(
@@ -295,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") &&
@@ -326,25 +331,36 @@ async function removePackageInternal(
     return NO_PACKAGE_MUTATION_OUTCOME;
   }
 
-  const failures = await executeRemovalTargets(targets, ctx, pi);
+  const results = await executeRemovalTargets(targets, ctx, pi);
   clearSearchCache();
 
+  const failures = results
+    .filter((result): result is RemovalExecutionResult & { success: false; error: string } =>
+      Boolean(!result.success && result.error)
+    )
+    .map((result) => result.error);
+  const successfulTargets = results
+    .filter((result) => result.success)
+    .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]);
   }
 
-  // Wait for selected targets to disappear from their target scopes before reloading.
-  if (failures.length === 0 && targets.length > 0) {
+  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(
-          targets.map((target) =>
+          successfulTargets.map((target) =>
             isSourceInstalled(target.source, ctx, pi, {
               scope: target.scope,
             })
@@ -360,6 +376,11 @@ async function removePackageInternal(
     }
   }
 
+  if (successfulRemovalCount === 0) {
+    void updateExtmgrStatus(ctx, pi);
+    return NO_PACKAGE_MUTATION_OUTCOME;
+  }
+
   const reloaded = await confirmReload(ctx, "Removal complete.");
   if (!reloaded) {
     void updateExtmgrStatus(ctx, pi);