seabox 0.1.0-beta.4 → 0.1.1

package/lib/multi-target-builder.mjs

@@ -11,7 +11,6 @@ import { fileURLToPath } from 'url';
 import Module from 'module';
 
 import { bundleWithRollup } from './rolldown-bundler.mjs';
-import { scanDependenciesForNativeModules } from './native-scanner.mjs';
 import { BuildCache } from './build-cache.mjs';
 import { parseTarget } from './config.mjs';
 import { generateManifest, serializeManifest } from './manifest.mjs';
@@ -21,6 +20,7 @@ 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);
@@ -37,8 +37,11 @@ export class MultiTargetBuilder {
   constructor(config, projectRoot = process.cwd()) {
     this.config = config;
     this.projectRoot = projectRoot;
-    this.cache = new BuildCache(path.join(projectRoot, '.seabox-cache'));
+    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);
   }
 
   /**
@@ -46,43 +49,39 @@ export class MultiTargetBuilder {
    * @returns {Promise<Array<{target: string, path: string}>>}
    */
   async buildAll() {
-    console.log('🚀 Seabox Multi-Target Build');
-    console.log('═══════════════════════════════════════\n');
+    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) {
-      console.log('\n🔍 Auto-detected assets:');
+      diag.separator();
+      diag.info('Auto-detected assets:');
       for (const assetPath of detectedAssets) {
-        console.log(`   - ${assetPath}`);
+        diag.listItem(assetPath, 1);
       }
     }
 
-    // Step 2: Scan for additional native modules in node_modules
-    const scannedNatives = await this.scanNativeModules();
-
-    // Merge detected native modules
-    const allNativeModules = this.mergeNativeModules(nativeModules, scannedNatives);
-
-    if (this.verbose && allNativeModules.size > 0) {
-      console.log('\n📦 Native modules detected:');
-      for (const [name, info] of allNativeModules) {
-        console.log(`   - ${name}: ${info.packageRoot}`);
+    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 3: Build all targets (can be parallelized)
-    console.log(`\n🎯 Building ${this.config.outputs.length} target(s)...\n`);
+    // 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, allNativeModules, detectedAssets, index + 1)
+      this.buildTarget(output, bundledPath, nativeModules, detectedAssets, index + 1)
     );
 
     const results = await Promise.all(buildPromises);
 
-    console.log('\n✅ All builds completed successfully!');
-    console.log('═══════════════════════════════════════\n');
+    diag.summary('All builds completed successfully!');
     
     return results;
   }
@@ -92,7 +91,7 @@ export class MultiTargetBuilder {
    * @returns {Promise<{bundledPath: string, nativeModules: Map}>}
    */
   async bundleEntry() {
-    console.log('[1/6] 📝 Bundling application with Rollup...');
+    diag.step(1, 6, 'Bundling application with Rollup...');
     
     const entryPath = path.resolve(this.projectRoot, this.config.entry);
     
@@ -114,45 +113,12 @@ export class MultiTargetBuilder {
       this.verbose
     );
     
-    console.log(`   ✓ Bundle created: ${bundledPath}`);
+    diag.success(`Bundle created: ${bundledPath}`);
     
     return result;
   }
 
-  /**
-   * Scan node_modules for native modules
-   * @returns {Promise<Array>}
-   */
-  async scanNativeModules() {
-    if (this.verbose) {
-      console.log('\n[2/6] 🔍 Scanning node_modules for native modules...');
-    }
-    
-    const nativeModules = await scanDependenciesForNativeModules(this.projectRoot, this.verbose);
-    
-    return nativeModules;
-  }
 
-  /**
-   * Merge detected native modules from bundler and scanner
-   */
-  mergeNativeModules(bundlerModules, scannedModules) {
-    const merged = new Map(bundlerModules);
-    
-    // Add scanned modules that weren't detected during bundling
-    for (const scanned of scannedModules) {
-      if (!merged.has(scanned.name)) {
-        merged.set(scanned.name, {
-          packageRoot: scanned.path,
-          moduleName: scanned.name,
-          buildPath: path.join(scanned.path, 'build/Release'),
-          binaryFiles: scanned.binaryFiles
-        });
-      }
-    }
-    
-    return merged;
-  }
 
   /**
    * Build a single target
@@ -167,8 +133,7 @@ export class MultiTargetBuilder {
     const { target, path: outputPath, output: executableName } = outputConfig;
     const { nodeVersion, platform, arch } = parseTarget(target);
 
-    console.log(`\n[Build ${buildNumber}] Target: ${target}`);
-    console.log('─────────────────────────────────────────');
+    diag.subheader(`[Build ${buildNumber}] Target: ${target}`);
 
     // Step 1: Rebuild native modules for this target
     const rebuiltModules = await this.rebuildNativeModulesForTarget(
@@ -213,6 +178,41 @@ export class MultiTargetBuilder {
     
     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,
@@ -228,7 +228,12 @@ export class MultiTargetBuilder {
     });
 
     const finalPath = path.join(outputPath, executableName);
-    console.log(`   ✅ Build complete: ${finalPath}`);
+    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,
@@ -244,24 +249,42 @@ export class MultiTargetBuilder {
       return [];
     }
 
-    console.log(`   [${buildNumber}.1] 🔨 Rebuilding ${nativeModules.size} native module(s)...`);
+    diag.buildStep(buildNumber, 1, `Rebuilding ${nativeModules.size} native module(s)...`);
 
     const rebuiltAssets = [];
     const { platform, arch } = parseTarget(target);
 
-    for (const [moduleName, moduleInfo] of nativeModules) {
+    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) {
-          if (this.verbose) {
-            console.log(`      ✓ Using cached build: ${moduleName}`);
-          }
+          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: `native/${moduleName}.node`,
+            assetKey: relativeFromProject,
             isBinary: true,
             hash: await this.computeHash(cachedBuild)
           });
@@ -269,9 +292,7 @@ export class MultiTargetBuilder {
         }
 
         // Rebuild the module
-        if (this.verbose) {
-          console.log(`      🔧 Rebuilding: ${moduleName}`);
-        }
+        diag.verbose(`Rebuilding: ${moduleName}`, 2);
 
         await this.rebuildNativeModule(moduleInfo.packageRoot, target);
 
@@ -282,23 +303,24 @@ export class MultiTargetBuilder {
           // 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: `native/${moduleName}.node`,
+            assetKey: relativeFromProject,
             isBinary: true,
             hash: await this.computeHash(builtPath)
           });
           
-          if (this.verbose) {
-            console.log(`      ✓ Built: ${moduleName} -> ${builtPath}`);
-          }
+          diag.verbose(`Built: ${moduleName} -> ${builtPath}`, 2);
         }
       } catch (err) {
-        console.warn(`      ⚠️  Failed to rebuild ${moduleName}:`, err.message);
+        diag.warn(`Failed to rebuild ${moduleName}: ${err.message}`, 2);
       }
     }
 
-    console.log(`   ✓ Native modules processed`);
+    diag.success('Native modules processed');
     return rebuiltAssets;
   }
 
@@ -349,33 +371,43 @@ export class MultiTargetBuilder {
 
   /**
    * Collect platform-specific libraries (DLLs, SOs, DYLIBs) that need filesystem extraction
-   * @param {string[]} libraryPatterns - Glob patterns for libraries
+   * 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) {
-    // Use provided patterns or default to platform-specific patterns
-    const { getDefaultLibraryPatterns } = await import('./config.mjs');
-    const patterns = libraryPatterns && libraryPatterns.length > 0 
-      ? libraryPatterns 
-      : getDefaultLibraryPatterns(platform);
-
-    if (!patterns || patterns.length === 0) {
+    // Only process explicitly configured library patterns
+    // Do NOT use default patterns - this prevents automatic inclusion of unrelated DLLs
+    if (!libraryPatterns || libraryPatterns.length === 0) {
       return [];
     }
 
-    console.log(`   [${buildNumber}.4] 📚 Collecting platform libraries (${platform})...`);
+    diag.buildStep(buildNumber, 4, `Collecting platform libraries (${platform})...`);
 
     const { glob } = await import('glob');
     const libraries = [];
 
-    for (const pattern of patterns) {
+    for (const pattern of libraryPatterns) {
       const matches = await glob(pattern, {
         cwd: this.projectRoot,
         nodir: true,
         absolute: false,
-        ignore: ['**/node_modules/**', '**/.git/**']
+        ignore: [
+          '**/node_modules/**',
+          '**/.git/**',
+          '**/dist/**',
+          '**/build/**',
+          '**/out/**',
+          '**/bin/**',
+          '**/obj/**',
+          '**/tools/**',
+          '**/.seabox-cache/**'
+        ]
       });
 
       for (const match of matches) {
@@ -391,7 +423,7 @@ export class MultiTargetBuilder {
     }
 
     if (libraries.length > 0) {
-      console.log(`   ✓ Collected ${libraries.length} library file(s)`);
+      diag.success(`Collected ${libraries.length} library file(s)`);
     }
 
     return libraries;
@@ -407,7 +439,7 @@ export class MultiTargetBuilder {
       return [];
     }
 
-    console.log(`   [${buildNumber}.2] 📦 Collecting config assets...`);
+    diag.buildStep(buildNumber, 2, 'Collecting config assets...');
 
     const { glob } = await import('glob');
     const assets = [];
@@ -417,7 +449,17 @@ export class MultiTargetBuilder {
         cwd: this.projectRoot,
         nodir: true,
         absolute: false,
-        ignore: ['**/node_modules/**', '**/.git/**']
+        ignore: [
+          '**/node_modules/**',
+          '**/.git/**',
+          '**/dist/**',
+          '**/build/**',
+          '**/out/**',
+          '**/bin/**',
+          '**/obj/**',
+          '**/tools/**',
+          '**/.seabox-cache/**'
+        ]
       });
 
       for (const match of matches) {
@@ -433,7 +475,7 @@ export class MultiTargetBuilder {
     }
 
     if (assets.length > 0) {
-      console.log(`   ✓ Collected ${assets.length} config asset(s)`);
+      diag.success(`Collected ${assets.length} config asset(s)`);
     }
 
     return assets;
@@ -449,7 +491,7 @@ export class MultiTargetBuilder {
       return [];
     }
 
-    console.log(`   [${buildNumber}.3] 🔍 Processing auto-detected assets...`);
+    diag.buildStep(buildNumber, 3, 'Processing auto-detected assets...');
 
     const assets = [];
 
@@ -468,7 +510,7 @@ export class MultiTargetBuilder {
     }
 
     if (assets.length > 0) {
-      console.log(`   ✓ Collected ${assets.length} auto-detected asset(s)`);
+      diag.success(`Collected ${assets.length} auto-detected asset(s)`);
     }
 
     return assets;
@@ -487,7 +529,7 @@ export class MultiTargetBuilder {
    * Prepare final entry with bootstrap
    */
   async prepareFinalEntry(bundledEntryPath, buildNumber) {
-    console.log(`   [${buildNumber}.3] 🎁 Preparing bootstrap...`);
+    diag.buildStep(buildNumber, 3, 'Preparing bootstrap...');
 
     const bootstrapPath = path.join(__dirname, 'bootstrap.cjs');
     const bootstrapContent = fs.readFileSync(bootstrapPath, 'utf8');
@@ -509,9 +551,7 @@ const SEA_ENCRYPTED_ASSETS = new Set([]);
         "  'use strict';\n" + encryptionSetup
       );
       
-      if (this.verbose) {
-        console.log('      ✓ Encryption enabled and bootstrap obfuscated');
-      }
+      diag.verbose('Encryption enabled and bootstrap obfuscated', 2);
       
       augmentedBootstrap = obfuscateBootstrap(augmentedBootstrap);
     }
@@ -526,7 +566,7 @@ const SEA_ENCRYPTED_ASSETS = new Set([]);
     const finalPath = bundledEntryPath.replace('.js', '-final.js');
     fs.writeFileSync(finalPath, finalEntry, 'utf8');
 
-    console.log(`   ✓ Bootstrap prepared`);
+    diag.success('Bootstrap prepared');
     return finalPath;
   }
 
@@ -547,7 +587,7 @@ const SEA_ENCRYPTED_ASSETS = new Set([]);
       buildNumber
     } = options;
 
-    console.log(`   [${buildNumber}.4] 🔧 Generating SEA blob...`);
+    diag.buildStep(buildNumber, 4, 'Generating SEA blob...');
 
     // Generate manifest
     const manifest = generateManifest(
@@ -583,16 +623,16 @@ const SEA_ENCRYPTED_ASSETS = new Set([]);
 
     // Generate blob
     await generateBlob(seaConfigPath, process.execPath);
-    console.log(`   ✓ SEA blob generated`);
+    diag.success('SEA blob generated');
 
     // Fetch Node binary
-    console.log(`   [${buildNumber}.5] 📥 Fetching Node.js 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);
-    console.log(`   ✓ Node binary ready`);
+    diag.success('Node binary ready');
 
     // Inject blob
-    console.log(`   [${buildNumber}.6] 💉 Injecting blob into executable...`);
+    diag.buildStep(buildNumber, 6, 'Injecting blob into executable...');
     const outputExe = path.join(outputDir, executableName);
     await injectBlob(nodeBinary, blobOutputPath, outputExe, platform, this.verbose, rcedit);
 
@@ -601,8 +641,8 @@ const SEA_ENCRYPTED_ASSETS = new Set([]);
       fs.rmSync(tempDir, { recursive: true, force: true });
     }
 
-    const sizeMB = (fs.statSync(outputExe).size / 1024 / 1024).toFixed(2);
-    console.log(`   ✓ Injected (${sizeMB} MB)`);
+    const size = diag.formatSize(fs.statSync(outputExe).size);
+    diag.success(`Injected (${size})`);
   }
 
   /**
@@ -617,4 +657,49 @@ const SEA_ENCRYPTED_ASSETS = new Set([]);
       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}`);
+    }
+  }
 }

package/lib/native-scanner.mjs

@@ -6,6 +6,7 @@
 import fs from 'fs/promises';
 import fsSync from 'fs';
 import path from 'path';
+import * as diag from './diagnostics.mjs';
 
 /**
  * @typedef {Object} NativeModuleMetadata
@@ -27,15 +28,11 @@ export async function scanDependenciesForNativeModules(projectRoot, verbose = fa
   const nodeModulesPath = path.join(projectRoot, 'node_modules');
 
   if (!fsSync.existsSync(nodeModulesPath)) {
-    if (verbose) {
-      console.log('[NativeScanner] No node_modules directory found');
-    }
+    diag.verbose('No node_modules directory found');
     return [];
   }
 
-  if (verbose) {
-    console.log('[NativeScanner] Scanning node_modules for native modules');
-  }
+  diag.verbose('Scanning node_modules for native modules');
 
   /**
    * Recursively scan a directory for packages
@@ -71,9 +68,7 @@ export async function scanDependenciesForNativeModules(projectRoot, verbose = fa
         }
       }
     } catch (err) {
-      if (verbose) {
-        console.warn('[NativeScanner] Error scanning directory:', dir, err.message);
-      }
+      diag.verbose(`Error scanning directory: ${dir} - ${err.message}`);
     }
   }
 
@@ -152,11 +147,9 @@ export async function scanDependenciesForNativeModules(projectRoot, verbose = fa
 
   await scanDir(nodeModulesPath);
 
-  if (verbose) {
-    console.log(`[NativeScanner] Found ${nativeModules.length} native modules`);
-    for (const mod of nativeModules) {
-      console.log(`  - ${mod.name}@${mod.version} (${mod.binaryFiles.length} binaries)`);
-    }
+  diag.verbose(`Found ${nativeModules.length} native modules`);
+  for (const mod of nativeModules) {
+    diag.verbose(`- ${mod.name}@${mod.version} (${mod.binaryFiles.length} binaries)`, 1);
   }
 
   return nativeModules;

package/lib/require-shim.mjs

@@ -3,6 +3,8 @@
  * SEA-aware require replacement that intercepts .node module loads
  */
 
+import * as diag from './diagnostics.mjs';
+
 /**
  * Generate the __requireSeabox shim code
  * @returns {string} - The shim code to inject
@@ -58,9 +60,9 @@ function __requireSeabox(id) {
         process.dlopen(module, resolvedPath);
         return module.exports;
       } else {
-        console.error('[__requireSeabox] ✗ Native module not found in map');
-        console.error('[__requireSeabox] Requested:', id);
-        console.error('[__requireSeabox] Available:', Object.keys(global.__seaNativeModuleMap));
+        console.error('[X] Native module not found in map');
+        console.error('    Requested:', id);
+        console.error('    Available:', Object.keys(global.__seaNativeModuleMap));
       }
     }
   }
@@ -88,7 +90,7 @@ function __requireSeabox(id) {
  * @returns {Object} - { code: string, count: number }
  */
 export function replaceRequireCalls(sourceCode, verbose = false) {
-  if (verbose) console.log('Replacing require() calls with __requireSeabox()');
+  diag.verbose('Replacing require() calls with __requireSeabox()');
   
   const requirePattern = /\brequire\s*\(/g;
   let replacementCount = 0;
@@ -98,7 +100,7 @@ export function replaceRequireCalls(sourceCode, verbose = false) {
     return '__requireSeabox(';
   });
   
-  if (verbose) console.log('Replaced ' + replacementCount + ' require() calls');
+  diag.verbose(`Replaced ${replacementCount} require() calls`);
   
   return {
     code: transformedCode,