electrobun 0.0.18 → 0.0.19-beta.100

package/BETA_RELEASE.md

@@ -0,0 +1,67 @@
+# Electrobun Beta Releases
+
+## For Users
+
+### Installing Beta Versions
+
+```bash
+# Install latest beta
+npm install electrobun@beta
+
+# Install specific beta version
+npm install electrobun@0.0.19-beta.1
+
+# View available versions
+npm view electrobun versions --json
+```
+
+### Switching Between Stable and Beta
+
+```bash
+# Switch to stable
+npm install electrobun@latest
+
+# Switch to beta
+npm install electrobun@beta
+```
+
+## For Maintainers
+
+### Publishing Beta Releases
+
+1. **Update version:**
+   ```bash
+   # First beta of a new version
+   npm version 0.0.19-beta.1
+   
+   # Increment beta number
+   bun npm:version:beta
+   ```
+
+2. **Create GitHub Release:**
+   ```bash
+   git push origin v0.0.19-beta.1
+   ```
+   Or manually trigger the workflow with the beta tag.
+
+3. **Publish to npm:**
+   ```bash
+   bun npm:publish:beta
+   ```
+
+### Beta Release Workflow
+
+1. Beta versions use semantic versioning: `MAJOR.MINOR.PATCH-beta.NUMBER`
+2. GitHub Actions automatically marks releases with `-beta` as pre-releases
+3. npm publishes to the `beta` dist-tag (not `latest`)
+4. Users on stable versions won't get beta updates
+
+### Promoting Beta to Stable
+
+```bash
+# Update version to stable
+npm version 0.0.19
+
+# Publish as latest
+bun npm:publish
+```

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/README.md

@@ -8,7 +8,7 @@
 
 ## What is Electrobun?
 
-> Electrobun is in the **_very_** early stages. We currently only support development on arm macs, it has memory leaks, has no tests, it's not available in npm yet, and many core things are still missing.
+> Electrobun is in the **_very_** early stages. We currently support development on macOS, Windows, and Linux, but it has memory leaks, has no tests, and many core things are still missing. We're actively working on stabilizing cross-platform support.
 
 Electrobun aims to be a complete **solution-in-a-box** for building, updating, and shipping ultra fast, tiny, and cross-platform desktop applications written in Typescript.
 Under the hood it uses <a href="https://bun.sh">bun</a> to execute the main process and to bundle webview typescript, and has native bindings written in <a href="https://ziglang.org/">zig</a>.
@@ -29,21 +29,7 @@ Read about how Electrobun is designed, and why, in our <a href="https://www.elec
 
 ## Roadmap
 
-See the detailed <a href="https://github.com/blackboardsh/electrobun/issues/2">detailed Roadmap</a>.
-
-**High level roadmap**
-
-|     | Milestones            | Description                                                                                                                             |
-| :-- | :-------------------- | :-------------------------------------------------------------------------------------------------------------------------------------- |
-| ✅  | Core Architecture     | Ship a working proof of concept with most of the core architecture wired up                                                             |
-| ✅  | Packaging and signing | Packaging and code signing for MacOS                                                                                                    |
-| ✅  | Shipping updates      | Integrated auto-updator                                                                                                                 |
-| ✅  | Webview Tag           | Cross browser electrobun implementation of the <webview> tag that electron has, for isolated nested webviews                            |
-| ✅  | Port co(lab)          | Harden implementation and enough electron parity to migrate <a href="https://colab.sh">https://colab.sh</a> from Electron to Electrobun |
-|     | Custom Web Runtime    | Optionally use a cross-platform web runtime (Chromium) instead of the system's native webview                                           |
-|     | Intel Mac Builds      | build on and distribute to intel macs                                                                                                   |
-|     | API Parity            | Accelerate development of Electrobun apis and native integrations to enable apps to migrate from Electron and Tauri                     |
-|     | Windows support       | build for and distribute to Windows                                                                                                     |
+See the <a href="https://github.com/orgs/blackboardsh/projects/5">roadmap</a>
 
 ## Contributing
 
@@ -53,14 +39,55 @@ As we get closer to 1.0.0 I'll probably make guidelines for PRs and stuff. In th
 
 Ways to get involved at this early stage:
 
-- Follow us on X for updates <a href="https://twitter.com/BlackboardTech">@BlackboardTech</a>
+- Follow us on X for updates <a href="https://twitter.com/BlackboardTech">@BlackboardTech</a> or <a href="https://bsky.app/profile/yoav.codes">@yoav.codes</a>
 - Join the conversation on <a href="https://discord.gg/ueKE4tjaCE">Discord</a>
 - Create and participate in Github issues and discussions
 
-## Building
+## Development Setup
+
+### Prerequisites
+
+**macOS:**
+- Xcode command line tools
+- cmake (install via homebrew: `brew install cmake`)
+
+**Windows:**
+- Visual Studio Build Tools or Visual Studio with C++ development tools
+- cmake
+
+**Linux:**
+- build-essential package
+- cmake
+- webkit2gtk and GTK development packages
+
+### First-time Setup
+
+```bash
+git clone <repo-url>
+cd electrobun
+bun install
+bun dev:playground:clean
+```
+
+### Development Workflow
+
+```bash
+# After making changes to source code
+bun dev:playground
+
+# If you only changed playground code (not electrobun source)
+bun dev:playground:rerun
+
+# If you need a completely fresh start
+bun dev:playground:clean
+```
+
+### Additional Commands
 
-run `bun run install-zig` to install the right version of zig to vendors/zig
+- `bun dev:playground:canary` - Build and run playground in canary mode
+- `bun build:dev` - Build electrobun in development mode
+- `bun build:release` - Build electrobun in release mode
 
-`bun dev:playground` and `bun dev:playground:canary` will compile everything in electrobun in either dev mode and then compile the playground app in either dev or canary modes and run it.
+### Debugging
 
-Note: use `lldb <path-to-bundle>/Contents/MacOS/launcher` and then `run` to debug release builds
+**macOS:** Use `lldb <path-to-bundle>/Contents/MacOS/launcher` and then `run` to debug release builds

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/debug.js

@@ -0,0 +1,5 @@
+console.log('process.argv:', process.argv);
+const indexOfElectrobun = process.argv.findIndex((arg) => arg.includes('electrobun'));
+console.log('indexOfElectrobun:', indexOfElectrobun);
+const commandArg = process.argv[indexOfElectrobun + 1] || 'build';
+console.log('commandArg:', commandArg);

package/dist/api/browser/builtinrpcSchema.ts

@@ -8,3 +8,12 @@ export type BuiltinBunToWebviewSchema = {
     };
   };
 };
+
+export type BuiltinWebviewToBunSchema = {
+  requests: {
+    webviewTagInit: {
+      params: {};
+      response: any;
+    }
+  }
+}