betterstart-cli 0.0.64 → 0.0.67

package/dist/cli.js

@@ -279,7 +279,7 @@ function runCommand(pm, script) {
 function createNextAppCommand(pm) {
   switch (pm) {
     case "pnpm":
-      return { bin: "pnpm", prefix: ["create", "next-app@latest"] };
+      return { bin: "pnpm", prefix: ["dlx", "create-next-app@latest"] };
     case "yarn":
       return { bin: "yarn", prefix: ["create", "next-app@latest"] };
     case "bun":
@@ -1078,8 +1078,11 @@ var REACT_ADMIN_DEPS = [
 var REACT_ADMIN_DEV_DEPS = ["@tailwindcss/typography"];
 
 // adapters/next/init/scaffolders/dependencies.ts
+import { parseDocument } from "yaml";
 var CLI_PACKAGE_NAME = "betterstart-cli";
 var LOCAL_PACKAGE_PREFIXES = ["workspace:", "link:", "file:", "portal:"];
+var MIN_SUPPORTED_PNPM_MAJOR = 9;
+var PINNED_PNPM_PACKAGE_MANAGER = "pnpm@11.9.0";
 var TIPTAP_PACKAGE_PREFIX = "@tiptap/";
 var TIPTAP_PACKAGE_VERSION_SPEC = "^3.26.0";
 var CODEMIRROR_PACKAGE_SPECS = {
@@ -1121,6 +1124,46 @@ function readProjectPackageJson(cwd) {
     return null;
   }
 }
+function findPnpmWorkspacePath(cwd) {
+  let currentDir = path8.resolve(cwd);
+  const filesystemRoot = path8.parse(currentDir).root;
+  while (true) {
+    const workspacePath = path8.join(currentDir, "pnpm-workspace.yaml");
+    if (fs7.existsSync(workspacePath)) {
+      return workspacePath;
+    }
+    if (currentDir === filesystemRoot) {
+      return path8.join(path8.resolve(cwd), "pnpm-workspace.yaml");
+    }
+    currentDir = path8.dirname(currentDir);
+  }
+}
+function isSupportedPnpmPackageManager(packageManager) {
+  const pnpmVersionMatch = /^pnpm@(\d+)\.\d+\.\d+(?:[-+].+)?$/.exec(packageManager);
+  return Boolean(pnpmVersionMatch && Number(pnpmVersionMatch[1]) >= MIN_SUPPORTED_PNPM_MAJOR);
+}
+function hasSupportedAncestorPnpmPackageManager(cwd) {
+  let currentDir = path8.dirname(path8.resolve(cwd));
+  const filesystemRoot = path8.parse(currentDir).root;
+  while (true) {
+    const packageJsonPath = path8.join(currentDir, "package.json");
+    if (fs7.existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(
+          fs7.readFileSync(packageJsonPath, "utf-8")
+        );
+        if (packageJson.packageManager) {
+          return isSupportedPnpmPackageManager(packageJson.packageManager);
+        }
+      } catch {
+      }
+    }
+    if (currentDir === filesystemRoot) {
+      return false;
+    }
+    currentDir = path8.dirname(currentDir);
+  }
+}
 function dependencySpecMatches(spec, name) {
   return spec === name || spec.startsWith(`${name}@`);
 }
@@ -1146,6 +1189,7 @@ function getPnpmPackageExtensionsToEnsure(pkg, dependencies) {
 }
 function ensurePnpmPackageExtensions(cwd, dependencies) {
   const pkgPath = path8.join(cwd, "package.json");
+  const workspacePath = findPnpmWorkspacePath(cwd);
   const pkg = readProjectPackageJson(cwd);
   if (!pkg) {
     return;
@@ -1154,31 +1198,66 @@ function ensurePnpmPackageExtensions(cwd, dependencies) {
   if (Object.keys(extensionsToEnsure).length === 0) {
     return;
   }
-  let changed = false;
-  const pnpmConfig = pkg.pnpm ?? {};
-  const packageExtensions = pnpmConfig.packageExtensions ?? {};
+  const workspaceContent = fs7.existsSync(workspacePath) ? fs7.readFileSync(workspacePath, "utf-8") : "{}\n";
+  const workspaceDocument = parseDocument(workspaceContent);
+  if (workspaceDocument.errors.length > 0) {
+    throw new Error(
+      `Could not update pnpm-workspace.yaml: ${workspaceDocument.errors[0]?.message ?? "invalid YAML"}`
+    );
+  }
+  let workspaceChanged = false;
+  let packageJsonChanged = false;
   for (const [selector, extension] of Object.entries(extensionsToEnsure)) {
-    const currentExtension = packageExtensions[selector] ?? {};
-    const currentDependencies = currentExtension.dependencies ?? {};
-    const nextDependencies = { ...currentDependencies };
+    const legacyExtension = pkg.pnpm?.packageExtensions?.[selector];
+    for (const section of ["dependencies", "peerDependencies"]) {
+      for (const [name, version2] of Object.entries(legacyExtension?.[section] ?? {})) {
+        const valuePath = ["packageExtensions", selector, section, name];
+        if (workspaceDocument.getIn(valuePath) === void 0) {
+          workspaceDocument.setIn(valuePath, version2);
+          workspaceChanged = true;
+        }
+      }
+    }
     for (const [name, version2] of Object.entries(extension.dependencies ?? {})) {
-      if (nextDependencies[name] !== version2) {
-        nextDependencies[name] = version2;
-        changed = true;
+      const valuePath = ["packageExtensions", selector, "dependencies", name];
+      if (workspaceDocument.getIn(valuePath) !== version2) {
+        workspaceDocument.setIn(valuePath, version2);
+        workspaceChanged = true;
       }
     }
-    packageExtensions[selector] = {
-      ...currentExtension,
-      dependencies: nextDependencies
-    };
+    const legacyPackageExtensions = pkg.pnpm?.packageExtensions;
+    if (legacyPackageExtensions && Object.hasOwn(legacyPackageExtensions, selector)) {
+      delete legacyPackageExtensions[selector];
+      packageJsonChanged = true;
+      if (Object.keys(legacyPackageExtensions).length === 0 && pkg.pnpm) {
+        const { packageExtensions: _packageExtensions, ...remainingPnpmConfig } = pkg.pnpm;
+        pkg.pnpm = Object.keys(remainingPnpmConfig).length > 0 ? remainingPnpmConfig : void 0;
+      }
+    }
+  }
+  if (workspaceChanged) {
+    fs7.writeFileSync(workspacePath, workspaceDocument.toString({ lineWidth: 0 }), "utf-8");
   }
-  if (!changed && pkg.pnpm?.packageExtensions) {
+  if (packageJsonChanged) {
+    fs7.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf-8");
+  }
+}
+function ensurePnpmPackageManager(cwd) {
+  const pkgPath = path8.join(cwd, "package.json");
+  const pkg = readProjectPackageJson(cwd);
+  if (!pkg) {
     return;
   }
-  pkg.pnpm = {
-    ...pnpmConfig,
-    packageExtensions
-  };
+  const currentPackageManager = pkg.packageManager;
+  if (currentPackageManager) {
+    if (isSupportedPnpmPackageManager(currentPackageManager)) {
+      return;
+    }
+  } else if (hasSupportedAncestorPnpmPackageManager(cwd)) {
+    return;
+  }
+  pkg.packageManager = PINNED_PNPM_PACKAGE_MANAGER;
   fs7.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf-8");
 }
@@ -1346,13 +1425,20 @@ function buildRemoveArgs(pm, deps, dev) {
 function spawnAsync(cmd, args, cwd) {
   return new Promise((resolve, reject) => {
     const child = spawn(cmd, args, { cwd, stdio: "pipe" });
+    let stdout = "";
     let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
     child.stderr?.on("data", (chunk) => {
       stderr += chunk.toString();
     });
     child.on("close", (code) => {
       if (code === 0) resolve();
-      else reject(new Error(stderr || `${cmd} exited with code ${code}`));
+      else {
+        const output = [stdout.trim(), stderr.trim()].filter(Boolean).join("\n");
+        reject(new Error(output || `${cmd} exited with code ${code}`));
+      }
     });
     child.on("error", reject);
   });
@@ -1392,6 +1478,7 @@ async function installDependenciesAsync({
   const installPlan = resolveDependencyInstallPlan({ cwd, pm, dependencies, devDependencies });
   try {
     if (pm === "pnpm") {
+      ensurePnpmPackageManager(cwd);
       ensurePnpmPackageExtensions(cwd, installPlan.dependencies);
     }
     if (installPlan.dependencies.length > 0) {
@@ -27367,10 +27454,8 @@ async function runInitCommand(name, options) {
       ])
     )
   });
-  let depsInstalled = false;
   if (depsResult.success) {
     s.stop("");
-    depsInstalled = true;
   } else {
     s.stop("Failed to install dependencies");
     p22.log.warning(depsResult.error ?? "Unknown error");
@@ -27379,10 +27464,10 @@ async function runInitCommand(name, options) {
   ${pc9.cyan(`${pm} add ${depsResult.dependencies.join(" ")}`)}
   ${pc9.cyan(`${pm} add -D ${depsResult.devDeps.join(" ")}`)}`
     );
+    disposeCancelGuard();
+    process.exit(1);
   }
-  if (depsInstalled) {
-    process.stdout.write("\x1B[2A\x1B[J");
-  }
+  process.stdout.write("\x1B[2A\x1B[J");
   s.start("Generating core schemas");
   const coreSchemasResult = scaffoldCoreSchemas({ cwd, config });
   s.stop("");