@penvhq/cli 0.11.0 → 0.12.0

package/dist/index.cjs

@@ -216,11 +216,25 @@ var LOCKFILES = [
   ["npm", "package-lock.json"]
 ];
 var ADD = {
-  pnpm: ["pnpm", "add", "--save-exact"],
-  npm: ["npm", "install", "--save-exact"],
-  yarn: ["yarn", "add", "--exact"],
-  bun: ["bun", "add", "--exact"]
+  pnpm: ["pnpm", "add"],
+  npm: ["npm", "install"],
+  yarn: ["yarn", "add"],
+  bun: ["bun", "add"]
 };
+var EXACT = {
+  pnpm: "--save-exact",
+  npm: "--save-exact",
+  yarn: "--exact",
+  bun: "--exact"
+};
+var DEV = {
+  pnpm: "-D",
+  npm: "--save-dev",
+  yarn: "--dev",
+  bun: "--dev"
+};
+var WORKSPACE_ROOT_FLAG = "-w";
+var PNPM_WORKSPACE = "pnpm-workspace.yaml";
 function engineVersion() {
   const version = ownManifest()?.version;
   if (typeof version === "string" && version.length > 0) {
@@ -283,69 +297,219 @@ function manifestOf(root) {
     return void 0;
   }
 }
-function declaredVersion(root, name) {
-  const manifest = manifestOf(root);
+function declaredIn(dir, name) {
+  const manifest = manifestOf(dir);
   for (const field of ["dependencies", "devDependencies"]) {
     const block = manifest?.[field];
     if (block !== null && typeof block === "object" && !Array.isArray(block)) {
       const version = block[name];
       if (typeof version === "string") {
-        return version;
+        return { version, dev: field === "devDependencies" };
       }
     }
   }
   return void 0;
 }
+function isPnpmWorkspaceRoot(root) {
+  return (0, import_node_fs2.existsSync)((0, import_node_path2.join)(root, PNPM_WORKSPACE)) && (0, import_node_fs2.existsSync)((0, import_node_path2.join)(root, "package.json"));
+}
+function workspaceGlobs(root) {
+  let text;
+  try {
+    text = (0, import_node_fs2.readFileSync)((0, import_node_path2.join)(root, PNPM_WORKSPACE), "utf8");
+  } catch {
+    return [];
+  }
+  const unquote = (raw) => raw.replace(/^['"]|['"]$/g, "").trim();
+  const globs = [];
+  let inside = false;
+  for (const line of text.split(/\r?\n/)) {
+    const flow = /^packages:\s*\[(.*)\]\s*$/.exec(line);
+    if (flow?.[1] !== void 0) {
+      return flow[1].split(",").map(unquote).filter((glob) => glob !== "");
+    }
+    if (/^packages:\s*$/.test(line)) {
+      inside = true;
+      continue;
+    }
+    if (!inside) {
+      continue;
+    }
+    const item = /^\s+-\s*(.+?)\s*$/.exec(line);
+    if (item?.[1] !== void 0) {
+      globs.push(unquote(item[1]));
+      continue;
+    }
+    if (line.trim() !== "" && !line.trimStart().startsWith("#")) {
+      break;
+    }
+  }
+  return globs;
+}
+function directoriesIn(dir) {
+  try {
+    return (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name !== "node_modules").map((entry) => (0, import_node_path2.join)(dir, entry.name));
+  } catch {
+    return [];
+  }
+}
+function isDirectory(path) {
+  try {
+    return (0, import_node_fs2.statSync)(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function expandGlob(root, glob) {
+  let dirs = [root];
+  for (const segment of glob.split("/").filter((part) => part !== "" && part !== ".")) {
+    const next = [];
+    for (const dir of dirs) {
+      if (segment === "**") {
+        const stack = [dir];
+        while (stack.length > 0) {
+          const current = stack.pop();
+          next.push(current);
+          stack.push(...directoriesIn(current));
+        }
+        continue;
+      }
+      if (segment.includes("*")) {
+        const pattern = new RegExp(
+          `^${segment.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*")}$`
+        );
+        next.push(
+          ...directoriesIn(dir).filter((child) => pattern.test(child.slice(dir.length + 1)))
+        );
+        continue;
+      }
+      const candidate = (0, import_node_path2.join)(dir, segment);
+      if (isDirectory(candidate)) {
+        next.push(candidate);
+      }
+    }
+    dirs = next;
+  }
+  return dirs;
+}
+function workspaceMembers(root, name) {
+  if (!isPnpmWorkspaceRoot(root)) {
+    return [];
+  }
+  const globs = workspaceGlobs(root);
+  const excluded = globs.filter((glob) => glob.startsWith("!")).flatMap((glob) => expandGlob(root, glob.slice(1)));
+  const found = /* @__PURE__ */ new Set();
+  for (const glob of globs.filter((entry) => !entry.startsWith("!"))) {
+    for (const dir of expandGlob(root, glob)) {
+      if (dir !== root && !excluded.includes(dir) && declaredIn(dir, name) !== void 0) {
+        found.add(dir);
+      }
+    }
+  }
+  return [...found].sort();
+}
+function manifestPathOf(root, dir) {
+  const within = (0, import_node_path2.relative)(root, dir).split(import_node_path2.sep).filter((part) => part !== "");
+  return [...within, "package.json"].join("/");
+}
+function addCommand(manager, options, specs) {
+  const [bin, verb] = ADD[manager];
+  return [
+    bin,
+    ...options.filter === void 0 ? [] : ["--filter", options.filter],
+    verb,
+    ...options.workspaceRoot ? [WORKSPACE_ROOT_FLAG] : [],
+    EXACT[manager],
+    ...options.dev ? [DEV[manager]] : [],
+    ...specs
+  ];
+}
+function stepFor(manager, manifest, packages, options) {
+  const pending = packages.filter((entry) => !entry.satisfied);
+  const specs = (pending.length === 0 ? packages : pending).map(
+    (entry) => `${entry.name}@${entry.version}`
+  );
+  return {
+    manifest,
+    packages,
+    command: addCommand(manager, options, specs),
+    satisfied: pending.length === 0
+  };
+}
 function planInstall(root, version = engineVersion()) {
   const manager = detectPackageManager(root);
   const lockfile = LOCKFILES.find(
     ([name, file]) => name === manager && (0, import_node_fs2.existsSync)((0, import_node_path2.join)(root, file))
   )?.[1];
-  const runtimeDeclared = declaredVersion(root, RUNTIME_PACKAGE);
-  const zodDeclared = declaredVersion(root, SCHEMA_PACKAGE);
+  const workspaceRoot = manager === "pnpm" && isPnpmWorkspaceRoot(root);
+  const runtime = declaredIn(root, RUNTIME_PACKAGE);
+  const zod = declaredIn(root, SCHEMA_PACKAGE);
   const packages = [
     {
       name: RUNTIME_PACKAGE,
       version,
-      ...runtimeDeclared === void 0 ? {} : { declared: runtimeDeclared },
-      satisfied: runtimeDeclared === version
+      ...runtime === void 0 ? {} : { declared: runtime.version },
+      satisfied: runtime?.version === version
     },
     {
       name: SCHEMA_PACKAGE,
       version: schemaPackageVersion(),
-      ...zodDeclared === void 0 ? {} : { declared: zodDeclared },
+      ...zod === void 0 ? {} : { declared: zod.version },
       // Any declared zod counts: which zod a project uses is the project's
       // decision, and penv is here to make sure there is one, not to move it.
-      satisfied: zodDeclared !== void 0
+      satisfied: zod !== void 0
     }
   ];
   const pending = packages.filter((entry) => !entry.satisfied);
-  const specs = (pending.length === 0 ? packages : pending).map(
-    (entry) => `${entry.name}@${entry.version}`
-  );
+  const steps = [
+    stepFor(manager, "package.json", packages, {
+      workspaceRoot,
+      dev: runtime?.dev === true && pending.every((entry) => entry.name === RUNTIME_PACKAGE) && pending.length > 0
+    })
+  ];
+  for (const dir of workspaceMembers(root, RUNTIME_PACKAGE)) {
+    const declared = declaredIn(dir, RUNTIME_PACKAGE);
+    steps.push(
+      stepFor(
+        manager,
+        manifestPathOf(root, dir),
+        [
+          {
+            name: RUNTIME_PACKAGE,
+            version,
+            declared: declared.version,
+            satisfied: declared.version === version
+          }
+        ],
+        {
+          filter: `./${(0, import_node_path2.relative)(root, dir).split(import_node_path2.sep).join("/")}`,
+          workspaceRoot: false,
+          dev: declared.dev
+        }
+      )
+    );
+  }
   return {
     root,
     manager,
-    packages,
-    command: [...ADD[manager], ...specs],
+    steps,
     ...lockfile === void 0 ? {} : { lockfile },
-    satisfied: pending.length === 0
+    satisfied: steps.every((step) => step.satisfied)
   };
 }
 function describe(entry) {
   return `${entry.name} ${entry.version}`;
 }
-function renderInstallPlan(plan2) {
-  if (plan2.satisfied) {
-    return [
-      `package.json already has ${plan2.packages.map(describe).join(" and ")} \u2014 nothing to install.`
-    ];
-  }
-  const pending = plan2.packages.filter((entry) => !entry.satisfied);
+function installedPackages(plan2) {
+  const pending = plan2.steps.flatMap((step) => step.packages).filter((entry) => !entry.satisfied);
+  return [...new Map(pending.map((entry) => [entry.name, entry])).values()];
+}
+function renderStep(step) {
+  const pending = step.packages.filter((entry) => !entry.satisfied);
   const added = pending.filter((entry) => entry.declared === void 0);
   const replaced = pending.filter((entry) => entry.declared !== void 0);
   return [
-    "package.json",
+    step.manifest,
     ...added.length === 0 ? [] : [
       '  + "dependencies": {',
       ...added.map((entry) => `  +   "${entry.name}": "${entry.version}"`),
@@ -354,29 +518,49 @@ function renderInstallPlan(plan2) {
     ...replaced.flatMap((entry) => [
       `  - "${entry.name}": "${entry.declared}"`,
       `  + "${entry.name}": "${entry.version}"`
-    ]),
-    ...plan2.lockfile === void 0 ? [] : [plan2.lockfile, ...pending.map((entry) => `  + ${entry.name}@${entry.version}`)],
+    ])
+  ];
+}
+function renderInstallPlan(plan2) {
+  if (plan2.satisfied) {
+    const packages = plan2.steps[0]?.packages ?? [];
+    return [
+      `package.json already has ${packages.map(describe).join(" and ")} \u2014 nothing to install.`
+    ];
+  }
+  const pending = plan2.steps.filter((step) => !step.satisfied);
+  const [first, ...rest] = pending.map((step) => step.command.join(" "));
+  const landing = installedPackages(plan2).map((entry) => `  + ${entry.name}@${entry.version}`);
+  return [
+    ...pending.flatMap(renderStep),
+    ...plan2.lockfile === void 0 ? [] : [plan2.lockfile, ...landing],
     "",
-    `Run with: ${plan2.command.join(" ")}`
+    `Run with: ${first ?? ""}`,
+    ...rest.map((command) => `     then ${command}`)
   ];
 }
 var installWithPackageManager = async (plan2) => {
-  const child = startChild({
-    command: plan2.command,
-    env: process.env,
-    cwd: plan2.root,
-    purpose: `install ${plan2.packages.map(describe).join(" and ")}`
-  });
-  const ended = await child.ended;
-  if (ended.exitCode !== 0 || ended.signal !== null) {
-    throw installFailed(plan2);
+  for (const step of plan2.steps) {
+    if (step.satisfied) {
+      continue;
+    }
+    const child = startChild({
+      command: step.command,
+      env: process.env,
+      cwd: plan2.root,
+      purpose: `install ${step.packages.map(describe).join(" and ")} in ${step.manifest}`
+    });
+    const ended = await child.ended;
+    if (ended.exitCode !== 0 || ended.signal !== null) {
+      throw installFailed(plan2, step);
+    }
   }
 };
-function installFailed(plan2) {
+function installFailed(plan2, step) {
   return new import_core2.PenvError(
     "INIT_INSTALL_FAILED",
-    `${plan2.command.join(" ")} did not finish, so penv migrated nothing`,
-    `Run \`${plan2.command.join(" ")}\` yourself, then start this command again. Your dotenv files are exactly where they were.`
+    `${step.command.join(" ")} did not finish, so penv migrated nothing`,
+    `Read what ${plan2.manager} printed above \u2014 it names what it refused. Fix that and run this command again; your dotenv files are exactly where they were.`
   );
 }
 
@@ -906,7 +1090,7 @@ function writeError(lines) {
   }
 }
 function reportError(error) {
-  if (error instanceof import_core6.PenvError) {
+  if ((0, import_core6.isPenvErrorLike)(error)) {
     process.stderr.write(`${err.red(CROSS)} ${error.summary}
 `);
     if (error.remedy !== void 0) {
@@ -4441,8 +4625,8 @@ function exportsSchema(file) {
     /export\s*\{[^}]*\bschema\b[^}]*\}/.test(source)
   );
 }
-function occupied(cwd, relative5) {
-  const file = (0, import_node_path11.join)(cwd, ...relative5.split("/"));
+function occupied(cwd, relative6) {
+  const file = (0, import_node_path11.join)(cwd, ...relative6.split("/"));
   return (0, import_node_fs11.existsSync)(file) && !exportsSchema(file);
 }
 function schemaFileFor(cwd) {
@@ -4864,7 +5048,7 @@ function environmentsFromFlag(flag) {
 function configOf(decisions) {
   return { environments: decisions.environments, providers: {}, schemaFile: decisions.schemaFile };
 }
-function declaredIn(root) {
+function declaredIn2(root) {
   const file = (0, import_node_path13.join)(root, CONFIG_FILE);
   if (!(0, import_node_fs13.existsSync)(file)) {
     return void 0;
@@ -4872,7 +5056,7 @@ function declaredIn(root) {
   return (0, import_core25.loadConfigFrom)(file);
 }
 function planInit(root, flags = {}) {
-  const declared = declaredIn(root);
+  const declared = declaredIn2(root);
   const detected = detectFramework(root);
   const notes = [];
   if (declared !== void 0) {
@@ -5539,7 +5723,7 @@ function scaffold(root, fields, draft, decisions = DEFAULT_DECISIONS, framework
   return seam === void 0 ? steps : [...steps, seam];
 }
 function scaffoldPaths(root, decisions = DEFAULT_DECISIONS, framework = detectFramework(root)?.name) {
-  const fileAt = (relative5) => (0, import_node_path13.join)(root, ...relative5.split("/"));
+  const fileAt = (relative6) => (0, import_node_path13.join)(root, ...relative6.split("/"));
   const seam = decisions.inject ? seamFor(framework, {
     alias: decisions.alias,
     srcDir: srcPrefix(root),
@@ -5586,7 +5770,7 @@ function planCutover(input) {
       "Run `penv init` again and choose the files penv should adopt."
     );
   }
-  const declared = declaredIn(root);
+  const declared = declaredIn2(root);
   const named = environmentsDeclaredBy(selected);
   const chosen = named.length > 0 ? named : [requireEnvironment(input)];
   const environments = declared === void 0 ? chosen : declared.environments;
@@ -5837,7 +6021,11 @@ function renderCutover(result2) {
       const glyph = step.action === "conflicted" ? WARN : step.action === "info" ? "\u2192" : CHECK;
       return step.note === void 0 ? { glyph, text: step.text } : { glyph, text: step.text, note: step.note };
     }),
-    ...plan2.install.packages.filter((entry) => !entry.satisfied).map((entry) => ({ glyph: CHECK, text: `Installed ${entry.name}`, note: entry.version })),
+    ...installedPackages(plan2.install).map((entry) => ({
+      glyph: CHECK,
+      text: `Installed ${entry.name}`,
+      note: entry.version
+    })),
     {
       glyph: CHECK,
       text: `Imported ${plan2.fields.length} parameters`,
@@ -5997,7 +6185,7 @@ async function cutoverInteractively(root, base, adoption) {
   write(renderCutover(await applyCutover({ ...plan2, decisions: { ...plan2.decisions, inject } })));
 }
 function offeredEnvironment(root) {
-  const declared = declaredIn(root);
+  const declared = declaredIn2(root);
   if (declared === void 0) {
     return DEVELOPMENT;
   }