wyvrnpm 2.0.4 → 2.3.2

package/src/build/clone.js

@@ -0,0 +1,170 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const log = require('../logger');
+
+/**
+ * Spawn a command with inherited stdio, resolve on exit 0, reject otherwise.
+ *
+ * @param {string}   cmd
+ * @param {string[]} args
+ * @param {{ cwd?: string }} [opts]
+ * @returns {Promise<void>}
+ */
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(cmd, args, { stdio: 'inherit', ...opts });
+    proc.on('error', (err) => reject(new Error(
+      `Failed to spawn ${cmd}: ${err.message} (is it installed and on PATH?)`,
+    )));
+    proc.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${cmd} ${args.join(' ')} exited ${code}`));
+    });
+  });
+}
+
+/**
+ * Ensure `gitRepo` is cloned into `destDir` at commit `gitSha`.
+ *
+ * Semantics:
+ *   - If destDir does not exist → fresh clone + checkout gitSha.
+ *   - If destDir exists and the HEAD commit already matches gitSha → no-op.
+ *   - If destDir exists with a different HEAD → fetch + checkout the right
+ *     SHA, reusing already-downloaded git objects.
+ *   - If reuse fails for any reason (corrupted cache, unreachable SHA),
+ *     blow away the cache and fresh-clone.
+ *
+ * Each path tries a fast shallow fetch by SHA first, then falls back to a
+ * full fetch. Some git servers disable `uploadpack.allowReachableSHA1InWant`
+ * (notably older Bitbucket Server installs), which makes direct SHA fetches
+ * fail with "upload-pack: not our ref"; the full-fetch fallback handles it.
+ *
+ * Credentials are delegated entirely to the user's ambient git config
+ * (SSH keys, credential helpers). We do NOT manage auth.
+ *
+ * @param {{ gitRepo: string, gitSha: string, destDir: string }} args
+ * @returns {Promise<void>}
+ */
+async function cloneAtSha({ gitRepo, gitSha, destDir }) {
+  if (!gitRepo) throw new Error('cloneAtSha: gitRepo is required');
+  if (!gitSha)  throw new Error('cloneAtSha: gitSha is required');
+
+  // Reuse existing clone if possible.
+  if (fs.existsSync(path.join(destDir, '.git'))) {
+    try {
+      await reuseExistingClone({ destDir, gitSha, gitRepo });
+      return;
+    } catch (err) {
+      // An unreachable-commit error is fatal and won't be helped by rebuilding.
+      if (/not reachable/.test(err.message)) throw err;
+      log.warn(`  cached clone unusable (${err.message}); rebuilding`);
+      fs.rmSync(destDir, { recursive: true, force: true });
+    }
+  }
+
+  await freshClone({ gitRepo, gitSha, destDir });
+}
+
+/**
+ * Verify that `gitSha` is present and reachable in `destDir`. Throws with an
+ * actionable error message when it isn't — the common root cause is an
+ * unpushed publisher-side commit or a feature branch that was deleted after
+ * publish, leaving the commit dangling on origin.
+ */
+async function verifyShaPresent({ destDir, gitSha, gitRepo }) {
+  try {
+    await run('git', ['cat-file', '-e', `${gitSha}^{commit}`], { cwd: destDir });
+  } catch {
+    throw new Error(
+      `commit ${gitSha.slice(0, 12)} is not reachable from any branch or tag on ${gitRepo}. ` +
+      `Likely cause: the publisher's HEAD was not pushed, OR the commit was on a ` +
+      `feature branch that was deleted/squash-merged after publish. ` +
+      `Fix: the package maintainer should republish from a commit that is pushed ` +
+      `and reachable from a remote branch or tag.`,
+    );
+  }
+}
+
+/**
+ * Checkout `gitSha` in an existing clone. Tries shallow-SHA fetch first,
+ * then full fetch (+ tags), then verifies reachability before checkout.
+ */
+async function reuseExistingClone({ destDir, gitSha, gitRepo }) {
+  const current = await getHeadSha(destDir);
+  if (current === gitSha) return;
+
+  log.info(`  reusing existing clone, switching to ${gitSha.slice(0, 12)}`);
+  try {
+    // Fast path: shallow fetch the specific SHA directly.
+    await run('git', ['fetch', '--depth', '1', 'origin', gitSha], { cwd: destDir });
+  } catch {
+    // Fallback: full fetch + tags. Fetching tags catches commits that live
+    // only under `refs/tags/*` — e.g. a release commit whose branch was
+    // deleted but whose tag remains.
+    log.info('  shallow SHA fetch unsupported by server; fetching all refs + tags (slower)');
+    await run('git', ['fetch', '--tags', 'origin'], { cwd: destDir });
+  }
+  await verifyShaPresent({ destDir, gitSha, gitRepo });
+  await run('git', ['checkout', '--detach', gitSha], { cwd: destDir });
+}
+
+/**
+ * Fresh clone. Tries `init + remote add + shallow-fetch <sha>` first, falls
+ * back to a full `git clone --tags` if the server refuses direct-SHA
+ * fetches. Verifies the commit is reachable before attempting checkout so
+ * the failure mode is a clear error rather than a cryptic `unable to read
+ * tree`.
+ */
+async function freshClone({ gitRepo, gitSha, destDir }) {
+  fs.mkdirSync(destDir, { recursive: true });
+  log.info(`  cloning ${gitRepo} at ${gitSha.slice(0, 12)} → ${destDir}`);
+  try {
+    await run('git', ['init', '--quiet'], { cwd: destDir });
+    await run('git', ['remote', 'add', 'origin', gitRepo], { cwd: destDir });
+    await run('git', ['fetch', '--depth', '1', 'origin', gitSha], { cwd: destDir });
+    await verifyShaPresent({ destDir, gitSha, gitRepo });
+    await run('git', ['checkout', '--detach', gitSha], { cwd: destDir });
+  } catch (err) {
+    // If the shallow-SHA fetch itself failed (server refuses it), fall
+    // through to a full clone. If instead the SHA-reachability check failed,
+    // re-throw with the actionable message — a full clone wouldn't help.
+    if (/not reachable/.test(err.message)) throw err;
+
+    log.warn(`  shallow fetch by SHA failed (${err.message}); falling back to full clone`);
+    fs.rmSync(destDir, { recursive: true, force: true });
+    fs.mkdirSync(destDir, { recursive: true });
+    // `--tags` brings down tag refs in the same round-trip so tag-only
+    // commits are reachable too.
+    await run('git', ['clone', '--quiet', '--tags', gitRepo, '.'], { cwd: destDir });
+    await verifyShaPresent({ destDir, gitSha, gitRepo });
+    await run('git', ['checkout', '--detach', gitSha], { cwd: destDir });
+  }
+}
+
+/**
+ * Return the current HEAD commit SHA of a git working tree, or null on error.
+ * @param {string} dir
+ * @returns {Promise<string|null>}
+ */
+function getHeadSha(dir) {
+  return new Promise((resolve) => {
+    const proc = spawn('git', ['rev-parse', 'HEAD'], {
+      cwd: dir,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    let out = '';
+    proc.stdout.on('data', (c) => { out += c.toString(); });
+    proc.on('error', () => resolve(null));
+    proc.on('close', (code) => {
+      if (code !== 0) return resolve(null);
+      const sha = out.trim();
+      resolve(/^[0-9a-f]{40}$/i.test(sha) ? sha : null);
+    });
+  });
+}
+
+module.exports = { cloneAtSha, getHeadSha };

package/src/build/cmake.js

@@ -0,0 +1,342 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const { loadMsvcEnv } = require('./msvc-env');
+const log = require('../logger');
+
+/**
+ * CMake configure + build + install orchestration for the source-build path.
+ *
+ * Separation of concerns:
+ *   - This module does NOT compute CMake flags from a profile. That is the
+ *     toolchain generator's job ([src/toolchain/index.js]). We take a
+ *     pre-generated toolchain file path and hand it to CMake.
+ *   - This module DOES translate a recipe (`{ generator, configure,
+ *     buildArgs, installDir, sourceSubdir }`) into `cmake` argv.
+ */
+
+const DEFAULT_CONFIG = 'Release';
+
+/**
+ * Probe whether a tool is available on PATH by spawning it with `--version`.
+ * Uses `shell: true` on Windows so `.cmd`/`.bat` shims resolve correctly.
+ *
+ * @param {string} cmd
+ * @returns {Promise<boolean>}
+ */
+function isToolOnPath(cmd) {
+  return new Promise((resolve) => {
+    const proc = spawn(cmd, ['--version'], {
+      stdio: 'ignore',
+      shell: process.platform === 'win32',
+    });
+    proc.on('error', () => resolve(false));
+    proc.on('close', (code) => resolve(code === 0));
+  });
+}
+
+/**
+ * Classify a CMake generator's availability on this machine. Tri-state so
+ * `pickGenerator` can distinguish "known-available" (take it) from
+ * "known-unavailable" (skip) from "unknown name" (use only if nothing else
+ * is confirmed — CMake will error itself if it can't handle the name).
+ *
+ * @param {string} name
+ * @returns {Promise<'yes'|'no'|'unknown'>}
+ */
+async function classifyGenerator(name) {
+  if (!name) return 'no';
+  if (name === 'Ninja' || name === 'Ninja Multi-Config') {
+    return (await isToolOnPath('ninja')) ? 'yes' : 'no';
+  }
+  if (name.startsWith('Visual Studio')) {
+    // CMake itself validates the exact VS version at configure time.
+    return process.platform === 'win32' ? 'yes' : 'no';
+  }
+  if (name === 'Unix Makefiles') {
+    return (await isToolOnPath('make')) ? 'yes' : 'no';
+  }
+  if (name === 'MinGW Makefiles' || name === 'MSYS Makefiles') {
+    if (process.platform !== 'win32') return 'no';
+    return (await isToolOnPath('mingw32-make') || await isToolOnPath('make')) ? 'yes' : 'no';
+  }
+  if (name === 'NMake Makefiles' || name === 'NMake Makefiles JOM') {
+    if (process.platform !== 'win32') return 'no';
+    return (await isToolOnPath('nmake')) ? 'yes' : 'no';
+  }
+  if (name === 'Xcode') {
+    if (process.platform !== 'darwin') return 'no';
+    return (await isToolOnPath('xcodebuild')) ? 'yes' : 'no';
+  }
+  return 'unknown';
+}
+
+/**
+ * Boolean convenience wrapper around `classifyGenerator` — true iff the
+ * generator is positively confirmed as available (status === 'yes'). Unknown
+ * generators return false here; use `classifyGenerator` directly if you
+ * need the distinction.
+ *
+ * @param {string} name
+ * @returns {Promise<boolean>}
+ */
+async function isGeneratorAvailable(name) {
+  return (await classifyGenerator(name)) === 'yes';
+}
+
+/**
+ * Choose the best generator from an ordered candidate list.
+ *
+ *   1. First pass: the first candidate whose probe positively confirms
+ *      availability (e.g. `ninja --version` succeeds) wins — array order
+ *      is preserved within this pass.
+ *   2. Second pass: if no candidate is known-available, fall back to the
+ *      first candidate with an unknown name (CMake gets a chance to resolve
+ *      it, erroring clearly if it can't).
+ *   3. Otherwise return `null` so CMake uses its own platform default
+ *      (VS on Windows, Make elsewhere).
+ *
+ * @param {string[]} candidates  from recipe.generators
+ * @returns {Promise<string|null>}
+ */
+async function pickGenerator(candidates) {
+  if (!candidates || candidates.length === 0) return null;
+
+  const results = [];
+  for (const name of candidates) {
+    results.push({ name, status: await classifyGenerator(name) });
+  }
+
+  const good = results.find((r) => r.status === 'yes');
+  if (good) {
+    if (candidates.length > 1) {
+      log.info(`  generator: ${good.name} (chosen from ${JSON.stringify(candidates)})`);
+    }
+    return good.name;
+  }
+
+  const unknown = results.find((r) => r.status === 'unknown');
+  if (unknown) {
+    log.info(
+      `  generator: ${unknown.name} (unknown to wyvrnpm's probe; trusting CMake to resolve)`,
+    );
+    return unknown.name;
+  }
+
+  log.warn(
+    `  None of the requested generators ${JSON.stringify(candidates)} ` +
+    `are installed. Falling through to CMake's platform default.`,
+  );
+  return null;
+}
+
+/**
+ * Run `cmake` with the given args, inheriting stdio so the user sees compiler
+ * output in real time.
+ * @param {string[]} args
+ * @param {{ cwd?: string, env?: object }} [opts]
+ * @returns {Promise<void>}
+ */
+function runCmake(args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('cmake', args, {
+      stdio: 'inherit',
+      cwd:   opts.cwd,
+      env:   opts.env || process.env,
+    });
+    proc.on('error', (err) => reject(new Error(
+      `Failed to spawn cmake: ${err.message} (is CMake installed and on PATH?)`,
+    )));
+    proc.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`cmake ${args.join(' ')} exited ${code}`));
+    });
+  });
+}
+
+/**
+ * Multi-config CMake generators pick the build configuration at build time
+ * (via `--config`), not configure time. Everything else is single-config
+ * and bakes `CMAKE_BUILD_TYPE` into the cache at configure time, so
+ * multiple configs need multiple build directories.
+ *
+ * @param {string|null} generatorName
+ * @returns {boolean}
+ */
+function isMultiConfigGenerator(generatorName) {
+  if (!generatorName) return false; // null = CMake default — usually Make on Linux, VS on Windows
+  if (generatorName.startsWith('Visual Studio')) return true;
+  return generatorName === 'Xcode' || generatorName === 'Ninja Multi-Config';
+}
+
+/**
+ * Build cmake CONFIGURE argv for a source-build.
+ *
+ * Exactly one of `buildType` (single-config) or `configurations`
+ * (multi-config) should be non-null. Setting `configurations` explicitly
+ * lets us pin `CMAKE_CONFIGURATION_TYPES` so every expected `build-<Config>.ninja`
+ * file is actually generated — CMake's default for that variable varies
+ * across versions and user CMakeLists.
+ *
+ * @param {{
+ *   sourceDir:       string,
+ *   buildDir:        string,
+ *   installDir:      string,
+ *   toolchainFile:   string,
+ *   generator?:      string|null,
+ *   configureExtra:  string[],
+ *   buildType?:      string|null,   // single-config only
+ *   configurations?: string[]|null, // multi-config only, pins CMAKE_CONFIGURATION_TYPES
+ * }} args
+ * @returns {string[]}
+ */
+function buildConfigureArgs({
+  sourceDir, buildDir, installDir, toolchainFile, generator, configureExtra,
+  buildType, configurations,
+}) {
+  const args = ['-S', sourceDir, '-B', buildDir];
+  if (generator) args.push('-G', generator);
+  args.push(`-DCMAKE_TOOLCHAIN_FILE=${toolchainFile}`);
+  args.push(`-DCMAKE_INSTALL_PREFIX=${installDir}`);
+  // Single-config generators bake CMAKE_BUILD_TYPE into the cache.
+  if (buildType) args.push(`-DCMAKE_BUILD_TYPE=${buildType}`);
+  // Multi-config generators ignore CMAKE_BUILD_TYPE and use
+  // CMAKE_CONFIGURATION_TYPES instead. Passed as a semicolon list.
+  if (configurations && configurations.length > 0) {
+    args.push(`-DCMAKE_CONFIGURATION_TYPES=${configurations.join(';')}`);
+  }
+  if (configureExtra.length > 0) args.push(...configureExtra);
+  return args;
+}
+
+/**
+ * Build cmake --build argv for the install target.
+ *
+ * @param {{
+ *   buildDir: string,
+ *   config:   string,
+ *   buildExtra: string[],
+ * }} args
+ * @returns {string[]}
+ */
+function buildInstallArgs({ buildDir, config, buildExtra }) {
+  const args = ['--build', buildDir, '--target', 'install', '--config', config];
+  if (buildExtra.length > 0) args.push('--', ...buildExtra);
+  return args;
+}
+
+/**
+ * Configure + build + install a package from source.
+ *
+ * @param {{
+ *   recipe:        import('./recipe').NormalizedRecipe,
+ *   srcRoot:       string,   // absolute path to the cloned source root
+ *   buildPaths:    { build: string, install: string },
+ *   toolchainFile: string,   // absolute path to wyvrn_toolchain.cmake
+ *   config?:       string,   // default 'Release'
+ * }} args
+ * @returns {Promise<void>}
+ */
+async function configureBuildInstall({ recipe, srcRoot, buildPaths, toolchainFile, configs, profile }) {
+  const configList = Array.isArray(configs) && configs.length > 0
+    ? configs
+    : [DEFAULT_CONFIG];
+
+  const sourceDir = path.resolve(srcRoot, recipe.sourceSubdir);
+  if (!fs.existsSync(path.join(sourceDir, 'CMakeLists.txt'))) {
+    throw new Error(
+      `CMakeLists.txt not found at ${sourceDir}. ` +
+      `Check the package's build.sourceSubdir in its wyvrn.json.`,
+    );
+  }
+
+  fs.mkdirSync(buildPaths.install, { recursive: true });
+
+  // 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);
+
+  // On Windows with an MSVC profile + non-VS generator (Ninja, Make, ...),
+  // auto-enter a Developer Command Prompt-equivalent env so `cl.exe` is on
+  // PATH. VS generators don't need this — MSBuild resolves MSVC itself.
+  // Returns null when nothing needs to change, in which case we inherit
+  // the caller's env.
+  const env = await loadMsvcEnv({ profile, skipForGenerator: generator });
+
+  const multiConfig = isMultiConfigGenerator(generator);
+  log.info(
+    `  generator: ${generator ?? '<CMake default>'} ` +
+    `(${multiConfig ? 'multi-config' : 'single-config'}), configs: ${configList.join(', ')}`,
+  );
+
+  if (multiConfig) {
+    // ── Multi-config: one build dir, run install target once per config ─────
+    fs.mkdirSync(buildPaths.build, { recursive: true });
+    const configureArgs = buildConfigureArgs({
+      sourceDir,
+      buildDir:       buildPaths.build,
+      installDir:     buildPaths.install,
+      toolchainFile,
+      generator,
+      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
+    });
+    log.info(`  cmake ${configureArgs.join(' ')}`);
+    await runCmake(configureArgs, { env });
+
+    for (const cfg of configList) {
+      const installArgs = buildInstallArgs({
+        buildDir:   buildPaths.build,
+        config:     cfg,
+        buildExtra: recipe.buildArgs,
+      });
+      log.info(`  cmake ${installArgs.join(' ')}`);
+      await runCmake(installArgs, { env });
+    }
+    return;
+  }
+
+  // ── Single-config: separate build dir + reconfigure per config ───────────
+  // `CMAKE_BUILD_TYPE` is baked into the cache, so mixing configs in one
+  // build dir would require clobbering the cache between each. Distinct
+  // dirs is simpler and lets CMake's own dependency tracking work per-config.
+  for (const cfg of configList) {
+    const perCfgBuildDir = `${buildPaths.build}-${cfg}`;
+    fs.mkdirSync(perCfgBuildDir, { recursive: true });
+    const configureArgs = buildConfigureArgs({
+      sourceDir,
+      buildDir:       perCfgBuildDir,
+      installDir:     buildPaths.install,
+      toolchainFile,
+      generator,
+      configureExtra: recipe.configure,
+      buildType:      cfg,
+    });
+    log.info(`  cmake ${configureArgs.join(' ')}`);
+    await runCmake(configureArgs, { env });
+
+    const installArgs = buildInstallArgs({
+      buildDir:   perCfgBuildDir,
+      config:     cfg,
+      buildExtra: recipe.buildArgs,
+    });
+    log.info(`  cmake ${installArgs.join(' ')}`);
+    await runCmake(installArgs, { env });
+  }
+}
+
+module.exports = {
+  configureBuildInstall,
+  pickGenerator,
+  classifyGenerator,
+  isGeneratorAvailable,
+  isMultiConfigGenerator,
+  // Exported for unit tests
+  buildConfigureArgs,
+  buildInstallArgs,
+  DEFAULT_CONFIG,
+};