wyvrnpm 2.1.0 → 2.4.1

package/src/toolchain/presets.js

@@ -4,6 +4,21 @@ const fs   = require('fs');
 const path = require('path');
 
 const VENDOR_KEY = 'wyvrnpm/generated';
+
+// Local copy of the arch→VS-platform mapping. Duplicated here rather than
+// imported from ./index so preset generation can run standalone (keeps
+// the dependency graph simple — presets.js doesn't otherwise need the
+// toolchain generator). Keep in sync with `archToVsPlatform` in index.js.
+const ARCH_VS_PLATFORM = {
+  x86_64: 'x64',
+  x86:    'Win32',
+  armv8:  'ARM64',
+  armv7:  'ARM',
+};
+
+function isVsGenerator(name) {
+  return typeof name === 'string' && /^Visual Studio \d/.test(name);
+}
 const SCHEMA_VERSION = 3;  // requires CMake ≥ 3.21
 
 /**
@@ -33,22 +48,83 @@ function isWyvrnGenerated(presets) {
 /**
  * Build the configure preset object for the active profile.
  *
+ * When the project has its own `build` recipe (i.e. it's a publishable
+ * library with `build.generator` / `build.configure` declared), those are
+ * propagated into the generated preset so `wyvrnpm build` locally honours
+ * the same knobs the source-build + publish paths use. Without this, a
+ * publisher's recipe is effectively advisory at install-time (F15 fix).
+ *
  * @param {object} args
  * @param {string} args.profileName
  * @param {string} args.profileHash
- * @param {string} args.toolchainRelPath   Relative from project root, CMake-style
- *                                         forward slashes.
+ * @param {string} args.toolchainRelPath       Relative from project root, CMake-style
+ *                                             forward slashes.
+ * @param {string|null} [args.generator]       Single generator name to pin on the
+ *                                             preset (e.g. "Ninja Multi-Config").
+ *                                             Null / undefined → let CMake pick.
+ * @param {Record<string,string>|null} [args.extraCacheVariables]
+ *                                             Merged into cacheVariables alongside
+ *                                             `CMAKE_TOOLCHAIN_FILE`. Usually
+ *                                             derived from the project's own
+ *                                             `build.configure` -D args.
+ * @param {string|null} [args.profileArch]     Active profile arch — used to pin
+ *                                             `architecture` for VS generators
+ *                                             so `cmake --preset` produces
+ *                                             binaries matching the profile
+ *                                             (VS otherwise defaults to x64).
  */
-function buildConfigurePreset({ profileName, profileHash, toolchainRelPath }) {
-  return {
+function buildConfigurePreset({
+  profileName,
+  profileHash,
+  toolchainRelPath,
+  generator = null,
+  extraCacheVariables = null,
+  installDir = null,
+  profileArch = null,
+}) {
+  const binaryDir = `\${sourceDir}/build/wyvrn-${profileName}`;
+  // Spread `extraCacheVariables` FIRST, then the wyvrn-owned entries. This
+  // means the recipe cannot redirect `CMAKE_TOOLCHAIN_FILE` — our dep
+  // injection is always the authoritative toolchain pointer. A malicious
+  // or sloppy recipe trying to override it is silently ignored, not
+  // quietly obeyed. Same protection applies to `CMAKE_INSTALL_PREFIX`:
+  // if a recipe declares `build.installDir`, we resolve it under the
+  // binary dir; any cacheVariables override is overwritten below.
+  const cacheVariables = {
+    ...(extraCacheVariables ?? {}),
+    CMAKE_TOOLCHAIN_FILE: `\${sourceDir}/${toolchainRelPath}`,
+  };
+  if (installDir) {
+    // `installDir` in wyvrn.json is defined as relative to the binary dir
+    // (same semantics as the source-build path, which passes
+    // -DCMAKE_INSTALL_PREFIX=<buildDir>/<installDir>). Without this, a
+    // `wyvrnpm build --install` falls back to CMake's system default —
+    // on Windows that's `C:/Program Files (x86)/<Project>`, which needs
+    // admin rights and almost always fails.
+    cacheVariables.CMAKE_INSTALL_PREFIX = `${binaryDir}/${installDir}`;
+  }
+  const preset = {
     name:         `wyvrn-${profileName}`,
     displayName:  `wyvrnpm (${profileName})`,
     description:  `Generated by wyvrnpm install — profile hash ${profileHash}`,
-    binaryDir:    `\${sourceDir}/build/wyvrn-${profileName}`,
-    cacheVariables: {
-      CMAKE_TOOLCHAIN_FILE: `\${sourceDir}/${toolchainRelPath}`,
-    },
+    binaryDir,
+    cacheVariables,
   };
+  if (generator) preset.generator = generator;
+
+  // Visual Studio generators default to x64 when `architecture` is
+  // unspecified — which silently overrides the profile arch and makes
+  // find_package() reject 32-bit installed packages with a pointer-size
+  // mismatch. Pin `architecture` from the profile so `cmake --preset`
+  // produces the right artefacts end-to-end.
+  if (isVsGenerator(generator) && profileArch && ARCH_VS_PLATFORM[profileArch]) {
+    preset.architecture = {
+      value:    ARCH_VS_PLATFORM[profileArch],
+      strategy: 'set',
+    };
+  }
+
+  return preset;
 }
 
 /**
@@ -78,7 +154,15 @@ function buildBuildPresets(profileName) {
 /**
  * Build a fresh presets file from scratch (no prior content to merge).
  */
-function buildFreshPresetsFile({ profileName, profileHash, toolchainRelPath }) {
+function buildFreshPresetsFile({
+  profileName,
+  profileHash,
+  toolchainRelPath,
+  generator = null,
+  extraCacheVariables = null,
+  installDir = null,
+  profileArch = null,
+}) {
   return {
     version: SCHEMA_VERSION,
     vendor: {
@@ -88,8 +172,10 @@ function buildFreshPresetsFile({ profileName, profileHash, toolchainRelPath }) {
         generatedAt: new Date().toISOString(),
       },
     },
-    configurePresets: [buildConfigurePreset({ profileName, profileHash, toolchainRelPath })],
-    buildPresets:     buildBuildPresets(profileName),
+    configurePresets: [buildConfigurePreset({
+      profileName, profileHash, toolchainRelPath, generator, extraCacheVariables, installDir, profileArch,
+    })],
+    buildPresets: buildBuildPresets(profileName),
   };
 }
 
@@ -103,8 +189,18 @@ function buildFreshPresetsFile({ profileName, profileHash, toolchainRelPath }) {
  * @param {object} args  forwarded to the preset builders
  * @returns {object}
  */
-function mergeIntoExisting(existing, { profileName, profileHash, toolchainRelPath }) {
-  const newConfigure = buildConfigurePreset({ profileName, profileHash, toolchainRelPath });
+function mergeIntoExisting(existing, {
+  profileName,
+  profileHash,
+  toolchainRelPath,
+  generator = null,
+  extraCacheVariables = null,
+  installDir = null,
+  profileArch = null,
+}) {
+  const newConfigure = buildConfigurePreset({
+    profileName, profileHash, toolchainRelPath, generator, extraCacheVariables, installDir, profileArch,
+  });
   const newBuilds    = buildBuildPresets(profileName);
   const newConfigureNames = new Set([newConfigure.name]);
   const newBuildNames     = new Set(newBuilds.map((b) => b.name));
@@ -150,9 +246,22 @@ function mergeIntoExisting(existing, { profileName, profileHash, toolchainRelPat
  * @param {string} args.profileName
  * @param {string} args.profileHash
  * @param {string} args.toolchainRelPath  CMake-style forward slashes, relative to projectRoot.
+ * @param {string|null} [args.generator]  Propagated onto the configure preset's `generator` field.
+ * @param {Record<string,string>|null} [args.extraCacheVariables]
+ *                                        Merged into the configure preset's `cacheVariables`.
  * @returns {{ path: string|null, action: 'created'|'updated'|'skipped', isUser: boolean }}
  */
-function generateCMakePresets({ projectRoot, profileName, profileHash, toolchainRelPath }) {
+function generateCMakePresets({
+  projectRoot,
+  profileName,
+  profileHash,
+  toolchainRelPath,
+  generator = null,
+  extraCacheVariables = null,
+  installDir = null,
+  profileArch = null,
+}) {
+  const args = { profileName, profileHash, toolchainRelPath, generator, extraCacheVariables, installDir, profileArch };
   const candidates = [
     { filePath: path.join(projectRoot, 'CMakePresets.json'),     isUser: false },
     { filePath: path.join(projectRoot, 'CMakeUserPresets.json'), isUser: true  },
@@ -160,14 +269,14 @@ function generateCMakePresets({ projectRoot, profileName, profileHash, toolchain
 
   for (const { filePath, isUser } of candidates) {
     if (!fs.existsSync(filePath)) {
-      const content = buildFreshPresetsFile({ profileName, profileHash, toolchainRelPath });
+      const content = buildFreshPresetsFile(args);
       fs.writeFileSync(filePath, JSON.stringify(content, null, 2) + '\n', 'utf8');
       return { path: filePath, action: 'created', isUser };
     }
 
     const existing = safeReadJson(filePath);
     if (isWyvrnGenerated(existing)) {
-      const merged = mergeIntoExisting(existing, { profileName, profileHash, toolchainRelPath });
+      const merged = mergeIntoExisting(existing, args);
       fs.writeFileSync(filePath, JSON.stringify(merged, null, 2) + '\n', 'utf8');
       return { path: filePath, action: 'updated', isUser };
     }

package/src/toolchain/template.cmake

@@ -17,6 +17,17 @@ set(WYVRN_PROFILE_NAME             "{{PROFILE_NAME}}")
 set(WYVRN_PROFILE_HASH             "{{PROFILE_HASH}}")
 set(WYVRN_PROFILE_OS               "{{PROFILE_OS}}")
 set(WYVRN_PROFILE_ARCH             "{{PROFILE_ARCH}}")
+
+# "64" for 64-bit arches (x86_64, armv8, …), "32" for 32-bit (x86, armv7, …),
+# empty for arches outside the known mapping. Derived at generation time from
+# the profile so it is valid BEFORE `project()` — unlike CMAKE_SIZEOF_VOID_P,
+# which is only set after the first project() call. Intended for suffixing
+# artefact names (e.g. "String${WYVRN_ARCH_SUFFIX}" → String64 / String32) so
+# x64 and x86 builds can coexist on disk without overwriting each other.
+# Call WYVRN_APPLY_ARCH_SUFFIX(<target>) from macros.cmake for the common
+# per-target shape, or reference the variable directly for other uses.
+set(WYVRN_ARCH_SUFFIX              "{{PROFILE_ARCH_SUFFIX}}")
+
 set(WYVRN_PROFILE_COMPILER         "{{PROFILE_COMPILER}}")
 set(WYVRN_PROFILE_COMPILER_VERSION "{{PROFILE_COMPILER_VERSION}}")
 set(WYVRN_PROFILE_CPPSTD           "{{PROFILE_CPPSTD}}")

package/src/upload-built.js

@@ -0,0 +1,256 @@
+'use strict';
+
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+
+const { getProvider }        = require('./providers');
+const { defaultCompatBlock } = require('./compat');
+const { getBuildPaths }      = require('./build/cache');
+const log                    = require('./logger');
+
+const WYVRNPM_VERSION = require('../package.json').version;
+
+const UPLOAD_SIDECAR = '.uploaded-to.json';
+
+/**
+ * Record a successful upload in a sidecar file alongside the build-cache
+ * entry. Append-only so repeated uploads to different destinations all
+ * leave a trail. Purely informational — nothing in the install/build flow
+ * branches on these files. Wiped by `wyvrnpm clean --uploaded-built`.
+ *
+ * @param {{ name: string, version: string, profileHash: string, source: string, contentSha256: string }} args
+ */
+function recordUploadSidecar({ name, version, profileHash, source, contentSha256 }) {
+  try {
+    const paths = getBuildPaths({ name, version, profileHash });
+    if (!fs.existsSync(paths.root)) return;
+    const sidecarPath = path.join(paths.root, UPLOAD_SIDECAR);
+    let doc = { uploads: [] };
+    if (fs.existsSync(sidecarPath)) {
+      try {
+        const raw = JSON.parse(fs.readFileSync(sidecarPath, 'utf8'));
+        if (Array.isArray(raw?.uploads)) doc = raw;
+      } catch { /* corrupt sidecar — overwrite with fresh doc */ }
+    }
+    doc.uploads.push({
+      uploadedAt: new Date().toISOString(),
+      source,
+      profileHash,
+      contentSha256,
+    });
+    fs.writeFileSync(sidecarPath, JSON.stringify(doc, null, 2) + '\n', 'utf8');
+  } catch {
+    // Sidecar bookkeeping is best-effort — never break an install over it.
+  }
+}
+
+/**
+ * Upload a freshly source-built artefact back to the v2 registry under the
+ * consumer's profileHash, so subsequent consumers with the same profile get
+ * a direct download instead of re-cloning and re-compiling.
+ *
+ * See PLAN-UPLOAD-BUILT.md for the full design. Key properties:
+ *
+ *   - Opt-in. Only called when the user passes `--upload-built` at install.
+ *   - Skips silently if the registry already has this (name, version,
+ *     profileHash) — the common case once the first teammate has uploaded.
+ *   - Never overwrites. A consumer with write credentials cannot clobber an
+ *     existing artefact; that still requires `publish --force` from the
+ *     source repo.
+ *   - Leaves `latest.json` and the `latest` pointer in `versions.json`
+ *     alone. A consumer upload is a new profileHash of an existing version,
+ *     not a new version release. Honoured via `updateLatest: false`.
+ *   - Records provenance in the uploaded manifest's `uploadedBy` block.
+ *     Absence of this block implies author-publish by convention.
+ *
+ * @param {object} args
+ * @param {string} args.name
+ * @param {string} args.version
+ * @param {import('./profile').WyvrnProfile} args.profile
+ * @param {string} args.profileHash
+ * @param {string} args.artefactPath       Absolute path to the built zip in %LOCALAPPDATA%\wyvrnpm\bc\.
+ * @param {string} args.clonedManifestPath Absolute path to the cloned-source wyvrn.json.
+ * @param {string} args.contentSha256      SHA256 of the built zip.
+ * @param {string} args.gitRepo            Source repo URL recorded at publish.
+ * @param {string} args.gitSha             Source commit recorded at publish.
+ * @param {string} args.uploadSource       Destination URL (resolved from --upload-source or config).
+ * @param {object} [args.uploadAuth]       { awsProfile?, token? }
+ * @param {Record<string, any>|null} [args.options]  Effective options for this build (fed through to buildSettings.options).
+ * @param {string} [args.toolchainHash]    Optional SHA of the generated wyvrn_toolchain.cmake.
+ * @returns {Promise<{ uploaded: boolean, reason: string }>}
+ */
+async function uploadSourceBuiltArtefact(args) {
+  const {
+    name, version, profile, profileHash,
+    artefactPath, clonedManifestPath,
+    contentSha256, gitRepo, gitSha,
+    uploadSource, uploadAuth = {},
+    options = null,
+    toolchainHash,
+  } = args;
+
+  if (!uploadSource) {
+    return { uploaded: false, reason: 'no upload source resolved' };
+  }
+  if (!fs.existsSync(artefactPath)) {
+    return { uploaded: false, reason: `artefact zip missing at ${artefactPath}` };
+  }
+  if (!fs.existsSync(clonedManifestPath)) {
+    // Cache-hit path on a previously-trimmed cache, or the source dir was
+    // manually deleted. We have the binary but not the manifest we would
+    // have uploaded alongside it. Surface it — nothing silent.
+    return { uploaded: false, reason: `cloned manifest missing at ${clonedManifestPath}` };
+  }
+
+  let provider;
+  try {
+    provider = getProvider(uploadSource);
+  } catch (err) {
+    return { uploaded: false, reason: `no provider for ${uploadSource}: ${err.message}` };
+  }
+
+  const { awsProfile, token } = uploadAuth;
+
+  // ── Skip-if-exists ────────────────────────────────────────────────────────
+  const exists = await provider.v2Exists({
+    source: uploadSource, name, version, profileHash, awsProfile, token,
+  });
+  if (exists) {
+    log.info(`upload-built: ${name}@${version} [${profileHash}] already on ${uploadSource} — skipping`);
+    return { uploaded: false, reason: 'already exists on registry' };
+  }
+
+  // ── Prepare manifest: cloned wyvrn.json + compat block + uploadedBy ──────
+  const rawManifest = JSON.parse(fs.readFileSync(clonedManifestPath, 'utf8'));
+  const manifestForUpload = {
+    ...rawManifest,
+    compatibility: rawManifest.compatibility ?? defaultCompatBlock(),
+    uploadedBy: {
+      kind:           'source-build',
+      profileHash,
+      builtFromGit:   gitRepo ?? null,
+      builtFromSha:   gitSha  ?? null,
+      ...(toolchainHash ? { toolchainHash } : {}),
+      uploadedAt:     new Date().toISOString(),
+      wyvrnpmVersion: WYVRNPM_VERSION,
+    },
+  };
+
+  const tmpManifestPath = path.join(
+    os.tmpdir(),
+    `wyvrnpm-upload-${name}-${version}-${profileHash}-${Date.now()}.json`,
+  );
+  fs.writeFileSync(tmpManifestPath, JSON.stringify(manifestForUpload, null, 2), 'utf8');
+
+  try {
+    log.info(`upload-built: ${name}@${version} [${profileHash}] → ${uploadSource}`);
+    await provider.v2Publish(
+      { manifest: tmpManifestPath, zip: artefactPath },
+      {
+        source:        uploadSource,
+        name, version, profileHash,
+        buildSettings: options ? { ...profile, options } : profile,
+        contentSha256,
+        gitSha:  gitSha  ?? null,
+        gitRepo: gitRepo ?? null,
+        // Consumer uploads must not reshape the "latest" pointer — see
+        // PLAN-UPLOAD-BUILT §3.3.
+        updateLatest: false,
+        uploadedBy:   manifestForUpload.uploadedBy,
+        awsProfile,
+        token,
+      },
+    );
+    log.success(`upload-built: ${name}@${version} [${profileHash}] uploaded`);
+    recordUploadSidecar({ name, version, profileHash, source: uploadSource, contentSha256 });
+    return { uploaded: true, reason: 'ok' };
+  } catch (err) {
+    // The caller wraps us in try/catch too, but returning {uploaded:false}
+    // here keeps the happy path type-stable.
+    return { uploaded: false, reason: `upload failed: ${err.message}` };
+  } finally {
+    try { fs.unlinkSync(tmpManifestPath); } catch { /* ignore */ }
+  }
+}
+
+/**
+ * Resolve `--upload-source` (URL or configured-publish-source name) + auth
+ * into an object the orchestrator understands. Mirrors the resolution
+ * pattern in src/commands/publish.js so the two flows behave identically.
+ *
+ * Returns null if no destination can be resolved — caller decides whether
+ * that is fatal (it is, if --upload-built was passed) or just skip-worthy.
+ *
+ * @param {object} argv
+ * @param {string|undefined} argv.uploadSource
+ * @param {string|undefined} argv.awsProfile
+ * @param {string|undefined} argv.token
+ * @param {{ publishSources: Array<{name:string, url:string, profile?:string, token?:string}> }} config
+ * @returns {{ uploadSource: string, uploadAuth: { awsProfile?: string, token?: string } } | null}
+ */
+function resolveUploadDestination(argv, config) {
+  let src = argv.uploadSource;
+  let awsProfile = argv.awsProfile;
+  let token      = argv.token;
+
+  const publishSources = config.publishSources ?? [];
+
+  if (src) {
+    // Check if it matches a configured publish source by name.
+    const named = publishSources.find((s) => s.name === src);
+    if (named) {
+      src        = named.url;
+      awsProfile = awsProfile ?? named.profile;
+      token      = token      ?? named.token;
+      log.info(`upload-built: using publish source "${named.name}" from config`);
+    }
+  } else if (publishSources.length > 0) {
+    const first = publishSources[0];
+    src        = first.url;
+    awsProfile = awsProfile ?? first.profile;
+    token      = token      ?? first.token;
+    log.info(`upload-built: using first configured publish source "${first.name}"`);
+  }
+
+  if (!src) return null;
+  return { uploadSource: src, uploadAuth: { awsProfile, token } };
+}
+
+/**
+ * Create an empty accumulator for aggregated upload outcomes. Pass the
+ * returned object as `options.uploadStats` to `downloadDependencies`, then
+ * feed it to `formatUploadSummary()` at the end of the install.
+ *
+ * @returns {{ uploaded: Array<object>, skipped: Array<object>, failed: Array<object> }}
+ */
+function createUploadStats() {
+  return { uploaded: [], skipped: [], failed: [] };
+}
+
+/**
+ * Produce the one-line aggregated summary shown at the end of an install
+ * when `--upload-built` was passed. Returns null when nothing was attempted
+ * (so the caller can skip printing).
+ *
+ * @param {{ uploaded: Array, skipped: Array, failed: Array }} stats
+ * @returns {string|null}
+ */
+function formatUploadSummary(stats) {
+  if (!stats) return null;
+  const total = stats.uploaded.length + stats.skipped.length + stats.failed.length;
+  if (total === 0) return null;
+  const n = (arr, singular) => `${arr.length} ${singular}${arr.length === 1 ? '' : 's'}`;
+  return (
+    `upload-built summary: ${n(stats.uploaded, 'artefact')} uploaded, ` +
+    `${stats.skipped.length} skipped (already existed), ` +
+    `${stats.failed.length} failed`
+  );
+}
+
+module.exports = {
+  uploadSourceBuiltArtefact,
+  resolveUploadDestination,
+  createUploadStats,
+  formatUploadSummary,
+};