novac 2.2.0 → 2.2.2

package/novac/bin/nvc

@@ -1,522 +0,0 @@
-#!/usr/bin/env node
-// nvc — novac global binary: native addon kit generator
-//
-// Usage:
-//   nvc natives --name myaddon --sources win32:src/addon_win.cpp linux-x64:src/addon_lnx.cpp darwin:src/addon_mac.cpp
-//
-// Output:
-//   nkitmyaddon/
-//     bins/                        ← compiled .node binaries per platform/arch
-//     src/                         ← copied source files
-//     CMakeLists.txt               ← auto-generated (no binding.gyp — node-gyp is never used)
-//     kitdef.js                    ← runtime loader (sniffs platform+arch)
-//     unsupported.cpp              ← auto-generated stub for missing targets
-//     build.js                     ← the build orchestrator (cmake-js → cmake → manual gcc/clang)
-
-'use strict';
-
-const fs       = require('fs');
-const path     = require('path');
-const os       = require('os');
-const { execSync, spawnSync } = require('child_process');
-
-// ─── CONSTANTS ────────────────────────────────────────────────────────────────
-
-const SUPPORTED_PLATFORMS = ['win32', 'linux', 'darwin', 'android', 'freebsd', 'openbsd'];
-const SUPPORTED_ARCHS     = ['x64', 'x86', 'arm64', 'arm', 'ia32', 'riscv64', 'mips'];
-
-// Node-API version to target (stable across Node 12+)
-const NAPI_VERSION = 6;
-
-// ─── HELPERS ─────────────────────────────────────────────────────────────────
-
-function run(cmd, cwd, silent = false) {
-  const result = spawnSync(cmd, { shell: true, cwd, stdio: silent ? 'pipe' : 'inherit' });
-  return result.status === 0;
-}
-
-function has(cmd) {
-  const r = spawnSync(cmd, ['--version'], { shell: true, stdio: 'pipe' });
-  return r.status === 0;
-}
-
-function mkdir(p) {
-  fs.mkdirSync(p, { recursive: true });
-}
-
-function write(p, content) {
-  fs.writeFileSync(p, content, 'utf8');
-}
-
-function copy(src, dest) {
-  fs.copyFileSync(src, dest);
-}
-
-// Parse "platform-arch:path" or "platform:path" source specs
-// e.g. "linux-x64:src/addon.cpp"  "win32:src/win.cpp"  "darwin-arm64:src/mac.cpp"
-function parseSourceSpec(spec) {
-  const colon = spec.indexOf(':');
-  if (colon === -1) throw new Error(`Invalid source spec (missing ':'): ${spec}`);
-  const tag  = spec.slice(0, colon).trim();
-  const file = spec.slice(colon + 1).trim();
-  const dash = tag.indexOf('-');
-  let platform, arch;
-  if (dash === -1) {
-    platform = tag;
-    arch     = '*'; // any arch for this platform
-  } else {
-    platform = tag.slice(0, dash);
-    arch     = tag.slice(dash + 1);
-  }
-  return { platform, arch, file };
-}
-
-// Canonical binary name: addon-linux-x64.node
-function binName(kitName, platform, arch) {
-  return `${kitName}-${platform}-${arch}.node`;
-}
-
-// ─── CODE GENERATORS ─────────────────────────────────────────────────────────
-
-function genCMakeLists(kitName, srcFile, napiVersion) {
-  // Resolve paths at generation time — avoids CMake execute_process quoting bugs on all platforms
-  const { execSync: _exec } = require('child_process');
-  let nodeInclude = '';
-  let napiInclude = '';
-  let nodeBinDir  = '';
-
-  try {
-    const _p = require('path');
-    nodeInclude = _p.join(_p.dirname(process.execPath), '..', 'include', 'node');
-  } catch(_) {}
-  // napi include: always use the local node_modules path — node-addon-api isn't
-  // installed globally, it gets installed by npm install inside the kit folder.
-  // CMakeLists.txt is generated before that happens, so we hardcode the relative path.
-  napiInclude = '${CMAKE_SOURCE_DIR}/node_modules/node-addon-api';
-  try {
-    nodeBinDir = require('path').dirname(process.execPath);
-  } catch(_) {}
-
-  return `cmake_minimum_required(VERSION 3.15)
-project(${kitName})
-
-set(CMAKE_CXX_STANDARD 17)
-
-# Paths baked in at kit-generation time by nvc (no runtime execute_process needed)
-set(NODE_INCLUDE_DIR "${nodeInclude}")
-set(NAPI_INCLUDE     "${napiInclude}")
-set(NODE_BIN_DIR     "${nodeBinDir}")
-
-add_library(\${PROJECT_NAME} SHARED ${srcFile})
-set_target_properties(\${PROJECT_NAME} PROPERTIES PREFIX "" SUFFIX ".node")
-
-target_include_directories(\${PROJECT_NAME} PRIVATE
-  \${NODE_INCLUDE_DIR}
-  \${NAPI_INCLUDE}
-)
-
-target_compile_definitions(\${PROJECT_NAME} PRIVATE
-  NAPI_VERSION=${napiVersion}
-  NAPI_DISABLE_CPP_EXCEPTIONS
-)
-
-if(WIN32)
-  target_link_libraries(\${PROJECT_NAME} "\${NODE_BIN_DIR}/node.lib")
-elseif(APPLE)
-  set_target_properties(\${PROJECT_NAME} PROPERTIES
-    LINK_FLAGS "-undefined dynamic_lookup"
-  )
-endif()
-`;
-}
-
-
-function genUnsupportedStub(kitName) {
-  return `// Auto-generated unsupported-arch stub for ${kitName}
-#include <node_api.h>
-#include <stdio.h>
-
-napi_value Init(napi_env env, napi_value exports) {
-  const char* arch =
-#if defined(__x86_64__) || defined(_M_X64)
-    "x64";
-#elif defined(__i386__) || defined(_M_IX86)
-    "x86";
-#elif defined(__aarch64__) || defined(_M_ARM64)
-    "arm64";
-#elif defined(__arm__) || defined(_M_ARM)
-    "arm";
-#elif defined(__riscv) && __riscv_xlen == 64
-    "riscv64";
-#else
-    "unknown";
-#endif
-
-  const char* plat =
-#if defined(_WIN32)
-    "win32";
-#elif defined(__APPLE__)
-    "darwin";
-#elif defined(__ANDROID__)
-    "android";
-#elif defined(__linux__)
-    "linux";
-#elif defined(__FreeBSD__)
-    "freebsd";
-#else
-    "unknown";
-#endif
-
-  fprintf(stderr, "\\n[${kitName}] This native addon does not support your platform: %s-%s\\n", plat, arch);
-  fprintf(stderr, "  Please check https://your-project/nkit${kitName} for supported targets.\\n\\n");
-
-  napi_throw_error(env, "UNSUPPORTED_PLATFORM",
-    "This native addon does not support your current platform/architecture.");
-  return exports;
-}
-
-NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
-`;
-}
-
-function genKitdef(kitName, sources) {
-  const entries = sources.map(s => {
-    const archClause = s.arch === '*'
-      ? `platform === '${s.platform}'`
-      : `platform === '${s.platform}' && arch === '${s.arch}'`;
-    return `  if (${archClause}) return require('./bins/${binName(kitName, s.platform, s.arch === '*' ? 'universal' : s.arch)}');`;
-  });
-
-  return `// kitdef.js — auto-generated by kitnatives for ${kitName}
-// Do not edit manually; re-run kitnatives to regenerate.
-
-'use strict';
-
-const path     = require('path');
-const platform = process.platform;
-const arch     = process.arch;
-
-function loadAddon() {
-${entries.join('\n')}
-
-  // Fallback: unsupported platform/arch
-  try {
-    return require('./bins/${kitName}-unsupported.node');
-  } catch (_) {
-    throw new Error(
-      \`[${kitName}] Unsupported platform: \${platform}-\${arch}. \` +
-      \`No native binary available for this target.\`
-    );
-  }
-}
-
-const addon = loadAddon();
-
-module.exports = {
-  kitdef: addon
-};
-`;
-}
-
-function genBuildScript(kitName, sources, outDir) {
-  const builds = sources.map((s, i) => {
-    const bname  = binName(kitName, s.platform, s.arch === '*' ? 'universal' : s.arch);
-    const srcRel = path.basename(s.file);
-    return `
-// ── Build ${i + 1}: ${s.platform}-${s.arch} ──────────────────────────────────
-{
-  const srcFile = path.join(__dirname, 'src', '${srcRel}');
-  const outBin  = path.join(__dirname, 'bins', '${bname}');
-  const cmake   = path.join(__dirname, 'cmake_build_${i}');
-
-  console.log('[kitnatives] Building ${s.platform}-${s.arch}...');
-
-  if (fs.existsSync(outBin)) {
-    console.log('  → Already built, skipping.');
-  } else {
-    let built = false;
-
-    // Strategy 1: cmake-js (explicitly told to use CMake, never gyp)
-    if (!built && hasTool('cmake-js')) {
-      console.log('  → Trying cmake-js...');
-      fs.mkdirSync(cmake, { recursive: true });
-      // Pass --cmake-options to avoid any gyp fallback; point at our CMakeLists.txt
-      const r = run(
-        \`cmake-js compile --runtime node --cmake-options="-DCMAKE_BUILD_TYPE=Release" --directory "\${__dirname}" --out "\${cmake}"\`,
-        __dirname
-      );
-      if (r) {
-        const nodeFile = findNodeFile(cmake);
-        if (nodeFile) { fs.copyFileSync(nodeFile, outBin); built = true; }
-      }
-    }
-
-    // Strategy 2: cmake manually
-    if (!built && hasTool('cmake')) {
-      console.log('  → Trying cmake...');
-      fs.mkdirSync(cmake, { recursive: true });
-      const r1 = run(\`cmake .. -DSRC_FILE="${srcRel}" -DKIT_NAME="${kitName}"\`, cmake);
-      const r2 = r1 && run('cmake --build . --config Release', cmake);
-      if (r2) {
-        const nodeFile = findNodeFile(cmake);
-        if (nodeFile) { fs.copyFileSync(nodeFile, outBin); built = true; }
-      }
-    }
-
-    // Strategy 3: raw gcc/clang
-    if (!built) {
-      console.log('  → Trying manual gcc/clang compile...');
-      const compiler = hasTool('clang++') ? 'clang++' : hasTool('g++') ? 'g++' : null;
-      if (compiler) {
-        // Resolve include paths at build time
-        let nodeHead = '', napiHead = '';
-        try { const _p = require('path'); nodeHead = _p.join(_p.dirname(process.execPath), '..', 'include', 'node'); } catch(_) {}
-        napiHead = require('path').join(__dirname, 'node_modules', 'node-addon-api');
-        const isAndroid = process.platform === 'android' || process.env.TERMUX_VERSION;
-        const sharedFlag = isAndroid ? '-shared' : process.platform === 'darwin' ? '-dynamiclib' : '-shared';
-        const extraFlags = process.platform === 'darwin' ? '-undefined dynamic_lookup' : '';
-        const flags = [
-          sharedFlag, '-fPIC', extraFlags,
-          nodeHead   ? \`-I"\${nodeHead}"\` : '',
-          napiHead   ? \`-I"\${napiHead}"\` : '',
-          \`-DNAPI_VERSION=${NAPI_VERSION}\`,
-          '-DNAPI_DISABLE_CPP_EXCEPTIONS',
-          '-std=c++17',
-          \`"\${srcFile}"\`,
-          \`-o "\${outBin}"\`
-        ].filter(Boolean).join(' ');
-        const r = run(\`\${compiler} \${flags}\`, __dirname);
-        if (r) built = true;
-      }
-    }
-
-    if (!built) {
-      console.warn(\`  ✗ Could not build ${s.platform}-${s.arch}. Skipping.\`);
-    } else {
-      console.log(\`  ✓ Built → bins/${bname}\`);
-    }
-  }
-}`;
-  });
-
-  return `#!/usr/bin/env node
-// build.js — auto-generated by kitnatives for ${kitName}
-// Run this to compile all native targets.
-
-'use strict';
-
-const fs        = require('fs');
-const path      = require('path');
-const { execSync, spawnSync } = require('child_process');
-
-function run(cmd, cwd) {
-  const r = spawnSync(cmd, { shell: true, cwd: cwd || __dirname, stdio: 'inherit' });
-  return r.status === 0;
-}
-
-function hasTool(name) {
-  const r = spawnSync(name, ['--version'], { shell: true, stdio: 'pipe' });
-  return r.status === 0;
-}
-
-function findNodeFile(dir) {
-  if (!fs.existsSync(dir)) return null;
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-  for (const e of entries) {
-    const full = path.join(dir, e.name);
-    if (e.isDirectory()) { const r = findNodeFile(full); if (r) return r; }
-    else if (e.name.endsWith('.node')) return full;
-  }
-  return null;
-}
-
-fs.mkdirSync(path.join(__dirname, 'bins'), { recursive: true });
-
-${builds.join('\n')}
-
-// Build unsupported stub
-{
-  const stubSrc = path.join(__dirname, 'src', 'unsupported.cpp');
-  const stubOut = path.join(__dirname, 'bins', '${kitName}-unsupported.node');
-  if (!fs.existsSync(stubOut)) {
-    console.log('[kitnatives] Building unsupported-arch stub...');
-    const compiler = hasTool('clang++') ? 'clang++' : hasTool('g++') ? 'g++' : null;
-    if (compiler) {
-      const _p = require('path');
-      const nodeHead = _p.join(_p.dirname(process.execPath), '..', 'include', 'node');
-      const flags = [
-        '-shared', '-fPIC', '-undefined dynamic_lookup',
-        \`-I"\${nodeHead}"\`,
-        \`-DNAPI_VERSION=${NAPI_VERSION}\`,
-        '-std=c++17',
-        \`"\${stubSrc}"\`,
-        \`-o "\${stubOut}"\`
-      ].join(' ');
-      if (run(\`\${compiler} \${flags}\`, __dirname)) {
-        console.log('  ✓ Built unsupported stub');
-      }
-    } else {
-      console.warn('  ✗ No compiler found for stub. Missing-arch errors will throw JS exceptions.');
-    }
-  }
-}
-
-console.log('\\n[kitnatives] Build complete.');
-`;
-}
-
-// ─── MAIN GENERATOR ──────────────────────────────────────────────────────────
-
-function generate(opts) {
-  const { name, sources, outBase } = opts;
-
-  if (!name)              throw new Error('--name is required');
-  if (!sources?.length)   throw new Error('--sources is required (at least one platform:file)');
-
-  const kitName = name;
-  const outDir  = path.resolve(outBase ?? '.', `nkit${kitName}`);
-
-  const srcDir  = path.join(outDir, 'src');
-  const binDir  = path.join(outDir, 'bins');
-
-  mkdir(outDir);
-  mkdir(srcDir);
-  mkdir(binDir);
-
-  const parsedSources = sources.map(parseSourceSpec);
-
-  // Copy source files into src/
-  for (const s of parsedSources) {
-    const dest = path.join(srcDir, path.basename(s.file));
-    if (fs.existsSync(s.file)) {
-      copy(s.file, dest);
-    } else {
-      // Create a placeholder if the file doesn't exist yet
-      write(dest, `// Placeholder for ${s.file} (file not found during generation)\n`);
-      console.warn(`[kitnatives] Warning: source file not found: ${s.file} — placeholder written`);
-    }
-  }
-
-  // Write unsupported stub
-  write(path.join(srcDir, 'unsupported.cpp'), genUnsupportedStub(kitName));
-
-  // Write CMakeLists.txt (no binding.gyp — node-gyp is never used)
-  const primarySrc = path.basename(parsedSources[0].file);
-  write(path.join(outDir, 'CMakeLists.txt'), genCMakeLists(kitName, `src/${primarySrc}`, NAPI_VERSION));
-
-  // Write kitdef.js
-  write(path.join(outDir, 'kitdef.js'), genKitdef(kitName, parsedSources));
-
-  // Write build.js
-  write(path.join(outDir, 'build.js'), genBuildScript(kitName, parsedSources, outDir));
-  try { fs.chmodSync(path.join(outDir, 'build.js'), 0o755); } catch (_) {}
-
-  // Write package.json
-  write(path.join(outDir, 'package.json'), JSON.stringify({
-    name:    `nkit${kitName}`,
-    version: '1.0.0',
-    main:    'kitdef.js',
-    scripts: {
-      build: 'node build.js'
-    },
-    dependencies: {
-      'node-addon-api': '^7.0.0'
-    },
-    description: `Native addon kit for ${kitName} (generated by kitnatives)`
-  }, null, 2));
-
-  // Write README
-  write(path.join(outDir, 'README.md'), `# nkit${kitName}
-
-Native addon kit generated by **kitnatives**.
-
-## Building
-
-\`\`\`sh
-npm install        # installs node-addon-api headers
-node build.js      # compiles all targets
-\`\`\`
-
-The build script tries three strategies in order:
-1. **cmake-js** — if available globally
-2. **cmake** — manual configure + build
-3. **gcc/clang** — raw compiler invocation with manual flags
-
-If none succeed for a target, a warning is printed and that target is skipped.
-A fallback \`unsupported.node\` stub is always compiled; it prints a descriptive
-error message and throws if loaded on an unsupported platform.
-
-## Supported targets
-
-| Platform | Arch | Source |
-|----------|------|--------|
-${parsedSources.map(s => `| ${s.platform} | ${s.arch} | \`src/${path.basename(s.file)}\` |`).join('\n')}
-
-## Usage
-
-\`\`\`js
-const { kitdef } = require('./kitdef.js');
-// kitdef === your addon's exports for this platform
-\`\`\`
-`);
-
-  console.log(`\n[nvc] Generated nkit${kitName} at: ${outDir}`);
-  console.log(`  src/           ← your C/C++ sources`);
-  console.log(`  bins/          ← compiled .node binaries (after build.js)`);
-  console.log(`  CMakeLists.txt ← cmake build (no node-gyp, no binding.gyp)`);
-  console.log(`  kitdef.js      ← runtime loader`);
-  console.log(`  build.js       ← build orchestrator`);
-  console.log(`\nNext: cd nkit${kitName} && npm install && node build.js\n`);
-
-  return outDir;
-}
-
-// ─── CLI ─────────────────────────────────────────────────────────────────────
-
-function parseCLI(argv) {
-  const args = argv.slice(2);
-  const opts = { sources: [] };
-
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--name')    { opts.name    = args[++i]; }
-    else if (args[i] === '--out')     { opts.outBase = args[++i]; }
-    else if (args[i] === '--sources') {
-      while (args[i + 1] && !args[i + 1].startsWith('--')) {
-        opts.sources.push(args[++i]);
-      }
-    }
-  }
-  return opts;
-}
-
-if (require.main === module) {
-  const opts = parseCLI(process.argv);
-  try {
-    generate(opts);
-  } catch (e) {
-    console.error('[nvc] Error:', e.message);
-    console.error('\nUsage:');
-    console.error('  nvc natives --name <kitname> --sources <platform[-arch]>:<file> ...\n');
-    console.error('Examples:');
-    console.error('  nvc natives --name myaddon --sources linux-x64:src/addon.cpp darwin-arm64:src/addon_mac.cpp win32:src/addon_win.cpp');
-    console.error('  nvc natives --name myaddon --sources linux:src/addon.cpp   # any arch on linux');
-    process.exit(1);
-  }
-}
-
-// ─── EXPORTS ─────────────────────────────────────────────────────────────────
-
-module.exports = {
-  kitdef: {
-    generate,
-    parseSourceSpec,
-    binName,
-    genCMakeLists,
-    genUnsupportedStub,
-    genKitdef,
-    genBuildScript,
-    SUPPORTED_PLATFORMS,
-    SUPPORTED_ARCHS,
-    NAPI_VERSION,
-  }
-};