electrobun 0.11.0-beta.3 → 0.13.0-beta.0

package/src/cli/index.ts

@@ -1,4 +1,5 @@
 import { join, dirname, basename, relative } from "path";
+import * as path from "path";
 import {
   existsSync,
   readFileSync,
@@ -531,7 +532,7 @@ const commandDefaults = {
   },
 };
 
-// todo (yoav): add types for config
+// TODO (yoav): add types for config
 const defaultConfig = {
   app: {
     name: "MyApp",
@@ -569,7 +570,10 @@ const defaultConfig = {
     },
   },
   scripts: {
+    preBuild: "",
     postBuild: "",
+    postWrap: "",
+    postPackage: "",
   },
   release: {
     bucketUrl: "",
@@ -606,6 +610,255 @@ function escapeXml(str: string): string {
     .replace(/'/g, ''');
 }
 
+// Helper functions
+function escapePathForTerminal(path: string): string {
+  return `"${path.replace(/"/g, '\\"')}"`;
+}
+
+// AppImage tooling functions
+async function ensureAppImageTooling(): Promise<void> {
+  // First check if FUSE2 is available
+  try {
+    execSync('ls /usr/lib/*/libfuse.so.2 || ls /lib/*/libfuse.so.2', { stdio: 'ignore' });
+  } catch (error) {
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('🚨 FUSE2 DEPENDENCY MISSING');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('AppImage creation requires libfuse2, but it was not found on your system.');
+    console.log('');
+    console.log('Please install it using:');
+    console.log('   sudo apt update && sudo apt install -y libfuse2');
+    console.log('');
+    console.log('Without libfuse2, AppImage creation will fail with FUSE errors.');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('');
+    throw new Error('libfuse2 is required for AppImage creation but not found. Please install it first.');
+  }
+
+  try {
+    // Check if appimagetool is available
+    execSync('which appimagetool', { stdio: 'ignore' });
+    console.log('✓ appimagetool found');
+    return;
+  } catch (error) {
+    // appimagetool not found, download it automatically
+    console.log('📥 appimagetool not found, downloading...');
+    
+    try {
+      // Determine architecture-specific download URL
+      const downloadUrl = ARCH === 'arm64' 
+        ? 'https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-aarch64.AppImage'
+        : 'https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage';
+      
+      // Download appimagetool
+      console.log(`Downloading appimagetool from ${downloadUrl}...`);
+      execSync(`wget -q "${downloadUrl}" -O /tmp/appimagetool.AppImage`, { stdio: 'inherit' });
+      
+      // Make it executable
+      execSync('chmod +x /tmp/appimagetool.AppImage', { stdio: 'inherit' });
+      
+      // Try to move to /usr/local/bin (with sudo)
+      try {
+        execSync('sudo mv /tmp/appimagetool.AppImage /usr/local/bin/appimagetool', { stdio: 'inherit' });
+        console.log('✓ appimagetool installed to /usr/local/bin/appimagetool');
+      } catch (sudoError) {
+        // Fallback: extract and place in user's local bin
+        console.log('sudo not available, installing to ~/.local/bin/...');
+        execSync('mkdir -p ~/.local/bin', { stdio: 'inherit' });
+        
+        // Extract the AppImage to get the binary
+        execSync('cd /tmp && ./appimagetool.AppImage --appimage-extract >/dev/null 2>&1', { stdio: 'inherit' });
+        execSync('cp /tmp/squashfs-root/usr/bin/appimagetool ~/.local/bin/appimagetool', { stdio: 'inherit' });
+        execSync('chmod +x ~/.local/bin/appimagetool', { stdio: 'inherit' });
+        
+        // Set up symlink for mksquashfs dependency
+        execSync('mkdir -p ~/.local/lib/appimagekit', { stdio: 'inherit' });
+        execSync('ln -sf /usr/bin/mksquashfs ~/.local/lib/appimagekit/mksquashfs', { stdio: 'inherit' });
+        
+        // Clean up
+        execSync('rm -rf /tmp/appimagetool.AppImage /tmp/squashfs-root', { stdio: 'inherit' });
+        
+        console.log('✓ appimagetool installed to ~/.local/bin/appimagetool');
+        console.log('Note: Make sure ~/.local/bin is in your PATH for future use');
+      }
+      
+    } catch (downloadError) {
+      console.error('Failed to download appimagetool:', downloadError);
+      throw new Error('Failed to install appimagetool automatically. Please install it manually.');
+    }
+  }
+}
+
+async function createAppImage(
+  appBundlePath: string,
+  appFileName: string,
+  config: any,
+  buildFolder: string
+): Promise<string> {
+  console.log(`🚀 CREATING APPIMAGE WITH PATH: ${appBundlePath}`);
+  console.log(`DEBUG: createAppImage called with:`);
+  console.log(`  appBundlePath: ${appBundlePath}`);
+  console.log(`  appFileName: ${appFileName}`);
+  console.log(`  buildFolder: ${buildFolder}`);
+  console.log(`  current working directory: ${process.cwd()}`);
+  
+  // Ensure appBundlePath is absolute - fix for when it's passed as basename only
+  let resolvedAppBundlePath = appBundlePath;
+  if (!path.isAbsolute(appBundlePath)) {
+    resolvedAppBundlePath = join(buildFolder, appBundlePath);
+    console.log(`DEBUG: Converted relative path to absolute: ${resolvedAppBundlePath}`);
+  }
+  
+  // Create AppDir structure
+  const appDirPath = join(buildFolder, `${appFileName}.AppDir`);
+  if (existsSync(appDirPath)) {
+    rmSync(appDirPath, { recursive: true, force: true });
+  }
+  mkdirSync(appDirPath, { recursive: true });
+  
+  // Copy the entire app bundle to AppDir/usr/bin/
+  const usrBinPath = join(appDirPath, 'usr', 'bin');
+  mkdirSync(usrBinPath, { recursive: true });
+  
+  console.log(`DEBUG: Attempting to copy from: ${resolvedAppBundlePath}`);
+  console.log(`DEBUG: Does source exist? ${existsSync(resolvedAppBundlePath)}`);
+  console.log(`DEBUG: To destination: ${join(usrBinPath, basename(resolvedAppBundlePath))}`);
+  
+  if (!existsSync(resolvedAppBundlePath)) {
+    throw new Error(`Source bundle does not exist: ${resolvedAppBundlePath}`);
+  }
+  
+  console.log(`DEBUG: About to copy with cpSync:`);
+  console.log(`  from: ${resolvedAppBundlePath} (exists: ${existsSync(resolvedAppBundlePath)})`);
+  console.log(`  to: ${join(usrBinPath, basename(resolvedAppBundlePath))}`);
+  
+  cpSync(resolvedAppBundlePath, join(usrBinPath, basename(resolvedAppBundlePath)), {
+    recursive: true,
+    dereference: true
+  });
+  
+  // Create AppRun script (the entry point)
+  const appBundleBasename = basename(resolvedAppBundlePath);
+  const appRunContent = `#!/bin/bash
+# AppRun script for ${appFileName}
+HERE="$(dirname "$(readlink -f "\${0}")")"
+EXEC="\${HERE}/usr/bin/${appBundleBasename}/bin/launcher"
+
+# Set up library path for CEF
+export LD_LIBRARY_PATH="\${HERE}/usr/bin/${appBundleBasename}/bin:\${HERE}/usr/bin/${appBundleBasename}/lib:\${LD_LIBRARY_PATH}"
+
+# Execute the application
+exec "\${EXEC}" "\$@"
+`;
+  
+  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.app.name}
+Comment=${config.app.description || ''}
+Exec=${appFileName}
+Icon=${appFileName}
+Terminal=false
+StartupWMClass=${appFileName}
+Categories=Utility;
+`;
+  
+  const desktopPath = join(appDirPath, `${appFileName}.desktop`);
+  writeFileSync(desktopPath, desktopContent);
+  
+  // Copy icon if available
+  if (config.build.linux?.icon && existsSync(join(projectRoot, config.build.linux.icon))) {
+    const iconSourcePath = join(projectRoot, config.build.linux.icon);
+    const iconDestPath = join(appDirPath, `${appFileName}.png`);
+    const dirIconPath = join(appDirPath, '.DirIcon');
+    
+    cpSync(iconSourcePath, iconDestPath, { dereference: true });
+    cpSync(iconSourcePath, dirIconPath, { dereference: true });
+    
+    console.log(`Copied icon for AppImage: ${iconSourcePath} -> ${iconDestPath}`);
+    console.log(`Created .DirIcon: ${iconSourcePath} -> ${dirIconPath}`);
+  }
+  
+  // Generate the AppImage using appimagetool
+  const appImagePath = join(buildFolder, `${appFileName}.AppImage`);
+  if (existsSync(appImagePath)) {
+    unlinkSync(appImagePath);
+  }
+  
+  console.log(`DEBUG: AppDir path: ${appDirPath}`);
+  console.log(`DEBUG: Does AppDir exist? ${existsSync(appDirPath)}`);
+  console.log(`Generating AppImage: ${appImagePath}`);
+  const appImageArch = ARCH === 'arm64' ? 'aarch64' : 'x86_64';
+  
+  // Use full path to appimagetool if not in PATH
+  let appimagetoolCmd = 'appimagetool';
+  try {
+    execSync('which appimagetool', { stdio: 'ignore' });
+  } catch {
+    // Try ~/.local/bin/appimagetool
+    const localBinPath = join(process.env['HOME'] || '', '.local', 'bin', 'appimagetool');
+    if (existsSync(localBinPath)) {
+      appimagetoolCmd = localBinPath;
+    }
+  }
+  
+  try {
+    // First try with --no-appstream flag to avoid some FUSE-related issues
+    execSync(`ARCH=${appImageArch} ${appimagetoolCmd} --no-appstream ${escapePathForTerminal(appDirPath)} ${escapePathForTerminal(appImagePath)}`, {
+      stdio: 'inherit',
+      env: { ...process.env, ARCH: appImageArch }
+    });
+  } catch (error) {
+    console.error('Failed to create AppImage:', error);
+    console.log('Note: If you see FUSE errors, you may need to install libfuse2:');
+    console.log('  sudo apt update && sudo apt install -y libfuse2');
+    throw error;
+  }
+  
+  // Verify the AppImage was created
+  if (!existsSync(appImagePath)) {
+    throw new Error(`AppImage was not created at expected path: ${appImagePath}`);
+  }
+  
+  // Extract and copy icon for desktop shortcut
+  const iconExtractPath = join(buildFolder, `${appFileName}.png`);
+  if (config.build.linux?.icon && existsSync(join(projectRoot, config.build.linux.icon))) {
+    const iconSourcePath = join(projectRoot, config.build.linux.icon);
+    cpSync(iconSourcePath, iconExtractPath, { dereference: true });
+    console.log(`✓ Icon extracted for desktop shortcut: ${iconExtractPath}`);
+  }
+  
+  // Create desktop shortcut alongside the AppImage
+  const desktopShortcutPath = join(buildFolder, `${appFileName}.desktop`);
+  const desktopShortcutContent = `[Desktop Entry]
+Version=1.0
+Type=Application
+Name=${config.app.name}
+Comment=${config.app.description || ''}
+Exec=${appImagePath}
+Icon=${iconExtractPath}
+Terminal=false
+StartupWMClass=${appFileName}
+Categories=Utility;
+`;
+  
+  writeFileSync(desktopShortcutPath, desktopShortcutContent);
+  execSync(`chmod +x ${escapePathForTerminal(desktopShortcutPath)}`);
+  console.log(`✓ Desktop shortcut created: ${desktopShortcutPath}`);
+  
+  // Clean up AppDir
+  rmSync(appDirPath, { recursive: true, force: true });
+  
+  console.log(`✓ AppImage created: ${appImagePath}`);
+  return appImagePath;
+}
+
 // Helper function to generate usage description entries for Info.plist
 function generateUsageDescriptions(entitlements: Record<string, boolean | string>): string {
   const usageEntries: string[] = [];
@@ -648,286 +901,8 @@ ${schemesXml}
     </array>`;
 }
 
-const command = commandDefaults[commandArg];
-
-if (!command) {
-  console.error("Invalid command: ", commandArg);
-  process.exit(1);
-}
-
-// Main execution function
-async function main() {
-  const config = await getConfig();
-
-  const envArg =
-    process.argv.find((arg) => arg.startsWith("--env="))?.split("=")[1] || "";
-
-  const targetsArg =
-    process.argv.find((arg) => arg.startsWith("--targets="))?.split("=")[1] || "";
-
-  const validEnvironments = ["dev", "canary", "stable"];
-
-  // todo (yoav): dev, canary, and stable;
-  const buildEnvironment: "dev" | "canary" | "stable" =
-    validEnvironments.includes(envArg || "dev") ? (envArg || "dev") : "dev";
-
-// Determine build targets
-type BuildTarget = { os: 'macos' | 'win' | 'linux', arch: 'arm64' | 'x64' };
-
-function parseBuildTargets(): BuildTarget[] {
-  // If explicit targets provided via CLI
-  if (targetsArg) {
-    if (targetsArg === 'current') {
-      return [{ os: OS, arch: ARCH }];
-    } else if (targetsArg === 'all') {
-      return parseConfigTargets();
-    } else {
-      // Parse comma-separated targets like "macos-arm64,win-x64"
-      return targetsArg.split(',').map(target => {
-        const [os, arch] = target.trim().split('-') as [string, string];
-        if (!['macos', 'win', 'linux'].includes(os) || !['arm64', 'x64'].includes(arch)) {
-          console.error(`Invalid target: ${target}. Format should be: os-arch (e.g., macos-arm64)`);
-          process.exit(1);
-        }
-        return { os, arch } as BuildTarget;
-      });
-    }
-  }
-
-  // Default behavior: always build for current platform only
-  // This ensures predictable, fast builds unless explicitly requesting multi-platform
-  return [{ os: OS, arch: ARCH }];
-}
-
-function parseConfigTargets(): BuildTarget[] {
-  // If config has targets, use them
-  if (config.build.targets && config.build.targets.length > 0) {
-    return config.build.targets.map(target => {
-      if (target === 'current') {
-        return { os: OS, arch: ARCH };
-      }
-      const [os, arch] = target.split('-') as [string, string];
-      if (!['macos', 'win', 'linux'].includes(os) || !['arm64', 'x64'].includes(arch)) {
-        console.error(`Invalid target in config: ${target}. Format should be: os-arch (e.g., macos-arm64)`);
-        process.exit(1);
-      }
-      return { os, arch } as BuildTarget;
-    });
-  }
-  
-  // If no config targets and --targets=all, use all available platforms
-  if (targetsArg === 'all') {
-    console.log('No targets specified in config, using all available platforms');
-    return [
-      { os: 'macos', arch: 'arm64' },
-      { os: 'macos', arch: 'x64' },
-      { os: 'win', arch: 'x64' },
-      { os: 'linux', arch: 'x64' },
-      { os: 'linux', arch: 'arm64' }
-    ];
-  }
-  
-  // Default to current platform
-  return [{ os: OS, arch: ARCH }];
-}
-
-const buildTargets = parseBuildTargets();
-
-// Show build targets to user
-if (buildTargets.length === 1) {
-  console.log(`Building for ${buildTargets[0].os}-${buildTargets[0].arch} (${buildEnvironment})`);
-} else {
-  const targetList = buildTargets.map(t => `${t.os}-${t.arch}`).join(', ');
-  console.log(`Building for multiple targets: ${targetList} (${buildEnvironment})`);
-  console.log(`Running ${buildTargets.length} parallel builds...`);
-  
-  // Spawn parallel build processes
-  const buildPromises = buildTargets.map(async (target) => {
-    const targetString = `${target.os}-${target.arch}`;
-    const prefix = `[${targetString}]`;
-    
-    try {
-      // Try to find the electrobun binary in node_modules/.bin or use bunx
-      const electrobunBin = join(projectRoot, 'node_modules', '.bin', 'electrobun');
-      let command: string[];
-      
-      if (existsSync(electrobunBin)) {
-        command = [electrobunBin, 'build', `--env=${buildEnvironment}`, `--targets=${targetString}`];
-      } else {
-        // Fallback to bunx which should resolve node_modules binaries
-        command = ['bunx', 'electrobun', 'build', `--env=${buildEnvironment}`, `--targets=${targetString}`];
-      }
-      
-      console.log(`${prefix} Running:`, command.join(' '));
-      
-      const result = await Bun.spawn(command, {
-        stdio: ['inherit', 'pipe', 'pipe'],
-        env: process.env,
-        cwd: projectRoot // Ensure we're in the right directory
-      });
-
-      // Pipe output with prefix
-      if (result.stdout) {
-        const reader = result.stdout.getReader();
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          const text = new TextDecoder().decode(value);
-          // Add prefix to each line
-          const prefixedText = text.split('\n').map(line => 
-            line ? `${prefix} ${line}` : line
-          ).join('\n');
-          process.stdout.write(prefixedText);
-        }
-      }
-
-      if (result.stderr) {
-        const reader = result.stderr.getReader();
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          const text = new TextDecoder().decode(value);
-          const prefixedText = text.split('\n').map(line => 
-            line ? `${prefix} ${line}` : line
-          ).join('\n');
-          process.stderr.write(prefixedText);
-        }
-      }
-
-      const exitCode = await result.exited;
-      return { target, exitCode, success: exitCode === 0 };
-      
-    } catch (error) {
-      console.error(`${prefix} Failed to start build:`, error);
-      return { target, exitCode: 1, success: false, error };
-    }
-  });
-
-  // Wait for all builds to complete
-  const results = await Promise.allSettled(buildPromises);
-  
-  // Report final results
-  console.log('\n=== Build Results ===');
-  let allSucceeded = true;
-  
-  for (const result of results) {
-    if (result.status === 'fulfilled') {
-      const { target, success, exitCode } = result.value;
-      const status = success ? '✅ SUCCESS' : '❌ FAILED';
-      console.log(`${target.os}-${target.arch}: ${status} (exit code: ${exitCode})`);
-      if (!success) allSucceeded = false;
-    } else {
-      console.log(`Build rejected: ${result.reason}`);
-      allSucceeded = false;
-    }
-  }
-  
-  if (!allSucceeded) {
-    console.log('\nSome builds failed. Check the output above for details.');
-    process.exit(1);
-  } else {
-    console.log('\nAll builds completed successfully! 🎉');
-  }
-  
-  process.exit(0);
-}
-
-// todo (yoav): dev builds should include the branch name, and/or allow configuration via external config
-// For now, assume single target build (we'll refactor for multi-target later)
-const currentTarget = buildTargets[0];
-const buildSubFolder = `${buildEnvironment}-${currentTarget.os}-${currentTarget.arch}`;
-
-// Use target OS/ARCH for build logic (instead of current machine's OS/ARCH)
-const targetOS = currentTarget.os;
-const targetARCH = currentTarget.arch;
-const targetBinExt = targetOS === 'win' ? '.exe' : '';
-
-const buildFolder = join(projectRoot, config.build.buildFolder, buildSubFolder);
-
-const artifactFolder = join(
-  projectRoot,
-  config.build.artifactFolder,
-  buildSubFolder
-);
-
-const buildIcons = (appBundleFolderResourcesPath: string) => {
-  if (OS === 'macos' && config.build.mac.icons) {
-    const iconSourceFolder = join(projectRoot, config.build.mac.icons);
-    const iconDestPath = join(appBundleFolderResourcesPath, "AppIcon.icns");
-    if (existsSync(iconSourceFolder)) {
-      Bun.spawnSync(
-        ["iconutil", "-c", "icns", "-o", iconDestPath, iconSourceFolder],
-        {
-          cwd: appBundleFolderResourcesPath,
-          stdio: ["ignore", "inherit", "inherit"],
-          env: {
-            ...process.env,
-            ELECTROBUN_BUILD_ENV: buildEnvironment,
-          },
-        }
-      );
-    }
-  }
-};
-
-function escapePathForTerminal(filePath: string) {
-  // List of special characters to escape
-  const specialChars = [
-    " ",
-    "(",
-    ")",
-    "&",
-    "|",
-    ";",
-    "<",
-    ">",
-    "`",
-    "\\",
-    '"',
-    "'",
-    "$",
-    "*",
-    "?",
-    "[",
-    "]",
-    "#",
-  ];
-
-  let escapedPath = "";
-  for (const char of filePath) {
-    if (specialChars.includes(char)) {
-      escapedPath += `\\${char}`;
-    } else {
-      escapedPath += char;
-    }
-  }
-
-  return escapedPath;
-}
-
-function sanitizeVolumeNameForHdiutil(volumeName: string) {
-  // Remove or replace characters that cause issues with hdiutil volume mounting
-  // Parentheses and other special characters can cause "Operation not permitted" errors
-  return volumeName.replace(/[()]/g, '');
-}
-
-// MyApp
-
-// const appName = config.app.name.replace(/\s/g, '-').toLowerCase();
-
-const appFileName = (
-  buildEnvironment === "stable"
-    ? config.app.name
-    : `${config.app.name}-${buildEnvironment}`
-)
-  .replace(/\s/g, "")
-  .replace(/\./g, "-");
-const bundleFileName = targetOS === 'macos' ? `${appFileName}.app` : appFileName;
-
-// const logPath = `/Library/Logs/Electrobun/ExampleApp/dev/out.log`;
-
-let proc = null;
-
+// Execute command handling
+(async () => {
 if (commandArg === "init") {
   await (async () => {
     const secondArg = process.argv[indexOfElectrobun + 2];
@@ -1041,13 +1016,116 @@ if (commandArg === "init") {
     console.log("🎉 Happy building with Electrobun!");
   })();
 } else if (commandArg === "build") {
+  // Get config
+  const config = await getConfig();
+  
+  // Get environment
+  const envArg = process.argv.find((arg) => arg.startsWith("--env="))?.split("=")[1] || "";
+  const buildEnvironment = ["dev", "canary", "stable"].includes(envArg) ? envArg : "dev";
+  
+  // Determine current platform as default target
+  const currentTarget = { os: OS, arch: ARCH };
+  
+  // Set up build variables
+  const targetOS = currentTarget.os;
+  const targetARCH = currentTarget.arch;
+  const targetBinExt = targetOS === 'win' ? '.exe' : '';
+  const appFileName = `${config.app.name.replace(/ /g, "")}-${buildEnvironment}`;
+  const buildSubFolder = `${buildEnvironment}-${currentTarget.os}-${currentTarget.arch}`;
+  const buildFolder = join(projectRoot, config.build.buildFolder, buildSubFolder);
+  const bundleFileName = targetOS === 'macos' ? `${appFileName}.app` : appFileName;
+  const artifactFolder = join(projectRoot, config.build.artifactFolder, buildSubFolder);
+  
   // Ensure core binaries are available for the target platform before starting build
   await ensureCoreDependencies(currentTarget.os, currentTarget.arch);
   
   // Get platform-specific paths for the current target
   const targetPaths = getPlatformPaths(currentTarget.os, currentTarget.arch);
   
-  // refresh build folder  
+  // Helper functions
+  const sanitizeVolumeNameForHdiutil = (name: string) => {
+    return name.replace(/[^a-zA-Z0-9 ]/g, '').trim();
+  };
+
+  // Helper to run lifecycle hook scripts
+  const runHook = (hookName: keyof typeof config.scripts, extraEnv: Record<string, string> = {}) => {
+    const hookScript = config.scripts[hookName];
+    if (!hookScript) return;
+
+    console.log(`Running ${hookName} script:`, hookScript);
+    // Use host platform's bun binary for running scripts, not target platform's
+    const hostPaths = getPlatformPaths(OS, ARCH);
+
+    const result = Bun.spawnSync([hostPaths.BUN_BINARY, hookScript], {
+      stdio: ["ignore", "inherit", "inherit"],
+      cwd: projectRoot,
+      env: {
+        ...process.env,
+        ELECTROBUN_BUILD_ENV: buildEnvironment,
+        ELECTROBUN_OS: targetOS,
+        ELECTROBUN_ARCH: targetARCH,
+        ELECTROBUN_BUILD_DIR: buildFolder,
+        ELECTROBUN_APP_NAME: appFileName,
+        ELECTROBUN_APP_VERSION: config.app.version,
+        ELECTROBUN_APP_IDENTIFIER: config.app.identifier,
+        ELECTROBUN_ARTIFACT_DIR: artifactFolder,
+        ...extraEnv,
+      },
+    });
+
+    if (result.exitCode !== 0) {
+      console.error(`${hookName} script failed with exit code:`, result.exitCode);
+      if (result.stderr) {
+        console.error("stderr:", result.stderr.toString());
+      }
+      console.error("Tried to run with bun at:", hostPaths.BUN_BINARY);
+      console.error("Script path:", hookScript);
+      console.error("Working directory:", projectRoot);
+      process.exit(1);
+    }
+  };
+
+  const buildIcons = (appBundleFolderResourcesPath: string) => {
+    // Platform-specific icon handling
+    if (targetOS === 'macos' && config.build.mac?.icon) {
+      const iconPath = join(projectRoot, config.build.mac.icon);
+      if (existsSync(iconPath)) {
+        const targetIconPath = join(appBundleFolderResourcesPath, "AppIcon.icns");
+        cpSync(iconPath, targetIconPath, { dereference: true });
+      }
+    } else if (targetOS === 'linux' && config.build.linux?.icon) {
+      const iconSourcePath = join(projectRoot, config.build.linux.icon);
+      if (existsSync(iconSourcePath)) {
+        const standardIconPath = join(appBundleFolderResourcesPath, 'appIcon.png');
+        
+        // Ensure Resources directory exists
+        mkdirSync(appBundleFolderResourcesPath, { recursive: true });
+        
+        // Copy the icon to standard location
+        cpSync(iconSourcePath, standardIconPath, { dereference: true });
+        console.log(`Copied Linux icon from ${iconSourcePath} to ${standardIconPath}`);
+        
+        // Also copy icon for the extractor (expects it in Resources/app/icon.png before ASAR packaging)
+        const extractorIconPath = join(appBundleFolderResourcesPath, 'app', 'icon.png');
+        mkdirSync(join(appBundleFolderResourcesPath, 'app'), { recursive: true });
+        cpSync(iconSourcePath, extractorIconPath, { dereference: true });
+        console.log(`Copied Linux icon for extractor from ${iconSourcePath} to ${extractorIconPath}`);
+      } else {
+        console.log(`WARNING: Linux icon not found: ${iconSourcePath}`);
+      }
+    } else if (targetOS === 'win' && config.build.win?.icon) {
+      const iconPath = join(projectRoot, config.build.win.icon);
+      if (existsSync(iconPath)) {
+        const targetIconPath = join(appBundleFolderResourcesPath, "app.ico");
+        cpSync(iconPath, targetIconPath, { dereference: true });
+      }
+    }
+  };
+
+  // Run preBuild hook before anything starts
+  runHook('preBuild');
+
+  // refresh build folder
   if (existsSync(buildFolder)) {
     rmdirSync(buildFolder, { recursive: true });
   }  
@@ -1158,6 +1236,59 @@ if (commandArg === "init") {
     dereference: true,
   });
 
+  // On Windows, ensure launcher has .exe extension
+  // Bun's cpSync on Windows may create files without .exe despite the destination path having it
+  if (targetOS === 'win') {
+    const launcherWithoutExt = join(appBundleMacOSPath, "launcher");
+
+    // Use PowerShell to force rename and add .exe extension
+    // This bypasses Bun's PATHEXT behavior that treats launcher and launcher.exe as the same
+    try {
+      execSync(`powershell -Command "if (Test-Path '${launcherWithoutExt}') { Rename-Item -Path '${launcherWithoutExt}' -NewName 'launcher.exe' -Force }"`, { stdio: 'pipe' });
+      console.log(`Ensured launcher has .exe extension on Windows`);
+    } catch (error) {
+      console.warn(`Warning: Could not rename launcher to launcher.exe: ${error}`);
+    }
+  }
+
+  // Embed icon into launcher.exe on Windows
+  if (targetOS === 'win' && config.build.win?.icon) {
+    const iconSourcePath = config.build.win.icon.startsWith('/') || config.build.win.icon.match(/^[a-zA-Z]:/)
+      ? config.build.win.icon
+      : join(projectRoot, config.build.win.icon);
+
+    if (existsSync(iconSourcePath)) {
+      console.log(`Embedding icon into launcher.exe: ${iconSourcePath}`);
+      try {
+        let iconPath = iconSourcePath;
+
+        // Convert PNG to ICO if needed
+        if (iconSourcePath.toLowerCase().endsWith('.png')) {
+          const pngToIco = (await import('png-to-ico')).default;
+          const tempIcoPath = join(buildFolder, 'temp-launcher-icon.ico');
+          const icoBuffer = await pngToIco(iconSourcePath);
+          writeFileSync(tempIcoPath, icoBuffer);
+          iconPath = tempIcoPath;
+          console.log(`Converted PNG to ICO format for launcher: ${tempIcoPath}`);
+        }
+
+        // Use rcedit to embed the icon into launcher.exe
+        const rcedit = (await import('rcedit')).default;
+        await rcedit(bunCliLauncherDestination, {
+          icon: iconPath
+        });
+        console.log(`Successfully embedded icon into launcher.exe`);
+
+        // Clean up temp ICO file
+        if (iconPath !== iconSourcePath && existsSync(iconPath)) {
+          unlinkSync(iconPath);
+        }
+      } catch (error) {
+        console.warn(`Warning: Failed to embed icon into launcher.exe: ${error}`);
+      }
+    }
+  }
+
   cpSync(targetPaths.MAIN_JS, join(appBundleFolderResourcesPath, 'main.js'), { dereference: true });
 
   // Bun runtime binary
@@ -1173,6 +1304,44 @@ if (commandArg === "init") {
   }
   cpSync(bunBinarySourcePath, bunBinaryDestInBundlePath, { dereference: true });
 
+  // Embed icon into bun.exe on Windows
+  if (targetOS === 'win' && config.build.win?.icon) {
+    const iconSourcePath = config.build.win.icon.startsWith('/') || config.build.win.icon.match(/^[a-zA-Z]:/)
+      ? config.build.win.icon
+      : join(projectRoot, config.build.win.icon);
+
+    if (existsSync(iconSourcePath)) {
+      console.log(`Embedding icon into bun.exe: ${iconSourcePath}`);
+      try {
+        let iconPath = iconSourcePath;
+
+        // Convert PNG to ICO if needed
+        if (iconSourcePath.toLowerCase().endsWith('.png')) {
+          const pngToIco = (await import('png-to-ico')).default;
+          const tempIcoPath = join(buildFolder, 'temp-bun-icon.ico');
+          const icoBuffer = await pngToIco(iconSourcePath);
+          writeFileSync(tempIcoPath, icoBuffer);
+          iconPath = tempIcoPath;
+          console.log(`Converted PNG to ICO format for bun.exe: ${tempIcoPath}`);
+        }
+
+        // Use rcedit to embed the icon into bun.exe
+        const rcedit = (await import('rcedit')).default;
+        await rcedit(bunBinaryDestInBundlePath, {
+          icon: iconPath
+        });
+        console.log(`Successfully embedded icon into bun.exe`);
+
+        // Clean up temp ICO file
+        if (iconPath !== iconSourcePath && existsSync(iconPath)) {
+          unlinkSync(iconPath);
+        }
+      } catch (error) {
+        console.warn(`Warning: Failed to embed icon into bun.exe: ${error}`);
+      }
+    }
+  }
+
   // copy native wrapper dynamic library
   if (targetOS === 'macos') {
   const nativeWrapperMacosSource = targetPaths.NATIVE_WRAPPER_MACOS;
@@ -1218,6 +1387,29 @@ if (commandArg === "init") {
   } else {
     throw new Error(`Native wrapper not found: ${nativeWrapperLinuxSource}`);
   }
+  
+  // Copy icon if specified for Linux to a standard location
+  if (config.build.linux?.icon) {
+    const iconSourcePath = join(projectRoot, config.build.linux.icon);
+    if (existsSync(iconSourcePath)) {
+      const standardIconPath = join(appBundleFolderResourcesPath, 'appIcon.png');
+      
+      // Ensure Resources directory exists
+      mkdirSync(appBundleFolderResourcesPath, { recursive: true });
+      
+      // Copy the icon to standard location
+      cpSync(iconSourcePath, standardIconPath, { dereference: true });
+      console.log(`Copied Linux icon from ${iconSourcePath} to ${standardIconPath}`);
+      
+      // Also copy icon for the extractor (expects it in Resources/app/icon.png before ASAR packaging)
+      const extractorIconPath = join(appBundleFolderResourcesPath, 'app', 'icon.png');
+      mkdirSync(join(appBundleFolderResourcesPath, 'app'), { recursive: true });
+      cpSync(iconSourcePath, extractorIconPath, { dereference: true });
+      console.log(`Copied Linux icon for extractor from ${iconSourcePath} to ${extractorIconPath}`);
+    } else {
+      console.log(`WARNING: Linux icon not found: ${iconSourcePath}`);
+    }
+  }
 }
   
 
@@ -1577,6 +1769,7 @@ if (commandArg === "init") {
       continue;
     }
   }
+
   // Copy assets like html, css, images, and other files
   for (const relSource in config.build.copy) {
     const source = join(projectRoot, relSource);
@@ -1605,39 +1798,7 @@ if (commandArg === "init") {
   
   
   // Run postBuild script
-  if (config.scripts.postBuild) {
-    console.log("Running postBuild script:", config.scripts.postBuild);
-    // Use host platform's bun binary for running scripts, not target platform's
-    const hostPaths = getPlatformPaths(OS, ARCH);
-    
-    const result = Bun.spawnSync([hostPaths.BUN_BINARY, config.scripts.postBuild], {
-      stdio: ["ignore", "inherit", "inherit"],
-      cwd: projectRoot, // Add cwd to ensure script runs from project root
-      env: {
-        ...process.env,
-        ELECTROBUN_BUILD_ENV: buildEnvironment,
-        ELECTROBUN_OS: targetOS, // Use target OS for environment variables
-        ELECTROBUN_ARCH: targetARCH, // Use target ARCH for environment variables
-        ELECTROBUN_BUILD_DIR: buildFolder,
-        ELECTROBUN_APP_NAME: appFileName,
-        ELECTROBUN_APP_VERSION: config.app.version,
-        ELECTROBUN_APP_IDENTIFIER: config.app.identifier,
-        ELECTROBUN_ARTIFACT_DIR: artifactFolder,
-      },
-    });
-    
-    if (result.exitCode !== 0) {
-      console.error("postBuild script failed with exit code:", result.exitCode);
-      if (result.stderr) {
-        console.error("stderr:", result.stderr.toString());
-      }
-      // Also log which bun binary we're trying to use
-      console.error("Tried to run with bun at:", hostPaths.BUN_BINARY);
-      console.error("Script path:", config.scripts.postBuild);
-      console.error("Working directory:", projectRoot);
-      process.exit(1);
-    }
-  }
+  runHook('postBuild');
 
   // Pack app resources into ASAR archive if enabled
   if (config.build.useAsar) {
@@ -1778,6 +1939,23 @@ if (commandArg === "init") {
     versionJsonContent
   );
 
+  // build.json inside the app bundle - runtime build configuration
+  const platformConfig = targetOS === 'macos' ? config.build?.mac :
+                         targetOS === 'win' ? config.build?.win :
+                         config.build?.linux;
+
+  const bundlesCEF = platformConfig?.bundleCEF ?? false;
+
+  const buildJsonContent = JSON.stringify({
+    defaultRenderer: platformConfig?.defaultRenderer ?? 'native',
+    availableRenderers: bundlesCEF ? ['native', 'cef'] : ['native'],
+  });
+
+  await Bun.write(
+    join(appBundleFolderResourcesPath, "build.json"),
+    buildJsonContent
+  );
+
   // todo (yoav): add these to config
   // Only codesign/notarize when building macOS targets on macOS host
   const shouldCodesign =
@@ -1801,8 +1979,113 @@ if (commandArg === "init") {
   } else {
     console.log("skipping notarization");
   }
+  
+  const artifactsToUpload = [];
+
+  console.log(`DEBUG: Checking for Linux AppImage creation - targetOS: ${targetOS}, buildEnvironment: ${buildEnvironment}`);
+  
+  // Linux AppImage creation (for all build environments including dev)
+  if (targetOS === 'linux') {
+    console.log("DEBUG: Creating Linux AppImage...");
+    // Ensure AppImage tooling is available
+    await ensureAppImageTooling();
+    
+    // Create AppImage from the app bundle (for both dev and production builds)
+    console.log(`🔍 CALLING createAppImage with appBundleFolderPath: ${appBundleFolderPath}`);
+    console.log(`🔍 buildFolder: ${buildFolder}`);
+    console.log(`🔍 appFileName: ${appFileName}`);
+    const appImagePath = await createAppImage(
+      appBundleFolderPath,
+      appFileName,
+      config,
+      buildFolder
+    );
+
+    console.log(`✓ Linux AppImage created at: ${appImagePath}`);
+    
+    // Only create compressed tar for non-dev builds
+    if (buildEnvironment !== "dev") {
+      // For Linux, create a compressed tar containing:
+      // 1. The AppImage
+      // 2. Desktop shortcut file
+      // 3. Icon file
+      // 4. Metadata
+      
+      const tempDirName = `${appFileName}-installer-contents`;
+      const tempDirPath = join(buildFolder, tempDirName);
+      
+      // Clean up any existing temp directory
+      if (existsSync(tempDirPath)) {
+        rmSync(tempDirPath, { recursive: true });
+      }
+      
+      // Create temp directory structure
+      mkdirSync(tempDirPath, { recursive: true });
+      const innerDirPath = join(tempDirPath, appFileName);
+      mkdirSync(innerDirPath, { recursive: true });
+      
+      // Copy AppImage
+      const appImageDestPath = join(innerDirPath, `${appFileName}.AppImage`);
+      cpSync(appImagePath, appImageDestPath, { dereference: true });
+      
+      // Copy desktop shortcut and icon (they were created alongside the AppImage)
+      const desktopPath = join(buildFolder, `${appFileName}.desktop`);
+      const iconPath = join(buildFolder, `${appFileName}.png`);
+      
+      if (existsSync(desktopPath)) {
+        cpSync(desktopPath, join(innerDirPath, `${appFileName}.desktop`));
+      }
+      
+      if (existsSync(iconPath)) {
+        cpSync(iconPath, join(innerDirPath, `${appFileName}.png`));
+      }
+      
+      // Create metadata file
+      const metadata = {
+        identifier: config.app.identifier,
+        name: config.app.name,
+        version: config.app.version,
+        channel: buildEnvironment
+      };
+      writeFileSync(join(innerDirPath, 'metadata.json'), JSON.stringify(metadata, null, 2));
+      
+      const appImageTarPath = join(buildFolder, `${appFileName}.tar`);
+      console.log(`Creating tar of installer contents: ${appImageTarPath}`);
+      
+      // Tar the inner directory
+      await tar.create(
+        {
+          file: appImageTarPath,
+          cwd: tempDirPath,
+          gzip: false, // We'll compress with zstd after
+        },
+        [appFileName]
+      );
+      
+      // Clean up temp directory
+      rmSync(tempDirPath, { recursive: true });
+      
+      // Compress with Zstandard
+      console.log(`Compressing tar with zstd...`);
+      const uncompressedTarData = readFileSync(appImageTarPath);
+      await ZstdInit().then(async ({ ZstdSimple }) => {
+        const data = new Uint8Array(uncompressedTarData);
+        const compressionLevel = 22;
+        const compressedData = ZstdSimple.compress(data, compressionLevel);
+        const compressedPath = `${appImageTarPath}.zst`;
+        writeFileSync(compressedPath, compressedData);
+        console.log(`✓ Created compressed tar: ${compressedPath} (${(compressedData.length / 1024 / 1024).toFixed(2)} MB)`);
+      });
+      
+      // Remove uncompressed tar
+      unlinkSync(appImageTarPath);
+      
+      // Add AppImage to artifacts for distribution (for direct download)
+      artifactsToUpload.push(appImagePath);
+    }
+  }
+
   if (buildEnvironment !== "dev")  {
-    const artifactsToUpload = [];
     // zstd wasm https://github.com/OneIdentity/zstd-js
     // tar https://github.com/isaacs/node-tar
 
@@ -1820,61 +2103,73 @@ if (commandArg === "init") {
     const platformSuffix = `-${targetOS}-${targetARCH}`;
     const tarPath = `${appBundleFolderPath}.tar`;
 
-    // tar the signed and notarized app bundle
-    await tar.c(
-      {
-        gzip: false,
-        file: tarPath,
-        cwd: buildFolder,
-      },
-      [basename(appBundleFolderPath)]
-    );
-
-    const tarball = Bun.file(tarPath);
-    const tarBuffer = await tarball.arrayBuffer();
-
-    // Note: The playground app bundle is around 48MB.
-    // compression on m1 max with 64GB ram:
-    //   brotli: 1min 38s, 48MB -> 11.1MB
-    //   zstd: 15s, 48MB -> 12.1MB
-    // 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.
+    // For Linux, we've already created the tar in the AppImage section above
+    // For macOS/Windows, tar the signed and notarized app bundle
+    if (targetOS !== 'linux') {
+      await tar.c(
+        {
+          gzip: false,
+          file: tarPath,
+          cwd: buildFolder,
+        },
+        [basename(appBundleFolderPath)]
+      );
+    }
 
     let compressedTarPath = `${tarPath}.zst`;
-    artifactsToUpload.push(compressedTarPath);
-
-    // zstd compress tarball
-    // todo (yoav): consider using c bindings for zstd for speed instead of wasm
-    // we already have it in the bsdiff binary
-    console.log("compressing tarball...");
-    await ZstdInit().then(async ({ ZstdSimple, ZstdStream }) => {
-      // Note: Simple is much faster than stream, but stream is better for large files
-      // todo (yoav): consider a file size cutoff to switch to stream instead of simple.
-      const useStream = tarball.size > 100 * 1024 * 1024;
-      
-      if (tarball.size > 0) {
-        // Uint8 array filestream of the tar file
-        const data = new Uint8Array(tarBuffer);
+    
+    // For Linux, skip compression as we already have the compressed tar
+    if (targetOS === 'linux') {
+      console.log("Linux tar.zst already created, skipping general compression step");
+      // compressedTarPath already points to the right file
+    } else {
+      const tarball = Bun.file(tarPath);
+      const tarBuffer = await tarball.arrayBuffer();
+
+      // Note: The playground app bundle is around 48MB.
+      // compression on m1 max with 64GB ram:
+      //   brotli: 1min 38s, 48MB -> 11.1MB
+      //   zstd: 15s, 48MB -> 12.1MB
+      // 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.
+
+      artifactsToUpload.push(compressedTarPath);
+
+      // zstd compress tarball
+      // todo (yoav): consider using c bindings for zstd for speed instead of wasm
+      // we already have it in the bsdiff binary
+      console.log("compressing tarball...");
+      await ZstdInit().then(async ({ ZstdSimple, ZstdStream }) => {
+        // Note: Simple is much faster than stream, but stream is better for large files
+        // todo (yoav): consider a file size cutoff to switch to stream instead of simple.
+        const useStream = tarball.size > 100 * 1024 * 1024;
         
-        const compressionLevel = 22;  // Maximum compression - now safe with stripped CEF libraries
-        const compressedData = ZstdSimple.compress(data, compressionLevel);
-
-        console.log(
-          "compressed",
-          data.length,
-          "bytes",
-          "from",
-          tarBuffer.byteLength,
-          "bytes"
-        );
+        if (tarball.size > 0) {
+          // Uint8 array filestream of the tar file
+          const data = new Uint8Array(tarBuffer);
+          
+          const compressionLevel = 22;  // Maximum compression - now safe with stripped CEF libraries
+          const compressedData = ZstdSimple.compress(data, compressionLevel);
+
+          console.log(
+            "compressed",
+            data.length,
+            "bytes",
+            "from",
+            tarBuffer.byteLength,
+            "bytes"
+          );
 
-        await Bun.write(compressedTarPath, compressedData);
-      }
-    });
+          await Bun.write(compressedTarPath, compressedData);
+        }
+      });
+    }
 
-    // we can delete the original app bundle since we've tarred and zstd it. We need to create the self-extracting app bundle
-    // now and it needs the same name as the original app bundle.
-    rmdirSync(appBundleFolderPath, { recursive: true });
+    // For macOS/Windows, delete the original app bundle since we've tarred it
+    // For Linux, the app bundle was already converted to AppImage, so the directory might not exist
+    if (targetOS !== 'linux') {
+      rmdirSync(appBundleFolderPath, { recursive: true });
+    }
 
     const selfExtractingBundle = createAppBundle(appFileName, buildFolder, targetOS);
     const compressedTarballInExtractingBundlePath = join(
@@ -1901,6 +2196,10 @@ if (commandArg === "init") {
       InfoPlistContents
     );
 
+    // Run postWrap hook after self-extracting bundle is created, before code signing
+    // This is where you can add files to the wrapper (e.g., for liquid glass support)
+    runHook('postWrap', { ELECTROBUN_WRAPPER_BUNDLE_PATH: selfExtractingBundle.appBundleFolderPath });
+
     if (shouldCodesign) {
       codesignAppBundle(
         selfExtractingBundle.appBundleFolderPath,
@@ -1989,7 +2288,9 @@ if (commandArg === "init") {
           appFileName,
           targetPaths,
           buildEnvironment,
-          hash
+          hash,
+          config,
+          projectRoot
         );
         
         // Wrap Windows installer files in zip for distribution
@@ -1999,48 +2300,19 @@ if (commandArg === "init") {
         // Also keep the raw exe for backwards compatibility (optional)
         // 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)}`);
-        
-        // Note: No longer creating shell script wrapper - users can run bin/launcher directly 
-        // or use the symlink created by the self-extractor
-        
-        // Create self-extracting Linux binary (similar to Windows approach)
-        const selfExtractingLinuxPath = await createLinuxSelfExtractingBinary(
+        // On Linux, create a self-extracting AppImage with embedded archive
+        // Use the Linux-specific compressed tar path
+        const linuxCompressedTarPath = join(buildFolder, `${appFileName}.tar.zst`);
+        const selfExtractingAppImagePath = await createLinuxSelfExtractingAppImage(
           buildFolder,
-          compressedTarPath,
+          linuxCompressedTarPath,
           appFileName,
-          targetPaths,
-          buildEnvironment
+          config,
+          buildEnvironment,
+          hash
         );
         
-        // Wrap Linux .run file in tar.gz to preserve permissions
-        const wrappedRunPath = await wrapInArchive(selfExtractingLinuxPath, buildFolder, 'tar.gz');
-        artifactsToUpload.push(wrappedRunPath);
-        
-        // Also keep the raw .run for backwards compatibility (optional)
-        // artifactsToUpload.push(selfExtractingLinuxPath);
-        
-        // On Linux, create a tar.gz of the bundle (for build process, not uploaded to artifacts)
-        const linuxTarPath = join(buildFolder, `${appFileName}.tar.gz`);
-        execSync(`tar -czf ${escapePathForTerminal(linuxTarPath)} -C ${escapePathForTerminal(buildFolder)} ${escapePathForTerminal(basename(appBundleFolderPath))}`);
-        // Note: Not adding to artifactsToUpload - we use .tar.zst for updates and .run.tar.gz for distribution
+        artifactsToUpload.push(selfExtractingAppImagePath);
       }
     }
 
@@ -2173,6 +2445,9 @@ Categories=Application;
     // you'll end up with a sequence of patch files that will
   }
 
+  // Run postPackage hook at the very end of the build process
+  runHook('postPackage');
+
   // NOTE: verify codesign
   //  codesign --verify --deep --strict --verbose=2 <app path>
 
@@ -2190,6 +2465,17 @@ Categories=Application;
   // run the project in dev mode
   // this runs the bundled bun binary with main.js directly
 
+  // Get config for dev mode
+  const config = await getConfig();
+  
+  // Set up dev build variables (similar to build mode)
+  const buildEnvironment = "dev";
+  const currentTarget = { os: OS, arch: ARCH };
+  const appFileName = `${config.app.name.replace(/ /g, "")}-${buildEnvironment}`;
+  const buildSubFolder = `${buildEnvironment}-${currentTarget.os}-${currentTarget.arch}`;
+  const buildFolder = join(projectRoot, config.build.buildFolder, buildSubFolder);
+  const bundleFileName = OS === 'macos' ? `${appFileName}.app` : appFileName;
+
   // Note: this cli will be a bun single-file-executable
   // Note: we want to use the version of bun that's packaged with electrobun
   // const bunPath = join(projectRoot, 'node_modules', '.bin', 'bun');
@@ -2208,11 +2494,25 @@ Categories=Application;
   let mainProc;
   let bundleExecPath: string;
   let bundleResourcesPath: string;
+  let isAppImage = false;
   
   if (OS === 'macos') {
     bundleExecPath = join(buildFolder, bundleFileName, "Contents", 'MacOS');
     bundleResourcesPath = join(buildFolder, bundleFileName, "Contents", 'Resources');
-  } else if (OS === 'linux' || OS === 'win') {
+  } else if (OS === 'linux') {
+    // Check if we have an AppImage or directory bundle
+    const appImagePath = join(buildFolder, `${bundleFileName}.AppImage`);
+    if (existsSync(appImagePath)) {
+      // AppImage mode
+      bundleExecPath = appImagePath;
+      bundleResourcesPath = join(buildFolder, bundleFileName, "Resources"); // For compatibility
+      isAppImage = true;
+    } else {
+      // Directory bundle mode (fallback)
+      bundleExecPath = join(buildFolder, bundleFileName, "bin");
+      bundleResourcesPath = join(buildFolder, bundleFileName, "Resources");
+    }
+  } else if (OS === 'win') {
     bundleExecPath = join(buildFolder, bundleFileName, "bin");
     bundleResourcesPath = join(buildFolder, bundleFileName, "Resources");
   } else {
@@ -2221,7 +2521,8 @@ Categories=Application;
 
   if (OS === 'macos' || OS === 'linux') {
     // For Linux dev mode, update libNativeWrapper.so based on bundleCEF setting
-    if (OS === 'linux') {
+    if (OS === 'linux' && !isAppImage) {
+      // Only update libNativeWrapper for directory bundle mode
       const currentLibPath = join(bundleExecPath, 'libNativeWrapper.so');
       const targetPaths = getPlatformPaths('linux', ARCH);
       const correctLibSource = config.build.linux?.bundleCEF 
@@ -2238,12 +2539,21 @@ Categories=Application;
       }
     }
     
-    // Use the zig launcher for macOS and Linux
-    mainProc = Bun.spawn([join(bundleExecPath, 'launcher')], {
-      stdio: ['inherit', 'inherit', 'inherit'],
-      cwd: bundleExecPath
-    })
-  } else if (OS === 'win') {  
+    if (OS === 'linux' && isAppImage) {
+      // For Linux AppImage mode, execute the AppImage directly
+      console.log(`Running AppImage: ${bundleExecPath}`);
+      mainProc = Bun.spawn([bundleExecPath], {
+        stdio: ['inherit', 'inherit', 'inherit'],
+        cwd: dirname(bundleExecPath)
+      });
+    } else {
+      // Use the zig launcher for macOS and directory bundle Linux
+      mainProc = Bun.spawn([join(bundleExecPath, 'launcher')], {
+        stdio: ['inherit', 'inherit', 'inherit'],
+        cwd: bundleExecPath
+      });
+    }
+  } else if (OS === 'win') {
     // Windows: Use launcher if available, otherwise fallback to direct execution
     const launcherPath = join(bundleExecPath, 'launcher.exe');
     if (existsSync(launcherPath)) {
@@ -2284,7 +2594,9 @@ Categories=Application;
     }
   });
 
-} 
+}
+
+// Helper functions
 
 async function getConfig() {
   let loadedConfig = {};
@@ -2384,21 +2696,63 @@ async function createWindowsSelfExtractingExe(
   appFileName: string,
   targetPaths: any,
   buildEnvironment: string,
-  hash: string
+  hash: string,
+  config: any,
+  projectRoot: string
 ): Promise<string> {
   console.log("Creating Windows installer with separate archive...");
-  
+
   // Format: MyApp-Setup.exe (stable) or MyApp-Setup-canary.exe (non-stable)
-  const setupFileName = buildEnvironment === "stable" 
+  const setupFileName = buildEnvironment === "stable"
     ? `${config.app.name}-Setup.exe`
     : `${config.app.name}-Setup-${buildEnvironment}.exe`;
-  
+
   const outputExePath = join(buildFolder, setupFileName);
-  
+
   // Copy the extractor exe
   const extractorExe = readFileSync(targetPaths.EXTRACTOR);
   writeFileSync(outputExePath, extractorExe);
-  
+
+  // Embed icon into the wrapper EXE if provided
+  if (config.build.win?.icon) {
+    const iconSourcePath = config.build.win.icon.startsWith('/') || config.build.win.icon.match(/^[a-zA-Z]:/)
+      ? config.build.win.icon
+      : join(projectRoot, config.build.win.icon);
+
+    if (existsSync(iconSourcePath)) {
+      console.log(`Embedding icon into Windows installer: ${iconSourcePath}`);
+      try {
+        let iconPath = iconSourcePath;
+
+        // Convert PNG to ICO if needed
+        if (iconSourcePath.toLowerCase().endsWith('.png')) {
+          const pngToIco = (await import('png-to-ico')).default;
+          const tempIcoPath = join(buildFolder, 'temp-icon.ico');
+          const icoBuffer = await pngToIco(iconSourcePath);
+          writeFileSync(tempIcoPath, icoBuffer);
+          iconPath = tempIcoPath;
+          console.log(`Converted PNG to ICO format: ${tempIcoPath}`);
+        }
+
+        // Use rcedit to embed the icon
+        const rcedit = (await import('rcedit')).default;
+        await rcedit(outputExePath, {
+          icon: iconPath
+        });
+        console.log(`Successfully embedded icon into ${setupFileName}`);
+
+        // Clean up temp ICO file
+        if (iconPath !== iconSourcePath && existsSync(iconPath)) {
+          unlinkSync(iconPath);
+        }
+      } catch (error) {
+        console.warn(`Warning: Failed to embed icon into Windows installer: ${error}`);
+      }
+    } else {
+      console.warn(`Warning: Windows icon not found at ${iconSourcePath}`);
+    }
+  }
+
   // Create metadata JSON file
   const metadata = {
     identifier: config.app.identifier,
@@ -2410,27 +2764,27 @@ async function createWindowsSelfExtractingExe(
   const metadataFileName = setupFileName.replace('.exe', '.metadata.json');
   const metadataPath = join(buildFolder, metadataFileName);
   writeFileSync(metadataPath, metadataJson);
-  
+
   // Copy the compressed archive with matching name
   const archiveFileName = setupFileName.replace('.exe', '.tar.zst');
   const archivePath = join(buildFolder, archiveFileName);
   copyFileSync(compressedTarPath, archivePath);
-  
+
   // Make the exe executable (though Windows doesn't need chmod)
   if (OS !== 'win') {
     execSync(`chmod +x ${escapePathForTerminal(outputExePath)}`);
   }
-  
+
   const exeSize = statSync(outputExePath).size;
   const archiveSize = statSync(archivePath).size;
   const totalSize = exeSize + archiveSize;
-  
+
   console.log(`Created Windows installer:`);
   console.log(`  - Extractor: ${outputExePath} (${(exeSize / 1024 / 1024).toFixed(2)} MB)`);
   console.log(`  - Archive: ${archivePath} (${(archiveSize / 1024 / 1024).toFixed(2)} MB)`);
   console.log(`  - Metadata: ${metadataPath}`);
   console.log(`  - Total size: ${(totalSize / 1024 / 1024).toFixed(2)} MB`);
-  
+
   return outputExePath;
 }
 
@@ -2526,12 +2880,14 @@ async function wrapWindowsInstallerInZip(exePath: string, buildFolder: string):
     });
     
     archive.pipe(output);
-    
-    // Add all three files to the archive
+
+    // Add Setup.exe at the root level for easy access
     archive.file(exePath, { name: basename(exePath) });
-    archive.file(metadataPath, { name: basename(metadataPath) });
-    archive.file(archivePath, { name: basename(archivePath) });
-    
+
+    // Put metadata and archive in a subdirectory to discourage manual extraction
+    archive.file(metadataPath, { name: `.installer/${basename(metadataPath)}` });
+    archive.file(archivePath, { name: `.installer/${basename(archivePath)}` });
+
     archive.finalize();
   });
 }
@@ -2600,81 +2956,159 @@ async function wrapInArchive(filePath: string, buildFolder: string, archiveType:
   }
 }
 
-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, dereference: true });
-    
-    // Create AppRun script (main executable for AppImage)
-    const appRunContent = `#!/bin/bash
+async function createLinuxSelfExtractingAppImage(
+  buildFolder: string,
+  compressedTarPath: string,
+  appFileName: string,
+  config: any,
+  buildEnvironment: string,
+  hash: string
+): Promise<string> {
+  console.log('Creating Linux AppImage wrapper...');
+
+  // Create wrapper AppImage filename
+  const wrapperName = buildEnvironment === 'stable' 
+    ? `${config.app.name}-Setup`
+    : `${config.app.name}-Setup-${buildEnvironment}`;
+  
+  const wrapperAppImagePath = join(buildFolder, `${wrapperName}.AppImage`);
+  const wrapperAppDirPath = join(buildFolder, `${wrapperName}.AppDir`);
+
+  // Clean up any existing AppDir
+  if (existsSync(wrapperAppDirPath)) {
+    rmSync(wrapperAppDirPath, { recursive: true, force: true });
+  }
+  mkdirSync(wrapperAppDirPath, { recursive: true });
+
+  // Create usr/bin directory structure
+  const usrBinPath = join(wrapperAppDirPath, 'usr', 'bin');
+  mkdirSync(usrBinPath, { recursive: true });
+
+  // Create self-extracting binary with embedded archive (following magic markers pattern)
+  const targetPaths = getPlatformPaths('linux', ARCH);
+  
+  // 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,
+    hash: hash
+  };
+  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 to AppImage/usr/bin/
+  const wrapperExtractorPath = join(usrBinPath, wrapperName);
+  writeFileSync(wrapperExtractorPath, combinedBuffer, { mode: 0o755 });
+  execSync(`chmod +x ${escapePathForTerminal(wrapperExtractorPath)}`);
+
+  // Create AppRun script
+  const appRunContent = `#!/bin/bash
+# AppRun script for ${wrapperName}
 HERE="$(dirname "$(readlink -f "\${0}")")"
-export APPDIR="\$HERE"
-cd "\$HERE"
-exec "\$HERE/app/bin/launcher" "\$@"
+EXEC="\${HERE}/usr/bin/${wrapperName}"
+
+# Execute the wrapper extractor
+exec "\${EXEC}" "\$@"
 `;
-    
-    const appRunPath = join(appDirPath, "AppRun");
-    writeFileSync(appRunPath, appRunContent);
-    execSync(`chmod +x ${escapePathForTerminal(appRunPath)}`);
-    
-    // Create desktop file in AppDir root
-    const desktopContent = `[Desktop Entry]
+  
+  const appRunPath = join(wrapperAppDirPath, 'AppRun');
+  writeFileSync(appRunPath, appRunContent);
+  execSync(`chmod +x ${escapePathForTerminal(appRunPath)}`);
+
+  // Create desktop file
+  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}
+Name=${config.app.name} Installer
+Comment=Install ${config.app.name}
+Exec=${wrapperName}
+Icon=${wrapperName}
 Terminal=false
-StartupWMClass=${appFileName}
-Categories=Application;
+Categories=Utility;
 `;
+  
+  const desktopPath = join(wrapperAppDirPath, `${wrapperName}.desktop`);
+  writeFileSync(desktopPath, desktopContent);
+
+  // Copy icon if available
+  if (config.build.linux?.icon && existsSync(join(projectRoot, config.build.linux.icon))) {
+    const iconSourcePath = join(projectRoot, config.build.linux.icon);
+    const iconDestPath = join(wrapperAppDirPath, `${wrapperName}.png`);
+    const dirIconPath = join(wrapperAppDirPath, '.DirIcon');
     
-    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, { dereference: true });
-    }
-    
-    // Try to create AppImage using available tools
-    const appImagePath = join(buildFolder, `${appFileName}.AppImage`);
+    cpSync(iconSourcePath, iconDestPath, { dereference: true });
+    cpSync(iconSourcePath, dirIconPath, { dereference: true });
     
-    // 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;
-      }
+    console.log(`Copied icon for wrapper AppImage: ${iconSourcePath} -> ${iconDestPath}`);
+  }
+
+  // Ensure appimagetool is available
+  await ensureAppImageTooling();
+
+  // Generate the wrapper AppImage
+  if (existsSync(wrapperAppImagePath)) {
+    unlinkSync(wrapperAppImagePath);
+  }
+
+  console.log(`Creating wrapper AppImage: ${wrapperAppImagePath}`);
+  const appImageArch = ARCH === 'arm64' ? 'aarch64' : 'x86_64';
+  
+  // Use appimagetool to create the wrapper AppImage
+  let appimagetoolCmd = 'appimagetool';
+  try {
+    execSync('which appimagetool', { stdio: 'ignore' });
+  } catch {
+    const localBinPath = join(process.env['HOME'] || '', '.local', 'bin', 'appimagetool');
+    if (existsSync(localBinPath)) {
+      appimagetoolCmd = localBinPath;
     }
+  }
+
+  try {
+    execSync(`ARCH=${appImageArch} ${appimagetoolCmd} --no-appstream ${escapePathForTerminal(wrapperAppDirPath)} ${escapePathForTerminal(wrapperAppImagePath)}`, {
+      stdio: 'inherit',
+      env: { ...process.env, ARCH: appImageArch }
+    });
   } catch (error) {
-    console.error("Failed to create AppImage:", error);
-    return null;
+    console.error('Failed to create wrapper AppImage:', error);
+    throw error;
   }
+
+  // Clean up AppDir
+  rmSync(wrapperAppDirPath, { recursive: true, force: true });
+
+  // Verify the wrapper AppImage was created
+  if (!existsSync(wrapperAppImagePath)) {
+    throw new Error(`Wrapper AppImage was not created at expected path: ${wrapperAppImagePath}`);
+  }
+
+  const stats = statSync(wrapperAppImagePath);
+  console.log(`✓ Linux wrapper AppImage created: ${wrapperAppImagePath} (${(stats.size / 1024 / 1024).toFixed(2)} MB)`);
+  
+  return wrapperAppImagePath;
 }
 
+
 function codesignAppBundle(
   appBundleOrDmgPath: string,
   entitlementsFilePath?: string
@@ -3013,10 +3447,11 @@ function createAppBundle(bundleName: string, parentFolder: string, targetOS: 'ma
   }
 }
 
-} // End of main() function
+// Close the command handling if/else chain
 
-// Run the main function
-main().catch((error) => {
+// Close and execute the async IIFE
+})().catch((error) => {
   console.error('Fatal error:', error);
   process.exit(1);
 });
+