electrobun 0.0.19-beta.71 → 0.0.19-beta.73

package/dist/api/bun/core/Updater.ts

@@ -5,7 +5,22 @@ import tar from "tar";
 import { ZstdInit } from "@oneidentity/zstd-js/wasm";
 import { OS as currentOS, ARCH as currentArch } from '../../shared/platform';
 
-const appSupportDir = join(homedir(), "Library", "Application Support");
+// Cross-platform app data directory
+function getAppDataDir(): string {
+  switch (currentOS) {
+    case 'macos':
+      return join(homedir(), "Library", "Application Support");
+    case 'win':
+      // Use APPDATA environment variable or fallback to default location
+      return process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+    case 'linux':
+      // Use XDG_CONFIG_HOME or fallback to ~/.config
+      return process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+    default:
+      // Fallback to home directory with .config
+      return join(homedir(), ".config");
+  }
+}
 
 // todo (yoav): share type with cli
 let localInfo: {
@@ -214,10 +229,20 @@ const Updater = {
       if (currentHash !== latestHash) {
         const cacheBuster = Math.random().toString(36).substring(7);
         const platformFolder = `${localInfo.channel}-${currentOS}-${currentArch}`;
+        // Platform-specific tarball naming
+        let tarballName: string;
+        if (currentOS === 'macos') {
+          tarballName = `${appFileName}.app.tar.zst`;
+        } else if (currentOS === 'win') {
+          tarballName = `${appFileName}.tar.zst`;
+        } else {
+          tarballName = `${appFileName}.tar.zst`;
+        }
+        
         const urlToLatestTarball = join(
           localInfo.bucketUrl,
           platformFolder,
-          `${appFileName}.app.tar.zst`
+          tarballName
         );
         const prevVersionCompressedTarballPath = join(
           appDataFolder,
@@ -294,47 +319,116 @@ const Updater = {
           file: latestTarPath,
           cwd: extractionFolder,
           onentry: (entry) => {
-            // find the first .app bundle in the tarball
-            // Some apps may have nested .app bundles
-            if (!appBundleSubpath && entry.path.endsWith(".app/")) {
-              appBundleSubpath = entry.path;
+            if (currentOS === 'macos') {
+              // find the first .app bundle in the tarball
+              // Some apps may have nested .app bundles
+              if (!appBundleSubpath && entry.path.endsWith(".app/")) {
+                appBundleSubpath = entry.path;
+              }
+            } else {
+              // For Windows/Linux, look for the main executable
+              // This assumes the tarball contains the app at the root
+              if (!appBundleSubpath) {
+                appBundleSubpath = "./";
+              }
             }
           },
         });
 
         if (!appBundleSubpath) {
-          console.error("Failed to find app bundle in tarball");
+          console.error("Failed to find app in tarball");
           return;
         }
 
         // Note: resolve here removes the extra trailing / that the tar file adds
-        const newAppBundlePath = resolve(
+        const extractedAppPath = resolve(
           join(extractionFolder, appBundleSubpath)
         );
-        // Note: dirname(process.execPath) is the path to the running app bundle's
-        // Contents/MacOS directory
-        const runningAppBundlePath = resolve(
-          dirname(process.execPath),
-          "..",
-          ".."
-        );
-        const backupAppBundlePath = join(extractionFolder, "backup.app");
+        
+        // On Linux, we need to move the app from self-extraction to the app directory
+        let newAppBundlePath: string;
+        if (currentOS === 'linux') {
+          // Get the parent directory (one level up from self-extraction)
+          const parentDir = resolve(extractionFolder, "..");
+          newAppBundlePath = join(parentDir, "app_new");
+          
+          // Move the extracted app to a temporary location
+          renameSync(extractedAppPath, newAppBundlePath);
+        } else {
+          newAppBundlePath = extractedAppPath;
+        }
+        // Platform-specific app path calculation
+        let runningAppBundlePath: string;
+        if (currentOS === 'macos') {
+          // On macOS, executable is at Contents/MacOS/binary inside .app bundle
+          runningAppBundlePath = resolve(
+            dirname(process.execPath),
+            "..",
+            ".."
+          );
+        } else if (currentOS === 'linux') {
+          // On Linux, executable is at app/bin/launcher
+          runningAppBundlePath = resolve(
+            dirname(process.execPath),
+            "..",
+            ".."
+          );
+        } else {
+          // On Windows, the executable is the app itself
+          runningAppBundlePath = process.execPath;
+        }
+        // Platform-specific backup naming and location
+        let backupAppBundlePath: string;
+        if (currentOS === 'linux') {
+          // On Linux, keep backup in self-extraction folder
+          backupAppBundlePath = join(extractionFolder, "backup");
+        } else {
+          // On macOS/Windows, backup in extraction folder
+          const backupName = currentOS === 'macos' ? "backup.app" : "backup";
+          backupAppBundlePath = join(extractionFolder, backupName);
+        }
 
         try {
-          // const backupState = statSync(backupAppBundlePath);
+          // Remove existing backup if it exists
           if (statSync(backupAppBundlePath, { throwIfNoEntry: false })) {
             rmdirSync(backupAppBundlePath, { recursive: true });
           } else {
             console.log("backupAppBundlePath does not exist");
           }
+          
+          // Move current running app to backup
           renameSync(runningAppBundlePath, backupAppBundlePath);
+          
+          // Move new app to running location
           renameSync(newAppBundlePath, runningAppBundlePath);
+          
+          // On Linux, clean up the temporary app_new if it wasn't already moved
+          if (currentOS === 'linux') {
+            try {
+              rmdirSync(newAppBundlePath, { recursive: true });
+            } catch {
+              // Ignore if already moved
+            }
+          }
         } catch (error) {
           console.error("Failed to replace app with new version", error);
           return;
         }
 
-        await Bun.spawn(["open", runningAppBundlePath]);
+        // Cross-platform app launch
+        switch (currentOS) {
+          case 'macos':
+            await Bun.spawn(["open", runningAppBundlePath]);
+            break;
+          case 'win':
+            // On Windows, the runningAppBundlePath would be the .exe file
+            await Bun.spawn([runningAppBundlePath]);
+            break;
+          case 'linux':
+            // On Linux, directly execute the binary
+            await Bun.spawn([runningAppBundlePath]);
+            break;
+        }
         process.exit(0);
       }
     }
@@ -349,7 +443,7 @@ const Updater = {
   appDataFolder: async () => {
     await Updater.getLocallocalInfo();
     const appDataFolder = join(
-      appSupportDir,
+      getAppDataDir(),
       localInfo.identifier,
       localInfo.name
     );

package/dist/api/bun/proc/native.ts

@@ -247,11 +247,14 @@ export const native = (() => {
       // },
     });
   } catch (err) {
-    console.log('FATAL Error opening native FFI', err);
+    console.log('FATAL Error opening native FFI:', err.message);
     console.log('This may be due to:');
     console.log('  - Missing libNativeWrapper.dll/so/dylib');
     console.log('  - Architecture mismatch (ARM64 vs x64)');
     console.log('  - Missing WebView2 or CEF dependencies');
+    if (suffix === 'so') {
+      console.log('  - Missing system libraries (try: ldd ./libNativeWrapper.so)');
+    }
     console.log('Check that the build process completed successfully for your architecture.');
     process.exit();
   }

package/dist/main.js

@@ -1,12 +1,53 @@
 // @bun
+var __require = import.meta.require;
+
 // src/launcher/main.ts
-import { join, dirname } from "path";
+import { join, dirname, resolve } from "path";
 import { dlopen, suffix } from "bun:ffi";
-var lib = dlopen(`./libNativeWrapper.${suffix}`, {
-  runNSApplication: { args: [], returns: "void" }
-});
-var pathToLauncherBin = process.argv0;
-var pathToMacOS = dirname(pathToLauncherBin);
-var appEntrypointPath = join(pathToMacOS, "..", "Resources", "app", "bun", "index.js");
-new Worker(appEntrypointPath, {});
-lib.symbols.runNSApplication();
+import { existsSync } from "fs";
+var libPath = `./libNativeWrapper.${suffix}`;
+var absoluteLibPath = resolve(libPath);
+function main() {
+  if (process.platform === "linux") {
+    const cefLibs = ["./libcef.so", "./libvk_swiftshader.so"];
+    const existingCefLibs = cefLibs.filter((lib2) => existsSync(lib2));
+    if (existingCefLibs.length > 0 && !process.env.LD_PRELOAD) {
+      console.error(`[LAUNCHER] ERROR: CEF libraries found but LD_PRELOAD not set!`);
+      console.error(`[LAUNCHER] Please run through the wrapper script: ./run.sh`);
+      console.error(`[LAUNCHER] Or set: LD_PRELOAD="${existingCefLibs.join(":")}" before starting.`);
+      const { spawn } = __require("child_process");
+      const env = { ...process.env, LD_PRELOAD: existingCefLibs.join(":") };
+      const child = spawn(process.argv[0], process.argv.slice(1), {
+        env,
+        stdio: "inherit"
+      });
+      child.on("exit", (code) => process.exit(code));
+      return;
+    }
+  }
+  let lib;
+  try {
+    if (!process.env.LD_LIBRARY_PATH?.includes(".")) {
+      process.env.LD_LIBRARY_PATH = `.${process.env.LD_LIBRARY_PATH ? ":" + process.env.LD_LIBRARY_PATH : ""}`;
+    }
+    lib = dlopen(libPath, {
+      runNSApplication: { args: [], returns: "void" }
+    });
+  } catch (error) {
+    console.error(`[LAUNCHER] Failed to load library: ${error.message}`);
+    try {
+      lib = dlopen(absoluteLibPath, {
+        runNSApplication: { args: [], returns: "void" }
+      });
+    } catch (absError) {
+      console.error(`[LAUNCHER] Library loading failed. Try running: ldd ${libPath}`);
+      throw error;
+    }
+  }
+  const pathToLauncherBin = process.argv0;
+  const pathToMacOS = dirname(pathToLauncherBin);
+  const appEntrypointPath = join(pathToMacOS, "..", "Resources", "app", "bun", "index.js");
+  new Worker(appEntrypointPath, {});
+  lib.symbols.runNSApplication();
+}
+main();

package/package.json

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

package/src/cli/index.ts

@@ -9,6 +9,8 @@ import {
   createWriteStream,
   unlinkSync,
   readdirSync,
+  rmSync,
+  symlinkSync,
 } from "fs";
 import { execSync } from "child_process";
 import tar from "tar";
@@ -400,6 +402,12 @@ const defaultConfig = {
       },
       icons: "icon.iconset",
     },
+    win: {
+      bundleCEF: false,
+    },
+    linux: {
+      bundleCEF: false,
+    },
     bun: {
       entrypoint: "src/bun/index.ts",
       external: [],
@@ -432,7 +440,7 @@ const validEnvironments = ["dev", "canary", "stable"];
 
 // todo (yoav): dev, canary, and stable;
 const buildEnvironment: "dev" | "canary" | "stable" =
-  validEnvironments.includes(envArg) ? envArg : "dev";
+  validEnvironments.includes(envArg || "dev") ? (envArg || "dev") : "dev";
 
 // Determine build targets
 type BuildTarget = { os: 'macos' | 'win' | 'linux', arch: 'arm64' | 'x64' };
@@ -1046,11 +1054,13 @@ if (commandArg === "init") {
           'libvulkan.so.1'
         ];
         
+        // Copy CEF .so files to main directory as symlinks to cef/ subdirectory
         cefSoFiles.forEach(soFile => {
           const sourcePath = join(cefSourcePath, soFile);
           const destPath = join(appBundleMacOSPath, soFile);
           if (existsSync(sourcePath)) {
-            cpSync(sourcePath, destPath);
+            // We'll create the actual file in cef/ and symlink from main directory
+            // This will be done after the cef/ directory is populated
           }
         });
         
@@ -1112,6 +1122,30 @@ if (commandArg === "init") {
           }
         });
         
+        // Create symlinks from main directory to cef/ subdirectory for .so files
+        console.log('Creating symlinks for CEF libraries...');
+        cefSoFiles.forEach(soFile => {
+          const cefFilePath = join(cefResourcesDestination, soFile);
+          const mainDirPath = join(appBundleMacOSPath, soFile);
+          
+          if (existsSync(cefFilePath)) {
+            try {
+              // Remove any existing file/symlink in main directory
+              if (existsSync(mainDirPath)) {
+                rmSync(mainDirPath);
+              }
+              // Create symlink from main directory to cef/ subdirectory
+              symlinkSync(join('cef', soFile), mainDirPath);
+              console.log(`Created symlink for CEF library: ${soFile} -> cef/${soFile}`);
+            } catch (error) {
+              console.log(`WARNING: Failed to create symlink for ${soFile}: ${error}`);
+              // Fallback to copying the file
+              cpSync(cefFilePath, mainDirPath);
+              console.log(`Fallback: Copied CEF library to main directory: ${soFile}`);
+            }
+          }
+        });
+        
         // Copy CEF helper processes with different names
         const cefHelperNames = [
           "bun Helper",
@@ -1352,7 +1386,7 @@ if (commandArg === "init") {
     // zstd is the clear winner here. dev iteration speed gain of 1min 15s per build is much more valubale
     // than saving 1 more MB of space/bandwidth.
 
-    const compressedTarPath = `${tarPath}.zst`;
+    let compressedTarPath = `${tarPath}.zst`;
     artifactsToUpload.push(compressedTarPath);
 
     // zstd compress tarball
@@ -1365,11 +1399,10 @@ if (commandArg === "init") {
       const useStream = tarball.size > 100 * 1024 * 1024;
       
       if (tarball.size > 0) {
-       // Uint8 array filestream of the tar file
-
+        // Uint8 array filestream of the tar file
         const data = new Uint8Array(tarBuffer);
         
-        const compressionLevel = 22;
+        const compressionLevel = 22;  // Maximum compression - now safe with stripped CEF libraries
         const compressedData = ZstdSimple.compress(data, compressionLevel);
 
         console.log(
@@ -1461,9 +1494,68 @@ if (commandArg === "init") {
       // Copy the self-extracting bundle to platform-specific filename
       if (targetOS === 'win') {
         // On Windows, create a self-extracting exe
-        // For now, just copy the bundle folder
-        artifactsToUpload.push(compressedTarPath);
+        const selfExtractingExePath = await createWindowsSelfExtractingExe(
+          buildFolder,
+          compressedTarPath,
+          appFileName,
+          targetPaths,
+          buildEnvironment
+        );
+        artifactsToUpload.push(selfExtractingExePath);
       } else if (targetOS === 'linux') {
+        // Create desktop file for Linux
+        const desktopFileContent = `[Desktop Entry]
+Version=1.0
+Type=Application
+Name=${config.package?.name || config.app.name}
+Comment=${config.package?.description || config.app.description || ''}
+Exec=${appFileName}
+Icon=${appFileName}
+Terminal=false
+StartupWMClass=${appFileName}
+Categories=Application;
+`;
+        
+        const desktopFilePath = join(appBundleFolderPath, `${appFileName}.desktop`);
+        writeFileSync(desktopFilePath, desktopFileContent);
+        
+        // Make desktop file executable
+        execSync(`chmod +x ${escapePathForTerminal(desktopFilePath)}`);
+        
+        // Create user-friendly launcher script
+        const launcherScriptContent = `#!/bin/bash
+# ${config.package?.name || config.app.name} Launcher
+# This script launches the application from any location
+
+# Get the directory where this script is located
+SCRIPT_DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
+
+# Find the launcher binary relative to this script
+LAUNCHER_BINARY="\$SCRIPT_DIR/bin/launcher"
+
+if [ ! -x "\$LAUNCHER_BINARY" ]; then
+    echo "Error: Could not find launcher binary at \$LAUNCHER_BINARY"
+    exit 1
+fi
+
+# Launch the application
+exec "\$LAUNCHER_BINARY" "\$@"
+`;
+        
+        const launcherScriptPath = join(appBundleFolderPath, `${appFileName}.sh`);
+        writeFileSync(launcherScriptPath, launcherScriptContent);
+        execSync(`chmod +x ${escapePathForTerminal(launcherScriptPath)}`);
+        
+        // Create self-extracting Linux binary (similar to Windows approach)
+        const selfExtractingLinuxPath = await createLinuxSelfExtractingBinary(
+          buildFolder,
+          compressedTarPath,
+          appFileName,
+          targetPaths,
+          buildEnvironment
+        );
+        artifactsToUpload.push(selfExtractingLinuxPath);
+        
         // On Linux, create a tar.gz of the bundle
         const linuxTarPath = join(buildFolder, `${appFileName}.tar.gz`);
         execSync(`tar -czf ${escapePathForTerminal(linuxTarPath)} -C ${escapePathForTerminal(buildFolder)} ${escapePathForTerminal(basename(appBundleFolderPath))}`);
@@ -1765,6 +1857,193 @@ function getEntitlementValue(value: boolean | string) {
   }
 }
 
+async function createWindowsSelfExtractingExe(
+  buildFolder: string,
+  compressedTarPath: string,
+  appFileName: string,
+  targetPaths: any,
+  buildEnvironment: string
+): Promise<string> {
+  console.log("Creating self-extracting Windows exe...");
+  
+  // Format: MyApp-Setup.exe (stable) or MyApp-Setup-canary.exe (non-stable)
+  const setupFileName = buildEnvironment === "stable" 
+    ? `${config.app.name}-Setup.exe`
+    : `${config.app.name}-Setup-${buildEnvironment}.exe`;
+  
+  const outputExePath = join(buildFolder, setupFileName);
+  
+  // Read the extractor exe
+  const extractorExe = readFileSync(targetPaths.EXTRACTOR);
+  
+  // Read the compressed archive
+  const compressedArchive = readFileSync(compressedTarPath);
+  
+  // Create metadata JSON
+  const metadata = {
+    identifier: config.app.identifier,
+    name: config.app.name,
+    channel: buildEnvironment
+  };
+  const metadataJson = JSON.stringify(metadata);
+  const metadataBuffer = Buffer.from(metadataJson, 'utf8');
+  
+  // Create marker buffers
+  const metadataMarker = Buffer.from('ELECTROBUN_METADATA_V1', 'utf8');
+  const archiveMarker = Buffer.from('ELECTROBUN_ARCHIVE_V1', 'utf8');
+  
+  // Combine extractor + metadata marker + metadata + archive marker + archive
+  const combinedBuffer = Buffer.concat([
+    extractorExe,
+    metadataMarker,
+    metadataBuffer,
+    archiveMarker,
+    compressedArchive
+  ]);
+  
+  // Write the self-extracting exe
+  writeFileSync(outputExePath, combinedBuffer);
+  
+  // Make it executable (though Windows doesn't need chmod)
+  if (OS !== 'win') {
+    execSync(`chmod +x ${escapePathForTerminal(outputExePath)}`);
+  }
+  
+  console.log(`Created self-extracting exe: ${outputExePath} (${(combinedBuffer.length / 1024 / 1024).toFixed(2)} MB)`);
+  
+  return outputExePath;
+}
+
+async function createLinuxSelfExtractingBinary(
+  buildFolder: string,
+  compressedTarPath: string,
+  appFileName: string,
+  targetPaths: any,
+  buildEnvironment: string
+): Promise<string> {
+  console.log("Creating self-extracting Linux binary...");
+  
+  // Format: MyApp-Setup.run (stable) or MyApp-Setup-canary.run (non-stable)
+  const setupFileName = buildEnvironment === "stable" 
+    ? `${config.app.name}-Setup.run`
+    : `${config.app.name}-Setup-${buildEnvironment}.run`;
+  
+  const outputPath = join(buildFolder, setupFileName);
+  
+  // Read the extractor binary
+  const extractorBinary = readFileSync(targetPaths.EXTRACTOR);
+  
+  // Read the compressed archive
+  const compressedArchive = readFileSync(compressedTarPath);
+  
+  // Create metadata JSON
+  const metadata = {
+    identifier: config.app.identifier,
+    name: config.app.name,
+    channel: buildEnvironment
+  };
+  const metadataJson = JSON.stringify(metadata);
+  const metadataBuffer = Buffer.from(metadataJson, 'utf8');
+  
+  // Create marker buffers
+  const metadataMarker = Buffer.from('ELECTROBUN_METADATA_V1', 'utf8');
+  const archiveMarker = Buffer.from('ELECTROBUN_ARCHIVE_V1', 'utf8');
+  
+  // Combine extractor + metadata marker + metadata + archive marker + archive
+  const combinedBuffer = Buffer.concat([
+    extractorBinary,
+    metadataMarker,
+    metadataBuffer,
+    archiveMarker,
+    compressedArchive
+  ]);
+  
+  // Write the self-extracting binary
+  writeFileSync(outputPath, combinedBuffer, { mode: 0o755 });
+  
+  // Ensure it's executable (redundant but explicit)
+  execSync(`chmod +x ${escapePathForTerminal(outputPath)}`);
+  
+  console.log(`Created self-extracting Linux binary: ${outputPath} (${(combinedBuffer.length / 1024 / 1024).toFixed(2)} MB)`);
+  
+  return outputPath;
+}
+
+async function createAppImage(buildFolder: string, appBundlePath: string, appFileName: string, config: any): Promise<string | null> {
+  try {
+    console.log("Creating AppImage...");
+    
+    // Create AppDir structure
+    const appDirPath = join(buildFolder, `${appFileName}.AppDir`);
+    mkdirSync(appDirPath, { recursive: true });
+    
+    // Copy app bundle contents to AppDir
+    const appDirAppPath = join(appDirPath, "app");
+    cpSync(appBundlePath, appDirAppPath, { recursive: true });
+    
+    // Create AppRun script (main executable for AppImage)
+    const appRunContent = `#!/bin/bash
+HERE="$(dirname "$(readlink -f "\${0}")")"
+export APPDIR="\$HERE"
+cd "\$HERE"
+exec "\$HERE/app/bin/launcher" "\$@"
+`;
+    
+    const appRunPath = join(appDirPath, "AppRun");
+    writeFileSync(appRunPath, appRunContent);
+    execSync(`chmod +x ${escapePathForTerminal(appRunPath)}`);
+    
+    // Create desktop file in AppDir root
+    const desktopContent = `[Desktop Entry]
+Version=1.0
+Type=Application
+Name=${config.package?.name || config.app.name}
+Comment=${config.package?.description || config.app.description || ''}
+Exec=AppRun
+Icon=${appFileName}
+Terminal=false
+StartupWMClass=${appFileName}
+Categories=Application;
+`;
+    
+    const appDirDesktopPath = join(appDirPath, `${appFileName}.desktop`);
+    writeFileSync(appDirDesktopPath, desktopContent);
+    
+    // Copy icon if it exists
+    const iconPath = config.build.linux?.appImageIcon;
+    if (iconPath && existsSync(iconPath)) {
+      const iconDestPath = join(appDirPath, `${appFileName}.png`);
+      cpSync(iconPath, iconDestPath);
+    }
+    
+    // Try to create AppImage using available tools
+    const appImagePath = join(buildFolder, `${appFileName}.AppImage`);
+    
+    // Check for appimagetool
+    try {
+      execSync('which appimagetool', { stdio: 'pipe' });
+      console.log("Using appimagetool to create AppImage...");
+      execSync(`appimagetool ${escapePathForTerminal(appDirPath)} ${escapePathForTerminal(appImagePath)}`, { stdio: 'inherit' });
+      return appImagePath;
+    } catch {
+      // Check for Docker
+      try {
+        execSync('which docker', { stdio: 'pipe' });
+        console.log("Using Docker to create AppImage...");
+        execSync(`docker run --rm -v "${buildFolder}:/workspace" linuxserver/appimagetool "/workspace/${basename(appDirPath)}" "/workspace/${basename(appImagePath)}"`, { stdio: 'inherit' });
+        return appImagePath;
+      } catch {
+        console.warn("Neither appimagetool nor Docker found. AppImage creation skipped.");
+        console.warn("To create AppImages, install appimagetool or Docker.");
+        return null;
+      }
+    }
+  } catch (error) {
+    console.error("Failed to create AppImage:", error);
+    return null;
+  }
+}
+
 function codesignAppBundle(
   appBundleOrDmgPath: string,
   entitlementsFilePath?: string

package/templates/hello-world/electrobun.config

@@ -1,17 +1,18 @@
 {
-  "name": "HelloWorld",
-  "id": "com.example.helloworld",
-  "version": "1.0.0",
-  "author": "Your Name",
-  "description": "A simple Electrobun hello world app",
-  "main": "src/bun/index.ts",
-  "views": {
-    "main": {
-      "html": "src/mainview/index.html",
-      "preload": "src/mainview/index.ts"
-    }
-  },
-  "build": {
-    "placeholderIcon": true
-  }
+    "app": {
+        "name": "hello-world",
+        "identifier": "helloworld.electrobun.dev",
+        "version": "0.0.1"
+    },
+    "build": {
+        "mac": {           
+          "bundleCEF": true            
+        },
+        "linux": {
+            "bundleCEF": true
+        },
+        "win": {
+            "bundleCEF": true
+        }
+    },
 }