seabox 0.1.0-beta.3 → 0.1.0

package/lib/multi-target-builder.mjs

@@ -0,0 +1,705 @@
+/**
+ * multi-target-builder.mjs
+ * Orchestrate parallel builds for multiple target platforms.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import crypto from 'crypto';
+import { fileURLToPath } from 'url';
+import Module from 'module';
+
+import { bundleWithRollup } from './rolldown-bundler.mjs';
+import { BuildCache } from './build-cache.mjs';
+import { parseTarget } from './config.mjs';
+import { generateManifest, serializeManifest } from './manifest.mjs';
+import { createSeaConfig, writeSeaConfigJson, generateBlob } from './blob.mjs';
+import { fetchNodeBinary } from './fetch-node.mjs';
+import { injectBlob } from './inject.mjs';
+import { generateEncryptionKey, encryptAssets, keyToObfuscatedCode } from './crypto-assets.mjs';
+import { obfuscateBootstrap } from './obfuscate.mjs';
+import { bundleEntry } from './entry-bundler.mjs';
+import * as diag from './diagnostics.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const require = Module.createRequire(import.meta.url);
+
+/**
+ * Multi-target build orchestrator
+ */
+export class MultiTargetBuilder {
+  /**
+   * @param {import('./config.mjs').SeaboxConfigV2} config - Build configuration
+   * @param {string} projectRoot - Project root directory
+   */
+  constructor(config, projectRoot = process.cwd()) {
+    this.config = config;
+    this.projectRoot = projectRoot;
+    this.cache = new BuildCache(path.join(projectRoot, 'node_modules', '.cache', '.seabox-cache'));
+    this.verbose = config.verbose || false;
+    
+    // Set verbose mode for diagnostics
+    diag.setVerbose(this.verbose);
+  }
+
+  /**
+   * Build all configured targets
+   * @returns {Promise<Array<{target: string, path: string}>>}
+   */
+  async buildAll() {
+    diag.header('Seabox Multi-Target Build');
+
+    // Step 1: Bundle entry once (platform-agnostic JavaScript)
+    const { bundledPath, nativeModules, detectedAssets } = await this.bundleEntry();
+
+    if (this.verbose && detectedAssets.size > 0) {
+      diag.separator();
+      diag.info('Auto-detected assets:');
+      for (const assetPath of detectedAssets) {
+        diag.listItem(assetPath, 1);
+      }
+    }
+
+    if (this.verbose && nativeModules.size > 0) {
+      diag.separator();
+      diag.info('Native modules detected:');
+      for (const [name, info] of nativeModules) {
+        diag.listItem(`${name}: ${info.packageRoot}`, 1);
+      }
+    }
+
+    // Step 2: Build all targets (can be parallelized)
+    diag.separator();
+    diag.info(`Building ${this.config.outputs.length} target(s)...`);
+    diag.separator();
+    
+    const buildPromises = this.config.outputs.map((output, index) =>
+      this.buildTarget(output, bundledPath, nativeModules, detectedAssets, index + 1)
+    );
+
+    const results = await Promise.all(buildPromises);
+
+    diag.summary('All builds completed successfully!');
+    
+    return results;
+  }
+
+  /**
+   * Bundle the entry file with Rollup
+   * @returns {Promise<{bundledPath: string, nativeModules: Map}>}
+   */
+  async bundleEntry() {
+    diag.step(1, 6, 'Bundling application with Rollup...');
+    
+    const entryPath = path.resolve(this.projectRoot, this.config.entry);
+    
+    if (!fs.existsSync(entryPath)) {
+      throw new Error(`Entry file not found: ${entryPath}`);
+    }
+
+    const bundledPath = path.join(this.projectRoot, 'out', '_sea-entry.js');
+    
+    // Create output directory
+    fs.mkdirSync(path.dirname(bundledPath), { recursive: true });
+
+    const result = await bundleWithRollup(
+      entryPath, 
+      bundledPath, 
+      { ...this.config, _projectRoot: this.projectRoot }, 
+      process.platform,  // Use current platform for bundling (JavaScript is platform-agnostic)
+      process.arch,
+      this.verbose
+    );
+    
+    diag.success(`Bundle created: ${bundledPath}`);
+    
+    return result;
+  }
+
+
+
+  /**
+   * Build a single target
+   * @param {import('./config.mjs').OutputTarget} outputConfig - Target configuration
+   * @param {string} bundledEntryPath - Path to bundled entry
+   * @param {Map} nativeModules - Detected native modules
+   * @param {Set<string>} detectedAssets - Auto-detected assets from bundler
+   * @param {number} buildNumber - Build number for display
+   * @returns {Promise<{target: string, path: string}>}
+   */
+  async buildTarget(outputConfig, bundledEntryPath, nativeModules, detectedAssets, buildNumber) {
+    const { target, path: outputPath, output: executableName } = outputConfig;
+    const { nodeVersion, platform, arch } = parseTarget(target);
+
+    diag.subheader(`[Build ${buildNumber}] Target: ${target}`);
+
+    // Step 1: Rebuild native modules for this target
+    const rebuiltModules = await this.rebuildNativeModulesForTarget(
+      nativeModules,
+      target,
+      buildNumber
+    );
+
+    // Step 2: Collect config assets (manual globs)
+    const configAssets = await this.collectConfigAssets(
+      this.config.assets || [],
+      buildNumber
+    );
+
+    // Step 3: Collect auto-detected assets (from path.join(__dirname, ...))
+    const autoAssets = await this.collectDetectedAssets(
+      detectedAssets,
+      buildNumber
+    );
+
+    // Step 4: Collect platform-specific libraries (DLLs/SOs)
+    const platformLibraries = await this.collectPlatformLibraries(
+      outputConfig.libraries,
+      platform,
+      arch,
+      buildNumber
+    );
+
+    // Step 5: Prepare bundled entry with bootstrap
+    const finalEntryPath = await this.prepareFinalEntry(
+      bundledEntryPath,
+      buildNumber
+    );
+
+    // Step 6: Combine all assets (dedupe by assetKey)
+    const assetMap = new Map();
+    
+    // Add in order of priority (later overwrites earlier)
+    for (const asset of [...rebuiltModules, ...configAssets, ...autoAssets, ...platformLibraries]) {
+      assetMap.set(asset.assetKey, asset);
+    }
+    
+    const allAssets = Array.from(assetMap.values());
+
+    // Verbose logging: List all embedded assets
+    if (this.verbose) {
+      diag.separator();
+      diag.verbose(`Embedded Assets (${allAssets.length} total):`, 1);
+      
+      const nativeAssets = allAssets.filter(a => a.assetKey.includes('.node'));
+      const libraryAssets = allAssets.filter(a => a.isBinary && !a.assetKey.includes('.node'));
+      const regularAssets = allAssets.filter(a => !a.isBinary);
+      
+      if (nativeAssets.length > 0) {
+        diag.verbose(`Native Modules (${nativeAssets.length}):`, 1);
+        for (const asset of nativeAssets) {
+          const size = diag.formatSize(fs.statSync(asset.sourcePath).size);
+          const displayName = path.basename(asset.assetKey);
+          diag.verbose(`- ${displayName} (${size})`, 2);
+        }
+      }
+      
+      if (libraryAssets.length > 0) {
+        diag.verbose(`Platform Libraries (${libraryAssets.length}):`, 1);
+        for (const asset of libraryAssets) {
+          const size = diag.formatSize(fs.statSync(asset.sourcePath).size);
+          diag.verbose(`- ${asset.assetKey} (${size})`, 2);
+        }
+      }
+      
+      if (regularAssets.length > 0) {
+        diag.verbose(`Regular Assets (${regularAssets.length}):`, 1);
+        for (const asset of regularAssets) {
+          const size = diag.formatSize(fs.statSync(asset.sourcePath).size);
+          diag.verbose(`- ${asset.assetKey} (${size})`, 2);
+        }
+      }
+    }
+
+    // Step 7: Generate SEA
+    await this.generateSEAForTarget({
+      assets: allAssets,
+      entryPath: finalEntryPath,
+      target,
+      outputPath,
+      executableName,
+      platform,
+      arch,
+      nodeVersion,
+      rcedit: outputConfig.rcedit,
+      buildNumber
+    });
+
+    const finalPath = path.join(outputPath, executableName);
+    diag.success(`Build complete: ${finalPath}`);
+
+    // Apply custom signing if configured
+    if (this.config.sign) {
+      await this.applyCustomSigning(finalPath, target, platform, arch, nodeVersion, buildNumber);
+    }
+
+    return {
+      target,
+      path: finalPath
+    };
+  }
+
+  /**
+   * Rebuild native modules for specific target
+   */
+  async rebuildNativeModulesForTarget(nativeModules, target, buildNumber) {
+    if (nativeModules.size === 0) {
+      return [];
+    }
+
+    diag.buildStep(buildNumber, 1, `Rebuilding ${nativeModules.size} native module(s)...`);
+
+    const rebuiltAssets = [];
+    const { platform, arch } = parseTarget(target);
+
+    for (const [moduleKey, moduleInfo] of nativeModules) {
+      const moduleName = moduleInfo.moduleName || path.basename(moduleKey, '.node');
+      
+      try {
+        // Skip rebuilding if this is already a prebuild for the target platform
+        if (moduleInfo.isPrebuild) {
+          diag.verbose(`Using prebuild: ${moduleName}`, 2);
+          
+          const relativeFromProject = path.relative(this.projectRoot, moduleInfo.binaryPath).replace(/\\/g, '/');
+          
+          rebuiltAssets.push({
+            sourcePath: moduleInfo.binaryPath,
+            assetKey: relativeFromProject,
+            isBinary: true,
+            hash: await this.computeHash(moduleInfo.binaryPath)
+          });
+          continue;
+        }
+        
+        // Check cache first
+        const cachedBuild = this.cache.getCachedNativeBuild(moduleInfo.packageRoot, target);
+        
+        if (cachedBuild) {
+          diag.verbose(`Using cached build: ${moduleName}`, 2);
+          
+          // Use relative path from project root
+          const relativeFromProject = path.relative(this.projectRoot, cachedBuild).replace(/\\/g, '/');
+          
+          rebuiltAssets.push({
+            sourcePath: cachedBuild,
+            assetKey: relativeFromProject,
+            isBinary: true,
+            hash: await this.computeHash(cachedBuild)
+          });
+          continue;
+        }
+
+        // Rebuild the module
+        diag.verbose(`Rebuilding: ${moduleName}`, 2);
+
+        await this.rebuildNativeModule(moduleInfo.packageRoot, target);
+
+        // Find the built binary
+        const builtPath = await this.findBuiltBinary(moduleInfo, target);
+        
+        if (builtPath) {
+          // Cache the build
+          this.cache.cacheNativeBuild(moduleInfo.packageRoot, target, builtPath);
+          
+          // Use relative path from project root
+          const relativeFromProject = path.relative(this.projectRoot, builtPath).replace(/\\/g, '/');
+          
+          rebuiltAssets.push({
+            sourcePath: builtPath,
+            assetKey: relativeFromProject,
+            isBinary: true,
+            hash: await this.computeHash(builtPath)
+          });
+          
+          diag.verbose(`Built: ${moduleName} -> ${builtPath}`, 2);
+        }
+      } catch (err) {
+        diag.warn(`Failed to rebuild ${moduleName}: ${err.message}`, 2);
+      }
+    }
+
+    diag.success('Native modules processed');
+    return rebuiltAssets;
+  }
+
+  /**
+   * Rebuild a single native module
+   */
+  async rebuildNativeModule(packageRoot, target) {
+    const rebuildScript = path.join(__dirname, '..', 'bin', 'seabox-rebuild.mjs');
+    
+    if (!fs.existsSync(rebuildScript)) {
+      throw new Error('seabox-rebuild.mjs not found');
+    }
+
+    try {
+      execSync(`node "${rebuildScript}" --target ${target} "${packageRoot}"`, {
+        stdio: this.verbose ? 'inherit' : 'pipe',
+        cwd: this.projectRoot
+      });
+    } catch (err) {
+      throw new Error(`Rebuild failed: ${err.message}`);
+    }
+  }
+
+  /**
+   * Find the built .node binary
+   */
+  async findBuiltBinary(moduleInfo, target) {
+    // Try common build locations
+    const searchPaths = [
+      path.join(moduleInfo.packageRoot, 'build/Release'),
+      path.join(moduleInfo.packageRoot, 'build/Debug'),
+      moduleInfo.buildPath
+    ];
+
+    for (const searchPath of searchPaths) {
+      if (fs.existsSync(searchPath)) {
+        const files = fs.readdirSync(searchPath);
+        const nodeFile = files.find(f => f.endsWith('.node'));
+        
+        if (nodeFile) {
+          return path.join(searchPath, nodeFile);
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Collect platform-specific libraries (DLLs, SOs, DYLIBs) that need filesystem extraction
+   * Only includes libraries explicitly listed in config patterns - no automatic discovery.
+   * Libraries referenced in code (e.g., path.join(__dirname, './lib/foo.dll')) are 
+   * already captured by the bundler's asset detection.
+   * 
+   * @param {string[]} libraryPatterns - Explicit glob patterns for libraries from config
+   * @param {string} platform - Target platform
+   * @param {string} arch - Target architecture
+   * @param {number} buildNumber - Build number for display
+   */
+  async collectPlatformLibraries(libraryPatterns, platform, arch, buildNumber) {
+    // Only process explicitly configured library patterns
+    // Do NOT use default patterns - this prevents automatic inclusion of unrelated DLLs
+    if (!libraryPatterns || libraryPatterns.length === 0) {
+      return [];
+    }
+
+    diag.buildStep(buildNumber, 4, `Collecting platform libraries (${platform})...`);
+
+    const { glob } = await import('glob');
+    const libraries = [];
+
+    for (const pattern of libraryPatterns) {
+      const matches = await glob(pattern, {
+        cwd: this.projectRoot,
+        nodir: true,
+        absolute: false,
+        ignore: [
+          '**/node_modules/**',
+          '**/.git/**',
+          '**/dist/**',
+          '**/build/**',
+          '**/out/**',
+          '**/bin/**',
+          '**/obj/**',
+          '**/tools/**',
+          '**/.seabox-cache/**'
+        ]
+      });
+
+      for (const match of matches) {
+        const sourcePath = path.resolve(this.projectRoot, match);
+        
+        libraries.push({
+          sourcePath,
+          assetKey: match.replace(/\\/g, '/'),
+          isBinary: true,
+          hash: await this.computeHash(sourcePath)
+        });
+      }
+    }
+
+    if (libraries.length > 0) {
+      diag.success(`Collected ${libraries.length} library file(s)`);
+    }
+
+    return libraries;
+  }
+
+  /**
+   * Collect assets from config globs
+   * @param {string[]} assetPatterns - Glob patterns for assets
+   * @param {number} buildNumber - Build number for display
+   */
+  async collectConfigAssets(assetPatterns, buildNumber) {
+    if (!assetPatterns || assetPatterns.length === 0) {
+      return [];
+    }
+
+    diag.buildStep(buildNumber, 2, 'Collecting config assets...');
+
+    const { glob } = await import('glob');
+    const assets = [];
+
+    for (const pattern of assetPatterns) {
+      const matches = await glob(pattern, {
+        cwd: this.projectRoot,
+        nodir: true,
+        absolute: false,
+        ignore: [
+          '**/node_modules/**',
+          '**/.git/**',
+          '**/dist/**',
+          '**/build/**',
+          '**/out/**',
+          '**/bin/**',
+          '**/obj/**',
+          '**/tools/**',
+          '**/.seabox-cache/**'
+        ]
+      });
+
+      for (const match of matches) {
+        const sourcePath = path.resolve(this.projectRoot, match);
+        
+        assets.push({
+          sourcePath,
+          assetKey: match.replace(/\\/g, '/'),
+          isBinary: this.isBinaryFile(sourcePath),
+          hash: await this.computeHash(sourcePath)
+        });
+      }
+    }
+
+    if (assets.length > 0) {
+      diag.success(`Collected ${assets.length} config asset(s)`);
+    }
+
+    return assets;
+  }
+
+  /**
+   * Collect auto-detected assets from bundler (path.join(__dirname, ...))
+   * @param {Set<string>} detectedAssets - Asset paths detected during bundling
+   * @param {number} buildNumber - Build number for display
+   */
+  async collectDetectedAssets(detectedAssets, buildNumber) {
+    if (!detectedAssets || detectedAssets.size === 0) {
+      return [];
+    }
+
+    diag.buildStep(buildNumber, 3, 'Processing auto-detected assets...');
+
+    const assets = [];
+
+    for (const assetKey of detectedAssets) {
+      const sourcePath = path.resolve(this.projectRoot, assetKey);
+      
+      // Verify file still exists
+      if (fs.existsSync(sourcePath)) {
+        assets.push({
+          sourcePath,
+          assetKey: assetKey,
+          isBinary: this.isBinaryFile(sourcePath),
+          hash: await this.computeHash(sourcePath)
+        });
+      }
+    }
+
+    if (assets.length > 0) {
+      diag.success(`Collected ${assets.length} auto-detected asset(s)`);
+    }
+
+    return assets;
+  }
+
+  /**
+   * Check if a file is binary based on extension
+   */
+  isBinaryFile(filePath) {
+    const binaryExtensions = ['.node', '.dll', '.so', '.dylib', '.exe', '.png', '.jpg', '.jpeg', '.gif', '.ico', '.woff', '.woff2', '.ttf', '.eot'];
+    const ext = path.extname(filePath).toLowerCase();
+    return binaryExtensions.includes(ext);
+  }
+
+  /**
+   * Prepare final entry with bootstrap
+   */
+  async prepareFinalEntry(bundledEntryPath, buildNumber) {
+    diag.buildStep(buildNumber, 3, 'Preparing bootstrap...');
+
+    const bootstrapPath = path.join(__dirname, 'bootstrap.cjs');
+    const bootstrapContent = fs.readFileSync(bootstrapPath, 'utf8');
+    
+    let augmentedBootstrap = bootstrapContent;
+
+    // Handle encryption if enabled
+    if (this.config.encryptAssets) {
+      const encryptionKey = generateEncryptionKey();
+      const keyCode = keyToObfuscatedCode(encryptionKey);
+      
+      const encryptionSetup = `
+const SEA_ENCRYPTION_KEY = ${keyCode};
+const SEA_ENCRYPTED_ASSETS = new Set([]);
+`;
+      
+      augmentedBootstrap = bootstrapContent.replace(
+        "  'use strict';",
+        "  'use strict';\n" + encryptionSetup
+      );
+      
+      diag.verbose('Encryption enabled and bootstrap obfuscated', 2);
+      
+      augmentedBootstrap = obfuscateBootstrap(augmentedBootstrap);
+    }
+
+    // Read bundled entry
+    const entryContent = fs.readFileSync(bundledEntryPath, 'utf8');
+
+    // Bundle with bootstrap
+    const finalEntry = bundleEntry(entryContent, augmentedBootstrap, this.config.useSnapshot, this.verbose);
+    
+    // Write final entry
+    const finalPath = bundledEntryPath.replace('.js', '-final.js');
+    fs.writeFileSync(finalPath, finalEntry, 'utf8');
+
+    diag.success('Bootstrap prepared');
+    return finalPath;
+  }
+
+  /**
+   * Generate SEA for a specific target
+   */
+  async generateSEAForTarget(options) {
+    const {
+      assets,
+      entryPath,
+      target,
+      outputPath: outputDir,
+      executableName,
+      platform,
+      arch,
+      nodeVersion,
+      rcedit,
+      buildNumber
+    } = options;
+
+    diag.buildStep(buildNumber, 4, 'Generating SEA blob...');
+
+    // Generate manifest
+    const manifest = generateManifest(
+      assets,
+      {
+        _packageName: this.config._packageName || 'app',
+        _packageVersion: this.config._packageVersion || '1.0.0',
+        cacheLocation: this.config.cacheLocation
+      },
+      platform,
+      arch
+    );
+
+    const manifestJson = serializeManifest(manifest);
+    const manifestAsset = {
+      sourcePath: null,
+      assetKey: 'sea-manifest.json',
+      isBinary: false,
+      content: Buffer.from(manifestJson, 'utf8')
+    };
+
+    const allAssets = [...assets, manifestAsset];
+
+    // Create SEA config
+    const tempDir = path.join(this.projectRoot, 'out', '.sea-temp', target);
+    fs.mkdirSync(tempDir, { recursive: true });
+
+    const blobOutputPath = path.join(tempDir, 'sea-blob.blob');
+    const seaConfig = createSeaConfig(entryPath, blobOutputPath, allAssets, this.config);
+    
+    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
+    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);
+    await injectBlob(nodeBinary, blobOutputPath, outputExe, platform, this.verbose, rcedit);
+
+    // Cleanup
+    if (!this.verbose) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+
+    const size = diag.formatSize(fs.statSync(outputExe).size);
+    diag.success(`Injected (${size})`);
+  }
+
+  /**
+   * Compute SHA-256 hash of a file
+   */
+  async computeHash(filePath) {
+    return new Promise((resolve, reject) => {
+      const hash = crypto.createHash('sha256');
+      const stream = fs.createReadStream(filePath);
+      stream.on('data', chunk => hash.update(chunk));
+      stream.on('end', () => resolve(hash.digest('hex')));
+      stream.on('error', reject);
+    });
+  }
+
+  /**
+   * Apply custom signing script
+   * @param {string} exePath - Path to executable
+   * @param {string} target - Build target
+   * @param {string} platform - Platform (win32, linux, darwin)
+   * @param {string} arch - Architecture (x64, arm64)
+   * @param {string} nodeVersion - Node version
+   * @param {number} buildNumber - Build number
+   */
+  async applyCustomSigning(exePath, target, platform, arch, nodeVersion, buildNumber) {
+    diag.buildStep(buildNumber, 7, 'Applying custom signing...');
+    
+    try {
+      const signScriptPath = path.resolve(this.projectRoot, this.config.sign);
+      
+      if (!fs.existsSync(signScriptPath)) {
+        throw new Error(`Signing script not found: ${signScriptPath}`);
+      }
+
+      // Dynamic import of the signing script - convert to file:// URL for Windows
+      const { pathToFileURL } = await import('url');
+      const signModuleURL = pathToFileURL(signScriptPath).href;
+      const signModule = await import(signModuleURL);
+      const signFunction = signModule.default;
+      
+      if (typeof signFunction !== 'function') {
+        throw new Error('Signing script must export a default function');
+      }
+
+      // Call the signing function with config
+      await signFunction({
+        exePath: path.resolve(exePath),
+        target,
+        platform,
+        arch,
+        nodeVersion,
+        projectRoot: this.projectRoot
+      });
+
+      diag.success('Custom signing applied');
+    } catch (error) {
+      throw new Error(`Signing failed: ${error.message}`);
+    }
+  }
+}