seabox 0.1.0-beta.3 → 0.1.0

package/lib/diagnostics.mjs

@@ -0,0 +1,203 @@
+/**
+ * diagnostics.mjs
+ * Centralized console output formatting for CLI tooling.
+ * Provides consistent formatting, indentation, and styling.
+ */
+
+/**
+ * Output levels
+ */
+export const Level = {
+  ERROR: 'error',
+  WARN: 'warn',
+  INFO: 'info',
+  SUCCESS: 'success',
+  VERBOSE: 'verbose'
+};
+
+/**
+ * Formatting utilities
+ */
+const colors = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  gray: '\x1b[90m'
+};
+
+function withColor(text, color) {
+  return `${color}${text}${colors.reset}`;
+}
+
+/**
+ * Global verbose flag
+ */
+let verboseEnabled = false;
+
+/**
+ * Enable or disable verbose output
+ * @param {boolean} enabled
+ */
+export function setVerbose(enabled) {
+  verboseEnabled = enabled;
+}
+
+/**
+ * Core logging function
+ * @param {string} message
+ * @param {string} prefix
+ * @param {number} indent
+ */
+function log(message, prefix = '', indent = 0) {
+  const indentation = '  '.repeat(indent);
+  console.log(`${indentation}${prefix}${message}`);
+}
+
+/**
+ * Print section header
+ * @param {string} title
+ */
+export function header(title) {
+  console.log(`\n${title}`);
+  console.log('='.repeat(40));
+}
+
+/**
+ * Print sub-header
+ * @param {string} title
+ */
+export function subheader(title) {
+  console.log(`\n${title}`);
+  console.log('-'.repeat(40));
+}
+
+/**
+ * Print step with number
+ * @param {number} step
+ * @param {number} total
+ * @param {string} message
+ */
+export function step(step, total, message) {
+  log(`[${step}/${total}] ${message}`);
+}
+
+/**
+ * Print build step
+ * @param {number} buildNum
+ * @param {number} stepNum
+ * @param {string} message
+ */
+export function buildStep(buildNum, stepNum, message) {
+  log(`[${buildNum}.${stepNum}] ${message}`, '', 1);
+}
+
+/**
+ * Print success message
+ * @param {string} message
+ * @param {number} indent
+ */
+export function success(message, indent = 1) {
+  log(withColor(`[✓] ${message}`, colors.green), '', indent);
+}
+
+/**
+ * Print info message
+ * @param {string} message
+ * @param {number} indent
+ */
+export function info(message, indent = 0) {
+  log(message, '', indent);
+}
+
+/**
+ * Print warning
+ * @param {string} message
+ * @param {number} indent
+ */
+export function warn(message, indent = 1) {
+  log(withColor(`[!] ${message}`, colors.yellow), '', indent);
+}
+
+/**
+ * Print error
+ * @param {string} message
+ * @param {number} indent
+ */
+export function error(message, indent = 0) {
+  console.error(`${'  '.repeat(indent)}${withColor(`[X] ${message}`, colors.red)}`);
+}
+
+/**
+ * Print verbose message (only if verbose enabled)
+ * @param {string} message
+ * @param {number} indent
+ */
+export function verbose(message, indent = 2) {
+  if (verboseEnabled) {
+    log(withColor(message, colors.gray), '', indent);
+  }
+}
+
+/**
+ * Print list item
+ * @param {string} message
+ * @param {number} indent
+ */
+export function listItem(message, indent = 1) {
+  log(`- ${message}`, '', indent);
+}
+
+/**
+ * Print numbered list item
+ * @param {number} num
+ * @param {string} message
+ * @param {number} indent
+ */
+export function numberedItem(num, message, indent = 1) {
+  log(`${num}. ${message}`, '', indent);
+}
+
+/**
+ * Print section separator
+ */
+export function separator() {
+  console.log('');
+}
+
+/**
+ * Print final summary
+ * @param {string} message
+ */
+export function summary(message) {
+  console.log('');
+  console.log('='.repeat(40));
+  log(withColor(message, colors.green));
+  console.log('='.repeat(40));
+  console.log('');
+}
+
+/**
+ * Format file size in human-readable format
+ * @param {number} bytes
+ * @returns {string}
+ */
+export function formatSize(bytes) {
+  const mb = bytes / 1024 / 1024;
+  if (mb >= 1) {
+    return `${mb.toFixed(2)} MB`;
+  }
+  const kb = bytes / 1024;
+  return `${kb.toFixed(2)} KB`;
+}
+
+/**
+ * Format target string
+ * @param {string} platform
+ * @param {string} arch
+ * @returns {string}
+ */
+export function formatTarget(platform, arch) {
+  return `${platform}-${arch}`;
+}

package/lib/entry-bundler.mjs

@@ -0,0 +1,64 @@
+/**
+ * entry-bundler.mjs
+ * Bundles the entry file with bootstrap and require shim
+ */
+
+import Module from 'module';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const require = Module.createRequire(import.meta.url);
+
+const { generateRequireShim, replaceRequireCalls } = require('./require-shim.mjs');
+
+/**
+ * Bundle the entry file for SEA
+ * @param {string} entryContent - The entry file content
+ * @param {string} augmentedBootstrap - The bootstrap code
+ * @param {boolean} useSnapshot - Whether to use snapshot mode
+ * @param {boolean} verbose - Enable verbose logging
+ * @returns {string} - The bundled entry content
+ */
+export function bundleEntry(entryContent, augmentedBootstrap, useSnapshot, verbose) {
+  // Generate the require shim and replace require() calls
+  const requireSeaboxShim = generateRequireShim();
+  const transformed = replaceRequireCalls(entryContent, verbose);
+  const transformedContent = transformed.code;
+  
+  let bundledEntry;
+  
+  if (useSnapshot) {
+    // Snapshot mode
+    const parts = [
+      augmentedBootstrap,
+      '\n\n',
+      requireSeaboxShim,
+      '\n\n',
+      '// Application entry - will be wrapped by bootstrap\'s setDeserializeMainFunction interceptor\n',
+      '(function() {\n',
+      '  const v8 = __originalRequire(\'v8\');\n',
+      '  if (v8.startupSnapshot && v8.startupSnapshot.isBuildingSnapshot()) {\n',
+      '    v8.startupSnapshot.setDeserializeMainFunction(() => {\n',
+      '      if (typeof exports === \'undefined\') {\n',
+      '        var exports = {};\n',
+      '        var module = { exports: exports };\n',
+      '      }\n',
+      '      // Run the application code\n',
+      transformedContent,
+      '\n',
+      '    });\n',
+      '  } else {\n',
+      '    // Not building snapshot, run normally\n',
+      transformedContent,
+      '\n',
+      '  }\n',
+      '})();\n'
+    ];
+    bundledEntry = parts.join('');
+  } else {
+    // Non-snapshot mode
+    bundledEntry = augmentedBootstrap + '\n\n' + requireSeaboxShim + '\n' + transformedContent;
+  }
+  
+  return bundledEntry;
+}

package/lib/{fetch-node.js → fetch-node.mjs}

@@ -1,13 +1,16 @@
 /**
- * fetch-node.js
+ * fetch-node.mjs
  * Download target Node.js binary for SEA injection.
  */
 
-const fs = require('fs');
-const path = require('path');
-const https = require('https');
-const { pipeline } = require('stream');
-const { promisify } = require('util');
+import fs from 'fs';
+import path from 'path';
+import https from 'https';
+import { pipeline } from 'stream';
+import { promisify } from 'util';
+import AdmZip from 'adm-zip';
+import tar from 'tar';
+import * as diag from './diagnostics.mjs';
 
 const pipelineAsync = promisify(pipeline);
 
@@ -78,9 +81,6 @@ async function downloadFile(url, outputPath) {
  * @returns {Promise<string>} - Path to extracted node binary
  */
 async function extractNodeBinary(archivePath, outputDir, platform) {
-  const AdmZip = require('adm-zip');
-  const tar = require('tar');
-
   if (platform === 'win32') {
     // Extract from ZIP
     const zip = new AdmZip(archivePath);
@@ -135,7 +135,7 @@ async function extractNodeBinary(archivePath, outputDir, platform) {
  * @param {string} cacheDir - Directory to cache downloads
  * @returns {Promise<string>} - Path to the node binary
  */
-async function fetchNodeBinary(nodeVersion, platform, arch, cacheDir) {
+export async function fetchNodeBinary(nodeVersion, platform, arch, cacheDir) {
   if (!fs.existsSync(cacheDir)) {
     fs.mkdirSync(cacheDir, { recursive: true });
   }
@@ -145,23 +145,23 @@ async function fetchNodeBinary(nodeVersion, platform, arch, cacheDir) {
 
   // Check cache
   if (fs.existsSync(cachedBinary)) {
-    console.log(`✓ Using cached Node binary: ${cachedBinary}`);
+    diag.verbose(`Using cached Node binary: ${cachedBinary}`, 1);
     return cachedBinary;
   }
 
-  console.log(`Downloading Node.js v${nodeVersion} for ${platform}-${arch}...`);
+  diag.verbose(`Downloading Node.js v${nodeVersion} for ${platform}-${arch}...`, 1);
   const url = getNodeDownloadUrl(nodeVersion, platform, arch);
   const archiveName = path.basename(url);
   const archivePath = path.join(cacheDir, archiveName);
 
   await downloadFile(url, archivePath);
-  console.log(`✓ Downloaded: ${archivePath}`);
+  diag.verbose(`Downloaded: ${archivePath}`, 1);
 
   const extractDir = path.join(cacheDir, `${nodeVersion}-${platform}-${arch}`);
   fs.mkdirSync(extractDir, { recursive: true });
 
   const binaryPath = await extractNodeBinary(archivePath, extractDir, platform);
-  console.log(`✓ Extracted Node binary: ${binaryPath}`);
+  diag.verbose(`Extracted Node binary: ${binaryPath}`, 1);
 
   // Clean up archive
   fs.unlinkSync(archivePath);
@@ -169,9 +169,4 @@ async function fetchNodeBinary(nodeVersion, platform, arch, cacheDir) {
   return binaryPath;
 }
 
-module.exports = {
-  getNodeDownloadUrl,
-  downloadFile,
-  extractNodeBinary,
-  fetchNodeBinary
-};
+export { getNodeDownloadUrl, downloadFile, extractNodeBinary };

package/lib/index.mjs

@@ -0,0 +1,26 @@
+/**
+ * index.mjs
+ * Main entry point for Seabox v2 library.
+ * Exports all public APIs.
+ */
+
+export { build } from './build.mjs';
+export { 
+  loadConfig, 
+  validateConfig, 
+  parseTarget, 
+  generateDefaultConfig,
+  normalizeConfig,
+  getDefaultLibraryPatterns
+} from './config.mjs';
+export { MultiTargetBuilder } from './multi-target-builder.mjs';
+export { bundleWithRollup, NativeModuleDetectorPlugin } from './rolldown-bundler.mjs';
+export { scanDependenciesForNativeModules, findNativeModuleBuildPath } from './native-scanner.mjs';
+export { BuildCache } from './build-cache.mjs';
+export { generateManifest, serializeManifest } from './manifest.mjs';
+export { createSeaConfig, writeSeaConfigJson, generateBlob } from './blob.mjs';
+export { fetchNodeBinary } from './fetch-node.mjs';
+export { injectBlob } from './inject.mjs';
+export { generateEncryptionKey, encryptAsset, decryptAsset, encryptAssets, keyToObfuscatedCode } from './crypto-assets.mjs';
+export { obfuscateBootstrap } from './obfuscate.mjs';
+export { bundleEntry } from './entry-bundler.mjs';

package/lib/inject.mjs

@@ -0,0 +1,95 @@
+/**
+ * inject.mjs
+ * Inject SEA blob into Node binary using postject.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import Module from 'module';
+import { fileURLToPath } from 'url';
+import * as diag from './diagnostics.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Import unsign using require since it's CommonJS
+const require = Module.createRequire(import.meta.url);
+const { removeSignature, setVerbose: setUnsignVerbose } = require('./unsign.cjs');
+
+/**
+ * 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)
+ * @param {boolean} verbose - Enable verbose logging
+ * @param {Object} [rceditOptions] - Optional rcedit configuration for Windows executables
+ * @returns {Promise<void>}
+ */
+export async function injectBlob(nodeBinaryPath, blobPath, outputPath, platform, verbose, rceditOptions) {
+  // Ensure output directory exists
+  const outputDir = path.dirname(outputPath);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  // Copy node binary to output location
+  fs.copyFileSync(nodeBinaryPath, outputPath);
+
+  // Remove existing signature before postject injection
+  setUnsignVerbose(verbose);
+  await removeSignature(outputPath, platform);
+
+  // Apply rcedit changes (Windows only, before postject)
+  if (platform === 'win32' && rceditOptions && typeof rceditOptions === 'object') {
+    await applyRcedit(outputPath, rceditOptions, verbose);
+  }
+
+  // Prepare postject command
+  const sentinel = 'NODE_SEA_BLOB';
+  const sentinelFuse = 'NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2';
+
+  diag.verbose(`Injecting SEA blob into: ${outputPath}`, 1);
+  
+  // Use postject programmatically
+  const postject = (await import('postject')).default;
+  
+  // Read blob data as buffer
+  const blobData = fs.readFileSync(blobPath);
+  
+  const injectOptions = {
+    sentinelFuse,
+    machoSegmentName: platform === 'darwin' ? 'NODE_SEA' : undefined
+  };
+
+  try {
+    await postject.inject(outputPath, sentinel, blobData, injectOptions);
+    diag.verbose('SEA blob injected successfully', 2);
+  } catch (error) {
+    throw new Error(`Postject injection failed: ${error.message}`);
+  }
+}
+
+/**
+ * Apply rcedit to modify Windows executable resources.
+ * @param {string} exePath - Path to the executable
+ * @param {Object} options - rcedit options (icon, version-string, file-version, product-version, etc.)
+ * @param {boolean} verbose - Enable verbose logging
+ * @returns {Promise<void>}
+ */
+async function applyRcedit(exePath, options, verbose) {
+  diag.verbose('Applying rcedit to modify executable resources...', 2);
+  diag.verbose(`Options: ${JSON.stringify(options, null, 2)}`, 2);
+
+  // Dynamic import for rcedit (it's CommonJS)
+  const rcedit = (await import('rcedit')).default;
+  
+  try {
+    await rcedit(exePath, options);
+    diag.verbose('rcedit applied successfully', 2);
+  } catch (error) {
+    throw new Error(`rcedit failed: ${error.message}`);
+  }
+}
+
+export { applyRcedit };

package/lib/{manifest.js → manifest.mjs}

@@ -1,9 +1,9 @@
 /**
- * manifest.js
+ * manifest.mjs
  * Generate runtime manifest with asset metadata and extraction rules.
  */
 
-const path = require('path');
+import path from 'path';
 
 /**
  * @typedef {Object} BinaryManifestEntry
@@ -28,13 +28,13 @@ const path = require('path');
 
 /**
  * Generate a runtime manifest from scanned assets.
- * @param {import('./scanner').AssetEntry[]} assets - All scanned assets
+ * @param {Array} assets - All scanned assets
  * @param {Object} config - SEA configuration
  * @param {string} targetPlatform - Target platform (win32, linux, darwin)
  * @param {string} targetArch - Target architecture (x64, arm64)
  * @returns {RuntimeManifest}
  */
-function generateManifest(assets, config, targetPlatform, targetArch) {
+export function generateManifest(assets, config, targetPlatform, targetArch) {
   const binaries = assets
     .filter(a => a.isBinary)
     .map((asset, index) => {
@@ -95,12 +95,6 @@ function inferExtractionOrder(fileName, fallbackIndex) {
  * @param {RuntimeManifest} manifest
  * @returns {string}
  */
-function serializeManifest(manifest) {
+export function serializeManifest(manifest) {
   return JSON.stringify(manifest, null, 2);
 }
-
-module.exports = {
-  generateManifest,
-  inferExtractionOrder,
-  serializeManifest
-};