electrobun 0.0.19-beta.6 → 0.0.19-beta.61

package/BUILD.md

@@ -0,0 +1,90 @@
+# Build System
+
+This document describes Electrobun's build system and cross-platform compilation approach.
+
+## Overview
+
+Electrobun uses a custom build system (`build.ts`) that handles:
+- Vendoring dependencies (Bun, Zig, CEF, WebView2)
+- Building native wrappers for each platform
+- Creating distribution packages
+
+## Platform-Specific Native Wrappers
+
+### macOS
+- Single `libNativeWrapper.dylib` with weak linking to CEF framework
+- Uses `-weak_framework 'Chromium Embedded Framework'` for optional CEF support
+- Gracefully falls back to WebKit when CEF is not bundled
+
+### Windows  
+- Single `libNativeWrapper.dll` with runtime CEF detection
+- Links both WebView2 and CEF libraries at build time
+- Uses runtime checks to determine which webview engine to use
+
+### Linux
+**Dual Binary Approach** - Linux builds create two separate native wrapper binaries:
+
+#### `libNativeWrapper.so` (GTK-only)
+- Size: ~1.46MB
+- Dependencies: WebKitGTK, GTK+3, AppIndicator only
+- No CEF dependencies linked
+- Used when `bundleCEF: false` in electrobun.config
+
+#### `libNativeWrapper_cef.so` (CEF-enabled)  
+- Size: ~3.47MB
+- Dependencies: WebKitGTK, GTK+3, AppIndicator + CEF libraries
+- Full CEF functionality available
+- Used when `bundleCEF: true` in electrobun.config
+
+#### Why Dual Binaries?
+
+Unlike macOS and Windows, Linux doesn't have reliable weak linking for shared libraries. Hard linking CEF libraries causes `dlopen` failures when CEF isn't bundled. The dual binary approach provides:
+
+1. **Small bundle sizes** - Developers can ship lightweight apps without CEF overhead
+2. **Flexibility** - Same codebase supports both system WebKitGTK and CEF rendering
+3. **Reliability** - No runtime linking failures or undefined symbols
+
+#### CLI Binary Selection
+
+The Electrobun CLI automatically copies the appropriate binary based on the `bundleCEF` setting:
+
+```typescript
+const useCEF = config.build.linux?.bundleCEF;
+const nativeWrapperSource = useCEF 
+  ? PATHS.NATIVE_WRAPPER_LINUX_CEF 
+  : PATHS.NATIVE_WRAPPER_LINUX;
+```
+
+Both binaries are included in the distributed `electrobun` npm package, ensuring developers can toggle CEF support without recompilation.
+
+## Build Commands
+
+```bash
+# Full build with all platforms
+bun build.ts
+
+# Development build with playground
+bun dev:playground
+
+# Release build  
+bun build.ts --release
+
+# CI build
+bun build.ts --ci
+```
+
+## Architecture Support
+
+- **macOS**: ARM64 (Apple Silicon), x64 (Intel) 
+- **Windows**: x64 only (ARM Windows users run via automatic emulation)
+- **Linux**: x64, ARM64
+
+### Windows Architecture Notes
+
+Windows builds are created on ARM VMs but target x64 architecture. Both x64 and ARM Windows users use the same x64 binary:
+- **x64 Windows**: Runs natively
+- **ARM Windows**: Runs via automatic Windows emulation layer
+
+This approach simplifies distribution while maintaining compatibility across Windows architectures.
+
+The build system automatically detects the host architecture and downloads appropriate dependencies.

package/bin/electrobun.cjs

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+
+const { execSync, spawn } = require('child_process');
+const { existsSync, mkdirSync, createWriteStream, unlinkSync, chmodSync } = require('fs');
+const { join, dirname } = require('path');
+const https = require('https');
+const tar = require('tar');
+
+// Detect platform and architecture
+function getPlatform() {
+  switch (process.platform) {
+    case 'win32': return 'win';
+    case 'darwin': return 'darwin';
+    case 'linux': return 'linux';
+    default: throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+
+function getArch() {
+  switch (process.arch) {
+    case 'arm64': return 'arm64';
+    case 'x64': return 'x64';
+    default: throw new Error(`Unsupported architecture: ${process.arch}`);
+  }
+}
+
+const platform = getPlatform();
+// Always use x64 for Windows since we only build x64 Windows binaries
+const arch = platform === 'win' ? 'x64' : getArch();
+const binExt = platform === 'win' ? '.exe' : '';
+
+// Paths
+const electrobunDir = join(__dirname, '..');
+const cacheDir = join(electrobunDir, '.cache');
+const cliBinary = join(cacheDir, `electrobun${binExt}`);
+
+async function downloadFile(url, filePath) {
+  return new Promise((resolve, reject) => {
+    mkdirSync(dirname(filePath), { recursive: true });
+    const file = createWriteStream(filePath);
+    
+    https.get(url, (response) => {
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        // Follow redirect
+        return downloadFile(response.headers.location, filePath).then(resolve).catch(reject);
+      }
+      
+      if (response.statusCode !== 200) {
+        reject(new Error(`Download failed: ${response.statusCode}`));
+        return;
+      }
+      
+      response.pipe(file);
+      
+      file.on('finish', () => {
+        file.close();
+        resolve();
+      });
+      
+      file.on('error', reject);
+    }).on('error', reject);
+  });
+}
+
+async function ensureCliBinary() {
+  // Check if CLI binary exists in bin location (where npm expects it)
+  const binLocation = join(electrobunDir, 'bin', 'electrobun' + binExt);
+  if (existsSync(binLocation)) {
+    return binLocation;
+  }
+  
+  // Check if core dependencies already exist in cache
+  if (existsSync(cliBinary)) {
+    // Copy to bin location if it exists in cache but not in bin
+    mkdirSync(dirname(binLocation), { recursive: true });
+    const fs = require('fs');
+    fs.copyFileSync(cliBinary, binLocation);
+    if (platform !== 'win') {
+      chmodSync(binLocation, '755');
+    }
+    return binLocation;
+  }
+
+  console.log('Downloading electrobun CLI for your platform...');
+  
+  // Get the package version to download the matching release
+  const packageJson = require(join(electrobunDir, 'package.json'));
+  const version = packageJson.version;
+  const tag = `v${version}`;
+  
+  const tarballUrl = `https://github.com/blackboardsh/electrobun/releases/download/${tag}/electrobun-cli-${platform}-${arch}.tar.gz`;
+  const tarballPath = join(cacheDir, `electrobun-${platform}-${arch}.tar.gz`);
+  
+  try {
+    // Download tarball
+    await downloadFile(tarballUrl, tarballPath);
+    
+    // Extract CLI binary  
+    await tar.x({
+      file: tarballPath,
+      cwd: cacheDir
+      // No strip needed - CLI tarball contains just the binary
+    });
+    
+    // Clean up tarball
+    unlinkSync(tarballPath);
+    
+    // Check if CLI binary was extracted
+    if (!existsSync(cliBinary)) {
+      throw new Error(`CLI binary not found at ${cliBinary} after extraction`);
+    }
+    
+    // Make executable on Unix systems
+    if (platform !== 'win') {
+      chmodSync(cliBinary, '755');
+    }
+    
+    // Copy CLI to bin location so npm scripts can find it
+    const binLocation = join(electrobunDir, 'bin', 'electrobun' + binExt);
+    mkdirSync(dirname(binLocation), { recursive: true });
+    
+    // Copy the downloaded CLI to replace this script
+    const fs = require('fs');
+    fs.copyFileSync(cliBinary, binLocation);
+    
+    // Make the bin location executable too
+    if (platform !== 'win') {
+      chmodSync(binLocation, '755');
+    }
+    
+    console.log('electrobun CLI downloaded successfully!');
+    return binLocation;
+    
+  } catch (error) {
+    throw new Error(`Failed to download electrobun CLI: ${error.message}`);
+  }
+}
+
+async function main() {
+  try {
+    const args = process.argv.slice(2);
+    const cliPath = await ensureCliBinary();
+    
+    // Replace this process with the actual CLI
+    const child = spawn(cliPath, args, {
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+    
+    child.on('exit', (code) => {
+      process.exit(code || 0);
+    });
+    
+    child.on('error', (error) => {
+      console.error('Failed to start electrobun CLI:', error.message);
+      process.exit(1);
+    });
+    
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrobun",
-  "version": "0.0.19-beta.6",
+  "version": "0.0.19-beta.61",
   "description": "Build ultra fast, tiny, and cross-platform desktop apps with Typescript.",
   "license": "MIT",
   "author": "Blackboard Technologies Inc.",
@@ -18,7 +18,7 @@
   },
   "type": "module",
   "bin": {
-    "electrobun": "./bin/electrobun"
+    "electrobun": "./bin/electrobun.cjs"
   },
   "homepage": "https://electrobun.dev",
   "repository": {
@@ -26,12 +26,12 @@
     "url": "git+https://github.com/blackboardsh/electrobun.git"
   },
   "scripts": {
-    "postinstall": "mkdir -p bin && bun build src/cli/index.ts --compile --outfile bin/electrobun",
+    "build:cli": "mkdir -p bin && bun build src/cli/index.ts --compile --outfile bin/electrobun",
     "start": "bun src/bun/index.ts",
     "check-zig-version": "vendors/zig/zig version",
     "build:dev": "bun build.ts",
     "build:release": "bun build.ts --release",
-    "dev:playground": "bun build:dev && cd playground && npm install && bun build:dev && bun start",
+    "dev:playground": "bun build:dev && bun build:cli && cd playground && npm install && bun build:dev && bun start",
     "dev:playground:linux": "bun build:dev && npm link && cd playground && npm link electrobun && bun build:dev && bun start",
     "dev:playground:clean": "cd playground && rm -rf node_modules && npm install && cd .. && bun dev:playground",
     "dev:playground:rerun": "cd playground && bun start",
@@ -40,11 +40,17 @@
     "build:docs:release": "cd documentation && bun run build",
     "npm:publish": "bun build:release && npm publish",
     "npm:publish:beta": "bun build:release && npm publish --tag beta",
-    "npm:version:beta": "npm version prerelease --preid=beta"
+    "npm:version:beta": "npm version prerelease --preid=beta",
+    "push:beta": "bun npm:version:beta && git push origin main --tags",
+    "push:patch": "npm version patch && git push origin main --tags",
+    "push:minor": "npm version minor && git push origin main --tags",
+    "push:major": "npm version major && git push origin main --tags",
+    "build:push:artifacts": "bun scripts/build-and-upload-artifacts.js"
+  },
+  "devDependencies": {
+    "@types/bun": "1.1.9"
   },
-  "devDependencies": {},
   "dependencies": {
-    "@types/bun": "1.1.9",
     "@oneidentity/zstd-js": "^1.0.3",
     "rpc-anywhere": "1.5.0",
     "tar": "^6.2.1"