seabox 0.2.0 → 0.4.0

package/README.md

@@ -148,17 +148,19 @@ seabox automates the entire SEA build process:
    - **Config globs**: Patterns specified in `assets` array
    - **Libraries**: Platform-specific shared libraries (DLLs/SOs)
 
-3. **Native Module Rebuilding** - Rebuilds native modules for target platform
+3. **Binary Preparation** - Downloads target Node.js binary 
 
-4. **Bootstrap Injection** - Adds runtime code for asset loading and native module extraction
+4. **Native Module Rebuilding** - Rebuilds native modules using the downloaded Node.js binary, ensuring ABI compatibility
 
-5. **SEA Blob Creation** - Packages everything using Node.js SEA tooling
+5. **Bootstrap Injection** - Adds runtime code for asset loading and native module extraction
 
-6. **Binary Preparation** - Downloads target Node.js binary and removes code signature
+6. **SEA Blob Creation** - Packages everything using the target Node.js binary 
 
-7. **Injection** - Uses `postject` to inject the blob into the Node.js binary
+7. **Signature Removal** - Removes code signature from the binary before injection
 
-8. **Output** - Produces standalone executable(s) ready for distribution
+8. **Injection** - Uses `postject` to inject the blob into the Node.js binary
+
+9. **Output** - Produces standalone executable(s) ready for distribution
 
 ### Automatic Asset Detection
 

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/fetch-node.mjs

@@ -9,7 +9,7 @@ import https from 'https';
 import { pipeline } from 'stream';
 import { promisify } from 'util';
 import AdmZip from 'adm-zip';
-import tar from 'tar';
+import * as tar from 'tar';
 import * as diag from './diagnostics.mjs';
 
 const pipelineAsync = promisify(pipeline);

package/lib/multi-target-builder.mjs

@@ -135,26 +135,33 @@ export class MultiTargetBuilder {
 
     diag.subheader(`[Build ${buildNumber}] Target: ${target}`);
 
-    // Step 1: Rebuild native modules for this target
+    // Step 1: Fetch Node binary FIRST - needed for all subsequent operations
+    diag.buildStep(buildNumber, 1, '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');
+
+    // Step 2: Rebuild native modules using the TARGET Node binary
     const rebuiltModules = await this.rebuildNativeModulesForTarget(
       nativeModules,
       target,
+      nodeBinary,
       buildNumber
     );
 
-    // Step 2: Collect config assets (manual globs)
+    // Step 3: Collect config assets (manual globs)
     const configAssets = await this.collectConfigAssets(
       this.config.assets || [],
       buildNumber
     );
 
-    // Step 3: Collect auto-detected assets (from path.join(__dirname, ...))
+    // Step 4: Collect auto-detected assets (from path.join(__dirname, ...))
     const autoAssets = await this.collectDetectedAssets(
       detectedAssets,
       buildNumber
     );
 
-    // Step 4: Collect platform-specific libraries (DLLs/SOs)
+    // Step 5: Collect platform-specific libraries (DLLs/SOs)
     const platformLibraries = await this.collectPlatformLibraries(
       outputConfig.libraries,
       platform,
@@ -162,13 +169,13 @@ export class MultiTargetBuilder {
       buildNumber
     );
 
-    // Step 5: Prepare bundled entry with bootstrap
+    // Step 6: Prepare bundled entry with bootstrap
     const finalEntryPath = await this.prepareFinalEntry(
       bundledEntryPath,
       buildNumber
     );
 
-    // Step 6: Combine all assets (dedupe by assetKey)
+    // Step 7: Combine all assets (dedupe by assetKey)
     const assetMap = new Map();
     
     // Add in order of priority (later overwrites earlier)
@@ -213,11 +220,12 @@ export class MultiTargetBuilder {
       }
     }
 
-    // Step 7: Generate SEA
+    // Step 8: Generate SEA using the target Node binary
     await this.generateSEAForTarget({
       assets: allAssets,
       entryPath: finalEntryPath,
       target,
+      nodeBinary,
       outputPath,
       executableName,
       platform,
@@ -244,12 +252,12 @@ export class MultiTargetBuilder {
   /**
    * Rebuild native modules for specific target
    */
-  async rebuildNativeModulesForTarget(nativeModules, target, buildNumber) {
+  async rebuildNativeModulesForTarget(nativeModules, target, nodeBinary, buildNumber) {
     if (nativeModules.size === 0) {
       return [];
     }
 
-    diag.buildStep(buildNumber, 1, `Rebuilding ${nativeModules.size} native module(s)...`);
+    diag.buildStep(buildNumber, 2, `Rebuilding ${nativeModules.size} native module(s)...`);
 
     const rebuiltAssets = [];
     const { platform, arch } = parseTarget(target);
@@ -287,9 +295,9 @@ 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);
+        await this.rebuildNativeModule(moduleInfo.packageRoot, target, nodeBinary);
 
         // Find the built binary
         const builtPath = await this.findBuiltBinary(moduleInfo, target);
@@ -317,18 +325,22 @@ export class MultiTargetBuilder {
   }
 
   /**
-   * Rebuild a single native module
+   * Rebuild a single native module using the target Node binary
    */
-  async rebuildNativeModule(packageRoot, target) {
+  async rebuildNativeModule(packageRoot, target, nodeBinary) {
     const rebuildScript = path.join(__dirname, '..', 'bin', 'seabox-rebuild.mjs');
     
     if (!fs.existsSync(rebuildScript)) {
       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',
+      // Use the TARGET Node.js binary (not system node) to run the rebuild script
+      // This ensures all operations use the exact Node version we'll embed in the SEA
+      execSync(`"${nodeBinary}" "${rebuildScript}" "${packageRoot}" ${nodeVersion} ${platform} ${arch}${this.verbose ? ' --verbose' : ''}`, {
+        stdio: 'inherit',  // Show node-gyp output including header downloads
         cwd: this.projectRoot
       });
     } catch (err) {
@@ -576,7 +588,8 @@ const SEA_ENCRYPTED_ASSETS = new Set([]);
       arch,
       nodeVersion,
       rcedit,
-      buildNumber
+      buildNumber,
+      nodeBinary
     } = options;
 
     diag.buildStep(buildNumber, 4, 'Generating SEA blob...');
@@ -613,16 +626,12 @@ 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);
+    // Generate blob using the TARGET Node.js binary (already fetched)
+    // This is critical for snapshots - they must be built with the target Node version
+    diag.buildStep(buildNumber, 5, 'Generating SEA blob...');
+    await generateBlob(seaConfigPath, nodeBinary);
     diag.success('SEA blob generated');
 
-    // Fetch Node binary
-    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');
-
     // 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.4.0",
   "description": "Node.js Single Executable Application (SEA) builder tool with native and library extraction",
   "main": "lib/index.mjs",
   "type": "module",
@@ -37,11 +37,11 @@
     "adm-zip": "^0.5.16",
     "glob": "^10.0.0",
     "postject": "^1.0.0-alpha.6",
-    "rolldown": "^1.0.0-beta.50",
-    "tar": "^6.2.1"
+    "rolldown": "^1.0.0-rc.2",
+    "tar": "^7.5.7"
   },
   "peerDependencies": {
-    "rcedit": "^4.0.1"
+    "rcedit": "^4 || ^5"
   },
   "peerDependenciesMeta": {
     "rcedit": {
@@ -51,7 +51,7 @@
   "devDependencies": {
     "chai": "^6.2.1",
     "javascript-obfuscator": "^4.1.1",
-    "mocha": "^11.7.5",
+    "mocha": "^11.3.0",
     "node-api-headers": "^1.2.0",
     "rimraf": "^6.0.1"
   },