electrobun 0.13.0-beta.21 → 0.13.0-beta.23

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

@@ -7,6 +7,29 @@ import { ZstdInit } from "@oneidentity/zstd-js/wasm";
 import { OS as currentOS, ARCH as currentArch } from '../../shared/platform';
 import { getPlatformFolder, 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')
@@ -144,7 +167,7 @@ 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 updateInfoUrl = urlJoin(localInfo.bucketUrl, platformFolder, `update.json?${cacheBuster}`);
 
     try {
       const updateInfoResponse = await fetch(updateInfoUrl);
@@ -213,7 +236,7 @@ const Updater = {
         // check if there's a patch file for it
         const platformFolder = getPlatformFolder(localInfo.channel, currentOS, currentArch);
         const patchResponse = await fetch(
-          join(localInfo.bucketUrl, platformFolder, `${currentHash}.patch`)
+          urlJoin(localInfo.bucketUrl, platformFolder, `${currentHash}.patch`)
         );
 
         if (!patchResponse.ok) {
@@ -332,7 +355,7 @@ const Updater = {
         const cacheBuster = Math.random().toString(36).substring(7);
         const platformFolder = getPlatformFolder(localInfo.channel, currentOS, currentArch);
         const tarballName = getTarballFileName(appFileName, currentOS);
-        const urlToLatestTarball = join(
+        const urlToLatestTarball = urlJoin(
           localInfo.bucketUrl,
           platformFolder,
           tarballName
@@ -471,10 +494,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 +508,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 +563,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
@@ -588,113 +620,108 @@ 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");
-
-            // Use start command to launch detached process that survives parent termination
-            await Bun.spawn(["cmd", "/c", "start", "", "/d", parentDir, "run.bat"], { detached: true });
-            break;
-          case 'linux':
-            // On Linux, launch the AppImage directly
-            Bun.spawn(["sh", "-c", `"${runningAppBundlePath}" &`], { detached: true});
-            break;
-        }
-
-        // Small delay on Windows to ensure new process starts before we terminate
-        if (currentOS === 'win') {
-          await new Promise(resolve => setTimeout(resolve, 500));
+        // 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();
       }
     }
   },
@@ -702,7 +729,7 @@ start "" launcher.exe
   channelBucketUrl: async () => {
     await Updater.getLocallocalInfo();
     const platformFolder = getPlatformFolder(localInfo.channel, currentOS, currentArch);
-    return join(localInfo.bucketUrl, platformFolder);
+    return urlJoin(localInfo.bucketUrl, platformFolder);
   },
 
   appDataFolder: async () => {

package/package.json

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

package/src/cli/index.ts

@@ -2098,20 +2098,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);
+
+      // Add tar.zst for Updater API (delta updates)
+      // Note: raw AppImage is NOT added - only the Setup.AppImage (zipped) is distributed
+      artifactsToUpload.push(compressedTarPath);
     }
   }
 
@@ -2338,8 +2339,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);
       }
     }
 
@@ -2918,11 +2921,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';
-    
+    // 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 files, ensure they have executable permissions before archiving
-    if (fileName.endsWith('.run')) {
+    if (fileName.endsWith('.run') || fileName.endsWith('.AppImage')) {
       try {
         // Try to set executable permissions (will only work on Unix-like systems)
         execSync(`chmod +x ${escapePathForTerminal(filePath)}`, { stdio: 'ignore' });