@penvhq/launcher 0.9.5 → 0.11.0

package/dist/bin.cjs

@@ -53,12 +53,17 @@ var import_core2 = require("@penvhq/core");
 // src/errors.ts
 var import_core = require("@penvhq/core");
 var INSTALL_COMMAND = "penv install";
+var UPGRADE_COMMAND = "penv upgrade";
+var YES_FLAG = "--yes";
 var MIN_PACKAGE_AGE_DAYS = 7;
 var TRUST_YOUNG_FLAG = "--trust-young";
 function addCommand(name, version, extra) {
   const spec = version === void 0 ? name : `${name}@${version}`;
   return `penv add ${spec}${extra === void 0 ? "" : ` ${extra}`}`;
 }
+function addCommandFor(name, local) {
+  return local ? `penv add ${LOCAL_FLAG} ${name}` : addCommand(name);
+}
 var NoProjectError = class extends import_core.PenvError {
   name = "NoProjectError";
   constructor(cwd) {
@@ -170,6 +175,26 @@ var AddLocalFlagError = class extends import_core.PenvError {
     );
   }
 };
+var ExtensionNotImportableError = class extends import_core.PenvError {
+  name = "ExtensionNotImportableError";
+  constructor(name, entry, local) {
+    super(
+      "PENV_EXTENSION_NOT_IMPORTABLE",
+      entry === void 0 ? `${name} declares no entry point penv can import` : `${name} resolves to ${entry}, which penv cannot import`,
+      `penv imports a provider with no transform, so its entry has to be built JavaScript. Point the package's \`exports\` at its build output \u2014 \`dist/index.js\` \u2014 then run \`${addCommandFor(name, local)}\` again.`
+    );
+  }
+};
+var ExtensionUnloadableError = class extends import_core.PenvError {
+  name = "ExtensionUnloadableError";
+  constructor(name, entry, detail, local) {
+    super(
+      "PENV_EXTENSION_UNLOADABLE",
+      `${name} threw while penv imported ${entry}: ${detail}`,
+      `Build the package and install its dependencies, then run \`${addCommandFor(name, local)}\` again. penv adds a provider it has loaded once, or none.`
+    );
+  }
+};
 var LocalExtensionUnresolvedError = class extends import_core.PenvError {
   name = "LocalExtensionUnresolvedError";
   constructor(name, root) {
@@ -212,11 +237,11 @@ var OfficialRegistryError = class extends import_core.PenvError {
 };
 var RegistryUnreadableError = class extends import_core.PenvError {
   name = "RegistryUnreadableError";
-  constructor(name, url, detail) {
+  constructor(name, url, detail, retry = addCommand(name)) {
     super(
       "PENV_REGISTRY_UNREADABLE",
       `Reading ${name} from ${url} failed: ${detail}`,
-      `Run \`${addCommand(name)}\` again when the registry is reachable.`
+      `Run \`${retry}\` again when the registry is reachable.`
     );
   }
 };
@@ -232,11 +257,11 @@ var PackageUnknownError = class extends import_core.PenvError {
 };
 var VersionUnknownError = class extends import_core.PenvError {
   name = "VersionUnknownError";
-  constructor(name, version, url) {
+  constructor(name, version, url, retry = addCommand(name)) {
     super(
       "PENV_VERSION_UNKNOWN",
       `${url} publishes no ${version} of ${name}`,
-      `Run \`${addCommand(name)}\` to take the version \`latest\` points at.`
+      `Run \`${retry}\` to take the version \`latest\` points at.`
     );
   }
 };
@@ -361,6 +386,66 @@ var EnginePinMismatchError = class extends import_core.PenvError {
     );
   }
 };
+var UpgradeSubjectError = class extends import_core.PenvError {
+  name = "UpgradeSubjectError";
+  constructor() {
+    super(
+      "PENV_UPGRADE_SUBJECT",
+      "`penv upgrade` takes one version, or none",
+      `Run \`${UPGRADE_COMMAND}\` to move to whatever \`latest\` points at, or \`${UPGRADE_COMMAND} 0.9.6\` to move to an exact release.`
+    );
+  }
+};
+var UpgradeFlagError = class extends import_core.PenvError {
+  name = "UpgradeFlagError";
+  constructor(flag) {
+    super(
+      "PENV_UPGRADE_FLAG",
+      `\`${UPGRADE_COMMAND}\` does not understand \`${flag}\``,
+      `Run \`${UPGRADE_COMMAND} [version]\` with \`${YES_FLAG}\` \u2014 that is the one flag it takes.`
+    );
+  }
+};
+var UpgradeNoDownloadError = class extends import_core.PenvError {
+  name = "UpgradeNoDownloadError";
+  constructor() {
+    super(
+      "PENV_UPGRADE_NO_DOWNLOAD",
+      `Upgrading means reading the registry for the version and integrity to pin, and \`--no-download\` says this run does not`,
+      `Run \`${UPGRADE_COMMAND}\` without \`--no-download\`. Nothing was fetched or written.`
+    );
+  }
+};
+var UpgradeUnattendedError = class extends import_core.PenvError {
+  name = "UpgradeUnattendedError";
+  constructor() {
+    super(
+      "PENV_UPGRADE_UNATTENDED",
+      `Upgrading rewrites ${import_core.MANIFEST_PATH} and package.json, and this run has nobody to decide that`,
+      `Run \`${UPGRADE_COMMAND} <version> ${YES_FLAG}\` \u2014 unattended, penv moves the pin only to a version you named. In CI, run \`${INSTALL_COMMAND}\`: it installs what the committed manifest already pins.`
+    );
+  }
+};
+var UpgradeDeclinedError = class extends import_core.PenvError {
+  name = "UpgradeDeclinedError";
+  constructor(version) {
+    super(
+      "PENV_UPGRADE_DECLINED",
+      `${import_core.ENGINE_PACKAGE} ${version} was not installed, so ${import_core.MANIFEST_PATH} and package.json are unchanged`,
+      `Run \`${UPGRADE_COMMAND} ${version}\` again when you want both of them to move.`
+    );
+  }
+};
+var UpgradeInstallFailedError = class extends import_core.PenvError {
+  name = "UpgradeInstallFailedError";
+  constructor(command) {
+    super(
+      "PENV_UPGRADE_INSTALL_FAILED",
+      `${command} did not finish, so ${import_core.MANIFEST_PATH} still pins the engine it pinned before`,
+      `Run \`${command}\` yourself, then run \`${UPGRADE_COMMAND}\` again \u2014 the pin and the dependency move together or not at all.`
+    );
+  }
+};
 var EngineEntryError = class extends import_core.PenvError {
   name = "EngineEntryError";
   constructor(name, version, dir) {
@@ -437,14 +522,15 @@ function httpFetcher() {
 }
 
 // src/launcher.ts
-var import_node_fs7 = require("fs");
+var import_node_fs8 = require("fs");
 var import_node_path7 = require("path");
-var import_core9 = require("@penvhq/core");
+var import_core11 = require("@penvhq/core");
 
 // src/add.ts
 var import_node_fs5 = require("fs");
 var import_node_module2 = require("module");
 var import_node_path5 = require("path");
+var import_node_url = require("url");
 var import_core6 = require("@penvhq/core");
 
 // src/config-edit.ts
@@ -714,35 +800,14 @@ function writeDeclaration(options) {
 // src/store.ts
 var import_node_fs4 = require("fs");
 var import_node_path4 = require("path");
+var import_core4 = require("@penvhq/core");
 
 // src/home.ts
 var import_node_fs3 = require("fs");
-var import_node_os2 = require("os");
 var import_node_path3 = require("path");
-var import_core4 = require("@penvhq/core");
-var PENV_HOME_VAR = "PENV_HOME";
 var HOME_META_FILE = "meta.json";
 var INTEGRITY_FILE = ".penv-integrity";
 var NPM_UPDATE_COMMAND = "npm install -g @penvhq/launcher";
-function penvHome(env) {
-  const declared = env[PENV_HOME_VAR];
-  if (declared !== void 0 && declared.trim() !== "") {
-    return (0, import_node_path3.resolve)(declared);
-  }
-  return (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".penv");
-}
-function packageDir(home, kind, name, version) {
-  const bucket = (0, import_node_path3.resolve)(home, kind);
-  const dir = (0, import_node_path3.resolve)(bucket, ...name.split("/"), version);
-  if (!dir.startsWith(bucket + import_node_path3.sep)) {
-    throw new import_core4.PenvError(
-      "PENV_HOME_ESCAPE",
-      `\`${name}\` at \`${version}\` resolves to ${dir}, which is outside ${bucket}`,
-      "Name the package exactly as npm does, e.g. `@penvhq/provider-vault`."
-    );
-  }
-  return dir;
-}
 function launcherUpdateCommand(home) {
   let meta;
   try {
@@ -844,7 +909,7 @@ function tarballUrl(pin) {
   return `${registry}/${pin.name}/-/${basename}-${pin.version}.tgz`;
 }
 function inspectInstall(home, kind, pin) {
-  const dir = packageDir(home, kind, pin.name, pin.version);
+  const dir = (0, import_core4.packageDir)(home, kind, pin.name, pin.version);
   if (!(0, import_node_fs4.existsSync)(dir)) {
     return { dir, state: "absent" };
   }
@@ -858,7 +923,7 @@ function inspectInstall(home, kind, pin) {
 }
 async function installPin(options) {
   const { home, kind, pin, fetcher } = options;
-  const dir = packageDir(home, kind, pin.name, pin.version);
+  const dir = (0, import_core4.packageDir)(home, kind, pin.name, pin.version);
   const url = tarballUrl(pin);
   let bytes;
   try {
@@ -923,7 +988,8 @@ async function fetchRelease(query) {
     throw new RegistryUnreadableError(
       query.name,
       url,
-      cause instanceof Error ? cause.message : String(cause)
+      cause instanceof Error ? cause.message : String(cause),
+      query.retry
     );
   }
   let parsed;
@@ -933,7 +999,8 @@ async function fetchRelease(query) {
     throw new RegistryUnreadableError(
       query.name,
       url,
-      cause instanceof Error ? cause.message : String(cause)
+      cause instanceof Error ? cause.message : String(cause),
+      query.retry
     );
   }
   const packument = record(parsed);
@@ -949,7 +1016,7 @@ async function fetchRelease(query) {
   const version = record(at(versions, asked)) === void 0 ? text3(at(tags, asked)) ?? asked : asked;
   const release = record(at(versions, version));
   if (release === void 0) {
-    throw new VersionUnknownError(query.name, asked, url);
+    throw new VersionUnknownError(query.name, asked, url, query.retry);
   }
   const dist = record(at(release, "dist"));
   const integrity = text3(at(dist, "integrity"));
@@ -1231,6 +1298,26 @@ function resolvePackageDir(name, root) {
     return void 0;
   }
 }
+function resolveProjectEntry(name, root) {
+  let file;
+  try {
+    file = (0, import_node_module2.createRequire)((0, import_node_path5.resolve)(root, "noop.js")).resolve(name);
+  } catch {
+    return void 0;
+  }
+  return { file, importable: (0, import_core6.isImportableEntry)(file) };
+}
+async function assertLoadable(name, entry, local) {
+  if (entry === void 0 || !entry.importable) {
+    throw new ExtensionNotImportableError(name, entry?.file, local);
+  }
+  try {
+    await import((0, import_node_url.pathToFileURL)(entry.file).href);
+  } catch (cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    throw new ExtensionUnloadableError(name, entry.file, detail, local);
+  }
+}
 function recordLocalExtension(root, name) {
   const file = (0, import_core6.localExtensionsFile)(root);
   let current;
@@ -1251,6 +1338,7 @@ async function addLocal(options, request) {
   if (dir === void 0) {
     throw new LocalExtensionUnresolvedError(request.name, root);
   }
+  await assertLoadable(request.name, resolveProjectEntry(request.name, root), true);
   const installed = readExtensionPackage(dir);
   const declaration = writeDeclaration({
     root,
@@ -1262,7 +1350,7 @@ async function addLocal(options, request) {
     types: installed.types
   });
   recordLocalExtension(root, request.name);
-  io2.out(`\u2713 ${request.name} resolves from this project \u2014 nothing is pinned`);
+  io2.out(`\u2713 ${request.name} resolves from this project and imports \u2014 nothing is pinned`);
   io2.out(`\u2713 ${import_core6.LOCAL_EXTENSIONS_PATH} records it`);
   io2.out(`\u2713 ${declaration} declares its config type`);
   await offerConfigEdit(options, request.name);
@@ -1307,6 +1395,7 @@ async function add(options) {
     },
     fetcher
   });
+  await assertLoadable(release.name, (0, import_core6.packageEntry)(dir), false);
   const installed = readExtensionPackage(dir);
   const declaration = writeDeclaration({
     root,
@@ -1325,14 +1414,59 @@ async function add(options) {
   return { onboard: await offerOnboarding(io2, release.name, installed.onboard) };
 }
 
-// src/pins.ts
+// src/help.ts
+var import_install = require("@penvhq/cli/install");
 var import_core7 = require("@penvhq/core");
+function printLauncherCommands(io2) {
+  io2.out("");
+  io2.out("LAUNCHER COMMANDS (penv itself, whatever engine a project pins)");
+  io2.out("");
+  io2.out(`  install                Installs everything ${import_core7.MANIFEST_PATH} pins`);
+  io2.out("  add <package>          Pins a provider extension, and commits the decision");
+  io2.out(`  add ${LOCAL_FLAG} <package>  Adds the one this repository builds \u2014 nothing is pinned`);
+  io2.out(`  upgrade [version]      Moves the engine pin and ${import_install.RUNTIME_PACKAGE} together`);
+  io2.out("");
+}
+function printInstallHelp(io2) {
+  io2.out(`${INSTALL_COMMAND}`);
+  io2.out("");
+  io2.out(`Downloads, verifies and installs every version ${import_core7.MANIFEST_PATH} pins \u2014 the engine and`);
+  io2.out("every extension \u2014 into $PENV_HOME. The one penv command CI and production run that");
+  io2.out("may reach the registry.");
+}
+function printAddHelp(io2) {
+  io2.out("penv add <package>[@<version>]");
+  io2.out("");
+  io2.out(`  ${LOCAL_FLAG}            Add the package this repository builds, resolved from it`);
+  io2.out("  --registry <url>   Take the release from a private registry instead of npmjs");
+  io2.out(
+    `  ${TRUST_YOUNG_FLAG}      Add a release published less than ${MIN_PACKAGE_AGE_DAYS} days ago`
+  );
+  io2.out("");
+  io2.out(`Pins the release in ${import_core7.MANIFEST_PATH} and writes its type declaration to`);
+  io2.out(`${import_core7.EXTENSIONS_PATH}/. Both are committed, so \`${INSTALL_COMMAND}\` gives every machine`);
+  io2.out(`the bytes you reviewed. \`${LOCAL_FLAG}\` pins nothing and touches no manifest.`);
+}
+function printUpgradeHelp(io2) {
+  io2.out("penv upgrade [version]");
+  io2.out("");
+  io2.out(`  ${YES_FLAG}              Skip the question \u2014 unattended runs need it and a version`);
+  io2.out("");
+  io2.out(`Moves the ${import_core7.ENGINE_PACKAGE} pin in ${import_core7.MANIFEST_PATH} and this project's`);
+  io2.out(`${import_install.RUNTIME_PACKAGE} dependency to the same exact version. No version takes whatever`);
+  io2.out("`latest` points at; the integrity is the one the registry states, never one penv");
+  io2.out("computed. Both files are shown before either moves, and they move together or not");
+  io2.out("at all. Extensions keep their own pins.");
+}
+
+// src/pins.ts
+var import_core8 = require("@penvhq/core");
 var DEV_PIN_INTEGRITY = "sha512-development-build-not-a-published-release";
 var DEV_PIN_VERSION = "0.0.0-dev";
 var BUNDLED_ENGINE_PIN = {
-  package: import_core7.ENGINE_PACKAGE,
-  version: "0.9.5",
-  integrity: "sha512-cacsvynscs6G0NThpGaK1BfKy3POQSoogI/vvQNZ5sTZaftzwg4mPtUpT+i2GSc3KbYAHQu4Kq9MpYLOvSvulA=="
+  package: import_core8.ENGINE_PACKAGE,
+  version: "0.11.0",
+  integrity: "sha512-Y+WKyuPsX4U8/1j0e+VMUhj0LaGrp67YEoDAWyyinrgA+c8IM4H1blqje/YK4LsQwzQDQQDF9bhWIhfmDAWoxA=="
 };
 function assertReleasePin(pin) {
   if (pin.integrity === DEV_PIN_INTEGRITY || pin.version === DEV_PIN_VERSION) {
@@ -1350,8 +1484,8 @@ function releaseEnginePin(pin, ranVersion) {
 // src/project.ts
 var import_node_fs6 = require("fs");
 var import_node_path6 = require("path");
-var import_core8 = require("@penvhq/core");
-var MANIFEST_SEGMENTS = import_core8.MANIFEST_PATH.split("/");
+var import_core9 = require("@penvhq/core");
+var MANIFEST_SEGMENTS = import_core9.MANIFEST_PATH.split("/");
 function findUp(cwd, matches) {
   let dir = (0, import_node_path6.resolve)(cwd);
   for (; ; ) {
@@ -1370,12 +1504,113 @@ function findProject(cwd) {
   return root === void 0 ? void 0 : { root, manifestFile: (0, import_node_path6.join)(root, ...MANIFEST_SEGMENTS) };
 }
 function findAdoptedRoot(cwd) {
-  return findUp(cwd, (dir) => (0, import_node_fs6.existsSync)((0, import_core8.stateDir)(dir)));
+  return findUp(cwd, (dir) => (0, import_node_fs6.existsSync)((0, import_core9.stateDir)(dir)));
+}
+
+// src/upgrade.ts
+var import_node_fs7 = require("fs");
+var import_install2 = require("@penvhq/cli/install");
+var import_core10 = require("@penvhq/core");
+function parseRequest2(argv) {
+  let version;
+  let yes = false;
+  for (const token of argv) {
+    if (token === YES_FLAG) {
+      yes = true;
+      continue;
+    }
+    if (token.startsWith("-")) {
+      throw new UpgradeFlagError(token);
+    }
+    if (version !== void 0 || token === "") {
+      throw new UpgradeSubjectError();
+    }
+    version = token;
+  }
+  return { version, yes };
+}
+function renderPinChange(engine, release) {
+  return [
+    import_core10.MANIFEST_PATH,
+    `  -   "integrity": "${engine.integrity}"`,
+    `  -   "version": "${engine.version}"`,
+    `  +   "integrity": "${release.integrity}"`,
+    `  +   "version": "${release.version}"`
+  ];
+}
+function pinnedElsewhere(manifest, version) {
+  return Object.entries(manifest.extensions).filter(([, entry]) => entry.version !== version).map(([name]) => name);
+}
+async function consent(options, release, plan, yes) {
+  const { io: io2, manifest } = options;
+  io2.out(`${import_core10.ENGINE_PACKAGE} ${manifest.engine.version} \u2192 ${release.version}`);
+  io2.out("");
+  for (const line of renderPinChange(manifest.engine, release)) {
+    io2.out(line);
+  }
+  for (const line of (0, import_install2.renderInstallPlan)(plan)) {
+    io2.out(line);
+  }
+  if (yes) {
+    return;
+  }
+  if (!await io2.confirm(`Move this project to ${release.version}?`)) {
+    throw new UpgradeDeclinedError(release.version);
+  }
+}
+async function upgrade(options) {
+  const { io: io2, fetcher, home, root, manifest, manifestFile } = options;
+  const request = parseRequest2(options.argv);
+  if (options.noDownload === true) {
+    throw new UpgradeNoDownloadError();
+  }
+  if ((options.ci === true || !io2.interactive) && !(request.yes && request.version !== void 0)) {
+    throw new UpgradeUnattendedError();
+  }
+  const release = await fetchRelease({
+    name: import_core10.ENGINE_PACKAGE,
+    ...request.version === void 0 ? {} : { version: request.version },
+    retry: UPGRADE_COMMAND,
+    fetcher
+  });
+  const plan = (0, import_install2.planInstall)(root, release.version);
+  if (manifest.engine.version === release.version && plan.satisfied) {
+    io2.out(`\u2713 Already on ${import_core10.ENGINE_PACKAGE} ${release.version} \u2014 nothing to move`);
+    return;
+  }
+  const manifestText = (0, import_core10.serializeManifest)({
+    ...manifest,
+    engine: { package: import_core10.ENGINE_PACKAGE, version: release.version, integrity: release.integrity }
+  });
+  await consent(options, release, plan, request.yes);
+  await installPin({
+    home,
+    kind: "engines",
+    pin: { name: import_core10.ENGINE_PACKAGE, version: release.version, integrity: release.integrity },
+    fetcher
+  });
+  io2.out(`\u2713 ${import_core10.ENGINE_PACKAGE} ${release.version} installed`);
+  if (!plan.satisfied) {
+    try {
+      await (options.install ?? import_install2.installWithPackageManager)(plan);
+    } catch {
+      throw new UpgradeInstallFailedError(plan.command.join(" "));
+    }
+    io2.out(`\u2713 package.json depends on ${import_install2.RUNTIME_PACKAGE} ${release.version}`);
+  }
+  (0, import_node_fs7.writeFileSync)(manifestFile, manifestText);
+  io2.out(`\u2713 ${import_core10.MANIFEST_PATH} pins ${import_core10.ENGINE_PACKAGE} ${release.version}`);
+  const kept = pinnedElsewhere(manifest, release.version);
+  if (kept.length > 0) {
+    const subject = kept.length === 1 ? "keeps its own pin" : "keep their own pins";
+    io2.out(`\u2192 ${kept.join(", ")} ${subject} \u2014 \`penv add <package>@<version>\` moves one.`);
+  }
 }
 
 // src/launcher.ts
 var INSTALL = "install";
 var ADD = "add";
+var UPGRADE = "upgrade";
 var VERSION_FLAGS = /* @__PURE__ */ new Set(["--version", "-v"]);
 var HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
 var NO_DOWNLOAD = "--no-download";
@@ -1419,27 +1654,27 @@ function pinsOf(manifest) {
   ];
 }
 function reportable(error, home, argv) {
-  return error instanceof import_core9.UnsupportedManifestFormatError ? error.withLauncherUpdate({
+  return error instanceof import_core11.UnsupportedManifestFormatError ? error.withLauncherUpdate({
     updateCommand: launcherUpdateCommand(home),
     invokedCommand: invokedCommand(argv)
   }) : error;
 }
 function readManifest(manifestFile, home, argv) {
   try {
-    return (0, import_core9.parseManifest)((0, import_node_fs7.readFileSync)(manifestFile, "utf8"));
+    return (0, import_core11.parseManifest)((0, import_node_fs8.readFileSync)(manifestFile, "utf8"));
   } catch (error) {
     throw reportable(error, home, argv);
   }
 }
 function readManifestToRepair(manifestFile, home, argv) {
   try {
-    return readManifestForRepair((0, import_node_fs7.readFileSync)(manifestFile, "utf8"));
+    return readManifestForRepair((0, import_node_fs8.readFileSync)(manifestFile, "utf8"));
   } catch (error) {
     throw reportable(error, home, argv);
   }
 }
 function report(error, io2) {
-  if (error instanceof import_core9.PenvError && error.remedy !== void 0) {
+  if (error instanceof import_core11.PenvError && error.remedy !== void 0) {
     const suffix = `
   ${error.remedy}`;
     const message = error.message.endsWith(suffix) ? error.message.slice(0, -suffix.length) : error.message;
@@ -1461,7 +1696,21 @@ async function launch(options) {
   const { argv, cwd, env, io: io2 } = options;
   const { noDownload, forwarded } = splitLauncherFlags(argv);
   const first = forwarded[0];
-  const home = penvHome(env);
+  const home = (0, import_core11.penvHome)(env);
+  if (first !== void 0 && forwarded.slice(1).some((token) => HELP_FLAGS.has(token))) {
+    if (first === INSTALL) {
+      printInstallHelp(io2);
+      return 0;
+    }
+    if (first === ADD) {
+      printAddHelp(io2);
+      return 0;
+    }
+    if (first === UPGRADE) {
+      printUpgradeHelp(io2);
+      return 0;
+    }
+  }
   const project = findProject(cwd);
   if (project === void 0) {
     if (first !== void 0 && VERSION_FLAGS.has(first)) {
@@ -1488,6 +1737,20 @@ async function launch(options) {
     io2.out(`penv ${manifest.engine.version}`);
     return 0;
   }
+  if (first === UPGRADE) {
+    await upgrade({
+      argv: forwarded.slice(1),
+      root: project.root,
+      manifestFile: project.manifestFile,
+      manifest,
+      home,
+      io: io2,
+      fetcher: options.fetcher,
+      noDownload,
+      ci: isCi(env)
+    });
+    return 0;
+  }
   const enginePin = enginePinOf(manifest);
   const engineDir = await ensure(options, "engines", enginePin, home, noDownload);
   for (const pin of extensionPinsOf(manifest)) {
@@ -1506,16 +1769,16 @@ async function adopt(options, forwarded, home, cwd, noDownload) {
   if (root === void 0) {
     return 0;
   }
-  const manifestFile = (0, import_node_path7.join)(root, ...import_core9.MANIFEST_PATH.split("/"));
-  if ((0, import_node_fs7.existsSync)(manifestFile)) {
+  const manifestFile = (0, import_node_path7.join)(root, ...import_core11.MANIFEST_PATH.split("/"));
+  if ((0, import_node_fs8.existsSync)(manifestFile)) {
     return 0;
   }
   const pin = releaseEnginePin(options.bundledPin, engine.version);
-  (0, import_node_fs7.writeFileSync)(
+  (0, import_node_fs8.writeFileSync)(
     manifestFile,
-    (0, import_core9.serializeManifest)({ format: import_core9.MANIFEST_FORMAT, engine: pin, extensions: {} })
+    (0, import_core11.serializeManifest)({ format: import_core11.MANIFEST_FORMAT, engine: pin, extensions: {} })
   );
-  options.io.out(`\u2713 ${import_core9.MANIFEST_PATH} pins ${pin.package} ${pin.version}`);
+  options.io.out(`\u2713 ${import_core11.MANIFEST_PATH} pins ${pin.package} ${pin.version}`);
   await ensureAdoptedEngine(
     options,
     { name: pin.package, version: pin.version, integrity: pin.integrity },
@@ -1594,13 +1857,21 @@ async function addExtension(options, project, home, argv, noDownload) {
   const engine = engineAt(dir, enginePin.name, enginePin.version);
   return delegate(options, engine, onboard, home, options.cwd);
 }
-function delegate(options, engine, forwarded, home, cwd) {
-  return options.spawn({
+function isRootHelp(forwarded) {
+  const first = forwarded[0];
+  return first === void 0 || HELP_FLAGS.has(first);
+}
+async function delegate(options, engine, forwarded, home, cwd) {
+  const code = await options.spawn({
     command: process.execPath,
     args: [engine.entry, ...forwarded],
     cwd,
-    env: { ...options.env, [PENV_HOME_VAR]: home }
+    env: { ...options.env, [import_core11.PENV_HOME_VAR]: home }
   });
+  if (code === 0 && isRootHelp(forwarded)) {
+    printLauncherCommands(options.io);
+  }
+  return code;
 }
 
 // src/bin.ts