seabox 0.1.0-beta.4 → 0.1.1

package/README.md

@@ -25,6 +25,16 @@ Note: **V8 snapshot includes and embedds the original source**, this is currentl
 npm install --save-dev seabox
 ```
 
+### Optional: Windows Executable Metadata
+
+If you want to customize Windows executable metadata (icon, version info), install `rcedit`:
+
+```bash
+npm install --save-dev rcedit
+```
+
+This is only needed if you use the `rcedit` configuration option.
+
 ## Configuration
 
 Create a `seabox.config.json` file in your project root:
@@ -57,12 +67,12 @@ Create a `seabox.config.json` file in your project root:
 | `outputs[].path` | `string` | Yes | Output directory for this target |
 | `outputs[].target` | `string` | Yes | Build target (format: `nodeX.Y.Z-platform-arch`) |
 | `outputs[].output` | `string` | Yes | Output filename |
-| `outputs[].libraries` | `array` | No | Glob patterns for shared libraries (DLLs/SOs) requiring filesystem extraction (defaults: `**/*.dll` for Windows, `**/*.so*` for Linux, `**/*.dylib` for macOS) |
+| `outputs[].libraries` | `array` | No | Explicit glob patterns for shared libraries (DLLs/SOs) requiring filesystem extraction. Libraries referenced in code via `, ...)` are automatically detected. |
 | `outputs[].rcedit` | `object` | No | Windows executable metadata (icon, version info) |
 | `assets` | `array` | No | Glob patterns for assets to embed (merged with auto-detected assets) |
-| `bundler` | `object` | No | Bundler options |
+| `bundler` | `object` | No | Rolldown Bundler options |
 | `bundler.external` | `array` | No | Modules to exclude from bundling |
-| `bundler.plugins` | `array` | No | Additional Rollup plugins |
+| `bundler.plugins` | `array` | No | Additional Rolldown plugins |
 | `bundler.minify` | `boolean` | No | Minify bundled code |
 | `bundler.sourcemap` | `boolean` | No | Generate source maps |
 | `encryptAssets` | `boolean` | No | Enable asset encryption (default: false) |
@@ -70,6 +80,7 @@ Create a `seabox.config.json` file in your project root:
 | `useSnapshot` | `boolean` | No | Enable V8 startup snapshots (default: true) |
 | `useCodeCache` | `boolean` | No | Enable V8 code cache (default: false) |
 | `cacheLocation` | `string` | No | Path for code cache storage |
+| `sign` | `string` | No | Path to custom signing script (.mjs/.cjs) |
 | `verbose` | `boolean` | No | Enable verbose logging (default: false) |
 
 ## Usage
@@ -127,9 +138,10 @@ await build({
 
 seabox automates the entire SEA build process:
 
-1. **Bundling** - Automatically bundles your app with Rollup, detecting:
+1. **Bundling** - Automatically bundles your app with Rolldown, detecting:
    - Native module patterns (`bindings`, `node-gyp-build`, direct `.node` requires)
    - Asset references via `path.join(__dirname, 'relative/path')`
+   - Additional 
 
 2. **Asset Collection** - Gathers assets from three sources:
    - **Auto-detected**: Files referenced via `path.join(__dirname, ...)` patterns
@@ -163,11 +175,6 @@ const configPath = path.join(__dirname, '../config/app.json');
 const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
 ```
 
-**Detection works with:**
-- `path.join(__dirname, 'relative/path')`
-- `path.resolve(__dirname, 'relative/path')`
-- Multiple path segments: `path.join(__dirname, '..', 'assets', 'file.txt')`
-
 **Asset sources (merged and deduplicated):**
 1. **Auto-detected** from code analysis during bundling
 2. **Config globs** from `assets: ["./data/**/*", "./public/**/*"]`
@@ -187,38 +194,81 @@ seabox automatically handles native modules without any configuration:
 - Native modules are extracted to a cache directory on first run
 - Modules are integrity-checked with SHA-256 hashes
 - Custom `require()` shim loads modules from cache
-- Works transparently with packages like `better-sqlite3`, `sharp`, `canvas`, etc.
-
 
 ### Platform-Specific Libraries
 
-Libraries that require filesystem access (like DLLs that are loaded via `dlopen`) can be specified with glob patterns:
+Libraries that require filesystem access (like DLLs loaded via `dlopen`) can be included in two ways:
+
+**1. Automatic Detection (Recommended)**
+
+If your code references a DLL using `path.join(__dirname, ...)`, it will be automatically detected and included:
+
+```javascript
+// This will be automatically detected during bundling
+const dllPath = path.join(__dirname, './lib/RGDevice.dll');
+```
+
+**2. Explicit Glob Patterns**
+
+You can also explicitly specify library patterns in your config:
 
 ```json
 {
   "outputs": [
     {
       "target": "node24.11.0-win32-x64",
-      "libraries": ["**/*.dll"]  // Auto-extracted at runtime
+      "libraries": ["lib/*.dll"]  // Manually specify DLLs to include
     }
   ]
 }
 ```
 
-**Defaults by platform:**
-- **Windows**: `**/*.dll`
-- **Linux**: `**/*.so`, `**/*.so.*`
-- **macOS**: `**/*.dylib`
 
 These files are extracted on first run (like `.node` files) since they need to be loaded from the filesystem.
 
 ### Code Signature Removal
-
-Required before SEA injection. Platform-specific tools needed:
+If you have sign tools available, the seabox will attempt to unsign the node exe before modifying it. This is to reduce issues afterward when you try to resign it. 
 - **Windows**: `signtool.exe` (from Windows SDK)
 - **macOS**: `codesign` (included with Xcode)
 - **Linux**: Not required
 
+### Custom Signing
+
+You can apply code signing after the build completes by specifying a custom signing script:
+
+```json
+{
+  "sign": "./scripts/sign.mjs"
+}
+```
+
+The signing script must export a default function that receives a config object:
+
+```javascript
+// scripts/sign.mjs
+export default async function sign(config) {
+  const { exePath, target, platform, arch, nodeVersion, projectRoot } = config;
+  
+  // Example: Windows code signing with signtool
+  if (platform === 'win32') {
+    execSync(`signtool sign /fd SHA256 /a "${exePath}"`);
+  }
+  
+  // Example: macOS code signing
+  if (platform === 'darwin') {
+    execSync(`codesign --force --sign "Developer ID" "${exePath}"`);
+  }
+}
+```
+
+**Config parameters:**
+- `exePath` - Absolute path to the built executable
+- `target` - Full target string (e.g., "node24.11.0-win32-x64")
+- `platform` - Platform name (win32, linux, darwin)
+- `arch` - Architecture (x64, arm64)
+- `nodeVersion` - Node.js version
+- `projectRoot` - Absolute path to project root
+
 ## Asset Encryption
 
 seabox supports optional AES-256-GCM encryption of embedded assets to protect your application code and data:
@@ -238,231 +288,17 @@ seabox supports optional AES-256-GCM encryption of embedded assets to protect yo
 1. **Build Time**: A random 256-bit encryption key is generated
 2. **Asset Encryption**: Non-binary assets are encrypted using AES-256-GCM
 3. **Key Embedding**: The encryption key is obfuscated and embedded in the bootstrap code
-4. **Key Obfuscation**: the bootstrap and key code are obfuscated, but not removed 
+4. **Key Obfuscation**: the bootstrap and key code are obfuscated
 5. **Runtime Decryption**: Assets are transparently decrypted when accessed
 
 ### Considerations
 
 - **Binary files** (`.node`, `.dll`, `.so`, `.dylib`) are **never encrypted** as they must be extracted as-is
 - The manifest (`sea-manifest.json`) is **not encrypted** to allow bootstrap initialization
-- **V8 snapshot includes the original source**, this is currently a limitation of Node's SEA. 
+- **V8 snapshot includes the original source**, this is currently a limitation of Node's SEA tooling. 
 - Encryption provides **obfuscation**, not cryptographic security against determined attackers
 - The bootloader code, that includes the encryption key, is obfuscated in the source embedded by Node's SEA
   
-
-## Platform Support
-
-- **Windows**: `win32-x64`, `win32-arm64`
-- **Linux**: `linux-x64`, `linux-arm64`
-- **macOS**: `darwin-x64`, `darwin-arm64`
-
-## License
-
-MIT
-Copyright Meirion Hughes 2025
-## Examples
-
-### Basic Application
-
-```javascript
-// src/index.js
-console.log('Hello from SEA!');
-console.log('Platform:', process.platform);
-console.log('Architecture:', process.arch);
-```
-
-```json
-// seabox.config.json
-{
-  "entry": "./src/index.js",
-  "outputs": [
-    {
-      "path": "./dist",
-      "target": "node24.11.0-win32-x64",
-      "output": "hello.exe"
-    }
-  ]
-}
-```
-
-### With Assets (Auto-Detection)
-
-```javascript
-// src/index.js
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-// Assets referenced via path.join(__dirname, ...) are auto-detected
-const configPath = path.join(__dirname, '../config/settings.json');
-const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-
-console.log('Config loaded:', config);
-```
-
-No configuration needed - the asset is automatically detected and embedded!
-
-### With Config Assets
-
-```json
-{
-  "entry": "./src/index.js",
-  "outputs": [
-    {
-      "path": "./dist",
-      "target": "node24.11.0-win32-x64",
-      "output": "myapp.exe"
-    }
-  ],
-  "assets": [
-    "./public/**/*",
-    "./data/**/*.json",
-    "!**/*.md"
-  ]
-}
-```
-
-All files matching the glob patterns will be embedded. Auto-detected assets are merged automatically.
-
-### With Native Modules
-
-```javascript
-// src/index.js
-import Database from 'better-sqlite3';
-
-const db = new Database(':memory:');
-db.exec('CREATE TABLE users (name TEXT)');
-db.prepare('INSERT INTO users VALUES (?)').run('Alice');
-
-const users = db.prepare('SELECT * FROM users').all();
-console.log('Users:', users);
-
-db.close();
-```
-
-No special configuration needed - seabox automatically detects and handles the native module!
-
-### Multi-Platform Build
-
-```json
-{
-  "entry": "./src/index.js",
-  "outputs": [
-    {
-      "path": "./dist/win",
-      "target": "node24.11.0-win32-x64",
-      "output": "myapp.exe"
-    },
-    {
-      "path": "./dist/linux",
-      "target": "node24.11.0-linux-x64",
-      "output": "myapp"
-    },
-    {
-      "path": "./dist/macos",
-      "target": "node24.11.0-darwin-arm64",
-      "output": "myapp"
-    }
-  ],
-  "bundler": {
-    "external": []
-  },
-  "useSnapshot": true
-}
-```
-
-Run `seabox build` and get executables for all three platforms!
-
-## Advanced Features
-
-### Asset Encryption
-
-Protect your source code with AES-256-GCM encryption:
-
-```json
-{
-  "entry": "./src/index.js",
-  "outputs": [
-    {
-      "path": "./dist",
-      "target": "node24.11.0-win32-x64",
-      "output": "myapp.exe"
-    }
-  ],
-  "encryptAssets": true,
-  "encryptExclude": ["*.txt"]
-}
-```
-
-### External Dependencies
-
-Exclude packages from bundling:
-
-```json
-{
-  "entry": "./src/index.js",
-  "outputs": [
-    {
-      "path": "./dist",
-      "target": "node24.11.0-win32-x64",
-      "output": "myapp.exe"
-    }
-  ],
-  "bundler": {
-    "external": ["fsevents", "some-optional-dep"]
-  }
-}
-```json
-{
-  "bundler": {
-    "external": ["fsevents", "some-optional-dep"]
-  }
-}
-```
-
-Useful for:
-- Platform-specific optional dependencies
-- Packages that don't bundle well
-- Reducing bundle size
-
-## Platform Support
-
-### Supported Targets
-
-| Platform | Architectures | Example |
-|----------|--------------|---------|
-| Windows | x64, arm64 | `node24.11.0-win32-x64` |
-| Linux | x64, arm64 | `node24.11.0-linux-x64` |
-| macOS | x64, arm64 | `node24.11.0-darwin-arm64` |
-
-### Node.js Versions
-
-Works with Node.js 18.0.0 and above that support SEA.
-
-## Troubleshooting
-
-### Native modules not loading
-
-If you see errors about missing `.node` files:
-1. Check that the module was detected during build (look for "Native modules detected" in output)
-2. Run with `--verbose` to see detailed bundling info
-3. Ensure the module uses standard patterns (`bindings`, `node-gyp-build`, etc.)
-
-### Build fails with signature removal error
-
-Install the required tools:
-- **Windows**: Install Windows SDK for `signtool.exe`
-- **macOS**: Install Xcode Command Line Tools for `codesign`
-
-### Cross-compilation issues
-
-When building for a different platform than your current OS:
-- Native module detection works cross-platform
-- The bundled JavaScript is platform-agnostic
-- Each target is built independently with the correct Node.js binary
-
 ## Contributing
 
 Contributions welcome! Please open an issue or PR on [GitHub](https://github.com/MeirionHughes/seabox).

package/bin/seabox-rebuild.mjs

@@ -8,6 +8,7 @@ import { execSync } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import * as diag from '../lib/diagnostics.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -20,10 +21,10 @@ const __dirname = path.dirname(__filename);
  * @param {boolean} verbose - Enable verbose logging
  */
 function rebuildNativeModule(modulePath, platform, arch, verbose = false) {
-  if (verbose) {
-    console.log(`Rebuilding native module: ${modulePath}`);
-    console.log(`Target: ${platform}-${arch}`);
-  }
+  diag.setVerbose(verbose);
+  
+  diag.verbose(`Rebuilding native module: ${modulePath}`);
+  diag.verbose(`Target: ${platform}-${arch}`);
 
   const packageJsonPath = path.join(modulePath, 'package.json');
   if (!fs.existsSync(packageJsonPath)) {
@@ -36,9 +37,7 @@ function rebuildNativeModule(modulePath, platform, arch, verbose = false) {
   // Check if module has native bindings
   const hasBindingGyp = fs.existsSync(path.join(modulePath, 'binding.gyp'));
   if (!hasBindingGyp && !pkg.gypfile) {
-    if (verbose) {
-      console.log(`Module ${moduleName} does not appear to have native bindings, skipping`);
-    }
+    diag.verbose(`Module ${moduleName} does not appear to have native bindings, skipping`);
     return;
   }
 
@@ -46,9 +45,7 @@ function rebuildNativeModule(modulePath, platform, arch, verbose = false) {
     // Use node-gyp to rebuild for the target platform
     const cmd = `npx node-gyp rebuild --target_platform=${platform} --target_arch=${arch}`;
     
-    if (verbose) {
-      console.log(`Running: ${cmd}`);
-    }
+    diag.verbose(`Running: ${cmd}`);
 
     execSync(cmd, {
       cwd: modulePath,
@@ -60,13 +57,9 @@ function rebuildNativeModule(modulePath, platform, arch, verbose = false) {
       }
     });
 
-    if (verbose) {
-      console.log(`✓ Successfully rebuilt ${moduleName}`);
-    }
+    diag.verbose(`Successfully rebuilt ${moduleName}`);
   } catch (error) {
-    if (verbose) {
-      console.error(`Failed to rebuild ${moduleName}:`, error.message);
-    }
+    diag.verbose(`Failed to rebuild ${moduleName}: ${error.message}`);
     throw error;
   }
 }
@@ -76,7 +69,7 @@ if (import.meta.url === `file://${process.argv[1]}`) {
   const args = process.argv.slice(2);
   
   if (args.length < 3) {
-    console.error('Usage: seabox-rebuild <module-path> <platform> <arch> [--verbose]');
+    diag.error('Usage: seabox-rebuild <module-path> <platform> <arch> [--verbose]');
     process.exit(1);
   }
 
@@ -87,7 +80,7 @@ if (import.meta.url === `file://${process.argv[1]}`) {
     rebuildNativeModule(modulePath, platform, arch, verbose);
     process.exit(0);
   } catch (error) {
-    console.error('Rebuild failed:', error.message);
+    diag.error(`Rebuild failed: ${error.message}`);
     process.exit(1);
   }
 }

package/bin/seabox.mjs

@@ -11,6 +11,7 @@ import path from 'path';
 import fs from 'fs';
 import { fileURLToPath } from 'url';
 import Module from 'module';
+import * as diag from '../lib/diagnostics.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -26,12 +27,15 @@ const commands = {
     const config = loadConfig(configPath, projectRoot);
     
     if (!config) {
-      console.log('❌ No configuration found\n');
-      console.log('Seabox looks for configuration in this order:');
-      console.log('  1. --config <path> (command line argument)');
-      console.log('  2. seabox.config.json (in current directory)');
-      console.log('  3. "seabox" field in package.json\n');
-      console.log('To get started, run: npx seabox init\n');
+      diag.error('No configuration found');
+      diag.separator();
+      diag.info('Seabox looks for configuration in this order:');
+      diag.numberedItem(1, '--config <path> (command line argument)');
+      diag.numberedItem(2, 'seabox.config.json (in current directory)');
+      diag.numberedItem(3, '"seabox" field in package.json');
+      diag.separator();
+      diag.info('To get started, run: npx seabox init');
+      diag.separator();
       commands.help();
       process.exit(1);
     }
@@ -61,7 +65,7 @@ const commands = {
     const configPath = path.join(process.cwd(), 'seabox.config.json');
     
     if (fs.existsSync(configPath)) {
-      console.error('❌ Error: seabox.config.json already exists');
+      diag.error('seabox.config.json already exists');
       process.exit(1);
     }
 
@@ -71,27 +75,34 @@ const commands = {
 
     fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + '\n', 'utf8');
     
-    console.log('✅ Created seabox.config.json');
-    console.log('\n📝 Next steps:');
-    console.log('   1. Edit seabox.config.json to configure your build');
-    console.log('   2. Run: npx seabox build\n');
+    diag.success('Created seabox.config.json', 0);
+    diag.separator();
+    diag.info('Next steps:');
+    diag.numberedItem(1, 'Edit seabox.config.json to configure your build');
+    diag.numberedItem(2, 'Run: npx seabox build');
+    diag.separator();
   },
 
   help: () => {
-    console.log('Seabox v2 - Node.js Single Executable Application Builder\n');
-    console.log('Usage: seabox [command] [options]\n');
-    console.log('Commands:');
-    console.log('  build      Build executable(s) for configured targets (default)');
-    console.log('  init       Create a default seabox.config.json\n');
-    console.log('Build Options:');
-    console.log('  --config   Path to config file (default: seabox.config.json)');
-    console.log('  --verbose  Enable verbose logging');
-    console.log('  --debug    Keep temporary build files\n');
-    console.log('Examples:');
-    console.log('  seabox init');
-    console.log('  seabox build');
-    console.log('  seabox --verbose           # Same as: seabox build --verbose');
-    console.log('  seabox build --verbose\n');
+    diag.info('Seabox v2 - Node.js Single Executable Application Builder');
+    diag.separator();
+    diag.info('Usage: seabox [command] [options]');
+    diag.separator();
+    diag.info('Commands:');
+    diag.info('  build      Build executable(s) for configured targets (default)');
+    diag.info('  init       Create a default seabox.config.json');
+    diag.separator();
+    diag.info('Build Options:');
+    diag.info('  --config   Path to config file (default: seabox.config.json)');
+    diag.info('  --verbose  Enable verbose logging');
+    diag.info('  --debug    Keep temporary build files');
+    diag.separator();
+    diag.info('Examples:');
+    diag.info('  seabox init');
+    diag.info('  seabox build');
+    diag.info('  seabox --verbose           # Same as: seabox build --verbose');
+    diag.info('  seabox build --verbose');
+    diag.separator();
   }
 };
 
@@ -119,14 +130,15 @@ async function main() {
     try {
       await commands[command](commandArgs);
     } catch (error) {
-      console.error('Error:', error.message);
+      diag.error(error.message);
       if (args.includes('--verbose')) {
         console.error(error.stack);
       }
       process.exit(1);
     }
   } else {
-    console.error(`Unknown command: ${command}\n`);
+    diag.error(`Unknown command: ${command}`);
+    diag.separator();
     commands.help();
     process.exit(1);
   }

package/lib/blob.mjs

@@ -7,6 +7,7 @@ import fs from 'fs';
 import path from 'path';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
+import * as diag from './diagnostics.mjs';
 
 const execFileAsync = promisify(execFile);
 
@@ -96,7 +97,7 @@ export function writeSeaConfigJson(seaConfig, outputPath, assets, tempDir) {
 export async function generateBlob(seaConfigPath, nodeBinary = process.execPath) {
   try {
     await execFileAsync(nodeBinary, ['--experimental-sea-config', seaConfigPath]);
-    console.log('✓ SEA blob generated successfully');
+    diag.verbose('SEA blob generated successfully', 2);
   } catch (error) {
     throw new Error(`Failed to generate SEA blob: ${error.message}`);
   }

package/lib/build.mjs

@@ -5,6 +5,7 @@
 
 import { loadConfig } from './config.mjs';
 import { MultiTargetBuilder } from './multi-target-builder.mjs';
+import * as diag from './diagnostics.mjs';
 import fs from 'fs';
 
 /**
@@ -49,17 +50,18 @@ export async function build(options = {}) {
     const results = await builder.buildAll();
 
     // Display results
-    console.log('📦 Output files:');
+    diag.separator();
+    diag.info('Output files:');
     for (const result of results) {
-      const stats = fs.statSync(result.path);
-      const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
-      console.log(`   ${result.target}: ${result.path} (${sizeMB} MB)`);
+      const size = diag.formatSize(fs.statSync(result.path).size);
+      diag.info(`  ${result.target}: ${result.path} (${size})`);
     }
-    console.log('');
+    diag.separator();
 
     return results;
   } catch (error) {
-    console.error('\n❌ Build failed:', error.message);
+    diag.separator();
+    diag.error(`Build failed: ${error.message}`);
     if (verbose || process.argv.includes('--verbose')) {
       console.error(error.stack);
     }

package/lib/config.mjs

@@ -34,6 +34,7 @@ import path from 'path';
  * @property {boolean} [useSnapshot] - Enable V8 snapshot
  * @property {boolean} [useCodeCache] - Enable V8 code cache
  * @property {string} [cacheLocation] - Cache directory for extracted binaries
+ * @property {string} [sign] - Path to signing script (.mjs/.cjs) that exports a function(config) => Promise<void>
  * @property {boolean} [verbose] - Enable verbose logging
  */
 
@@ -89,11 +90,19 @@ export function loadConfig(configPath, projectRoot = process.cwd()) {
  * @returns {SeaboxConfig}
  */
 export function normalizeConfig(pkgConfig, pkg) {
+  // Helper to normalize assets to array
+  const normalizeAssets = (assets) => {
+    if (!assets) return [];
+    if (Array.isArray(assets)) return assets;
+    if (typeof assets === 'string') return [assets];
+    return [];
+  };
+
   // If already in outputs format, return as-is
   if (pkgConfig.outputs) {
     return {
       ...pkgConfig,
-      assets: pkgConfig.assets || [],
+      assets: normalizeAssets(pkgConfig.assets),
       bundler: pkgConfig.bundler || { external: [] },
       _packageName: pkg.name,
       _packageVersion: pkg.version
@@ -112,7 +121,7 @@ export function normalizeConfig(pkgConfig, pkg) {
   return {
     entry: pkgConfig.entry,
     outputs: outputs,
-    assets: pkgConfig.assets || [],
+    assets: normalizeAssets(pkgConfig.assets),
     bundler: {
       external: pkgConfig.external || []
     },