@penvhq/cli 0.9.5 → 0.10.0

package/dist/index.cjs

@@ -492,19 +492,12 @@ async function createSourceProvider(type, context) {
   return loadPluginProvider(type, context);
 }
 async function loadPluginProvider(type, context) {
-  const resolved = resolvePlugin(type, context.root);
-  if (resolved === void 0) {
-    throw unknownProvider(type, context.environment);
-  }
+  const path = resolveExtension(type, context.root, context.environment);
   let mod;
   try {
-    mod = await importPlugin(resolved);
-  } catch {
-    throw new import_core4.PenvError(
-      "PROVIDER_PLUGIN_LOAD",
-      `The provider package \`${type}\` failed to load`,
-      "It resolved but threw while importing. Check it builds and its dependencies are installed."
-    );
+    mod = await importPlugin(path);
+  } catch (cause) {
+    throw providerLoadFailed(type, path, cause);
   }
   const factory = mod[PLUGIN_FACTORY_EXPORT];
   if (typeof factory !== "function") {
@@ -528,10 +521,42 @@ function assertProvidersRegistered(config, projectRoot, options) {
     if (ci && local.includes(provider.type)) {
       throw localExtensionInCi(provider.type, environment);
     }
-    if (resolvePlugin(provider.type, projectRoot) === void 0) {
-      throw unknownProvider(provider.type, environment);
+    resolveExtension(provider.type, projectRoot, environment, local);
+  }
+}
+function resolveExtension(type, projectRoot, environment, local = localExtensions(projectRoot)) {
+  const fromProject = resolvePlugin(type, projectRoot);
+  if (local.includes(type)) {
+    if (fromProject === void 0) {
+      throw localExtensionUnresolved(type, projectRoot, environment);
     }
+    return fromProject;
+  }
+  if (fromProject !== void 0) {
+    return fromProject;
   }
+  const version = pinnedVersion(type, projectRoot);
+  if (version === void 0) {
+    throw unknownProvider(type, environment);
+  }
+  const stored = storedExtension(type, version);
+  if (stored === void 0) {
+    throw extensionNotInstalled(type, version, environment);
+  }
+  return stored;
+}
+function pinnedVersion(type, projectRoot) {
+  let manifest;
+  try {
+    manifest = (0, import_core4.parseManifest)((0, import_node_fs3.readFileSync)((0, import_node_path3.join)(projectRoot, ...import_core4.MANIFEST_PATH.split("/")), "utf8"));
+  } catch {
+    return void 0;
+  }
+  return manifest.extensions[type]?.version;
+}
+function storedExtension(type, version) {
+  const entry = (0, import_core4.packageEntry)((0, import_core4.packageDir)((0, import_core4.penvHome)(process.env), "extensions", type, version));
+  return entry?.file;
 }
 function localExtensions(projectRoot) {
   let text;
@@ -583,13 +608,37 @@ function assertSatisfiesContract(provider, specifier) {
     }
   }
 }
+function where(environment) {
+  return environment === void 0 ? "" : ` for environment ${environment}`;
+}
 function unknownProvider(type, environment) {
   const preinstalled = [...REGISTRY.keys()].map((name) => `\`${name}\``).join(", ");
-  const where = environment === void 0 ? "" : ` for environment ${environment}`;
   return new import_core4.PenvError(
     "UNKNOWN_PROVIDER",
-    `The provider \`${type}\`${where} in penv.config.ts is not installed in this project`,
-    `A provider's \`type\` is the package penv imports, so it has to resolve from this project: install it with \`npm i ${type}\`, or \u2014 if this repository is the one that builds it \u2014 run \`penv add --local ${type}\` once it is a dependency of the root. The CLI ships ${preinstalled} pre-installed.`
+    `The provider \`${type}\`${where(environment)} in penv.config.ts is nowhere penv looks for it`,
+    `Run \`penv add ${type}\` to pin a release, or \`penv add --local ${type}\` if this repository is the one that builds it. penv looks in ${import_core4.LOCAL_EXTENSIONS_PATH}, this project's node_modules, and then $PENV_HOME at the version ${import_core4.MANIFEST_PATH} pins. The CLI ships ${preinstalled} pre-installed.`
+  );
+}
+function extensionNotInstalled(type, version, environment) {
+  return new import_core4.PenvError(
+    "EXTENSION_NOT_INSTALLED",
+    `${import_core4.MANIFEST_PATH} pins \`${type}\` ${version}${where(environment)}, and it is not installed in ${(0, import_core4.penvHome)(process.env)}`,
+    "Run `penv install` \u2014 it downloads and verifies every version the manifest pins, extensions included."
+  );
+}
+function localExtensionUnresolved(type, projectRoot, environment) {
+  return new import_core4.PenvError(
+    "LOCAL_EXTENSION_UNRESOLVED",
+    `${import_core4.LOCAL_EXTENSIONS_PATH} records \`${type}\`${where(environment)} as a package this project develops, and it does not resolve from ${projectRoot}`,
+    `Add it as a dependency of the root (a workspace link is one) and run \`pnpm install\`, or drop the name from ${import_core4.LOCAL_EXTENSIONS_PATH} if this project no longer builds it.`
+  );
+}
+function providerLoadFailed(type, path, cause) {
+  const detail = cause instanceof Error ? cause.message : String(cause);
+  return new import_core4.PenvError(
+    "PROVIDER_PLUGIN_LOAD",
+    `The provider package \`${type}\` failed to load from ${path}: ${detail}`,
+    "penv imports that file exactly as it stands, with no transform, so it has to be built JavaScript with its dependencies installed."
   );
 }
 
@@ -4310,9 +4359,9 @@ function assertImportable(ref, variable) {
     `Filenames are split on \`.\`. Rename ${variable} in the source file, then import it again.`
   );
 }
-function assertNotReserved(ref, variable, where, config) {
+function assertNotReserved(ref, variable, where2, config) {
   if ((0, import_core22.isReservedToken)(ref.name, config)) {
-    throw new import_core22.ReservedTokenError("parameter", variable, where);
+    throw new import_core22.ReservedTokenError("parameter", variable, where2);
   }
 }
 function assertRoundTrips(ref, variable, config) {
@@ -4329,12 +4378,12 @@ function assertRoundTrips(ref, variable, config) {
     `\`penv generate\` would write ${generated}, so anything reading \`process.env["${variable}"]\` would read \`undefined\`. Declare the name you want in the \`override\` block of penv.config.ts \u2014 \`override: { "${ref.name}": "${variable}" }\` \u2014 then import it again. Nothing was imported.`
   );
 }
-function refsForEntries(entries, where, config) {
+function refsForEntries(entries, where2, config) {
   const refs = [];
   for (const entry of entries) {
     const ref = (0, import_core22.refFromVariable)(entry.key);
     assertImportable(ref, entry.key);
-    assertNotReserved(ref, entry.key, where, config);
+    assertNotReserved(ref, entry.key, where2, config);
     assertRoundTrips(ref, entry.key, config);
     refs.push(ref);
   }
@@ -5324,7 +5373,7 @@ function writeTsconfigAlias(root, decisions = DEFAULT_DECISIONS) {
   const alias = decisions.alias;
   const imports = alias.startsWith(IMPORTS_PREFIX);
   const file = (0, import_node_path13.join)(root, imports ? PACKAGE_FILE : TSCONFIG_FILE);
-  const where = imports ? PACKAGE_FILE : TSCONFIG_FILE;
+  const where2 = imports ? PACKAGE_FILE : TSCONFIG_FILE;
   if (!(0, import_node_fs13.existsSync)(file)) {
     if (imports) {
       return {
@@ -5347,7 +5396,7 @@ function writeTsconfigAlias(root, decisions = DEFAULT_DECISIONS) {
     return {
       target: "tsconfig",
       action: "conflicted",
-      text: `${where} already maps ${alias} to ${edit.conflict}`,
+      text: `${where2} already maps ${alias} to ${edit.conflict}`,
       note: `(left alone \u2014 \`import { env } from "${alias}"\` will not reach ${decisions.schemaFile})`
     };
   }
@@ -5355,14 +5404,14 @@ function writeTsconfigAlias(root, decisions = DEFAULT_DECISIONS) {
     return {
       target: "tsconfig",
       action: "kept",
-      text: `Kept the ${alias} alias in ${where}`
+      text: `Kept the ${alias} alias in ${where2}`
     };
   }
   (0, import_node_fs13.writeFileSync)(file, edit.source, "utf8");
   return {
     target: "tsconfig",
     action: "updated",
-    text: `Added ${alias} alias to ${where}`
+    text: `Added ${alias} alias to ${where2}`
   };
 }
 function writeGitignore(root, decisions = DEFAULT_DECISIONS) {