electrobun 0.13.0-beta.8 → 1.0.2-beta.0

package/dist/api/bun/ElectrobunConfig.ts

@@ -228,10 +228,10 @@ export interface ElectrobunConfig {
    */
   release?: {
     /**
-     * Base URL for artifact distribution (e.g., S3 bucket URL)
+     * Base URL for artifact distribution (e.g., S3 bucket, GitHub Releases)
      * Used for auto-updates and patch generation
      */
-    bucketUrl?: string;
+    baseUrl?: string;
   };
 }
 

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

@@ -5,8 +5,31 @@ import { execSync } from "child_process";
 import tar from "tar";
 import { ZstdInit } from "@oneidentity/zstd-js/wasm";
 import { OS as currentOS, ARCH as currentArch } from '../../shared/platform';
-import { getPlatformFolder, getTarballFileName } from '../../shared/naming';
+import { getPlatformPrefix, getTarballFileName } from '../../shared/naming';
 import { native } from '../proc/native';
+import { quit } from './Utils';
+
+// Helper to join URL paths without breaking the protocol (path.join mangles https:// to https:/)
+function urlJoin(...parts: string[]): string {
+  if (parts.length === 0) return '';
+
+  // Start with the first part (base URL)
+  let result = parts[0];
+
+  // Join remaining parts
+  for (let i = 1; i < parts.length; i++) {
+    const part = parts[i];
+    if (!part) continue;
+
+    // Remove trailing slash from result and leading slash from part
+    const cleanResult = result.endsWith('/') ? result.slice(0, -1) : result;
+    const cleanPart = part.startsWith('/') ? part.slice(1) : part;
+
+    result = `${cleanResult}/${cleanPart}`;
+  }
+
+  return result;
+}
 
 // setTimeout(async () => {
 //   console.log('killing')
@@ -107,7 +130,7 @@ function getAppDataDir(): string {
 let localInfo: {
   version: string;
   hash: string;
-  bucketUrl: string;
+  baseUrl: string;
   channel: string;
   name: string;
   identifier: string;
@@ -141,17 +164,36 @@ const Updater = {
       };
     }
 
-    const channelBucketUrl = await Updater.channelBucketUrl();
     const cacheBuster = Math.random().toString(36).substring(7);
-    const platformFolder = getPlatformFolder(localInfo.channel, currentOS, currentArch);
-    const updateInfoUrl = join(localInfo.bucketUrl, platformFolder, `update.json?${cacheBuster}`);
+    const platformPrefix = getPlatformPrefix(localInfo.channel, currentOS, currentArch);
+    const updateInfoUrl = `${localInfo.baseUrl}/${platformPrefix}-update.json?${cacheBuster}`;
 
     try {
       const updateInfoResponse = await fetch(updateInfoUrl);
 
       if (updateInfoResponse.ok) {
-        // todo: this seems brittle
-        updateInfo = await updateInfoResponse.json();
+        const responseText = await updateInfoResponse.text();
+        try {
+          updateInfo = JSON.parse(responseText);
+        } catch {
+          return {
+            version: "",
+            hash: "",
+            updateAvailable: false,
+            updateReady: false,
+            error: `Invalid update.json: failed to parse JSON`,
+          };
+        }
+
+        if (!updateInfo.hash) {
+          return {
+            version: "",
+            hash: "",
+            updateAvailable: false,
+            updateReady: false,
+            error: `Invalid update.json: missing hash`,
+          };
+        }
 
         if (updateInfo.hash !== localInfo.hash) {
           updateInfo.updateAvailable = true;
@@ -211,9 +253,9 @@ const Updater = {
         }
 
         // check if there's a patch file for it
-        const platformFolder = getPlatformFolder(localInfo.channel, currentOS, currentArch);
+        const platformPrefix = getPlatformPrefix(localInfo.channel, currentOS, currentArch);
         const patchResponse = await fetch(
-          join(localInfo.bucketUrl, platformFolder, `${currentHash}.patch`)
+          `${localInfo.baseUrl}/${platformPrefix}-${currentHash}.patch`
         );
 
         if (!patchResponse.ok) {
@@ -330,13 +372,9 @@ const Updater = {
       // then just download it and unpack it
       if (currentHash !== latestHash) {
         const cacheBuster = Math.random().toString(36).substring(7);
-        const platformFolder = getPlatformFolder(localInfo.channel, currentOS, currentArch);
+        const platformPrefix = getPlatformPrefix(localInfo.channel, currentOS, currentArch);
         const tarballName = getTarballFileName(appFileName, currentOS);
-        const urlToLatestTarball = join(
-          localInfo.bucketUrl,
-          platformFolder,
-          tarballName
-        );
+        const urlToLatestTarball = `${localInfo.baseUrl}/${platformPrefix}-${tarballName}`;
         const prevVersionCompressedTarballPath = join(
           appDataFolder,
           "self-extraction",
@@ -471,10 +509,12 @@ const Updater = {
         // Platform-specific path handling
         let newAppBundlePath: string;
         if (currentOS === 'linux') {
-          // On Linux, look for the .AppImage file in the extraction directory
+          // On Linux, the tarball contains a directory named {appFileName}, and inside it is the AppImage
+          // Structure: extractionDir/{appFileName}/{appFileName}.AppImage
+          const innerDirName = localInfo.name.replace(/ /g, "");
           const appImageName = `${localInfo.name.replace(/ /g, "").replace(/\./g, "-")}.AppImage`;
-          newAppBundlePath = join(extractionDir, appImageName);
-          
+          newAppBundlePath = join(extractionDir, innerDirName, appImageName);
+
           // Verify the AppImage exists
           if (!statSync(newAppBundlePath, { throwIfNoEntry: false })) {
             console.error(`AppImage not found at: ${newAppBundlePath}`);
@@ -483,6 +523,14 @@ const Updater = {
               const files = readdirSync(extractionDir);
               for (const file of files) {
                 console.log(`  - ${file}`);
+                // Also list contents of subdirectories
+                const subPath = join(extractionDir, file);
+                if (statSync(subPath).isDirectory()) {
+                  const subFiles = readdirSync(subPath);
+                  for (const subFile of subFiles) {
+                    console.log(`    - ${subFile}`);
+                  }
+                }
               }
             } catch (e) {
               console.log("Could not list directory contents:", e);
@@ -530,9 +578,8 @@ const Updater = {
             const appImageName = `${localInfo.name.replace(/ /g, "").replace(/\./g, "-")}.AppImage`;
             runningAppBundlePath = join(appDataFolder, appImageName);
           } else {
-            // On Windows, use versioned app folders
-            const currentHash = (await Updater.getLocallocalInfo()).hash;
-            runningAppBundlePath = join(appDataFolder, `app-${currentHash}`);
+            // On Windows, use fixed 'app' folder to match extractor
+            runningAppBundlePath = join(appDataFolder, 'app');
           }
         }
         // Platform-specific backup handling
@@ -555,9 +602,18 @@ const Updater = {
             
             // Move current running app to backup
             renameSync(runningAppBundlePath, backupPath);
-            
+
             // Move new app to running location
             renameSync(newAppBundlePath, runningAppBundlePath);
+
+            // Remove quarantine extended attributes to prevent "damaged" error
+            // The inner bundle is already signed/notarized, but macOS applies
+            // quarantine attributes when extracting from a downloaded archive
+            try {
+              execSync(`xattr -r -d com.apple.quarantine "${runningAppBundlePath}"`, { stdio: 'ignore' });
+            } catch (e) {
+              // Ignore errors - attribute may not exist
+            }
           } else if (currentOS === 'linux') {
             // On Linux, backup and replace AppImage file
             // Remove existing backup if it exists
@@ -579,115 +635,117 @@ const Updater = {
             // Create/update launcher script that points to the AppImage
             await createLinuxAppImageLauncherScript(runningAppBundlePath);
           } else {
-            // On Windows, use versioned app folders
+            // On Windows, files are locked while in use, so we need a helper script
+            // that runs after the app exits to do the replacement
             const parentDir = dirname(runningAppBundlePath);
-            const newVersionDir = join(parentDir, `app-${latestHash}`);
-            
-            // Create the versioned directory
-            mkdirSync(newVersionDir, { recursive: true });
-            
-            // Copy all contents from the extracted app to the versioned directory
-            const files = readdirSync(newAppBundlePath);
-            for (const file of files) {
-              const srcPath = join(newAppBundlePath, file);
-              const destPath = join(newVersionDir, file);
-              const stats = statSync(srcPath);
-              
-              if (stats.isDirectory()) {
-                // Recursively copy directories
-                cpSync(srcPath, destPath, { recursive: true });
-              } else {
-                // Copy files
-                cpSync(srcPath, destPath);
-              }
-            }
-            
-            // Clean up the temporary extraction directory on Windows
-            if (currentOS === 'win') {
-              rmdirSync(extractionDir, { recursive: true });
-            }
-            
-            // Create/update the launcher batch file
-            const launcherPath = join(parentDir, "run.bat");
-            const launcherContent = `@echo off
-:: Electrobun App Launcher
-:: This file launches the current version
-
-:: Set current version
-set CURRENT_HASH=${latestHash}
-set APP_DIR=%~dp0app-%CURRENT_HASH%
-
-:: TODO: Implement proper cleanup mechanism that checks for running processes
-:: For now, old versions are kept to avoid race conditions during updates
-:: :: Clean up old app versions (keep current and one backup)
-:: for /d %%D in ("%~dp0app-*") do (
-::     if not "%%~nxD"=="app-%CURRENT_HASH%" (
-::         echo Removing old version: %%~nxD
-::         rmdir /s /q "%%D" 2>nul
-::     )
-:: )
-
-:: Launch the app
-cd /d "%APP_DIR%\\bin"
-start "" launcher.exe
+            const updateScriptPath = join(parentDir, 'update.bat');
+            const backupDir = join(parentDir, 'app-backup');
+            const launcherPath = join(runningAppBundlePath, 'bin', 'launcher.exe');
+
+            // Convert paths to Windows format
+            const backupDirWin = backupDir.replace(/\//g, '\\');
+            const runningAppWin = runningAppBundlePath.replace(/\//g, '\\');
+            const newAppWin = newAppBundlePath.replace(/\//g, '\\');
+            const extractionDirWin = extractionDir.replace(/\//g, '\\');
+            const launcherPathWin = launcherPath.replace(/\//g, '\\');
+
+            // Create a batch script that will:
+            // 1. Wait for the current app to exit
+            // 2. Remove old backup
+            // 3. Move current app to backup
+            // 4. Move new app to current location
+            // 5. Launch the new app
+            // 6. Clean up
+            const updateScript = `@echo off
+setlocal
+
+:: Wait for the app to fully exit (check if launcher.exe is still running)
+:waitloop
+tasklist /FI "IMAGENAME eq launcher.exe" 2>NUL | find /I /N "launcher.exe">NUL
+if "%ERRORLEVEL%"=="0" (
+    timeout /t 1 /nobreak >nul
+    goto waitloop
+)
+
+:: Small extra delay to ensure all file handles are released
+timeout /t 2 /nobreak >nul
+
+:: Remove old backup if exists
+if exist "${backupDirWin}" (
+    rmdir /s /q "${backupDirWin}"
+)
+
+:: Backup current app folder
+if exist "${runningAppWin}" (
+    move "${runningAppWin}" "${backupDirWin}"
+)
+
+:: Move new app to current location
+move "${newAppWin}" "${runningAppWin}"
+
+:: Clean up extraction directory
+rmdir /s /q "${extractionDirWin}" 2>nul
+
+:: Launch the new app
+start "" "${launcherPathWin}"
+
+:: Clean up scheduled tasks starting with ElectrobunUpdate_
+for /f "tokens=1" %%t in ('schtasks /query /fo list ^| findstr /i "ElectrobunUpdate_"') do (
+    schtasks /delete /tn "%%t" /f >nul 2>&1
+)
+
+:: Delete this update script after a short delay
+ping -n 2 127.0.0.1 >nul
+del "%~f0"
 `;
-            
-            await Bun.write(launcherPath, launcherContent);
-            
-            // Update desktop shortcuts to point to run.bat
-            // This is handled by the running app, not the updater
-            
-            runningAppBundlePath = newVersionDir;
+
+            await Bun.write(updateScriptPath, updateScript);
+
+            // Use Windows Task Scheduler to run the update script independently
+            // This ensures the script runs even after the app exits
+            const scriptPathWin = updateScriptPath.replace(/\//g, '\\');
+            const taskName = `ElectrobunUpdate_${Date.now()}`;
+
+            // Create a scheduled task that runs immediately and deletes itself
+            execSync(`schtasks /create /tn "${taskName}" /tr "cmd /c \\"${scriptPathWin}\\"" /sc once /st 00:00 /f`, { stdio: 'ignore' });
+            execSync(`schtasks /run /tn "${taskName}"`, { stdio: 'ignore' });
+            // The task will be cleaned up by Windows after it runs, or we delete it in the batch script
+
+            // Use quit() for graceful shutdown - this closes all windows and processes
+            quit();
           }
         } catch (error) {
           console.error("Failed to replace app with new version", error);
           return;
         }
 
-        // Cross-platform app launch
-        switch (currentOS) {
-          case 'macos':
-            // Use a detached shell so relaunch survives after killApp terminates the current process
-            await Bun.spawn(
-              [
-                "sh",
-                "-c",
-                `open "${runningAppBundlePath}" &`,
-              ],
-              { detached: true }
-            );
-            break;
-          case 'win':
-            // On Windows, launch the run.bat file which handles versioning
-            const parentDir = dirname(runningAppBundlePath);
-            const runBatPath = join(parentDir, "run.bat");
-            
-            
-            await Bun.spawn(["cmd", "/c", runBatPath], { detached: true });
-            break;
-          case 'linux':
-            // On Linux, launch the AppImage directly
-            Bun.spawn(["sh", "-c", `"${runningAppBundlePath}" &`], { detached: true});
-            break;
+        // Cross-platform app launch (Windows is handled above with its own update script)
+        if (currentOS === 'macos') {
+          // Use a detached shell so relaunch survives after killApp terminates the current process
+          await Bun.spawn(
+            [
+              "sh",
+              "-c",
+              `open "${runningAppBundlePath}" &`,
+            ],
+            { detached: true }
+          );
+        } else if (currentOS === 'linux') {
+          // On Linux, launch the AppImage directly
+          Bun.spawn(["sh", "-c", `"${runningAppBundlePath}" &`], { detached: true});
         }
-        // Use native killApp to properly clean up all resources        
-        try {
-          native.symbols.killApp();
-          // Still call process.exit as a fallback
-          process.exit(0);
-        } catch (e) {
-          // Fallback if native binding fails
-          console.error('Failed to call native killApp:', e);
-          process.exit(0);
-        }        
+
+        // Use quit() for graceful shutdown
+        quit();
       }
     }
   },
 
   channelBucketUrl: async () => {
     await Updater.getLocallocalInfo();
-    const platformFolder = getPlatformFolder(localInfo.channel, currentOS, currentArch);
-    return join(localInfo.bucketUrl, platformFolder);
+    // With flat prefix-based naming, channelBucketUrl is just the baseUrl
+    // Users can also use Updater.localInfo.baseUrl() directly
+    return localInfo.baseUrl;
   },
 
   appDataFolder: async () => {
@@ -712,8 +770,8 @@ start "" launcher.exe
     channel: async () => {
       return (await Updater.getLocallocalInfo()).channel;
     },
-    bucketUrl: async () => {
-      return (await Updater.getLocallocalInfo()).bucketUrl;
+    baseUrl: async () => {
+      return (await Updater.getLocallocalInfo()).baseUrl;
     },
   },
 

package/dist/api/shared/naming.test.ts

@@ -3,10 +3,9 @@ import {
   sanitizeAppName,
   getAppFileName,
   getBundleFileName,
-  getPlatformFolder,
+  getPlatformPrefix,
   getTarballFileName,
   getWindowsSetupFileName,
-  getLinuxSetupFileName,
   getLinuxAppImageBaseName,
   getLinuxAppImageFileName,
   sanitizeVolumeNameForHdiutil,
@@ -82,13 +81,13 @@ describe('getBundleFileName', () => {
   });
 });
 
-describe('getPlatformFolder', () => {
-  it('constructs correct folder format for all platform combinations', () => {
-    expect(getPlatformFolder('stable', 'macos', 'arm64')).toBe('stable-macos-arm64');
-    expect(getPlatformFolder('stable', 'macos', 'x64')).toBe('stable-macos-x64');
-    expect(getPlatformFolder('canary', 'win', 'x64')).toBe('canary-win-x64');
-    expect(getPlatformFolder('dev', 'linux', 'arm64')).toBe('dev-linux-arm64');
-    expect(getPlatformFolder('dev', 'linux', 'x64')).toBe('dev-linux-x64');
+describe('getPlatformPrefix', () => {
+  it('constructs correct prefix format for all platform combinations', () => {
+    expect(getPlatformPrefix('stable', 'macos', 'arm64')).toBe('stable-macos-arm64');
+    expect(getPlatformPrefix('stable', 'macos', 'x64')).toBe('stable-macos-x64');
+    expect(getPlatformPrefix('canary', 'win', 'x64')).toBe('canary-win-x64');
+    expect(getPlatformPrefix('dev', 'linux', 'arm64')).toBe('dev-linux-arm64');
+    expect(getPlatformPrefix('dev', 'linux', 'x64')).toBe('dev-linux-x64');
   });
 });
 
@@ -136,19 +135,10 @@ describe('getWindowsSetupFileName', () => {
   it('includes channel suffix for dev builds', () => {
     expect(getWindowsSetupFileName('MyApp', 'dev')).toBe('MyApp-Setup-dev.exe');
   });
-});
-
-describe('getLinuxSetupFileName', () => {
-  it('returns AppName-Setup.run for stable builds', () => {
-    expect(getLinuxSetupFileName('MyApp', 'stable')).toBe('MyApp-Setup.run');
-  });
-
-  it('includes channel suffix for canary builds', () => {
-    expect(getLinuxSetupFileName('MyApp', 'canary')).toBe('MyApp-Setup-canary.run');
-  });
 
-  it('includes channel suffix for dev builds', () => {
-    expect(getLinuxSetupFileName('MyApp', 'dev')).toBe('MyApp-Setup-dev.run');
+  it('preserves spaces in app name', () => {
+    expect(getWindowsSetupFileName('My App', 'stable')).toBe('My App-Setup.exe');
+    expect(getWindowsSetupFileName('My App', 'canary')).toBe('My App-Setup-canary.exe');
   });
 });
 
@@ -160,6 +150,11 @@ describe('getLinuxAppImageBaseName', () => {
   it('includes channel suffix for canary builds', () => {
     expect(getLinuxAppImageBaseName('MyApp', 'canary')).toBe('MyApp-Setup-canary');
   });
+
+  it('preserves spaces in app name', () => {
+    expect(getLinuxAppImageBaseName('My App', 'stable')).toBe('My App-Setup');
+    expect(getLinuxAppImageBaseName('My App', 'canary')).toBe('My App-Setup-canary');
+  });
 });
 
 describe('getLinuxAppImageFileName', () => {
@@ -170,6 +165,11 @@ describe('getLinuxAppImageFileName', () => {
   it('returns full filename with .AppImage extension for canary', () => {
     expect(getLinuxAppImageFileName('MyApp', 'canary')).toBe('MyApp-Setup-canary.AppImage');
   });
+
+  it('preserves spaces in app name', () => {
+    expect(getLinuxAppImageFileName('My App', 'stable')).toBe('My App-Setup.AppImage');
+    expect(getLinuxAppImageFileName('My App', 'canary')).toBe('My App-Setup-canary.AppImage');
+  });
 });
 
 describe('sanitizeVolumeNameForHdiutil', () => {
@@ -195,63 +195,64 @@ describe('sanitizeVolumeNameForHdiutil', () => {
 });
 
 describe('getDmgVolumeName', () => {
-  it('adds -stable suffix for stable builds (to avoid CI volume conflicts)', () => {
-    expect(getDmgVolumeName('MyApp', 'stable')).toBe('MyApp-stable');
+  it('returns plain name for stable builds', () => {
+    expect(getDmgVolumeName('MyApp', 'stable')).toBe('MyApp');
   });
 
-  it('returns sanitized name for canary builds (already has suffix)', () => {
-    expect(getDmgVolumeName('MyApp-canary', 'canary')).toBe('MyAppcanary');
+  it('adds channel suffix for non-stable builds', () => {
+    expect(getDmgVolumeName('MyApp', 'canary')).toBe('MyApp-canary');
   });
 
   it('sanitizes special characters', () => {
-    expect(getDmgVolumeName('My-App', 'stable')).toBe('MyApp-stable');
+    expect(getDmgVolumeName('My-App', 'stable')).toBe('MyApp');
+    expect(getDmgVolumeName('My-App', 'canary')).toBe('MyApp-canary');
   });
 });
 
 describe('URL construction functions', () => {
-  const bucketUrl = 'https://storage.example.com/releases';
-  const platformFolder = 'canary-macos-arm64';
+  const baseUrl = 'https://storage.example.com/releases';
+  const platformPrefix = 'canary-macos-arm64';
 
   describe('getUpdateInfoUrl', () => {
-    it('constructs correct URL', () => {
-      expect(getUpdateInfoUrl(bucketUrl, platformFolder))
-        .toBe('https://storage.example.com/releases/canary-macos-arm64/update.json');
+    it('constructs correct flat URL with prefix', () => {
+      expect(getUpdateInfoUrl(baseUrl, platformPrefix))
+        .toBe('https://storage.example.com/releases/canary-macos-arm64-update.json');
     });
 
     it('handles bucket URLs with trailing content', () => {
       expect(getUpdateInfoUrl('https://example.com/bucket', 'stable-win-x64'))
-        .toBe('https://example.com/bucket/stable-win-x64/update.json');
+        .toBe('https://example.com/bucket/stable-win-x64-update.json');
     });
   });
 
   describe('getPatchFileUrl', () => {
-    it('constructs correct URL with hash', () => {
-      expect(getPatchFileUrl(bucketUrl, platformFolder, 'abc123def456'))
-        .toBe('https://storage.example.com/releases/canary-macos-arm64/abc123def456.patch');
+    it('constructs correct flat URL with prefix and hash', () => {
+      expect(getPatchFileUrl(baseUrl, platformPrefix, 'abc123def456'))
+        .toBe('https://storage.example.com/releases/canary-macos-arm64-abc123def456.patch');
     });
   });
 
   describe('getTarballUrl', () => {
-    it('constructs correct URL for macOS tarball', () => {
-      expect(getTarballUrl(bucketUrl, platformFolder, 'MyApp.app.tar.zst'))
-        .toBe('https://storage.example.com/releases/canary-macos-arm64/MyApp.app.tar.zst');
+    it('constructs correct flat URL for macOS tarball', () => {
+      expect(getTarballUrl(baseUrl, platformPrefix, 'MyApp.app.tar.zst'))
+        .toBe('https://storage.example.com/releases/canary-macos-arm64-MyApp.app.tar.zst');
     });
 
-    it('constructs correct URL for Windows tarball', () => {
-      expect(getTarballUrl(bucketUrl, 'stable-win-x64', 'MyApp.tar.zst'))
-        .toBe('https://storage.example.com/releases/stable-win-x64/MyApp.tar.zst');
+    it('constructs correct flat URL for Windows tarball', () => {
+      expect(getTarballUrl(baseUrl, 'stable-win-x64', 'MyApp.tar.zst'))
+        .toBe('https://storage.example.com/releases/stable-win-x64-MyApp.tar.zst');
     });
   });
 });
 
 // Integration tests that verify CLI and Updater would produce matching values
 describe('CLI and Updater consistency', () => {
-  it('produces matching platform folders', () => {
+  it('produces matching platform prefixes', () => {
     // CLI uses: `${buildEnvironment}-${currentTarget.os}-${currentTarget.arch}`
     // Updater uses: `${localInfo.channel}-${currentOS}-${currentArch}`
-    // Both should use getPlatformFolder()
-    const cliResult = getPlatformFolder('canary', 'macos', 'arm64');
-    const updaterResult = getPlatformFolder('canary', 'macos', 'arm64');
+    // Both should use getPlatformPrefix()
+    const cliResult = getPlatformPrefix('canary', 'macos', 'arm64');
+    const updaterResult = getPlatformPrefix('canary', 'macos', 'arm64');
     expect(cliResult).toBe(updaterResult);
     expect(cliResult).toBe('canary-macos-arm64');
   });
@@ -280,6 +281,6 @@ describe('CLI and Updater consistency', () => {
     expect(getAppFileName('MyApp', 'stable')).not.toContain('-stable');
     expect(getTarballFileName(getAppFileName('MyApp', 'stable'), 'macos')).toBe('MyApp.app.tar.zst');
     expect(getWindowsSetupFileName('MyApp', 'stable')).toBe('MyApp-Setup.exe');
-    expect(getLinuxSetupFileName('MyApp', 'stable')).toBe('MyApp-Setup.run');
+    expect(getLinuxAppImageFileName('MyApp', 'stable')).toBe('MyApp-Setup.AppImage');
   });
 });

package/dist/api/shared/naming.ts

@@ -27,6 +27,19 @@ export function getAppFileName(appName: string, buildEnvironment: BuildEnvironme
   return buildEnvironment === 'stable' ? sanitized : `${sanitized}-${buildEnvironment}`;
 }
 
+/**
+ * Generates the macOS bundle display name (with spaces preserved).
+ * Used for the actual .app folder name on macOS.
+ * Format: "App Name" (stable) or "App Name-channel" (non-stable)
+ *
+ * @example
+ * getMacOSBundleDisplayName("My App", "stable") // "My App"
+ * getMacOSBundleDisplayName("My App", "canary") // "My App-canary"
+ */
+export function getMacOSBundleDisplayName(appName: string, buildEnvironment: BuildEnvironment): string {
+  return buildEnvironment === 'stable' ? appName : `${appName}-${buildEnvironment}`;
+}
+
 /**
  * Generates the bundle file name (with platform-specific extension).
  * macOS: "AppName.app" or "AppName-channel.app"
@@ -38,10 +51,11 @@ export function getBundleFileName(appName: string, buildEnvironment: BuildEnviro
 }
 
 /**
- * Generates the platform folder name for artifacts.
+ * Generates the platform prefix for artifacts.
  * Format: "channel-os-arch" (e.g., "stable-macos-arm64", "canary-win-x64")
+ * Used for flat file naming in artifact folders and bucket URLs.
  */
-export function getPlatformFolder(buildEnvironment: BuildEnvironment, os: SupportedOS, arch: SupportedArch): string {
+export function getPlatformPrefix(buildEnvironment: BuildEnvironment, os: SupportedOS, arch: SupportedArch): string {
   return `${buildEnvironment}-${os}-${arch}`;
 }
 
@@ -56,7 +70,8 @@ export function getTarballFileName(appFileName: string, os: SupportedOS): string
 
 /**
  * Generates the Windows installer setup file name.
- * Format: "AppName-Setup.exe" (stable) or "AppName-Setup-channel.exe" (non-stable)
+ * Preserves spaces in app name for user-friendly display.
+ * Format: "App Name-Setup.exe" (stable) or "App Name-Setup-channel.exe" (non-stable)
  */
 export function getWindowsSetupFileName(appName: string, buildEnvironment: BuildEnvironment): string {
   return buildEnvironment === 'stable'
@@ -64,19 +79,10 @@ export function getWindowsSetupFileName(appName: string, buildEnvironment: Build
     : `${appName}-Setup-${buildEnvironment}.exe`;
 }
 
-/**
- * Generates the Linux self-extracting binary file name.
- * Format: "AppName-Setup.run" (stable) or "AppName-Setup-channel.run" (non-stable)
- */
-export function getLinuxSetupFileName(appName: string, buildEnvironment: BuildEnvironment): string {
-  return buildEnvironment === 'stable'
-    ? `${appName}-Setup.run`
-    : `${appName}-Setup-${buildEnvironment}.run`;
-}
-
 /**
  * Generates the Linux AppImage wrapper name (without extension).
- * Format: "AppName-Setup" (stable) or "AppName-Setup-channel" (non-stable)
+ * Preserves spaces in app name for user-friendly display.
+ * Format: "App Name-Setup" (stable) or "App Name-Setup-channel" (non-stable)
  */
 export function getLinuxAppImageBaseName(appName: string, buildEnvironment: BuildEnvironment): string {
   return buildEnvironment === 'stable'
@@ -100,32 +106,35 @@ export function sanitizeVolumeNameForHdiutil(name: string): string {
 }
 
 /**
- * Generates the DMG volume name for macOS during creation.
- * Uses sanitized name with "-stable" suffix for stable builds to avoid
- * CI volume mounting conflicts. The DMG is renamed after creation.
+ * Generates the DMG volume name for macOS.
+ * Takes the original app name (with spaces) and preserves them for display.
+ * Format: "App Name" (stable) or "App Name-channel" (non-stable)
  */
-export function getDmgVolumeName(appFileName: string, buildEnvironment: BuildEnvironment): string {
-  const baseName = sanitizeVolumeNameForHdiutil(appFileName);
-  return buildEnvironment === 'stable' ? `${baseName}-stable` : baseName;
+export function getDmgVolumeName(appName: string, buildEnvironment: BuildEnvironment): string {
+  const baseName = sanitizeVolumeNameForHdiutil(appName);
+  return buildEnvironment === 'stable' ? baseName : `${baseName}-${buildEnvironment}`;
 }
 
 /**
  * Constructs the full URL for the update.json file.
+ * Uses flat prefix-based naming for compatibility with GitHub Releases and other hosts.
  */
-export function getUpdateInfoUrl(bucketUrl: string, platformFolder: string): string {
-  return `${bucketUrl}/${platformFolder}/update.json`;
+export function getUpdateInfoUrl(baseUrl: string, platformPrefix: string): string {
+  return `${baseUrl}/${platformPrefix}-update.json`;
 }
 
 /**
  * Constructs the full URL for a patch file.
+ * Uses flat prefix-based naming for compatibility with GitHub Releases and other hosts.
  */
-export function getPatchFileUrl(bucketUrl: string, platformFolder: string, hash: string): string {
-  return `${bucketUrl}/${platformFolder}/${hash}.patch`;
+export function getPatchFileUrl(baseUrl: string, platformPrefix: string, hash: string): string {
+  return `${baseUrl}/${platformPrefix}-${hash}.patch`;
 }
 
 /**
  * Constructs the full URL for a tarball.
+ * Uses flat prefix-based naming for compatibility with GitHub Releases and other hosts.
  */
-export function getTarballUrl(bucketUrl: string, platformFolder: string, tarballFileName: string): string {
-  return `${bucketUrl}/${platformFolder}/${tarballFileName}`;
+export function getTarballUrl(baseUrl: string, platformPrefix: string, tarballFileName: string): string {
+  return `${baseUrl}/${platformPrefix}-${tarballFileName}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrobun",
-  "version": "0.13.0-beta.8",
+  "version": "1.0.2-beta.0",
   "description": "Build ultra fast, tiny, and cross-platform desktop apps with Typescript.",
   "license": "MIT",
   "author": "Blackboard Technologies Inc.",
@@ -35,6 +35,7 @@
     "dev:clean": "cd ../kitchen && rm -rf node_modules && rm -rf vendors/cef && cd ../package && bun dev",
     "dev:rerun": "cd ../kitchen && bun start",
     "dev:canary": "bun install && bun build:release && bun build:cli && cd ../kitchen && bun install && bun build:canary",
+    "dev:stable": "bun install && bun build:release && bun build:cli && cd ../kitchen && bun install && bun build:stable",
     "run:template": "bun install && bun build:dev && bun build:cli && cd ../templates/interactive-playground && bun install && bun build:dev && bun start",
     "dev:docs": "cd ../documentation && bun start",
     "build:docs:release": "cd ../documentation && bun run build",

package/src/cli/index.ts

@@ -25,13 +25,13 @@ import { OS, ARCH } from '../shared/platform';
 import {
   getAppFileName,
   getBundleFileName,
-  getPlatformFolder,
+  getPlatformPrefix,
   getTarballFileName,
   getWindowsSetupFileName,
-  getLinuxSetupFileName,
   getLinuxAppImageBaseName,
   sanitizeVolumeNameForHdiutil,
   getDmgVolumeName,
+  getMacOSBundleDisplayName,
 } from '../shared/naming';
 import { getTemplate, getTemplateNames } from './templates/embedded';
 // import { loadBsdiff, loadBspatch } from 'bsdiff-wasm';
@@ -107,7 +107,9 @@ async function ensureCoreDependencies(targetOS?: 'macos' | 'win' | 'linux', targ
   
   // Check platform-specific binaries
   const requiredBinaries = [
-    platformPaths.BUN_BINARY
+    platformPaths.BUN_BINARY,
+    platformPaths.BSDIFF,
+    platformPaths.BSPATCH
   ];
   if (platformOS === 'macos') {
     requiredBinaries.push(
@@ -254,7 +256,11 @@ async function ensureCoreDependencies(targetOS?: 'macos' | 'win' | 'linux', targ
     }
     
     // Verify extraction completed successfully - check platform-specific binaries only
-    const requiredBinaries = [platformPaths.BUN_BINARY];
+    const requiredBinaries = [
+      platformPaths.BUN_BINARY,
+      platformPaths.BSDIFF,
+      platformPaths.BSPATCH
+    ];
     if (platformOS === 'macos') {
       requiredBinaries.push(
         platformPaths.LAUNCHER_RELEASE,
@@ -587,7 +593,7 @@ const defaultConfig = {
     postPackage: "",
   },
   release: {
-    bucketUrl: "",
+    baseUrl: "",
   },
 };
 
@@ -708,17 +714,17 @@ async function createAppImage(
   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()}`);
+  // 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}`);
+    // console.log(`DEBUG: Converted relative path to absolute: ${resolvedAppBundlePath}`);
   }
   
   // Create AppDir structure
@@ -732,17 +738,17 @@ async function createAppImage(
   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))}`);
+  // 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))}`);
+  // 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,
@@ -802,8 +808,8 @@ Categories=Utility;
     unlinkSync(appImagePath);
   }
   
-  console.log(`DEBUG: AppDir path: ${appDirPath}`);
-  console.log(`DEBUG: Does AppDir exist? ${existsSync(appDirPath)}`);
+  // 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';
   
@@ -1048,10 +1054,12 @@ if (commandArg === "init") {
   const targetARCH = currentTarget.arch;
   const targetBinExt = targetOS === 'win' ? '.exe' : '';
   const appFileName = getAppFileName(config.app.name, buildEnvironment);
-  const buildSubFolder = getPlatformFolder(buildEnvironment, currentTarget.os, currentTarget.arch);
-  const buildFolder = join(projectRoot, config.build.buildFolder, buildSubFolder);
+  // macOS bundle display name preserves spaces for the actual .app folder
+  const macOSBundleDisplayName = getMacOSBundleDisplayName(config.app.name, buildEnvironment);
+  const platformPrefix = getPlatformPrefix(buildEnvironment, currentTarget.os, currentTarget.arch);
+  const buildFolder = join(projectRoot, config.build.buildFolder, platformPrefix);
   const bundleFileName = getBundleFileName(config.app.name, buildEnvironment, targetOS);
-  const artifactFolder = join(projectRoot, config.build.artifactFolder, buildSubFolder);
+  const artifactFolder = join(projectRoot, config.build.artifactFolder);
   
   // Ensure core binaries are available for the target platform before starting build
   await ensureCoreDependencies(currentTarget.os, currentTarget.arch);
@@ -1171,13 +1179,15 @@ if (commandArg === "init") {
   }
 
   // build macos bundle
+  // Use display name (with spaces) for macOS bundle folders, sanitized name for other platforms
+  const bundleName = targetOS === 'macos' ? macOSBundleDisplayName : appFileName;
   const {
     appBundleFolderPath,
     appBundleFolderContentsPath,
     appBundleMacOSPath,
     appBundleFolderResourcesPath,
     appBundleFolderFrameworksPath,
-  } = createAppBundle(appFileName, buildFolder, targetOS);
+  } = createAppBundle(bundleName, buildFolder, targetOS);
 
   const appBundleAppCodePath = join(appBundleFolderResourcesPath, "app");
 
@@ -1206,7 +1216,7 @@ if (commandArg === "init") {
     <key>CFBundleIdentifier</key>
     <string>${config.app.identifier}</string>
     <key>CFBundleName</key>
-    <string>${appFileName}</string>
+    <string>${bundleName}</string>
     <key>CFBundleVersion</key>
     <string>${config.app.version}</string>
     <key>CFBundlePackageType</key>
@@ -1932,7 +1942,8 @@ if (commandArg === "init") {
   // 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
-  const tmpTarPath = `${appBundleFolderPath}-temp.tar`;
+  // Use sanitized appFileName for tarball paths (URL-safe), but tar content uses actual bundle folder
+  const tmpTarPath = join(buildFolder, `${appFileName}${targetOS === 'macos' ? '.app' : ''}-temp.tar`);
   await tar.c(
     {
       gzip: false,
@@ -1958,7 +1969,7 @@ if (commandArg === "init") {
     // then gets used for patching and updating.
     hash: hash,
     channel: buildEnvironment,
-    bucketUrl: config.release.bucketUrl,
+    baseUrl: config.release.baseUrl,
     name: appFileName,
     identifier: config.app.identifier,
   });
@@ -2011,12 +2022,9 @@ if (commandArg === "init") {
   }
 
   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...");
+  if (targetOS === 'linux') {    
     // Ensure AppImage tooling is available
     await ensureAppImageTooling();
     
@@ -2098,20 +2106,21 @@ if (commandArg === "init") {
       // Compress with Zstandard
       console.log(`Compressing tar with zstd...`);
       const uncompressedTarData = readFileSync(appImageTarPath);
+      const compressedTarPath = `${appImageTarPath}.zst`;
       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)`);
+        writeFileSync(compressedTarPath, compressedData);
+        console.log(`✓ Created compressed tar: ${compressedTarPath} (${(compressedData.length / 1024 / 1024).toFixed(2)} MB)`);
       });
-      
-      // Remove uncompressed tar
-      unlinkSync(appImageTarPath);
-      
-      // Add AppImage to artifacts for distribution (for direct download)
-      artifactsToUpload.push(appImagePath);
+
+      // Note: Don't delete uncompressed tar here - bsdiff needs it later for patch generation
+      // It will be cleaned up after bsdiff runs
+
+      // Add tar.zst for Updater API (delta updates)
+      // Note: raw AppImage is NOT added - only the Setup.AppImage (zipped) is distributed
+      artifactsToUpload.push(compressedTarPath);
     }
   }
 
@@ -2131,7 +2140,8 @@ if (commandArg === "init") {
 
     // Platform suffix is only used for folder names, not file names
     const platformSuffix = `-${targetOS}-${targetARCH}`;
-    const tarPath = `${appBundleFolderPath}.tar`;
+    // Use sanitized appFileName for tarball path (URL-safe), but tar content uses actual bundle folder name
+    const tarPath = join(buildFolder, `${appFileName}${targetOS === 'macos' ? '.app' : ''}.tar`);
 
     // For Linux, we've already created the tar in the AppImage section above
     // For macOS/Windows, tar the signed and notarized app bundle
@@ -2201,7 +2211,7 @@ if (commandArg === "init") {
       rmdirSync(appBundleFolderPath, { recursive: true });
     }
 
-    const selfExtractingBundle = createAppBundle(appFileName, buildFolder, targetOS);
+    const selfExtractingBundle = createAppBundle(bundleName, buildFolder, targetOS);
     const compressedTarballInExtractingBundlePath = join(
       selfExtractingBundle.appBundleFolderResourcesPath,
       `${hash}.tar.zst`
@@ -2260,7 +2270,7 @@ if (commandArg === "init") {
         buildEnvironment === "stable"
           ? join(buildFolder, `${appFileName}-stable.dmg`)
           : finalDmgPath;
-      const dmgVolumeName = getDmgVolumeName(appFileName, buildEnvironment);
+      const dmgVolumeName = getDmgVolumeName(config.app.name, buildEnvironment);
 
       // Create a staging directory for DMG contents (app + Applications shortcut)
       const dmgStagingDir = join(buildFolder, '.dmg-staging');
@@ -2338,8 +2348,10 @@ if (commandArg === "init") {
           buildEnvironment,
           hash
         );
-        
-        artifactsToUpload.push(selfExtractingAppImagePath);
+
+        // Wrap the Setup.AppImage in a tar.gz to preserve executable permissions
+        const archivedAppImagePath = await wrapInArchive(selfExtractingAppImagePath, buildFolder, 'tar.gz');
+        artifactsToUpload.push(archivedAppImagePath);
       }
     }
 
@@ -2362,40 +2374,33 @@ if (commandArg === "init") {
       platform: OS,
       arch: ARCH,
       // channel: buildEnvironment,
-      // bucketUrl: config.release.bucketUrl
+      // baseUrl: config.release.baseUrl
     });
 
-    // update.json (no platform suffix in filename, platform is in folder name)
-    await Bun.write(join(artifactFolder, 'update.json'), updateJsonContent);
+    // update.json with platform prefix for flat naming structure
+    await Bun.write(join(artifactFolder, `${platformPrefix}-update.json`), updateJsonContent);
 
     // generate bsdiff
     // https://storage.googleapis.com/eggbun-static/electrobun-playground/canary/ElectrobunPlayground-canary.app.tar.zst
-    console.log("bucketUrl: ", config.release.bucketUrl);
+    console.log("baseUrl: ", config.release.baseUrl);
 
     console.log("generating a patch from the previous version...");
-    
-    // Skip patch generation if bucketUrl is not configured
-    if (!config.release.bucketUrl || config.release.bucketUrl.trim() === '') {
-      console.log("No bucketUrl configured, skipping patch generation");
-      console.log("To enable patch generation, configure bucketUrl in your electrobun.config");
+
+    // Skip patch generation if baseUrl is not configured
+    if (!config.release.baseUrl || config.release.baseUrl.trim() === '') {
+      console.log("No baseUrl configured, skipping patch generation");
+      console.log("To enable patch generation, configure baseUrl in your electrobun.config");
     } else {
-      const urlToPrevUpdateJson = join(
-        config.release.bucketUrl,
-        buildSubFolder,
-        'update.json'
-      );
+      const urlToPrevUpdateJson = `${config.release.baseUrl}/${platformPrefix}-update.json`;
       const cacheBuster = Math.random().toString(36).substring(7);
       const updateJsonResponse = await fetch(
         urlToPrevUpdateJson + `?${cacheBuster}`
       ).catch((err) => {
-        console.log("bucketURL not found: ", err);
+        console.log("baseUrl not found: ", err);
       });
 
-    const urlToLatestTarball = join(
-      config.release.bucketUrl,
-      buildSubFolder,
-      `${appFileName}.app.tar.zst`
-    );
+    const tarballFileName = getTarballFileName(appFileName, OS);
+    const urlToLatestTarball = `${config.release.baseUrl}/${platformPrefix}-${tarballFileName}`;
 
 
     // attempt to get the previous version to create a patch file
@@ -2441,7 +2446,6 @@ if (commandArg === "init") {
         // especially for creating multiple diffs in parallel
         const bsdiffpath = targetPaths.BSDIFF;
         const patchFilePath = join(buildFolder, `${prevHash}.patch`);
-        artifactsToUpload.push(patchFilePath);
         const result = Bun.spawnSync(
           [bsdiffpath, prevTarballPath, tarPath, patchFilePath, "--use-zstd"],
           {
@@ -2451,21 +2455,37 @@ if (commandArg === "init") {
           }
         );
         if (!result.success) {
-          throw new Error(`bsdiff failed with exit code ${result.exitCode}`);
+          // Patch generation is non-critical - users will just download full updates instead of delta patches
+          console.error("\n" + "=".repeat(80));
+          console.error("WARNING: Patch generation failed (exit code " + result.exitCode + ")");
+          console.error("Delta updates will not be available for this release.");
+          console.error("Users will download the full update instead.");
+          console.error("=".repeat(80) + "\n");
+        } else {
+          // Only add patch to artifacts if it was successfully created
+          artifactsToUpload.push(patchFilePath);
+        }
+
+        // Clean up uncompressed tars now that bsdiff is done
+        if (existsSync(tarPath)) {
+          unlinkSync(tarPath);
+        }
+        if (existsSync(prevTarballPath)) {
+          unlinkSync(prevTarballPath);
         }
       }
     } else {
       console.log("prevoius version not found at: ", urlToLatestTarball);
       console.log("skipping diff generation");
     }
-    } // End of bucketUrl validation block
+    } // End of baseUrl validation block
 
     // compress all the upload files
     console.log("copying artifacts...");
 
     artifactsToUpload.forEach((filePath) => {
       const filename = basename(filePath);
-      cpSync(filePath, join(artifactFolder, filename), { dereference: true });
+      cpSync(filePath, join(artifactFolder, `${platformPrefix}-${filename}`), { dereference: true });
     });
 
     // todo: now just upload the artifacts to your bucket replacing the ones that exist
@@ -2811,59 +2831,6 @@ async function createWindowsSelfExtractingExe(
   return outputExePath;
 }
 
-async function createLinuxSelfExtractingBinary(
-  buildFolder: string,
-  compressedTarPath: string,
-  appFileName: string,
-  targetPaths: any,
-  buildEnvironment: string,
-  config: Awaited<ReturnType<typeof getConfig>>
-): Promise<string> {
-  console.log("Creating self-extracting Linux binary...");
-
-  const setupFileName = getLinuxSetupFileName(config.app.name, buildEnvironment);
-  
-  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 wrapWindowsInstallerInZip(exePath: string, buildFolder: string): Promise<string> {
   const exeName = basename(exePath);
   const exeStem = exeName.replace('.exe', '');
@@ -2918,11 +2885,14 @@ async function wrapInArchive(filePath: string, buildFolder: string, archiveType:
   const fileDir = dirname(filePath);
   
   if (archiveType === 'tar.gz') {
-    // Output filename: Setup.exe -> Setup.exe.tar.gz or Setup.run -> Setup.run.tar.gz
-    const archivePath = filePath + '.tar.gz';
-    
-    // For Linux files, ensure they have executable permissions before archiving
-    if (fileName.endsWith('.run')) {
+    // Output filename: Setup.exe -> Setup.exe.tar.gz, Setup.AppImage -> Setup.tar.gz
+    // For AppImage files, strip the .AppImage extension so archive extracts to .AppImage
+    const archivePath = fileName.endsWith('.AppImage')
+      ? filePath.replace(/\.AppImage$/, '.tar.gz')
+      : filePath + '.tar.gz';
+
+    // For Linux AppImage files, ensure they have executable permissions before archiving
+    if (fileName.endsWith('.AppImage')) {
       try {
         // Try to set executable permissions (will only work on Unix-like systems)
         execSync(`chmod +x ${escapePathForTerminal(filePath)}`, { stdio: 'ignore' });