seabox 0.1.0-beta.2 → 0.1.0-beta.4

package/lib/build.js

@@ -1,283 +0,0 @@
-/**
- * build.js
- * Main orchestrator for SEA build pipeline.
- * Usage: node scripts/sea/build.js [--config <path>] [--verbose]
- */
-
-const fs = require('fs');
-const path = require('path');
-const { loadConfig, parseTarget } = require('./config');
-const { scanAssets, groupAssets } = require('./scanner');
-const { generateManifest, serializeManifest } = require('./manifest');
-const { createSeaConfig, writeSeaConfigJson, generateBlob } = require('./blob');
-const { fetchNodeBinary } = require('./fetch-node');
-const { injectBlob } = require('./inject');
-const { generateEncryptionKey, encryptAssets, keyToObfuscatedCode } = require('./crypto-assets');
-const { obfuscateBootstrap } = require('./obfuscate');
-const { execSync } = require('child_process');
-
-/**
- * Main build orchestrator.
- * @param {Object} options - Build options
- * @param {string} [options.configPath] - Path to config file
- * @param {boolean} [options.verbose] - Enable verbose logging
- * @param {boolean} [options.debug] - Keep temporary build files
- * @param {string} [options.projectRoot] - Project root directory
- */
-async function build(options = {}) {
-  // Support both options object and legacy process.argv parsing
-  let configPath = options.configPath;
-  let verbose = options.verbose;
-  let debug = options.debug;
-  let projectRoot = options.projectRoot || process.cwd();
-  
-  // Fallback to process.argv if called without options
-  if (!options.configPath && !options.verbose && !options.debug) {
-    const args = process.argv.slice(2);
-    configPath = args.includes('--config') ? args[args.indexOf('--config') + 1] : null;
-    verbose = args.includes('--verbose');
-    debug = args.includes('--debug');
-  }
-
-  if (!verbose) {
-    console.log('Building SEA...');
-  }
-
-  const config = loadConfig(configPath, projectRoot);
-  
-  if (verbose) {
-    console.log('\n[1/8] Loading configuration');
-    console.log('Config:', JSON.stringify(config, null, 2));
-  }
-
-  const target = config.targets[0];
-  const { nodeVersion, platform, arch } = parseTarget(target);
-  
-  if (verbose) {
-    console.log(`Target: Node ${nodeVersion} on ${platform}-${arch}`);
-  }
-
-  if (config.rebuild) {
-    if (verbose) console.log('\n[1b] Rebuilding native modules');
-    const rebuildScript = path.join(__dirname, '..', 'bin', 'seabox-rebuild.js');
-    try {
-      execSync(`node "${rebuildScript}" --target ${target} "${projectRoot}"`, {
-        stdio: verbose ? 'inherit' : 'ignore'
-      });
-      if (verbose) console.log('✓ Native modules rebuilt');
-    } catch (error) {
-      console.error('✗ Native module rebuild failed:', error.message);
-      throw new Error('Native module rebuild failed. See output above for details.');
-    }
-  }
-
-  const assets = await scanAssets(
-    config.assets,
-    config.binaries || [],
-    config.exclude || [],
-    projectRoot
-  );
-
-  const { binaries, nonBinaries } = groupAssets(assets);
-  
-  if (verbose) {
-    console.log(`\n[2/8] Scanning assets`);
-    console.log(`Found ${assets.length} assets (${binaries.length} binaries, ${nonBinaries.length} non-binaries)`);
-    console.log('Binaries:', binaries.map(b => b.assetKey));
-    const nonBinariesList = assets.filter(a => !a.isBinary);
-    console.log('Non-binary assets:', nonBinariesList.map(a => a.assetKey));
-  }
-
-  let encryptionKey = null;
-  let encryptedAssetKeys = new Set();
-  
-  if (config.encryptAssets) {
-    if (verbose) console.log('\n[2b] Encrypting assets');
-    encryptionKey = generateEncryptionKey();
-    
-    const excludeFromEncryption = [
-      'sea-manifest.json',
-      ...(config.encryptExclude || [])
-    ];
-    
-    const encryptedMap = encryptAssets(assets, encryptionKey, excludeFromEncryption);
-    
-    for (const asset of assets) {
-      if (encryptedMap.has(asset.assetKey)) {
-        asset.content = encryptedMap.get(asset.assetKey);
-        asset.encrypted = true;
-        encryptedAssetKeys.add(asset.assetKey);
-      }
-    }
-    
-    if (verbose) {
-      console.log(`Encrypted ${encryptedAssetKeys.size} assets`);
-      console.log('Encrypted assets:', Array.from(encryptedAssetKeys));
-    }
-  }
-
-  if (verbose) console.log('\n[3/8] Generating manifest');
-  const manifest = generateManifest(assets, config, platform, arch);
-  const manifestJson = serializeManifest(manifest);
-  
-  const manifestAsset = {
-    sourcePath: null,
-    assetKey: 'sea-manifest.json',
-    isBinary: false,
-    content: Buffer.from(manifestJson, 'utf8')
-  };
-  assets.push(manifestAsset);
-
-  if (verbose) console.log('\n[4/8] Preparing bootstrap');
-  const bootstrapPath = path.join(__dirname, 'bootstrap.js');
-  const bootstrapContent = fs.readFileSync(bootstrapPath, 'utf8');
-  
-  let augmentedBootstrap = bootstrapContent;
-  if (config.encryptAssets && encryptionKey && encryptedAssetKeys.size > 0) {
-    const keyCode = keyToObfuscatedCode(encryptionKey);
-    const encryptedKeysJson = JSON.stringify(Array.from(encryptedAssetKeys));
-    
-    const encryptionSetup = `
-const SEA_ENCRYPTION_KEY = ${keyCode};
-const SEA_ENCRYPTED_ASSETS = new Set(${encryptedKeysJson});
-`;
-    
-    augmentedBootstrap = bootstrapContent.replace(
-      "  'use strict';",
-      "  'use strict';\n" + encryptionSetup
-    );
-    
-    if (verbose) console.log('Injecting encryption key and obfuscating bootstrap');
-    augmentedBootstrap = obfuscateBootstrap(augmentedBootstrap);
-  }
-  
-  const entryPath = path.resolve(projectRoot, config.entry);
-  let entryContent = fs.readFileSync(entryPath, 'utf8');
-  
-  // Strip shebang if present (e.g., #!/usr/bin/env node) - handle both Unix and Windows line endings
-  entryContent = entryContent.replace(/^#!.*(\r?\n)/, '');
-  
-  // When using snapshot, wrap the application in v8.startupSnapshot.setDeserializeMainFunction
-  let bundledEntry;
-  if (config.useSnapshot) {
-    // Snapshot mode: Bootstrap runs at build time to set up deserialization callback
-    // Application code runs at runtime inside the callback
-    
-    bundledEntry = `${augmentedBootstrap}\n\n`;
-    bundledEntry += `(function() {\n`;
-    bundledEntry += `  const v8 = require('v8');\n`;
-    bundledEntry += `  if (v8.startupSnapshot && v8.startupSnapshot.isBuildingSnapshot()) {\n`;
-    bundledEntry += `    v8.startupSnapshot.setDeserializeMainFunction(() => {\n`;
-    bundledEntry += entryContent + '\n';
-    bundledEntry += `    });\n`;
-    bundledEntry += `  } else {\n`;
-    bundledEntry += entryContent + '\n';
-    bundledEntry += `  }\n`;
-    bundledEntry += `})();\n`;
-  } else {
-    const requireOverride = `
-(function() {
-  const originalRequire = require;
-  const __seaNativeModuleMap = typeof global.__seaNativeModuleMap !== 'undefined' ? global.__seaNativeModuleMap : {};
-  const __seaCacheDir = typeof global.__seaCacheDir !== 'undefined' ? global.__seaCacheDir : '';
-  
-  require = function(id) {
-    if (typeof id === 'string' && id.endsWith('.node')) {
-      const path = originalRequire('path');
-      const basename = path.basename(id);
-      
-      if (__seaNativeModuleMap[basename]) {
-        const exports = {};
-        process.dlopen({ exports }, __seaNativeModuleMap[basename]);
-        return exports;
-      }
-      
-      if (path.isAbsolute(id) && id.startsWith(__seaCacheDir)) {
-        const exports = {};
-        process.dlopen({ exports }, id);
-        return exports;
-      }
-    }
-    
-    if (id === 'bindings') {
-      return function(name) {
-        if (!name.endsWith('.node')) {
-          name += '.node';
-        }
-        if (__seaNativeModuleMap[name]) {
-          const exports = {};
-          process.dlopen({ exports }, __seaNativeModuleMap[name]);
-          return exports;
-        }
-        throw new Error('Could not load native module "' + name + '" - not found in SEA cache');
-      };
-    }
-    
-    return originalRequire.call(this, id);
-  };
-})();
-`;
-    bundledEntry = `${augmentedBootstrap}\n\n${requireOverride}\n${entryContent}`;
-  }
-  
-  const bundledEntryPath = path.join(projectRoot, 'out', '_sea-entry.js');
-  
-  fs.mkdirSync(path.dirname(bundledEntryPath), { recursive: true });
-  fs.writeFileSync(bundledEntryPath, bundledEntry, 'utf8');
-  
-  if (verbose) console.log(`Bundled entry: ${bundledEntryPath}`);
-
-  if (verbose) console.log('\n[5/8] Creating SEA blob configuration');
-  const blobOutputPath = path.join(projectRoot, config.outputPath, 'sea-blob.bin');
-  const seaConfig = createSeaConfig(bundledEntryPath, blobOutputPath, assets, config);
-  
-  const seaConfigPath = path.join(projectRoot, config.outputPath, 'sea-config.json');
-  const tempDir = path.join(projectRoot, config.outputPath, '.sea-temp');
-  fs.mkdirSync(path.dirname(seaConfigPath), { recursive: true });
-  fs.mkdirSync(tempDir, { recursive: true });
-  writeSeaConfigJson(seaConfig, seaConfigPath, assets, tempDir);
-  
-  if (verbose) {
-    console.log(`SEA config: ${seaConfigPath}`);
-    console.log('\n[6/8] Generating SEA blob');
-  }
-  await generateBlob(seaConfigPath);
-
-  if (verbose) console.log('\n[7/8] Fetching Node.js binary');
-  const cacheDir = path.join(projectRoot, 'node_modules', '.cache', 'sea-node-binaries');
-  const nodeBinary = await fetchNodeBinary(nodeVersion, platform, arch, cacheDir);
-
-  if (verbose) console.log('\n[8/8] Injecting SEA blob into Node binary');
-  const outputExe = path.join(projectRoot, config.outputPath, config.output);
-  await injectBlob(nodeBinary, blobOutputPath, outputExe, platform, verbose);
-
-  if (!debug) {
-    if (verbose) console.log('\nCleaning up temporary files');
-    const filesToClean = [seaConfigPath, blobOutputPath];
-    for (const file of filesToClean) {
-      if (fs.existsSync(file)) {
-        fs.unlinkSync(file);
-      }
-    }
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-  }
-
-  const sizeMB = (fs.statSync(outputExe).size / 1024 / 1024).toFixed(2);
-  console.log(`\n✓ Build complete: ${config.output} (${sizeMB} MB)`);
-  if (verbose) console.log(`Output path: ${outputExe}`);
-}
-
-// Run if called directly
-if (require.main === module) {
-  build().catch(error => {
-    console.error('Build failed:', error.message);
-    if (process.argv.includes('--verbose')) {
-      console.error(error.stack);
-    }
-    process.exit(1);
-  });
-}
-
-module.exports = { build };

package/lib/bytenode-hack.js

@@ -1,56 +0,0 @@
-/*MIT License
-
-Copyright (c) 2018 Osama Abbas
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-
-module.exports.fixBytecode = function (bytecodeBuffer) {
-  if (!isBuffer(bytecodeBuffer)) {
-    throw new Error('bytecodeBuffer must be a buffer object.');
-  }
-
-  const dummyBytecode = compileCode('"ಠ_ಠ"');
-  const version = parseFloat(process.version.slice(1, 5));
-
-  if (process.version.startsWith('v8.8') || process.version.startsWith('v8.9')) {
-    // Node is v8.8.x or v8.9.x
-    dummyBytecode.subarray(16, 20).copy(bytecodeBuffer, 16);
-    dummyBytecode.subarray(20, 24).copy(bytecodeBuffer, 20);
-  } else if (version >= 12 && version <= 23) {
-    dummyBytecode.subarray(12, 16).copy(bytecodeBuffer, 12);
-  } else {
-    dummyBytecode.subarray(12, 16).copy(bytecodeBuffer, 12);
-    dummyBytecode.subarray(16, 20).copy(bytecodeBuffer, 16);
-  }
-};
-
-module.exports.readSourceHash = function (bytecodeBuffer) {
-  if (!isBuffer(bytecodeBuffer)) {
-    throw new Error('bytecodeBuffer must be a buffer object.');
-  }
-
-  if (process.version.startsWith('v8.8') || process.version.startsWith('v8.9')) {
-    // Node is v8.8.x or v8.9.x
-    // eslint-disable-next-line no-return-assign
-    return bytecodeBuffer.subarray(12, 16).reduce((sum, number, power) => sum += number * Math.pow(256, power), 0);
-  } else {
-    // eslint-disable-next-line no-return-assign
-    return bytecodeBuffer.subarray(8, 12).reduce((sum, number, power) => sum += number * Math.pow(256, power), 0);
-  }
-};

package/lib/config.js

@@ -1,118 +0,0 @@
-/**
- * config.js
- * Load and validate SEA configuration from package.json or standalone config file.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-/**
- * @typedef {Object} SeaConfig
- * @property {string} entry - Path to the bundled application entry script
- * @property {string[]} assets - Array of glob patterns or paths to include in SEA blob (supports '!' prefix for exclusions)
- * @property {string[]} targets - Array of target specifiers (e.g., "node24.11.0-win-x64")
- * @property {string} output - Output executable filename
- * @property {string} outputPath - Directory for the final executable
- * @property {string[]} [binaries] - Array of binary filename patterns to extract at runtime
- * @property {boolean} [disableExperimentalSEAWarning] - Suppress SEA experimental warning
- * @property {boolean} [useSnapshot] - Enable V8 snapshot
- * @property {boolean} [useCodeCache] - Enable V8 code cache
- * @property {string[]} [exclude] - (Legacy) Glob patterns to exclude from assets - use '!' prefix in assets instead
- * @property {boolean} [encryptAssets] - Enable asset encryption (default: false)
- * @property {string[]} [encryptExclude] - Asset patterns to exclude from encryption
- * @property {boolean} [rebuild] - Automatically rebuild native modules for target platform (default: false)
- * @property {boolean} [verbose] - Enable diagnostic logging
- * @property {string} [cacheLocation] - Cache directory for extracted binaries (default: './.sea-cache', supports env vars like '%LOCALAPPDATA%\\path')
- */
-
-/**
- * Load SEA configuration from package.json or a standalone file.
- * @param {string} [configPath] - Optional path to a standalone config file
- * @param {string} [projectRoot] - Project root directory (defaults to cwd)
- * @returns {SeaConfig}
- */
-function loadConfig(configPath, projectRoot = process.cwd()) {
-  let config;
-
-  if (configPath) {
-    // Load from standalone config file
-    const fullPath = path.resolve(projectRoot, configPath);
-    if (!fs.existsSync(fullPath)) {
-      throw new Error(`Config file not found: ${fullPath}`);
-    }
-    config = JSON.parse(fs.readFileSync(fullPath, 'utf8'));
-  } else {
-    // Load from package.json
-    const pkgPath = path.join(projectRoot, 'package.json');
-    if (!fs.existsSync(pkgPath)) {
-      throw new Error(`package.json not found in: ${projectRoot}`);
-    }
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-    
-    // Check for 'sea' field first, fall back to 'pkg' for migration compatibility
-    config = pkg.seabox || pkg.pkg;
-    
-    if (!config) {
-      throw new Error('No "seabox" or "pkg" configuration found in package.json');
-    }
-
-    // Attach package metadata for manifest
-    config._packageName = pkg.name;
-    config._packageVersion = pkg.version;
-  }
-
-  validateConfig(config);
-  return config;
-}
-
-/**
- * Validate required configuration fields.
- * @param {SeaConfig} config
- */
-function validateConfig(config) {
-  const required = ['entry', 'assets', 'targets', 'output', 'outputPath'];
-  const missing = required.filter(field => !config[field]);
-  
-  if (missing.length > 0) {
-    throw new Error(`Missing required SEA config fields: ${missing.join(', ')}`);
-  }
-
-  if (!Array.isArray(config.assets) || config.assets.length === 0) {
-    throw new Error('SEA config "assets" must be a non-empty array');
-  }
-
-  if (!Array.isArray(config.targets) || config.targets.length === 0) {
-    throw new Error('SEA config "targets" must be a non-empty array');
-  }
-
-  // Validate target format (e.g., "node24.11.0-win-x64")
-  const targetPattern = /^node\d+\.\d+\.\d+-\w+-\w+$/;
-  config.targets.forEach(target => {
-    if (!targetPattern.test(target)) {
-      throw new Error(`Invalid target format: "${target}". Expected format: "nodeX.Y.Z-platform-arch"`);
-    }
-  });
-}
-
-/**
- * Parse a target string into components.
- * @param {string} target - e.g., "node24.11.0-win-x64"
- * @returns {{nodeVersion: string, platform: string, arch: string}}
- */
-function parseTarget(target) {
-  const match = target.match(/^node(\d+\.\d+\.\d+)-(\w+)-(\w+)$/);
-  if (!match) {
-    throw new Error(`Cannot parse target: ${target}`);
-  }
-  return {
-    nodeVersion: match[1],
-    platform: match[2],
-    arch: match[3]
-  };
-}
-
-module.exports = {
-  loadConfig,
-  validateConfig,
-  parseTarget
-};

package/lib/index.js

@@ -1,27 +0,0 @@
-/**
- * index.js
- * Main entry point for seabox
- */
-
-const { build } = require('./build');
-const { loadConfig, parseTarget } = require('./config');
-const { scanAssets, groupAssets } = require('./scanner');
-const { generateManifest, serializeManifest } = require('./manifest');
-const { createSeaConfig, writeSeaConfigJson, generateBlob } = require('./blob');
-const { fetchNodeBinary } = require('./fetch-node');
-const { injectBlob } = require('./inject');
-
-module.exports = {
-  build,
-  loadConfig,
-  parseTarget,
-  scanAssets,
-  groupAssets,
-  generateManifest,
-  serializeManifest,
-  createSeaConfig,
-  writeSeaConfigJson,
-  generateBlob,
-  fetchNodeBinary,
-  injectBlob
-};

package/lib/inject.js

@@ -1,81 +0,0 @@
-/**
- * inject.js
- * Inject SEA blob into Node binary using postject.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { execFile } = require('child_process');
-const { promisify } = require('util');
-const { removeSignature } = require('./unsign');
-
-const execFileAsync = promisify(execFile);
-
-/**
- * Inject a SEA blob into a Node.js binary using postject.
- * @param {string} nodeBinaryPath - Path to the source Node binary
- * @param {string} blobPath - Path to the SEA blob file
- * @param {string} outputPath - Path for the output executable
- * @param {string} platform - Target platform (win32, linux, darwin)
- * @returns {Promise<void>}
- */
-async function injectBlob(nodeBinaryPath, blobPath, outputPath, platform, verbose) {
-  // Copy node binary to output location
-  fs.copyFileSync(nodeBinaryPath, outputPath);
-
-  // Remove existing signature before postject injection
-  // The downloaded Node.js binary is signed, and postject will corrupt this signature
-  await removeSignature(outputPath, platform);
-
-  // Prepare postject command
-  const sentinel = 'NODE_SEA_BLOB';
-  const sentinelFuse = 'NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2';
-
-  const args = [
-    outputPath,
-    sentinel,
-    blobPath,
-    '--sentinel-fuse', sentinelFuse
-  ];
-
-  // Platform-specific postject options
-  if (platform === 'darwin') {
-    args.push('--macho-segment-name', 'NODE_SEA');
-  }
-
-  console.log(`Injecting SEA blob into: ${outputPath}`);
-  
-  // Use cmd.exe on Windows to run npx
-  const isWindows = process.platform === 'win32';
-  const command = isWindows ? 'cmd.exe' : 'npx';
-  const cmdArgs = isWindows 
-    ? ['/c', 'npx', 'postject', ...args]
-    : ['postject', ...args];
-
-  //console.log(`Command: ${command} ${cmdArgs.join(' ')}`);
-
-  try {
-    const { stdout, stderr } = await execFileAsync(command, cmdArgs);
-    if (stdout && verbose) console.log(stdout);
-    if (stderr && verbose) console.error(stderr);
-    console.log('✓ SEA blob injected successfully');
-  } catch (error) {
-    throw new Error(`Postject injection failed: ${error.message}`);
-  }
-
-  //console.log('\nNote: Executable is now ready for signing with your certificate');
-}
-
-/**
- * Resolve the postject executable path.
- * @returns {string}
- */
-function resolvePostject() {
-  // Use npx to run postject
-  return 'npx';
-}
-
-module.exports = {
-  injectBlob,
-  resolvePostject
-};