@sparkelf/dsh-plus 0.1.0-rc.37 → 0.1.0-rc.39

package/lib/bin.js

@@ -401,16 +401,63 @@ function alignReplacedPackageNames(profileModules) {
 		renameSync(temporary, manifestPath);
 	}
 }
-/** Run pnpm in one directory, inheriting its output. */
+/**
+* Run pnpm in one directory, inheriting its output.
+*
+* Windows resolves a command through its shell: \`spawnSync\` on a \`.cmd\` shim fails
+* with EINVAL, so the call goes through \`cmd.exe\` there. This matches the runner in
+* \`apply.ts\`, which the apply path has used on Windows since it shipped.
+*
+* @param cwd - the directory pnpm runs in.
+* @param args - pnpm arguments, without the executable.
+* @param label - the failing step's name, for the error.
+*/
 function runPnpm(cwd, args, label) {
-	const result = spawnSync(process.platform === "win32" ? "pnpm.cmd" : "pnpm", [...args], {
+	const result = spawnSync("pnpm", [...args], {
 		cwd,
-		stdio: "inherit"
+		stdio: "inherit",
+		shell: process.platform === "win32"
 	});
 	if (result.error !== void 0) throw result.error;
 	if (result.status !== 0) throw new Error(label + " failed with exit code " + String(result.status));
 }
 /**
+* Report whether pnpm can run.
+*
+* The profile installs its own tree so its \`overrides\` apply, and only pnpm reads those
+* from a workspace, so pnpm is a prerequisite the distribution cannot supply. Probing
+* first turns a cryptic failure from the install into a message naming what is missing.
+*
+* @returns \`true\` when pnpm answers with a version.
+*/
+function pnpmAvailable() {
+	return spawnSync("pnpm", ["--version"], {
+		stdio: "pipe",
+		shell: process.platform === "win32",
+		encoding: "utf8"
+	}).status === 0;
+}
+/**
+* The commands that install pnpm, in the order worth trying.
+*
+* Corepack ships with Node and needs no download, so it comes first; npm is the fallback
+* for an installation whose Corepack is absent or disabled. Both are the consumer's own
+* toolchain, which is what lets the first start offer to install rather than only report.
+*
+* @returns commands to try in order, stopping at the first that works.
+*/
+function pnpmInstallCommands() {
+	return ["corepack enable pnpm", "npm install -g pnpm"];
+}
+/**
+* The command to show a consumer who declines the automatic install.
+*
+* @returns the preferred command, which is the one the offer runs first.
+*/
+function pnpmInstallCommand() {
+	return pnpmInstallCommands()[0] ?? "npm install -g pnpm";
+}
+/**
 * Expose the distribution's nested packages at the top level the profile searches.
 *
 * The profile resolves a bundle from one directory, so a package npm nested under the
@@ -687,6 +734,30 @@ async function start(argv) {
 	const options = parseStartOptions(argv);
 	const anchor = installationAnchor();
 	const paths = resolvePaths(anchor);
+	if (!pnpmAvailable()) {
+		const command = pnpmInstallCommand();
+		console.log("pnpm is required to install the plus profile, and was not found.");
+		console.log("Install it with: " + command);
+		if (!await confirm("Install pnpm now?")) {
+			console.log("Install pnpm and run dsh-plus start again.");
+			return 1;
+		}
+		let installed = false;
+		for (const candidate of pnpmInstallCommands()) if (spawnSync(candidate, {
+			stdio: "inherit",
+			shell: true
+		}).status === 0 && pnpmAvailable()) {
+			installed = true;
+			break;
+		}
+		if (!installed) {
+			console.log("Could not install pnpm automatically.");
+			console.log("Run one of these, then run dsh-plus start again:");
+			for (const candidate of pnpmInstallCommands()) console.log("  " + candidate);
+			return 1;
+		}
+		console.log("pnpm installed.");
+	}
 	const created = ensureProfile(paths, installationRoot());
 	console.log(created ? "Created the plus profile at " + paths.profileDirectory : "Using the existing plus profile");
 	for (const label of applyProfileNpmPatches(paths.distributionDirectory, paths.profileDirectory)) console.log("Applied the reviewed patch " + label);

package/lib/types/standalone-cli.js

@@ -14,7 +14,7 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { newerVersion } from "./registry-versions.js";
 import { DEFAULT_PORT, STOP_GRACE_MILLISECONDS, choosePort, clearState, isRunning, portAvailable, readState, spawnServer, stateDirectory, waitForAuthenticatedUrl, waitForServer, writeState, } from "./standalone-server.js";
-import { STANDALONE_PROFILE, applyProfileNpmPatches, ensureProfile, readDistributionProfile, resolvePaths, } from "./standalone-profile.js";
+import { STANDALONE_PROFILE, applyProfileNpmPatches, ensureProfile, pnpmAvailable, pnpmInstallCommand, pnpmInstallCommands, readDistributionProfile, resolvePaths, } from "./standalone-profile.js";
 /** Milliseconds a start waits for the server to answer before reporting failure. */
 const READY_TIMEOUT_MILLISECONDS = 90_000;
 function parseStartOptions(argv) {
@@ -100,6 +100,36 @@ async function start(argv) {
     const options = parseStartOptions(argv);
     const anchor = installationAnchor();
     const paths = resolvePaths(anchor);
+    // The profile installs its own dependency tree, which needs pnpm. Asking here rather
+    // than failing inside the install turns a missing prerequisite into a decision the
+    // consumer makes, and the install it can run is the one command that provides it.
+    if (!pnpmAvailable()) {
+        const command = pnpmInstallCommand();
+        console.log('pnpm is required to install the ' + STANDALONE_PROFILE + ' profile, and was not found.');
+        console.log('Install it with: ' + command);
+        if (!await confirm('Install pnpm now?')) {
+            console.log('Install pnpm and run dsh-plus start again.');
+            return 1;
+        }
+        // Try each installer in turn: Corepack is absent on an installation that disabled it,
+        // and npm succeeds there. A failure reports the commands rather than a stack trace.
+        let installed = false;
+        for (const candidate of pnpmInstallCommands()) {
+            const attempt = spawnSync(candidate, { stdio: 'inherit', shell: true });
+            if (attempt.status === 0 && pnpmAvailable()) {
+                installed = true;
+                break;
+            }
+        }
+        if (!installed) {
+            console.log('Could not install pnpm automatically.');
+            console.log('Run one of these, then run dsh-plus start again:');
+            for (const candidate of pnpmInstallCommands())
+                console.log('  ' + candidate);
+            return 1;
+        }
+        console.log('pnpm installed.');
+    }
     const created = ensureProfile(paths, installationRoot());
     console.log(created
         ? 'Created the ' + STANDALONE_PROFILE + ' profile at ' + paths.profileDirectory

package/lib/types/standalone-profile.d.ts

@@ -94,6 +94,32 @@ export declare function installProfilePackages(paths: StandalonePaths, consumerD
  * @param profileModules - the profile's \`node_modules\` directory.
  */
 export declare function alignReplacedPackageNames(profileModules: string): void;
+/**
+ * Report whether pnpm can run.
+ *
+ * The profile installs its own tree so its \`overrides\` apply, and only pnpm reads those
+ * from a workspace, so pnpm is a prerequisite the distribution cannot supply. Probing
+ * first turns a cryptic failure from the install into a message naming what is missing.
+ *
+ * @returns \`true\` when pnpm answers with a version.
+ */
+export declare function pnpmAvailable(): boolean;
+/**
+ * The commands that install pnpm, in the order worth trying.
+ *
+ * Corepack ships with Node and needs no download, so it comes first; npm is the fallback
+ * for an installation whose Corepack is absent or disabled. Both are the consumer's own
+ * toolchain, which is what lets the first start offer to install rather than only report.
+ *
+ * @returns commands to try in order, stopping at the first that works.
+ */
+export declare function pnpmInstallCommands(): readonly string[];
+/**
+ * The command to show a consumer who declines the automatic install.
+ *
+ * @returns the preferred command, which is the one the offer runs first.
+ */
+export declare function pnpmInstallCommand(): string;
 /** Resolve every path a command needs, without creating anything. */
 export declare function resolvePaths(anchor: string, env?: NodeJS.ProcessEnv): StandalonePaths;
 /**

package/lib/types/standalone-profile.js

@@ -197,15 +197,65 @@ export function alignReplacedPackageNames(profileModules) {
         renameSync(temporary, manifestPath);
     }
 }
-/** Run pnpm in one directory, inheriting its output. */
+/**
+ * Run pnpm in one directory, inheriting its output.
+ *
+ * Windows resolves a command through its shell: \`spawnSync\` on a \`.cmd\` shim fails
+ * with EINVAL, so the call goes through \`cmd.exe\` there. This matches the runner in
+ * \`apply.ts\`, which the apply path has used on Windows since it shipped.
+ *
+ * @param cwd - the directory pnpm runs in.
+ * @param args - pnpm arguments, without the executable.
+ * @param label - the failing step's name, for the error.
+ */
 function runPnpm(cwd, args, label) {
-    const command = process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm';
-    const result = spawnSync(command, [...args], { cwd, stdio: 'inherit' });
+    const result = spawnSync('pnpm', [...args], {
+        cwd,
+        stdio: 'inherit',
+        shell: process.platform === 'win32',
+    });
     if (result.error !== undefined)
         throw result.error;
     if (result.status !== 0)
         throw new Error(label + ' failed with exit code ' + String(result.status));
 }
+/**
+ * Report whether pnpm can run.
+ *
+ * The profile installs its own tree so its \`overrides\` apply, and only pnpm reads those
+ * from a workspace, so pnpm is a prerequisite the distribution cannot supply. Probing
+ * first turns a cryptic failure from the install into a message naming what is missing.
+ *
+ * @returns \`true\` when pnpm answers with a version.
+ */
+export function pnpmAvailable() {
+    const probe = spawnSync('pnpm', ['--version'], {
+        stdio: 'pipe',
+        shell: process.platform === 'win32',
+        encoding: 'utf8',
+    });
+    return probe.status === 0;
+}
+/**
+ * The commands that install pnpm, in the order worth trying.
+ *
+ * Corepack ships with Node and needs no download, so it comes first; npm is the fallback
+ * for an installation whose Corepack is absent or disabled. Both are the consumer's own
+ * toolchain, which is what lets the first start offer to install rather than only report.
+ *
+ * @returns commands to try in order, stopping at the first that works.
+ */
+export function pnpmInstallCommands() {
+    return ['corepack enable pnpm', 'npm install -g pnpm'];
+}
+/**
+ * The command to show a consumer who declines the automatic install.
+ *
+ * @returns the preferred command, which is the one the offer runs first.
+ */
+export function pnpmInstallCommand() {
+    return pnpmInstallCommands()[0] ?? 'npm install -g pnpm';
+}
 /**
  * Expose the distribution's nested packages at the top level the profile searches.
  *

package/package.json

@@ -166,5 +166,5 @@
   },
   "type": "module",
   "types": "lib/types/index.d.ts",
-  "version": "0.1.0-rc.37"
+  "version": "0.1.0-rc.39"
 }