wyvrnpm 1.2.1 → 2.0.1

package/src/commands/install.js

@@ -1,109 +1,156 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { readManifest } = require('../manifest');
-const { resolveDependencies } = require('../resolve');
-const { downloadDependencies } = require('../download');
-const { readConfig } = require('../config');
-
-/**
- * Resolves and downloads all dependencies declared in the manifest, then writes
- * a wyvrn.lock file recording exactly what was installed.
- *
- * @param {object} argv - Parsed yargs arguments.
- * @param {string} argv.manifest - Path to wyvrn.json.
- * @param {string} argv.root - Project root directory.
- * @param {string[]} [argv.source] - One or more base URLs for package sources.
- * @param {string} argv.platform - Target platform string.
- * @param {number} argv.timeout - HTTP timeout in seconds.
- * @returns {Promise<void>}
- */
-async function install(argv) {
-  const manifestPath = path.resolve(argv.manifest);
-  const rootDir = path.resolve(argv.root);
-
-  // CLI --source takes priority; fall back to config installSources.
-  let packageSources;
-  if (argv.source && argv.source.length > 0) {
-    packageSources = argv.source;
-  } else {
-    const config = readConfig();
-    packageSources = config.installSources.map((s) => s.url);
-    if (packageSources.length > 0) {
-      console.log(`[wyvrn] Using ${packageSources.length} source(s) from config`);
-    }
-  }
-
-  if (packageSources.length === 0) {
-    console.warn(
-      '[wyvrn] Warning: no sources configured. ' +
-        'Pass --source <url> or run: wyvrnpm configure add-source --kind install ...',
-    );
-  }
-
-  const lockPath = path.join(path.dirname(manifestPath), 'wyvrn.lock');
-  const lockedVersions = new Map();
-  if (fs.existsSync(lockPath)) {
-    try {
-      const lock = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
-      for (const [name, version] of Object.entries(lock.packages || {})) {
-        lockedVersions.set(name, version);
-      }
-      console.log(`[wyvrn] Lock file found — ${lockedVersions.size} pinned package(s)`);
-    } catch {
-      console.warn('[wyvrn] Warning: could not read wyvrn.lock, resolving from scratch');
-    }
-  }
-
-  const manifest = readManifest(manifestPath);
-
-  // Normalize dependencies: support both array [{ Name, Version }] and object { name: version }.
-  const rawDeps = manifest.dependencies || manifest.Dependencies || {};
-  const rootDeps = Array.isArray(rawDeps)
-    ? Object.fromEntries(rawDeps.map((d) => [d.Name ?? d.name, d.Version ?? d.version]))
-    : rawDeps;
-
-  console.log(
-    `[wyvrn] Installing dependencies for "${manifest.name}" (platform: ${argv.platform})`,
-  );
-
-  const resolvedDeps = await resolveDependencies(
-    rootDeps,
-    packageSources,
-    argv.platform,
-    fetch,
-    lockedVersions,
-  );
-
-  const razerDir = path.join(rootDir, 'wyvrn_internal');
-
-  await downloadDependencies(
-    resolvedDeps,
-    packageSources,
-    argv.platform,
-    razerDir,
-    fetch,
-    argv.timeout,
-  );
-
-  // Build lock file — packages sorted alphabetically for deterministic diffs.
-  const sortedPackages = {};
-  for (const key of [...resolvedDeps.keys()].sort()) {
-    sortedPackages[key] = resolvedDeps.get(key);
-  }
-
-  const lockData = {
-    generatedAt: new Date().toISOString(),
-    platform: argv.platform,
-    packages: sortedPackages,
-  };
-
-  fs.writeFileSync(lockPath, JSON.stringify(lockData, null, 2) + '\n', 'utf8');
-  console.log(`[wyvrn] Lock file written to ${lockPath}`);
-
-  const count = resolvedDeps.size;
-  console.log(`[wyvrn] Done — ${count} package${count !== 1 ? 's' : ''} installed.`);
-}
-
-module.exports = install;
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const { readManifest, normalizeDependencies }               = require('../manifest');
+const { resolveDependencies }                               = require('../resolve');
+const { downloadDependencies }                              = require('../download');
+const { readConfig }                                        = require('../config');
+const { loadProfile, hashProfile, formatProfile, mergeProfile } = require('../profile');
+
+/**
+ * Resolves and downloads all dependencies declared in the manifest, then writes
+ * a wyvrn.lock file recording exactly what was installed.
+ *
+ * v2 behaviour:
+ *  - Loads the named build profile (--profile flag → config.defaultProfile → "default")
+ *  - Each dependency can override individual profile settings via its `settings` field
+ *  - Lock file records the full profile + per-package SHA256, profileHash, and git metadata
+ *
+ * @param {object} argv
+ */
+async function install(argv) {
+  const manifestPath = path.resolve(argv.manifest);
+  const rootDir      = path.resolve(argv.root);
+
+  // ── Auth / sources ────────────────────────────────────────────────────────
+  let packageSources;
+  if (argv.source && argv.source.length > 0) {
+    packageSources = argv.source;
+  } else {
+    const config   = readConfig();
+    packageSources = config.installSources.map((s) => s.url);
+    if (packageSources.length > 0) {
+      console.log(`[wyvrn] Using ${packageSources.length} source(s) from config`);
+    }
+  }
+
+  if (packageSources.length === 0) {
+    console.warn(
+      '[wyvrn] Warning: no sources configured. ' +
+        'Pass --source <url> or run: wyvrnpm configure add-source --kind install ...',
+    );
+  }
+
+  // ── Active build profile ──────────────────────────────────────────────────
+  const config          = readConfig();
+  const profileName     = argv.profile ?? config.defaultProfile ?? 'default';
+  const { profile: baseProfile, fromFile } = loadProfile(profileName);
+
+  console.log(`[wyvrn] Profile: "${profileName}"${fromFile ? '' : ' (auto-detected)'}`);
+  console.log(formatProfile(baseProfile).split('\n').map((l) => `  ${l}`).join('\n'));
+  console.log(`  Profile hash : ${hashProfile(baseProfile)}`);
+
+  // ── Lock file ─────────────────────────────────────────────────────────────
+  const lockPath       = path.join(path.dirname(manifestPath), 'wyvrn.lock');
+  const lockedVersions = new Map();
+
+  if (fs.existsSync(lockPath)) {
+    try {
+      const lock = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+      for (const [name, entry] of Object.entries(lock.packages ?? {})) {
+        const ver = typeof entry === 'string' ? entry : entry.version;
+        if (ver) lockedVersions.set(name, ver);
+      }
+      console.log(`[wyvrn] Lock file found — ${lockedVersions.size} pinned package(s)`);
+    } catch {
+      console.warn('[wyvrn] Warning: could not read wyvrn.lock, resolving from scratch');
+    }
+  }
+
+  // ── Read manifest ─────────────────────────────────────────────────────────
+  const manifest = readManifest(manifestPath);
+
+  // Normalize to { name: { version, settings } }
+  const normalizedDeps = normalizeDependencies(manifest.dependencies ?? manifest.Dependencies);
+
+  // For resolution, only pass name → version (settings don't affect resolution)
+  const depsForResolution = Object.fromEntries(
+    Object.entries(normalizedDeps).map(([name, d]) => [name, d.version]),
+  );
+
+  console.log(
+    `[wyvrn] Installing dependencies for "${manifest.name}" (platform: ${argv.platform})`,
+  );
+
+  const resolvedDeps = await resolveDependencies(
+    depsForResolution,
+    packageSources,
+    argv.platform,
+    fetch,
+    lockedVersions,
+  );
+
+  // ── Build per-dependency enriched map ─────────────────────────────────────
+  // Each dep gets a profileHash based on base profile + any settings overrides
+  // declared in wyvrn.json under that dependency's "settings" key.
+  const enrichedDeps = new Map();
+  for (const [name, version] of resolvedDeps) {
+    const depOverrides    = normalizedDeps[name]?.settings ?? {};
+    const effectiveProfile = mergeProfile(baseProfile, depOverrides);
+    const profileHash      = hashProfile(effectiveProfile);
+
+    if (Object.keys(depOverrides).length > 0) {
+      console.log(
+        `[wyvrn] ${name}: settings override → profileHash ${profileHash}` +
+        ` (${JSON.stringify(depOverrides)})`,
+      );
+    }
+
+    enrichedDeps.set(name, { version, profileHash, profile: effectiveProfile });
+  }
+
+  const razerDir = path.join(rootDir, 'wyvrn_internal');
+
+  // Extract auth from the first install source (if any)
+  const firstInstallSrc = config.installSources?.[0];
+  const authOptions = {
+    awsProfile: firstInstallSrc?.profile ?? undefined,
+    token:      firstInstallSrc?.token   ?? undefined,
+  };
+
+  const lockEntries = await downloadDependencies(
+    enrichedDeps,
+    packageSources,
+    argv.platform,
+    razerDir,
+    fetch,
+    argv.timeout,
+    authOptions,
+  );
+
+  // ── Write v2 lock file ────────────────────────────────────────────────────
+  const sortedPackages = {};
+  for (const key of [...resolvedDeps.keys()].sort()) {
+    sortedPackages[key] = lockEntries?.get(key) ?? { version: resolvedDeps.get(key) };
+  }
+
+  const lockData = {
+    wyvrnVersion: 2,
+    generatedAt:  new Date().toISOString(),
+    platform:     argv.platform,
+    profileName,
+    profile:      baseProfile,
+    profileHash:  hashProfile(baseProfile),
+    packages:     sortedPackages,
+  };
+
+  fs.writeFileSync(lockPath, JSON.stringify(lockData, null, 2) + '\n', 'utf8');
+  console.log(`[wyvrn] Lock file written to ${lockPath}`);
+
+  const count = resolvedDeps.size;
+  console.log(`[wyvrn] Done — ${count} package${count !== 1 ? 's' : ''} installed.`);
+}
+
+module.exports = install;

package/src/commands/link.js

@@ -0,0 +1,316 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { readConfig, writeConfig } = require('../config');
+const { readManifest } = require('../manifest');
+const { createLink, isLink, removeLink, getLinkTarget } = require('../link-utils');
+const { downloadDependencies } = require('../download');
+const { resolveDependencies } = require('../resolve');
+
+/**
+ * Normalizes a linked package entry to object form.
+ * Supports both legacy string format and new object format.
+ *
+ * @param {string|object} entry - Either a path string or {path, subdir} object.
+ * @returns {{path: string, subdir?: string}}
+ */
+function normalizeLinkedEntry(entry) {
+  if (typeof entry === 'string') {
+    return { path: entry };
+  }
+  return entry;
+}
+
+/**
+ * Gets the effective link target path (combining path + subdir).
+ *
+ * @param {{path: string, subdir?: string}} entry - Linked package entry.
+ * @returns {string} The full path to link to.
+ */
+function getEffectivePath(entry) {
+  if (entry.subdir) {
+    return path.join(entry.path, entry.subdir);
+  }
+  return entry.path;
+}
+
+/**
+ * Register the current directory's package globally for linking.
+ * Reads wyvrn.json to get the package name, stores {name: {path, subdir}} in config.
+ *
+ * @param {string} manifestPath - Path to wyvrn.json
+ * @param {string} [subdir] - Optional subdirectory within the package to link.
+ */
+function registerGlobal(manifestPath, subdir) {
+  const manifest = readManifest(manifestPath);
+  const packageName = manifest.name || manifest.Name;
+
+  if (!packageName) {
+    console.error('[wyvrn] Error: wyvrn.json must have a "name" field');
+    process.exit(1);
+  }
+
+  const packagePath = path.dirname(path.resolve(manifestPath));
+  const config = readConfig();
+  config.linkedPackages = config.linkedPackages || {};
+
+  const entry = { path: packagePath };
+  if (subdir) {
+    entry.subdir = subdir;
+  }
+  config.linkedPackages[packageName] = entry;
+  writeConfig(config);
+
+  const effectivePath = getEffectivePath(entry);
+  console.log(`[wyvrn] Registered "${packageName}" → ${effectivePath}`);
+}
+
+/**
+ * Link a package into the current project's wyvrn_internal directory.
+ *
+ * @param {string} name - Package name to link.
+ * @param {string} sourcePath - Source directory path (absolute or relative).
+ * @param {string} rootDir - Project root directory.
+ */
+function linkToProject(name, sourcePath, rootDir) {
+  const absoluteSource = path.resolve(sourcePath);
+
+  if (!fs.existsSync(absoluteSource)) {
+    console.error(`[wyvrn] Error: source path does not exist: ${absoluteSource}`);
+    process.exit(1);
+  }
+
+  const razerDir = path.join(rootDir, 'wyvrn_internal');
+  const linkPath = path.join(razerDir, name);
+
+  // Create the link
+  createLink(absoluteSource, linkPath);
+
+  // Write a .wyvrn-version file to indicate it's linked
+  const versionFile = path.join(linkPath, '.wyvrn-version');
+  fs.writeFileSync(versionFile, 'linked', 'utf8');
+
+  // Update the lock file to record the link
+  const lockPath = path.join(rootDir, 'wyvrn.lock');
+  let lockData = { packages: {} };
+  if (fs.existsSync(lockPath)) {
+    try {
+      lockData = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+    } catch {
+      // Use default if parsing fails
+    }
+  }
+  lockData.packages = lockData.packages || {};
+  lockData.packages[name] = `linked:${absoluteSource}`;
+  lockData.generatedAt = new Date().toISOString();
+  fs.writeFileSync(lockPath, JSON.stringify(lockData, null, 2) + '\n', 'utf8');
+
+  console.log(`[wyvrn] Linked: ${name} → ${absoluteSource}`);
+}
+
+/**
+ * Unlink a package from the current project.
+ *
+ * @param {string} name - Package name to unlink.
+ * @param {string} rootDir - Project root directory.
+ * @param {boolean} restore - Whether to re-download from registry.
+ * @param {object} argv - Original argv for re-download options.
+ */
+async function unlinkFromProject(name, rootDir, restore, argv) {
+  const razerDir = path.join(rootDir, 'wyvrn_internal');
+  const linkPath = path.join(razerDir, name);
+
+  if (!fs.existsSync(linkPath)) {
+    console.error(`[wyvrn] Error: package "${name}" is not installed`);
+    process.exit(1);
+  }
+
+  if (!isLink(linkPath)) {
+    console.error(`[wyvrn] Error: package "${name}" is not a linked package`);
+    process.exit(1);
+  }
+
+  // Remove the symlink
+  removeLink(linkPath);
+  console.log(`[wyvrn] Unlinked: ${name}`);
+
+  // Update the lock file
+  const lockPath = path.join(rootDir, 'wyvrn.lock');
+  if (fs.existsSync(lockPath)) {
+    try {
+      const lockData = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+      if (lockData.packages && lockData.packages[name]) {
+        delete lockData.packages[name];
+        lockData.generatedAt = new Date().toISOString();
+        fs.writeFileSync(lockPath, JSON.stringify(lockData, null, 2) + '\n', 'utf8');
+      }
+    } catch {
+      // Ignore lock file errors
+    }
+  }
+
+  // Re-download from registry if requested
+  if (restore) {
+    const manifestPath = path.resolve(argv.manifest);
+    const manifest = readManifest(manifestPath);
+
+    const rawDeps = manifest.dependencies || manifest.Dependencies || {};
+    const deps = Array.isArray(rawDeps)
+      ? Object.fromEntries(rawDeps.map((d) => [d.Name ?? d.name, d.Version ?? d.version]))
+      : rawDeps;
+
+    if (!deps[name]) {
+      console.warn(`[wyvrn] Warning: "${name}" is not in manifest dependencies, cannot restore`);
+      return;
+    }
+
+    // Get package sources
+    let packageSources;
+    if (argv.source && argv.source.length > 0) {
+      packageSources = argv.source;
+    } else {
+      const config = readConfig();
+      packageSources = config.installSources.map((s) => s.url);
+    }
+
+    if (packageSources.length === 0) {
+      console.warn('[wyvrn] Warning: no sources configured, cannot restore package');
+      return;
+    }
+
+    // Resolve just this one dependency
+    const resolvedDeps = await resolveDependencies(
+      { [name]: deps[name] },
+      packageSources,
+      argv.platform || 'win_x64',
+      fetch,
+      new Map(),
+    );
+
+    // Download it
+    await downloadDependencies(
+      resolvedDeps,
+      packageSources,
+      argv.platform || 'win_x64',
+      razerDir,
+      fetch,
+      argv.timeout || 300,
+    );
+
+    // Update lock file with restored version
+    if (fs.existsSync(lockPath)) {
+      try {
+        const lockData = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+        for (const [depName, version] of resolvedDeps) {
+          lockData.packages[depName] = version;
+        }
+        lockData.generatedAt = new Date().toISOString();
+        fs.writeFileSync(lockPath, JSON.stringify(lockData, null, 2) + '\n', 'utf8');
+      } catch {
+        // Ignore lock file errors
+      }
+    }
+  }
+}
+
+/**
+ * List all globally registered packages.
+ */
+function listLinked() {
+  const config = readConfig();
+  const linked = config.linkedPackages || {};
+  const entries = Object.entries(linked);
+
+  if (entries.length === 0) {
+    console.log('[wyvrn] No globally registered packages');
+    return;
+  }
+
+  console.log('[wyvrn] Globally registered packages:');
+  for (const [name, rawEntry] of entries) {
+    const entry = normalizeLinkedEntry(rawEntry);
+    const effectivePath = getEffectivePath(entry);
+    const exists = fs.existsSync(effectivePath);
+    const status = exists ? '' : ' (path not found)';
+    const subdirInfo = entry.subdir ? ` [subdir: ${entry.subdir}]` : '';
+    console.log(`  ${name} → ${effectivePath}${subdirInfo}${status}`);
+  }
+}
+
+/**
+ * Main link command handler.
+ *
+ * @param {object} argv - Parsed yargs arguments.
+ */
+async function link(argv) {
+  const rootDir = path.resolve(argv.root);
+  const manifestPath = path.resolve(argv.manifest);
+
+  // wyvrnpm link --list
+  if (argv.list) {
+    listLinked();
+    return;
+  }
+
+  // wyvrnpm link (no args) - register current package globally
+  if (!argv.name) {
+    if (!fs.existsSync(manifestPath)) {
+      console.error(`[wyvrn] Error: no wyvrn.json found at ${manifestPath}`);
+      process.exit(1);
+    }
+    registerGlobal(manifestPath, argv.subdir);
+    return;
+  }
+
+  // wyvrnpm link <name> <path> - direct path link
+  if (argv.name && argv.path) {
+    let targetPath = argv.path;
+    if (argv.subdir) {
+      targetPath = path.join(argv.path, argv.subdir);
+    }
+    linkToProject(argv.name, targetPath, rootDir);
+    return;
+  }
+
+  // wyvrnpm link <name> - link from global registry
+  const config = readConfig();
+  const linked = config.linkedPackages || {};
+
+  if (!linked[argv.name]) {
+    console.error(`[wyvrn] Error: "${argv.name}" is not registered globally`);
+    console.error('[wyvrn] Run "wyvrnpm link" in the package directory first, or use:');
+    console.error(`[wyvrn]   wyvrnpm link ${argv.name} <path>`);
+    process.exit(1);
+  }
+
+  const entry = normalizeLinkedEntry(linked[argv.name]);
+  // Command-line --subdir overrides the registered subdir
+  let effectivePath;
+  if (argv.subdir) {
+    effectivePath = path.join(entry.path, argv.subdir);
+  } else {
+    effectivePath = getEffectivePath(entry);
+  }
+
+  linkToProject(argv.name, effectivePath, rootDir);
+}
+
+/**
+ * Unlink command handler.
+ *
+ * @param {object} argv - Parsed yargs arguments.
+ */
+async function unlink(argv) {
+  const rootDir = path.resolve(argv.root);
+  await unlinkFromProject(argv.name, rootDir, argv.restore, argv);
+}
+
+module.exports = {
+  link,
+  unlink,
+  listLinked,
+  registerGlobal,
+  linkToProject,
+  unlinkFromProject,
+};