electrobun 0.0.19-beta.74 → 0.0.19-beta.76

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrobun",
-  "version": "0.0.19-beta.74",
+  "version": "0.0.19-beta.76",
   "description": "Build ultra fast, tiny, and cross-platform desktop apps with Typescript.",
   "license": "MIT",
   "author": "Blackboard Technologies Inc.",
@@ -48,10 +48,12 @@
     "build:push:artifacts": "bun scripts/build-and-upload-artifacts.js"
   },
   "devDependencies": {
+    "@types/archiver": "^6.0.3",
     "@types/bun": "1.1.9"
   },
   "dependencies": {
     "@oneidentity/zstd-js": "^1.0.3",
+    "archiver": "^7.0.1",
     "rpc-anywhere": "1.5.0",
     "tar": "^6.2.1"
   }

package/src/cli/index.ts

@@ -11,9 +11,12 @@ import {
   readdirSync,
   rmSync,
   symlinkSync,
+  statSync,
+  copyFileSync,
 } from "fs";
 import { execSync } from "child_process";
 import tar from "tar";
+import archiver from "archiver";
 import { ZstdInit } from "@oneidentity/zstd-js/wasm";
 import { OS, ARCH } from '../shared/platform';
 import { getTemplate, getTemplateNames } from './templates/embedded';
@@ -22,7 +25,7 @@ import { getTemplate, getTemplateNames } from './templates/embedded';
 const MAX_CHUNK_SIZE = 1024 * 2;
 
 
-const binExt = OS === 'win' ? '.exe' : '';
+// const binExt = OS === 'win' ? '.exe' : '';
 
 // this when run as an npm script this will be where the folder where package.json is.
 const projectRoot = process.cwd();
@@ -611,6 +614,7 @@ const buildSubFolder = `${buildEnvironment}-${currentTarget.os}-${currentTarget.
 // 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);
 
@@ -846,7 +850,7 @@ if (commandArg === "init") {
   // Only copy launcher for non-dev builds
   if (buildEnvironment !== "dev") {
     const bunCliLauncherBinarySource = targetPaths.LAUNCHER_RELEASE;
-    const bunCliLauncherDestination = join(appBundleMacOSPath, "launcher") + binExt;
+    const bunCliLauncherDestination = join(appBundleMacOSPath, "launcher") + targetBinExt;
     const destLauncherFolder = dirname(bunCliLauncherDestination);
     if (!existsSync(destLauncherFolder)) {
       // console.info('creating folder: ', destFolder);
@@ -866,7 +870,7 @@ if (commandArg === "init") {
   const bunBinarySourcePath = targetPaths.BUN_BINARY;
   // Note: .bin/bun binary in node_modules is a symlink to the versioned one in another place
   // in node_modules, so we have to dereference here to get the actual binary in the bundle.
-  const bunBinaryDestInBundlePath = join(appBundleMacOSPath, "bun") + binExt;
+  const bunBinaryDestInBundlePath = join(appBundleMacOSPath, "bun") + targetBinExt;
   const destFolder2 = dirname(bunBinaryDestInBundlePath);
   if (!existsSync(destFolder2)) {
     // console.info('creating folder: ', destFolder);
@@ -1172,7 +1176,7 @@ if (commandArg === "init") {
 
   // copy native bindings
   const bsPatchSource = targetPaths.BSPATCH;
-  const bsPatchDestination = join(appBundleMacOSPath, "bspatch") + binExt;
+  const bsPatchDestination = join(appBundleMacOSPath, "bspatch") + targetBinExt;
   const bsPatchDestFolder = dirname(bsPatchDestination);
   if (!existsSync(bsPatchDestFolder)) {
     mkdirSync(bsPatchDestFolder, { recursive: true });
@@ -1501,7 +1505,13 @@ if (commandArg === "init") {
           targetPaths,
           buildEnvironment
         );
-        artifactsToUpload.push(selfExtractingExePath);
+        
+        // Wrap Windows installer files in zip for distribution
+        const wrappedExePath = await wrapWindowsInstallerInZip(selfExtractingExePath, buildFolder);
+        artifactsToUpload.push(wrappedExePath);
+        
+        // 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]
@@ -1554,7 +1564,13 @@ exec "\$LAUNCHER_BINARY" "\$@"
           targetPaths,
           buildEnvironment
         );
-        artifactsToUpload.push(selfExtractingLinuxPath);
+        
+        // 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
         const linuxTarPath = join(buildFolder, `${appFileName}.tar.gz`);
@@ -1864,7 +1880,7 @@ async function createWindowsSelfExtractingExe(
   targetPaths: any,
   buildEnvironment: string
 ): Promise<string> {
-  console.log("Creating self-extracting Windows exe...");
+  console.log("Creating Windows installer with separate archive...");
   
   // Format: MyApp-Setup.exe (stable) or MyApp-Setup-canary.exe (non-stable)
   const setupFileName = buildEnvironment === "stable" 
@@ -1873,43 +1889,40 @@ async function createWindowsSelfExtractingExe(
   
   const outputExePath = join(buildFolder, setupFileName);
   
-  // Read the extractor exe
+  // Copy the extractor exe
   const extractorExe = readFileSync(targetPaths.EXTRACTOR);
+  writeFileSync(outputExePath, extractorExe);
   
-  // Read the compressed archive
-  const compressedArchive = readFileSync(compressedTarPath);
-  
-  // Create metadata JSON
+  // Create metadata JSON file
   const metadata = {
     identifier: config.app.identifier,
     name: config.app.name,
     channel: buildEnvironment
   };
-  const metadataJson = JSON.stringify(metadata);
-  const metadataBuffer = Buffer.from(metadataJson, 'utf8');
+  const metadataJson = JSON.stringify(metadata, null, 2);
+  const metadataFileName = setupFileName.replace('.exe', '.metadata.json');
+  const metadataPath = join(buildFolder, metadataFileName);
+  writeFileSync(metadataPath, metadataJson);
   
-  // Create marker buffers
-  const metadataMarker = Buffer.from('ELECTROBUN_METADATA_V1', 'utf8');
-  const archiveMarker = Buffer.from('ELECTROBUN_ARCHIVE_V1', 'utf8');
+  // Copy the compressed archive with matching name
+  const archiveFileName = setupFileName.replace('.exe', '.tar.zst');
+  const archivePath = join(buildFolder, archiveFileName);
+  copyFileSync(compressedTarPath, archivePath);
   
-  // Combine extractor + metadata marker + metadata + archive marker + archive
-  const combinedBuffer = Buffer.concat([
-    extractorExe,
-    metadataMarker,
-    metadataBuffer,
-    archiveMarker,
-    compressedArchive
-  ]);
-  
-  // Write the self-extracting exe
-  writeFileSync(outputExePath, combinedBuffer);
-  
-  // Make it executable (though Windows doesn't need chmod)
+  // Make the exe executable (though Windows doesn't need chmod)
   if (OS !== 'win') {
     execSync(`chmod +x ${escapePathForTerminal(outputExePath)}`);
   }
   
-  console.log(`Created self-extracting exe: ${outputExePath} (${(combinedBuffer.length / 1024 / 1024).toFixed(2)} MB)`);
+  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;
 }
@@ -1969,6 +1982,117 @@ async function createLinuxSelfExtractingBinary(
   return outputPath;
 }
 
+async function wrapWindowsInstallerInZip(exePath: string, buildFolder: string): Promise<string> {
+  const exeName = basename(exePath);
+  const exeStem = exeName.replace('.exe', '');
+  
+  // Derive the paths for metadata and archive files
+  const metadataPath = join(buildFolder, `${exeStem}.metadata.json`);
+  const archivePath = join(buildFolder, `${exeStem}.tar.zst`);
+  const zipPath = join(buildFolder, `${exeStem}.zip`);
+  
+  // Verify all files exist
+  if (!existsSync(exePath)) {
+    throw new Error(`Installer exe not found: ${exePath}`);
+  }
+  if (!existsSync(metadataPath)) {
+    throw new Error(`Metadata file not found: ${metadataPath}`);
+  }
+  if (!existsSync(archivePath)) {
+    throw new Error(`Archive file not found: ${archivePath}`);
+  }
+  
+  // Create zip archive
+  const output = createWriteStream(zipPath);
+  const archive = archiver('zip', {
+    zlib: { level: 9 } // Maximum compression
+  });
+  
+  return new Promise((resolve, reject) => {
+    output.on('close', () => {
+      console.log(`Created Windows installer package: ${zipPath} (${(archive.pointer() / 1024 / 1024).toFixed(2)} MB)`);
+      resolve(zipPath);
+    });
+    
+    archive.on('error', (err) => {
+      reject(err);
+    });
+    
+    archive.pipe(output);
+    
+    // Add all three files to the archive
+    archive.file(exePath, { name: basename(exePath) });
+    archive.file(metadataPath, { name: basename(metadataPath) });
+    archive.file(archivePath, { name: basename(archivePath) });
+    
+    archive.finalize();
+  });
+}
+
+async function wrapInArchive(filePath: string, buildFolder: string, archiveType: 'tar.gz' | 'zip'): Promise<string> {
+  const fileName = basename(filePath);
+  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')) {
+      try {
+        // Try to set executable permissions (will only work on Unix-like systems)
+        execSync(`chmod +x ${escapePathForTerminal(filePath)}`, { stdio: 'ignore' });
+      } catch {
+        // Ignore errors on Windows hosts
+      }
+    }
+    
+    // Create tar.gz archive preserving permissions
+    // Using the tar package for cross-platform compatibility
+    await tar.c(
+      {
+        gzip: true,
+        file: archivePath,
+        cwd: fileDir,
+        portable: true,  // Ensures consistent behavior across platforms
+        preservePaths: false,
+        // The tar package should preserve file modes when creating archives
+      },
+      [fileName]
+    );
+    
+    console.log(`Created archive: ${archivePath} (preserving executable permissions)`);
+    return archivePath;
+  } else if (archiveType === 'zip') {
+    // Output filename: Setup.exe -> Setup.zip
+    const archivePath = filePath.replace(/\.[^.]+$/, '.zip');
+    
+    // Create zip archive
+    const output = createWriteStream(archivePath);
+    const archive = archiver('zip', {
+      zlib: { level: 9 } // Maximum compression
+    });
+    
+    return new Promise((resolve, reject) => {
+      output.on('close', () => {
+        console.log(`Created archive: ${archivePath} (${(archive.pointer() / 1024 / 1024).toFixed(2)} MB)`);
+        resolve(archivePath);
+      });
+      
+      archive.on('error', (err) => {
+        reject(err);
+      });
+      
+      archive.pipe(output);
+      
+      // Add the file to the archive
+      archive.file(filePath, { name: fileName });
+      
+      archive.finalize();
+    });
+  }
+}
+
 async function createAppImage(buildFolder: string, appBundlePath: string, appFileName: string, config: any): Promise<string | null> {
   try {
     console.log("Creating AppImage...");