wyvrnpm 2.19.0 → 2.20.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wyvrnpm",
-  "version": "2.19.0",
+  "version": "2.20.1",
   "description": "A simple, static-hosting-compatible C++ package manager",
   "keywords": [
     "c++",

package/src/build/cmake-exe.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+// Default CMake install location on Windows (the Kitware MSI default). When
+// CMake isn't on PATH — common in stripped CI agents or a fresh dev box where
+// the installer's "add to PATH" box was unchecked — fall back to this so
+// install/build/source-build still work instead of failing with "is CMake on
+// PATH?".
+const WINDOWS_DEFAULT_CMAKE = 'C:\\Program Files\\CMake\\bin\\cmake.exe';
+
+/**
+ * Decide which `cmake` command to spawn. Pure — all environment inputs are
+ * injected, so it's testable across platforms.
+ *
+ *   1. cmake found on PATH → `'cmake'` (let spawn / PATH resolve it; preserves
+ *      the pre-fix behaviour and respects a user's chosen cmake).
+ *   2. else, on Windows, the default install location exists → its absolute
+ *      path.
+ *   3. else → `'cmake'` so the caller's spawn fails with the normal
+ *      "is CMake installed and on PATH?" error rather than a confusing ENOENT
+ *      on a hard-coded path.
+ *
+ * @param {{ platform: string, pathValue: string|undefined,
+ *           exists: (p: string) => boolean }} args
+ * @returns {string}
+ */
+function pickCmakeExe({ platform, pathValue, exists }) {
+  const isWin   = platform === 'win32';
+  const pathLib = isWin ? path.win32 : path.posix;
+  const delim   = isWin ? ';' : ':';
+  // .bat/.cmd cover shim installs (e.g. via package managers); .exe is the
+  // stock installer.
+  const names = isWin ? ['cmake.exe', 'cmake.bat', 'cmake.cmd'] : ['cmake'];
+
+  for (const dir of (pathValue || '').split(delim).filter(Boolean)) {
+    for (const name of names) {
+      if (exists(pathLib.join(dir, name))) return 'cmake';
+    }
+  }
+
+  if (isWin && exists(WINDOWS_DEFAULT_CMAKE)) return WINDOWS_DEFAULT_CMAKE;
+  return 'cmake';
+}
+
+let cached; // undefined = unprobed; string = resolved command (per-process)
+
+/**
+ * Resolve the cmake executable to spawn, memoised per-process (PATH and the
+ * install location don't change mid-run). Returns either `'cmake'` (on PATH /
+ * give-up) or an absolute path to the Windows-default cmake.exe.
+ *
+ * @returns {string}
+ */
+function resolveCmakeExe() {
+  if (cached === undefined) {
+    cached = pickCmakeExe({
+      platform:  process.platform,
+      pathValue: process.env.PATH,
+      exists:    fs.existsSync,
+    });
+  }
+  return cached;
+}
+
+module.exports = {
+  resolveCmakeExe,
+  WINDOWS_DEFAULT_CMAKE,
+  // Exported for unit tests
+  pickCmakeExe,
+};

package/src/build/cmake.js

@@ -5,6 +5,9 @@ const path = require('path');
 const { spawn } = require('child_process');
 
 const { loadMsvcEnv } = require('./msvc-env');
+const { archToVsPlatform, isVisualStudioGenerator } = require('../toolchain');
+const { detectDefaultGenerator } = require('./default-generator');
+const { resolveCmakeExe } = require('./cmake-exe');
 const log = require('../logger');
 
 /**
@@ -142,7 +145,7 @@ async function pickGenerator(candidates) {
  */
 function runCmake(args, opts = {}) {
   return new Promise((resolve, reject) => {
-    const proc = spawn('cmake', args, {
+    const proc = spawn(resolveCmakeExe(), args, {
       stdio: 'inherit',
       cwd:   opts.cwd,
       env:   opts.env || process.env,
@@ -190,15 +193,21 @@ function isMultiConfigGenerator(generatorName) {
  *   configureExtra:  string[],
  *   buildType?:      string|null,   // single-config only
  *   configurations?: string[]|null, // multi-config only, pins CMAKE_CONFIGURATION_TYPES
+ *   vsPlatform?:     string|null,   // VS generators only — emits -A <platform>
  * }} args
  * @returns {string[]}
  */
 function buildConfigureArgs({
   sourceDir, buildDir, installDir, toolchainFile, generator, configureExtra,
-  buildType, configurations,
+  buildType, configurations, vsPlatform = null,
 }) {
   const args = ['-S', sourceDir, '-B', buildDir];
   if (generator) args.push('-G', generator);
+  // Visual Studio generators default to host x64 unless the target platform is
+  // pinned with -A. Without this, an x86/ARM profile silently produces x64
+  // binaries (PLAN-VS-ARCH-PIN gate 3). Mapped from the profile arch by the
+  // caller; null for non-VS generators.
+  if (vsPlatform) args.push('-A', vsPlatform);
   args.push(`-DCMAKE_TOOLCHAIN_FILE=${toolchainFile}`);
   args.push(`-DCMAKE_INSTALL_PREFIX=${installDir}`);
   // Single-config generators bake CMAKE_BUILD_TYPE into the cache.
@@ -257,7 +266,22 @@ async function configureBuildInstall({ recipe, srcRoot, buildPaths, toolchainFil
 
   // Resolve generator from the fallback chain (probes each candidate's
   // backing tool). `null` → omit `-G`, let CMake pick its default.
-  const generator = await pickGenerator(recipe.generators);
+  let generator = await pickGenerator(recipe.generators);
+
+  // No recipe generator → CMake's Windows default is the newest VS, which
+  // builds host x64 unless `-A` is pinned. Resolve it to a concrete VS
+  // generator so the -A below applies (PLAN-VS-ARCH-PIN gate 3). Non-Windows /
+  // non-MSVC leaves `generator` null → CMake default, no -A (target arch is
+  // the compiler's job there).
+  if (!generator && profile && profile.os === 'Windows' && profile.compiler === 'msvc') {
+    generator = await detectDefaultGenerator();
+  }
+
+  // VS generators need -A <platform> to honour the profile arch — recipe-pinned
+  // VS generators get it too, not just the detected default.
+  const vsPlatform = isVisualStudioGenerator(generator)
+    ? archToVsPlatform(profile && profile.arch)
+    : null;
 
   // On Windows with an MSVC profile + non-VS generator (Ninja, Make, ...),
   // auto-enter a Developer Command Prompt-equivalent env so `cl.exe` is on
@@ -281,6 +305,7 @@ async function configureBuildInstall({ recipe, srcRoot, buildPaths, toolchainFil
       installDir:     buildPaths.install,
       toolchainFile,
       generator,
+      vsPlatform,
       configureExtra: recipe.configure,
       buildType:      null,        // multi-config picks at build time
       configurations: configList,  // pin CMAKE_CONFIGURATION_TYPES so all 4 build-<Config>.ninja files get generated
@@ -313,6 +338,7 @@ async function configureBuildInstall({ recipe, srcRoot, buildPaths, toolchainFil
       installDir:     buildPaths.install,
       toolchainFile,
       generator,
+      vsPlatform,
       configureExtra: recipe.configure,
       buildType:      cfg,
     });

package/src/build/default-generator.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const { spawn } = require('child_process');
+
+const { isVisualStudioGenerator } = require('../toolchain');
+const { resolveCmakeExe } = require('./cmake-exe');
+
+/**
+ * Parse `cmake --help` output for the platform's default generator. CMake
+ * marks the default with a leading `* ` in the "Generators" section, e.g.:
+ *
+ *   The following generators are available on this platform (* marks default):
+ *   * Visual Studio 17 2022 [arch] = Generates Visual Studio 2022 project files.
+ *     Visual Studio 16 2019 [arch] = Generates Visual Studio 2019 project files.
+ *     Ninja                        = Generates build.ninja files.
+ *
+ * Returns the default generator's name verbatim (with any trailing ` [arch]`
+ * annotation stripped), or null when no default marker is present. The name is
+ * returned as-is — deciding whether it's a Visual Studio generator is the
+ * caller's job.
+ *
+ * @param {string} helpText
+ * @returns {string|null}
+ */
+function parseDefaultGenerator(helpText) {
+  if (typeof helpText !== 'string') return null;
+  for (const line of helpText.split(/\r?\n/)) {
+    const m = line.match(/^\*\s+(.+?)\s*=/);
+    if (!m) continue;
+    return m[1].replace(/\s*\[arch\]\s*$/, '').trim();
+  }
+  return null;
+}
+
+/**
+ * Spawn `cmake --help` and resolve its stdout. Resolves null (never rejects)
+ * when cmake is absent from PATH or exits non-zero — generator detection is
+ * best-effort, and an unavailable cmake simply means the caller falls back to
+ * leaving the generator unpinned, exactly as before this feature.
+ *
+ * @returns {Promise<string|null>}
+ */
+function runCmakeHelp() {
+  return new Promise((resolve) => {
+    let out = '';
+    const cmakeExe = resolveCmakeExe();
+    // shell:true (Windows) lets a bare `cmake` resolve .bat/.cmd shims on PATH.
+    // But a resolved absolute fallback path contains spaces ("Program Files"),
+    // which a shell would word-split — spawn it directly without a shell.
+    const proc = spawn(cmakeExe, ['--help'], {
+      shell: process.platform === 'win32' && cmakeExe === 'cmake',
+    });
+    proc.stdout.on('data', (chunk) => { out += chunk.toString(); });
+    // cmake not on PATH → detection unavailable; recoverable, fall back to null.
+    proc.on('error', () => resolve(null));
+    proc.on('close', (code) => resolve(code === 0 ? out : null));
+  });
+}
+
+// Per-process memo of the production (no-injection) probe result. The default
+// generator can't change mid-run, so a single `cmake --help` spawn is enough
+// for the whole process — important when one process drives many installs
+// (e.g. a source-build that resolves several deps, or the test suite). Calls
+// that inject `platform`/`runHelp` (tests) bypass this cache to stay hermetic.
+let cachedDefault; // undefined = unprobed; string|null = probed result
+
+/**
+ * Detect the Visual Studio generator CMake would use by default on this
+ * machine. On Windows with VS installed, CMake's implicit default is the
+ * newest installed VS — which builds host x64 unless `-A`/architecture is
+ * pinned. Returns that VS generator name so callers can pin it (and the
+ * matching `-A`), or null when the default is not a VS generator
+ * (non-Windows, or VS not installed → today's behaviour, no pin).
+ *
+ * `platform` and `runHelp` are injectable for tests; the defaults probe the
+ * real machine and memoise the result per-process.
+ *
+ * @param {{ platform?: string, runHelp?: () => Promise<string|null> }} [opts]
+ * @returns {Promise<string|null>}
+ */
+async function detectDefaultGenerator({ platform, runHelp } = {}) {
+  const injected = platform !== undefined || runHelp !== undefined;
+  if (!injected && cachedDefault !== undefined) return cachedDefault;
+
+  const plat = platform ?? process.platform;
+  let result = null;
+  if (plat === 'win32') {
+    const helpText = await (runHelp ?? runCmakeHelp)();
+    const name = helpText ? parseDefaultGenerator(helpText) : null;
+    // Only VS generators need an arch pin; everything else (Ninja, NMake, …)
+    // already honours the active vcvarsall env for target arch.
+    result = isVisualStudioGenerator(name) ? name : null;
+  }
+
+  if (!injected) cachedDefault = result;
+  return result;
+}
+
+/**
+ * Resolve the generator a CMake invocation will actually use, given an
+ * optional explicit choice (CLI `--generator` or a recipe `build.generator`)
+ * and the active profile.
+ *
+ *   - An explicit non-empty generator always wins, verbatim.
+ *   - Otherwise, on a Windows/MSVC profile, fall back to the detected default
+ *     VS generator so callers can pin `-A`/architecture against it.
+ *   - Otherwise null — the caller leaves the generator unpinned (CMake picks
+ *     its default), exactly as before this feature. On non-Windows toolchains
+ *     target arch is the compiler's job, not the generator's.
+ *
+ * @param {{ explicit?: string|null,
+ *           profile?: { os?: string, compiler?: string }|null,
+ *           detect?: () => Promise<string|null> }} [args]
+ * @returns {Promise<string|null>}
+ */
+async function resolveEffectiveGenerator({ explicit = null, profile = null, detect = detectDefaultGenerator } = {}) {
+  if (typeof explicit === 'string' && explicit.trim()) return explicit;
+  if (profile && profile.os === 'Windows' && profile.compiler === 'msvc') {
+    return detect();
+  }
+  return null;
+}
+
+module.exports = {
+  resolveEffectiveGenerator,
+  detectDefaultGenerator,
+  // Exported for unit tests
+  parseDefaultGenerator,
+};

package/src/commands/build.js

@@ -7,6 +7,8 @@ const { spawn } = require('child_process');
 const { normalizeRecipe, hasBuildRecipe, VALID_CMAKE_CONFIGS, DEFAULT_RECIPE } = require('../build/recipe');
 const { loadMsvcEnv }  = require('../build/msvc-env');
 const { archToVsPlatform, isVisualStudioGenerator } = require('../toolchain');
+const { resolveEffectiveGenerator } = require('../build/default-generator');
+const { resolveCmakeExe } = require('../build/cmake-exe');
 const { LOCAL_OVERLAY_FILENAME, readLocalOverlay } = require('../conf');
 const { resolveBinaryDirRoot, DEFAULT_BINARY_DIR_ROOT } = require('../binary-dir');
 const { buildContext } = require('../context');
@@ -243,7 +245,7 @@ function runCmake(args, env = null) {
   return new Promise((resolve, reject) => {
     const opts = { stdio: 'inherit' };
     if (env) opts.env = env;
-    const proc = spawn('cmake', args, opts);
+    const proc = spawn(resolveCmakeExe(), args, opts);
     proc.on('error', (err) => {
       reject(new Error(
         `Failed to spawn cmake: ${err.message}\n` +
@@ -384,9 +386,17 @@ async function build(argv) {
         if (recipe.generators.length > 0) [presetGenerator] = recipe.generators;
       } catch { /* templates need options → skip env activation */ }
     }
-    // CLI --generator wins — that is the generator CMake will actually use,
-    // so it is the one that determines whether vcvarsall must be activated.
-    if (!effectiveGenerator) effectiveGenerator = presetGenerator;
+    // CLI --generator wins, then the recipe's generator, then — on a
+    // Windows/MSVC profile with neither — CMake's detected default VS
+    // generator. Resolving the default here keeps the `-A` pin below and the
+    // vcvarsall-skip decision consistent with the generator `cmake --preset`
+    // will actually use (install pins the same generator into the preset).
+    // Non-Windows / non-MSVC → null, unchanged from before.
+    // See claude/PLAN-VS-ARCH-PIN.md.
+    effectiveGenerator = await resolveEffectiveGenerator({
+      explicit: effectiveGenerator ?? presetGenerator,
+      profile:  activeProfile,
+    });
     cmakeEnv = await loadMsvcEnv({
       profile:          activeProfile,
       skipForGenerator: effectiveGenerator,

package/src/commands/install.js

@@ -18,6 +18,7 @@ const { resolveBinaryDirRoot }                              = require('../binary
 const { hashProfile, formatProfile, mergeProfile }          = require('../profile');
 const { generateToolchain, generateCMakePresets }           = require('../toolchain');
 const { normalizeRecipe, hasBuildRecipe }                   = require('../build/recipe');
+const { resolveEffectiveGenerator }                         = require('../build/default-generator');
 const { buildContext }                                      = require('../context');
 const {
   normalizeOptionsDeclaration,
@@ -661,6 +662,21 @@ async function install(argv) {
     }
   }
 
+  // When no generator was pinned by a recipe (the common recipe-less consumer
+  // case), CMake falls back to its platform default. On Windows that's the
+  // newest Visual Studio, which silently targets host x64 unless
+  // `-A`/architecture is pinned — so an x86 (or any non-host-arch) profile
+  // would produce mismatched binaries that find_package() later rejects with a
+  // pointer-size error. Resolve the default to a concrete VS generator so the
+  // preset carries both `generator` and `architecture` (buildConfigurePreset
+  // pins arch only when it knows the generator is VS). Non-Windows / non-MSVC
+  // → null, leaving the preset generator-less exactly as before. See
+  // claude/PLAN-VS-ARCH-PIN.md.
+  presetGenerator = await resolveEffectiveGenerator({
+    explicit: presetGenerator,
+    profile:  baseProfile,
+  });
+
   // PLAN-CONF.md §4.3 / §5 presets sink: fold effectiveConf's
   // cmake.cache namespace into the preset's cacheVariables. Runs
   // regardless of whether the project has its own build recipe —