electrobun 0.1.21-beta.0 → 0.2.0-beta.7

package/README.md

@@ -8,12 +8,10 @@
 
 ## What is Electrobun?
 
-> Electrobun is in the **_very_** early stages. We currently support development on macOS, Windows, and Linux. You can also bundle your app for these platform targets and cross-bundle them from a mac. We're actively working on stabilizing so any bug reports, especially on different platforms are most welcome.
-
 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>.
 
-Visit <a href="https://www.electrobun.dev/">Electrobun.dev</a> to see api documentation, guides, and more.
+Visit <a href="https://blackboard.sh/electrobun/">https://blackboard.sh/electrobun/</a> to see api documentation, guides, and more.
 
 **Project Goals**
 
@@ -27,6 +25,9 @@ Visit <a href="https://www.electrobun.dev/">Electrobun.dev</a> to see api docume
 
 Read about how Electrobun is designed, and why, in our <a href="https://www.electrobun.dev/docs/guides/Architecture/Overview">architecture docs</a>.
 
+## Apps Built with Electrobun
+- [Co(lab)](https://blackboard.sh/colab/) - a hybrid web browser + code editor for deep work
+
 ## Roadmap
 
 See the <a href="https://github.com/orgs/blackboardsh/projects/5">roadmap</a>

package/dist/api/bun/ElectrobunConfig.ts

@@ -88,6 +88,20 @@ export interface ElectrobunConfig {
      */
     targets?: string;
 
+    /**
+     * Enable ASAR archive packaging for bundled assets
+     * When enabled, all files in the Resources folder will be packed into an app.asar archive
+     * @default false
+     */
+    useAsar?: boolean;
+
+    /**
+     * Glob patterns for files to exclude from ASAR packing (extract to app.asar.unpacked)
+     * Useful for native modules or executables that need to be accessible as regular files
+     * @default ["*.node", "*.dll", "*.dylib", "*.so"]
+     */
+    asarUnpack?: string[];
+
     /**
      * macOS-specific build configuration
      */

package/dist/main.js

@@ -3,8 +3,9 @@ var __require = import.meta.require;
 
 // src/launcher/main.ts
 import { join, dirname, resolve } from "path";
-import { dlopen, suffix, ptr } from "bun:ffi";
-import { existsSync } from "fs";
+import { dlopen, suffix, ptr, toArrayBuffer } from "bun:ffi";
+import { existsSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
 var pathToMacOS = dirname(process.argv0);
 var libPath = join(pathToMacOS, `libNativeWrapper.${suffix}`);
 var absoluteLibPath = resolve(libPath);
@@ -66,7 +67,67 @@ function main() {
   }
   const pathToLauncherBin = process.argv0;
   const pathToBinDir = dirname(pathToLauncherBin);
-  const appEntrypointPath = join(pathToBinDir, "..", "Resources", "app", "bun", "index.js");
+  const resourcesDir = join(pathToBinDir, "..", "Resources");
+  const asarPath = join(resourcesDir, "app.asar");
+  const appFolderPath = join(resourcesDir, "app");
+  let appEntrypointPath;
+  if (existsSync(asarPath)) {
+    console.log(`[LAUNCHER] Loading app code from ASAR: ${asarPath}`);
+    const asarLibPath = join(pathToMacOS, `libasar.${suffix}`);
+    let asarLib;
+    try {
+      asarLib = dlopen(asarLibPath, {
+        asar_open: { args: ["cstring"], returns: "ptr" },
+        asar_read_file: { args: ["ptr", "cstring", "ptr"], returns: "ptr" },
+        asar_free_buffer: { args: ["ptr", "u64"], returns: "void" },
+        asar_close: { args: ["ptr"], returns: "void" }
+      });
+    } catch (error) {
+      console.error(`[LAUNCHER] Failed to load ASAR library: ${error.message}`);
+      throw error;
+    }
+    const asarArchive = asarLib.symbols.asar_open(ptr(Buffer.from(asarPath + "\x00", "utf8")));
+    if (!asarArchive || asarArchive === 0n) {
+      console.error(`[LAUNCHER] Failed to open ASAR archive at: ${asarPath}`);
+      throw new Error("Failed to open ASAR archive");
+    }
+    const filePath = "bun/index.js";
+    const sizeBuffer = new BigUint64Array(1);
+    const fileDataPtr = asarLib.symbols.asar_read_file(asarArchive, ptr(Buffer.from(filePath + "\x00", "utf8")), ptr(sizeBuffer));
+    if (!fileDataPtr || fileDataPtr === 0n) {
+      console.error(`[LAUNCHER] Failed to read ${filePath} from ASAR`);
+      asarLib.symbols.asar_close(asarArchive);
+      throw new Error(`Failed to read ${filePath} from ASAR`);
+    }
+    const fileSize = Number(sizeBuffer[0]);
+    console.log(`[LAUNCHER] Read ${fileSize} bytes from ASAR for ${filePath}`);
+    const arrayBuffer = toArrayBuffer(fileDataPtr, 0, fileSize);
+    const fileData = Buffer.from(arrayBuffer);
+    const systemTmpDir = tmpdir();
+    const randomFileName = `electrobun-${Date.now()}-${Math.random().toString(36).substring(7)}.js`;
+    appEntrypointPath = join(systemTmpDir, randomFileName);
+    const wrappedFileData = `
+// Auto-delete temp file after Worker loads it
+const __tempFilePath = "${appEntrypointPath}";
+setTimeout(() => {
+    try {
+        require("fs").unlinkSync(__tempFilePath);
+        console.log("[LAUNCHER] Deleted temp file:", __tempFilePath);
+    } catch (error) {
+        console.warn("[LAUNCHER] Failed to delete temp file:", error.message);
+    }
+}, 100);
+
+${fileData.toString("utf8")}
+`;
+    writeFileSync(appEntrypointPath, wrappedFileData);
+    console.log(`[LAUNCHER] Wrote app entrypoint to: ${appEntrypointPath}`);
+    asarLib.symbols.asar_free_buffer(fileDataPtr, BigInt(fileSize));
+    asarLib.symbols.asar_close(asarArchive);
+  } else {
+    console.log(`[LAUNCHER] Loading app code from flat files`);
+    appEntrypointPath = join(appFolderPath, "bun", "index.js");
+  }
   new Worker(appEntrypointPath, {});
   lib.symbols.runNSApplication(ptr(Buffer.from(identifier + "\x00", "utf8")), ptr(Buffer.from(channel + "\x00", "utf8")));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrobun",
-  "version": "0.1.21-beta.0",
+  "version": "0.2.0-beta.7",
   "description": "Build ultra fast, tiny, and cross-platform desktop apps with Typescript.",
   "license": "MIT",
   "author": "Blackboard Technologies Inc.",

package/src/cli/index.ts

@@ -542,6 +542,8 @@ const defaultConfig = {
     buildFolder: "build",
     artifactFolder: "artifacts",
     targets: undefined, // Will default to current platform if not specified
+    useAsar: false,
+    asarUnpack: undefined, // Glob patterns for files to exclude from ASAR (e.g., ["*.node", "*.dll"])
     mac: {
       codesign: false,
       notarize: false,
@@ -1456,6 +1458,17 @@ if (commandArg === "init") {
     dereference: true,
   });
 
+  // Copy libasar dynamic library for ASAR support
+  const libExt = targetOS === 'win' ? '.dll' : targetOS === 'macos' ? '.dylib' : '.so';
+  const asarLibSource = join(dirname(targetPaths.BSPATCH), 'libasar' + libExt);
+  if (existsSync(asarLibSource)) {
+    const asarLibDestination = join(appBundleMacOSPath, 'libasar' + libExt);
+    cpSync(asarLibSource, asarLibDestination, {
+      recursive: true,
+      dereference: true,
+    });
+  }
+
   // transpile developer's bun code
   const bunDestFolder = join(appBundleAppCodePath, "bun");
   // Build bun-javascript ts files
@@ -1572,6 +1585,87 @@ if (commandArg === "init") {
       process.exit(1);
     }
   }
+
+  // Pack app resources into ASAR archive if enabled
+  if (config.build.useAsar) {
+    console.log("Packing resources into ASAR archive...");
+
+    const asarPath = join(appBundleFolderResourcesPath, "app.asar");
+    const asarUnpackedPath = join(appBundleFolderResourcesPath, "app.asar.unpacked");
+
+    // Get zig-asar CLI path - on Windows, check if we need the ARM64 version
+    let zigAsarCli = join(targetPaths.BSPATCH).replace('bspatch', 'zig-asar');
+
+    // If the derived path doesn't exist and we're on Windows, try the runtime architecture vendor path
+    if (!existsSync(zigAsarCli) && process.platform === 'win32') {
+      const runtimeArch = process.arch === 'arm64' ? 'arm64' : 'x64';
+      const vendorPath = join(ELECTROBUN_DEP_PATH, 'vendors', 'zig-asar', runtimeArch, 'zig-asar.exe');
+      if (existsSync(vendorPath)) {
+        zigAsarCli = vendorPath;
+        console.log(`Using ${runtimeArch} zig-asar from vendors`);
+      }
+    }
+
+    const appDirPath = appBundleAppCodePath;
+
+    // Check if app directory exists
+    if (!existsSync(appDirPath)) {
+      console.log("⚠ No app directory found, skipping ASAR creation");
+    } else {
+      // Default unpack patterns for native modules and libraries
+      const defaultUnpackPatterns = ["*.node", "*.dll", "*.dylib", "*.so"];
+      const unpackPatterns = config.build.asarUnpack || defaultUnpackPatterns;
+
+      // Check if zig-asar CLI exists
+      if (!existsSync(zigAsarCli)) {
+        console.error(`zig-asar CLI not found at: ${zigAsarCli}`);
+        console.error("Make sure to run setup/vendoring first");
+        process.exit(1);
+      }
+
+      // Build zig-asar command arguments
+      // Pack the entire app directory
+      const asarArgs = [
+        "pack",
+        appDirPath,    // source: entire app directory
+        asarPath,      // output asar file
+      ];
+
+      // Add unpack patterns if any
+      // Each pattern needs its own --unpack flag
+      for (const pattern of unpackPatterns) {
+        asarArgs.push("--unpack", pattern);
+      }
+
+      // Run zig-asar pack
+      const asarResult = Bun.spawnSync([zigAsarCli, ...asarArgs], {
+        stdio: ["ignore", "inherit", "inherit"],
+        cwd: projectRoot,
+      });
+
+      if (asarResult.exitCode !== 0) {
+        console.error("ASAR packing failed with exit code:", asarResult.exitCode);
+        if (asarResult.stderr) {
+          console.error("stderr:", asarResult.stderr.toString());
+        }
+        console.error("Command:", zigAsarCli, ...asarArgs);
+        process.exit(1);
+      }
+
+      // Verify ASAR was created
+      if (!existsSync(asarPath)) {
+        console.error("ASAR file was not created:", asarPath);
+        process.exit(1);
+      }
+
+      console.log("✓ Created app.asar");
+
+      // Remove the entire app folder since it's now packed in ASAR
+      rmdirSync(appDirPath, { recursive: true });
+      console.log("✓ Removed app/ folder (now in ASAR)");
+    }
+  }
+
   // All the unique files are in the bundle now. Create an initial temporary tar file
   // for hashing the contents
   // tar the signed and notarized app bundle