seabox 0.2.0 → 0.3.0

package/bin/seabox-rebuild.mjs

@@ -16,15 +16,16 @@ const __dirname = path.dirname(__filename);
 /**
  * Rebuild a native module for a specific target
  * @param {string} modulePath - Path to the native module
+ * @param {string} nodeVersion - Target Node.js version (e.g., "24.13.0")
  * @param {string} platform - Target platform (win32, linux, darwin)
  * @param {string} arch - Target architecture (x64, arm64)
  * @param {boolean} verbose - Enable verbose logging
  */
-function rebuildNativeModule(modulePath, platform, arch, verbose = false) {
+function rebuildNativeModule(modulePath, nodeVersion, platform, arch, verbose = false) {
   diag.setVerbose(verbose);
   
   diag.verbose(`Rebuilding native module: ${modulePath}`);
-  diag.verbose(`Target: ${platform}-${arch}`);
+  diag.verbose(`Target: Node.js ${nodeVersion} ${platform}-${arch}`);
 
   const packageJsonPath = path.join(modulePath, 'package.json');
   if (!fs.existsSync(packageJsonPath)) {
@@ -42,42 +43,60 @@ function rebuildNativeModule(modulePath, platform, arch, verbose = false) {
   }
 
   try {
-    // Use node-gyp to rebuild for the target platform
-    const cmd = `npx node-gyp rebuild --target_platform=${platform} --target_arch=${arch}`;
+    // Use node-gyp to rebuild for the target Node.js version, platform, and architecture
+    // --target specifies the Node.js version (critical for NODE_MODULE_VERSION)
+    // --dist-url ensures node-gyp downloads headers from the correct location
+    const cmd = `npx node-gyp rebuild --target=${nodeVersion} --arch=${arch} --dist-url=https://nodejs.org/dist`;
     
-    diag.verbose(`Running: ${cmd}`);
+    diag.verbose(`Building for Node.js ${nodeVersion} (${platform}-${arch})`, 2);
+    diag.verbose(`Command: ${cmd}`, 2);
 
     execSync(cmd, {
       cwd: modulePath,
-      stdio: verbose ? 'inherit' : 'pipe',
+      stdio: 'pipe',  // Hide output unless error occurs
       env: {
         ...process.env,
-        npm_config_target_platform: platform,
-        npm_config_target_arch: arch
+        npm_config_target: nodeVersion,
+        npm_config_arch: arch,
+        npm_config_target_arch: arch,
+        npm_config_disturl: 'https://nodejs.org/dist'
       }
     });
 
-    diag.verbose(`Successfully rebuilt ${moduleName}`);
+    diag.verbose(`Successfully built for Node.js ${nodeVersion}`, 2);
   } catch (error) {
+    // Show node-gyp output on error
+    if (error.stdout) console.error(error.stdout.toString());
+    if (error.stderr) console.error(error.stderr.toString());
     diag.verbose(`Failed to rebuild ${moduleName}: ${error.message}`);
     throw error;
   }
 }
 
-// CLI entry point
-if (import.meta.url === `file://${process.argv[1]}`) {
+// CLI entry point - compare normalized paths for cross-platform compatibility
+const isMainModule = (() => {
+  try {
+    const scriptPath = fileURLToPath(import.meta.url);
+    const argPath = path.resolve(process.argv[1]);
+    return scriptPath === argPath;
+  } catch {
+    return false;
+  }
+})();
+
+if (isMainModule) {
   const args = process.argv.slice(2);
   
-  if (args.length < 3) {
-    diag.error('Usage: seabox-rebuild <module-path> <platform> <arch> [--verbose]');
+  if (args.length < 4) {
+    diag.error('Usage: seabox-rebuild <module-path> <node-version> <platform> <arch> [--verbose]');
     process.exit(1);
   }
 
-  const [modulePath, platform, arch] = args;
+  const [modulePath, nodeVersion, platform, arch] = args;
   const verbose = args.includes('--verbose') || args.includes('-v');
 
   try {
-    rebuildNativeModule(modulePath, platform, arch, verbose);
+    rebuildNativeModule(modulePath, nodeVersion, platform, arch, verbose);
     process.exit(0);
   } catch (error) {
     diag.error(`Rebuild failed: ${error.message}`);

package/lib/build-cache.mjs

@@ -110,13 +110,15 @@ export class BuildCache {
   /**
    * Get cached native module build
    * @param {string} moduleRoot - Module root path
-   * @param {string} target - Build target
+   * @param {string} target - Build target (e.g., node24.11.0-win32-x64)
    * @returns {string|null} - Path to cached .node file
    */
   getCachedNativeBuild(moduleRoot, target) {
+    // Include the FULL target string (with Node.js version) in cache key
+    // This ensures different Node.js versions have separate cache entries
     const cacheKey = crypto
       .createHash('sha256')
-      .update(moduleRoot + target)
+      .update(`${moduleRoot}||${target}`)
       .digest('hex')
       .substring(0, 16);
 
@@ -132,6 +134,9 @@ export class BuildCache {
         if (cacheStats.mtime > sourceStats.mtime) {
           return cachePath;
         }
+      } else {
+        // If no binding.gyp, still return cached binary (e.g., prebuild scenario)
+        return cachePath;
       }
     }
 
@@ -141,13 +146,15 @@ export class BuildCache {
   /**
    * Cache a native module build
    * @param {string} moduleRoot - Module root path
-   * @param {string} target - Build target
+   * @param {string} target - Build target (e.g., node24.11.0-win32-x64)
    * @param {string} builtBinaryPath - Path to built .node file
    */
   cacheNativeBuild(moduleRoot, target, builtBinaryPath) {
+    // Use the FULL target string (with Node.js version) in cache key
+    // This ensures different Node.js versions have separate cache entries
     const cacheKey = crypto
       .createHash('sha256')
-      .update(moduleRoot + target)
+      .update(`${moduleRoot}||${target}`)
       .digest('hex')
       .substring(0, 16);
 

package/lib/multi-target-builder.mjs

@@ -287,7 +287,7 @@ export class MultiTargetBuilder {
         }
 
         // Rebuild the module
-        diag.verbose(`Rebuilding: ${moduleName}`, 2);
+        diag.verbose(`Rebuilding: ${moduleName} for Node.js ${parseTarget(target).nodeVersion}`, 2);
 
         await this.rebuildNativeModule(moduleInfo.packageRoot, target);
 
@@ -326,9 +326,12 @@ export class MultiTargetBuilder {
       throw new Error('seabox-rebuild.mjs not found');
     }
 
+    const { nodeVersion, platform, arch } = parseTarget(target);
+
     try {
-      execSync(`node "${rebuildScript}" --target ${target} "${packageRoot}"`, {
-        stdio: this.verbose ? 'inherit' : 'pipe',
+      // Always inherit stdio to show node-gyp progress (header downloads, etc.)
+      execSync(`node "${rebuildScript}" "${packageRoot}" ${nodeVersion} ${platform} ${arch}${this.verbose ? ' --verbose' : ''}`, {
+        stdio: 'inherit',  // Show node-gyp output including header downloads
         cwd: this.projectRoot
       });
     } catch (err) {
@@ -613,16 +616,17 @@ const SEA_ENCRYPTED_ASSETS = new Set([]);
     const seaConfigPath = path.join(tempDir, 'sea-config.json');
     writeSeaConfigJson(seaConfig, seaConfigPath, allAssets, tempDir);
 
-    // Generate blob
-    await generateBlob(seaConfigPath, process.execPath);
-    diag.success('SEA blob generated');
-
-    // Fetch Node binary
+    // Fetch Node binary FIRST - needed for blob generation
     diag.buildStep(buildNumber, 5, 'Fetching Node.js binary...');
     const cacheDir = path.join(this.projectRoot, 'node_modules', '.cache', 'sea-node-binaries');
     const nodeBinary = await fetchNodeBinary(nodeVersion, platform, arch, cacheDir);
     diag.success('Node binary ready');
 
+    // Generate blob using the TARGET Node.js binary (not current process.execPath)
+    // This is critical for snapshots - they must be built with the target Node version
+    await generateBlob(seaConfigPath, nodeBinary);
+    diag.success('SEA blob generated');
+
     // Inject blob
     diag.buildStep(buildNumber, 6, 'Injecting blob into executable...');
     const outputExe = path.join(outputDir, executableName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "seabox",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Node.js Single Executable Application (SEA) builder tool with native and library extraction",
   "main": "lib/index.mjs",
   "type": "module",