electrobun 1.18.4-beta.6 → 2.0.1-beta.13

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

@@ -1,1162 +0,0 @@
-import { join, dirname, resolve } from "path";
-import { homedir } from "os";
-import {
-	renameSync,
-	unlinkSync,
-	mkdirSync,
-	rmSync,
-	statSync,
-	readdirSync,
-} from "fs";
-import { execSync } from "child_process";
-import { OS as currentOS, ARCH as currentArch } from "../../shared/platform";
-import { getPlatformPrefix, getTarballFileName } from "../../shared/naming";
-import { quit } from "./Utils";
-
-// Update status types for granular progress tracking
-export type UpdateStatusType =
-	| "idle"
-	| "checking"
-	| "check-complete"
-	| "no-update"
-	| "update-available"
-	| "downloading"
-	| "download-starting"
-	| "checking-local-tar"
-	| "local-tar-found"
-	| "local-tar-missing"
-	| "fetching-patch"
-	| "patch-found"
-	| "patch-not-found"
-	| "downloading-patch"
-	| "applying-patch"
-	| "patch-applied"
-	| "patch-failed"
-	| "extracting-version"
-	| "patch-chain-complete"
-	| "downloading-full-bundle"
-	| "download-progress"
-	| "decompressing"
-	| "download-complete"
-	| "applying"
-	| "extracting"
-	| "replacing-app"
-	| "launching-new-version"
-	| "complete"
-	| "error";
-
-export interface UpdateStatusDetails {
-	fromHash?: string;
-	toHash?: string;
-	currentHash?: string;
-	latestHash?: string;
-	patchNumber?: number;
-	totalPatchesApplied?: number;
-	progress?: number;
-	bytesDownloaded?: number;
-	totalBytes?: number;
-	usedPatchPath?: boolean;
-	errorMessage?: string;
-	url?: string;
-	zstdPath?: string;
-	exitCode?: number | null;
-}
-
-export interface UpdateStatusEntry {
-	status: UpdateStatusType;
-	message: string;
-	timestamp: number;
-	details?: UpdateStatusDetails;
-}
-
-// Status history and callback
-const statusHistory: UpdateStatusEntry[] = [];
-let onStatusChangeCallback: ((entry: UpdateStatusEntry) => void) | null = null;
-
-function emitStatus(
-	status: UpdateStatusType,
-	message: string,
-	details?: UpdateStatusDetails,
-): void {
-	const entry: UpdateStatusEntry = {
-		status,
-		message,
-		timestamp: Date.now(),
-		details,
-	};
-	statusHistory.push(entry);
-	if (onStatusChangeCallback) {
-		onStatusChangeCallback(entry);
-	}
-}
-
-// setTimeout(async () => {
-//   console.log('killing')
-//   const { native } = await import('../proc/native');
-//             native.symbols.killApp();
-// }, 1000)
-
-
-// Cross-platform app data directory
-function getAppDataDir(): string {
-	switch (currentOS) {
-		case "macos":
-			return join(homedir(), "Library", "Application Support");
-		case "win":
-			// Use LOCALAPPDATA to match extractor location
-			return process.env["LOCALAPPDATA"] || join(homedir(), "AppData", "Local");
-		case "linux":
-			// Use XDG_DATA_HOME or fallback to ~/.local/share to match extractor
-			return process.env["XDG_DATA_HOME"] || join(homedir(), ".local", "share");
-		default:
-			// Fallback to home directory with .config
-			return join(homedir(), ".config");
-	}
-}
-
-// todo (yoav): share type with cli
-let localInfo: {
-	version: string;
-	hash: string;
-	baseUrl: string;
-	channel: string;
-	name: string;
-	identifier: string;
-};
-
-let updateInfo: {
-	version: string;
-	hash: string;
-	updateAvailable: boolean;
-	updateReady: boolean;
-	error: string;
-};
-
-function cleanupExtractionFolder(
-	extractionFolder: string,
-	keepTarHash: string,
-) {
-	const keepFile = `${keepTarHash}.tar`;
-	try {
-		const entries = readdirSync(extractionFolder);
-		for (const entry of entries) {
-			if (entry === keepFile) continue;
-			const fullPath = join(extractionFolder, entry);
-			try {
-				const s = statSync(fullPath);
-				if (s.isDirectory()) {
-					rmSync(fullPath, { recursive: true });
-				} else {
-					unlinkSync(fullPath);
-				}
-			} catch (e) {
-				// Best effort — file may be in use on Windows
-			}
-		}
-	} catch (e) {
-		// Ignore errors in cleanup
-	}
-}
-
-const Updater = {
-	updateInfo: () => {
-		return updateInfo;
-	},
-
-	// Status history and subscription methods
-	getStatusHistory: () => {
-		return [...statusHistory];
-	},
-
-	clearStatusHistory: () => {
-		statusHistory.length = 0;
-	},
-
-	onStatusChange: (callback: ((entry: UpdateStatusEntry) => void) | null) => {
-		onStatusChangeCallback = callback;
-	},
-
-	// todo: allow switching channels, by default will check the current channel
-	checkForUpdate: async () => {
-		emitStatus("checking", "Checking for updates...");
-		const localInfo = await Updater.getLocalInfo();
-
-		if (localInfo.channel === "dev") {
-			emitStatus("no-update", "Dev channel - updates disabled", {
-				currentHash: localInfo.hash,
-			});
-			return {
-				version: localInfo.version,
-				hash: localInfo.hash,
-				updateAvailable: false,
-				updateReady: false,
-				error: "",
-			};
-		}
-
-		const cacheBuster = Math.random().toString(36).substring(7);
-		const platformPrefix = getPlatformPrefix(
-			localInfo.channel,
-			currentOS,
-			currentArch,
-		);
-		const updateInfoUrl = `${localInfo.baseUrl.replace(/\/+$/, "")}/${platformPrefix}-update.json?${cacheBuster}`;
-
-		try {
-			const updateInfoResponse = await fetch(updateInfoUrl);
-
-			if (updateInfoResponse.ok) {
-				const responseText = await updateInfoResponse.text();
-				try {
-					updateInfo = JSON.parse(responseText);
-				} catch {
-					emitStatus("error", "Invalid update.json: failed to parse JSON", {
-						url: updateInfoUrl,
-					});
-					return {
-						version: "",
-						hash: "",
-						updateAvailable: false,
-						updateReady: false,
-						error: `Invalid update.json: failed to parse JSON`,
-					};
-				}
-
-				if (!updateInfo.hash) {
-					emitStatus("error", "Invalid update.json: missing hash", {
-						url: updateInfoUrl,
-					});
-					return {
-						version: "",
-						hash: "",
-						updateAvailable: false,
-						updateReady: false,
-						error: `Invalid update.json: missing hash`,
-					};
-				}
-
-				if (updateInfo.hash !== localInfo.hash) {
-					updateInfo.updateAvailable = true;
-					emitStatus(
-						"update-available",
-						`Update available: ${localInfo.hash.slice(0, 8)} → ${updateInfo.hash.slice(0, 8)}`,
-						{
-							currentHash: localInfo.hash,
-							latestHash: updateInfo.hash,
-						},
-					);
-				} else {
-					emitStatus("no-update", "Already on latest version", {
-						currentHash: localInfo.hash,
-					});
-				}
-			} else {
-				emitStatus(
-					"error",
-					`Failed to fetch update info (HTTP ${updateInfoResponse.status})`,
-					{ url: updateInfoUrl },
-				);
-				return {
-					version: "",
-					hash: "",
-					updateAvailable: false,
-					updateReady: false,
-					error: `Failed to fetch update info from ${updateInfoUrl}`,
-				};
-			}
-		} catch (error) {
-			return {
-				version: "",
-				hash: "",
-				updateAvailable: false,
-				updateReady: false,
-				error: `Failed to fetch update info from ${updateInfoUrl}`,
-			};
-		}
-
-		return updateInfo;
-	},
-
-	downloadUpdate: async () => {
-		emitStatus("download-starting", "Starting update download...");
-		const appDataFolder = await Updater.appDataFolder();
-		await Updater.channelBucketUrl(); // Ensure localInfo is loaded
-		const appFileName = localInfo.name;
-
-		let currentHash = (await Updater.getLocalInfo()).hash;
-		let latestHash = (await Updater.checkForUpdate()).hash;
-
-		const extractionFolder = join(appDataFolder, "self-extraction");
-		if (!(await Bun.file(extractionFolder).exists())) {
-			mkdirSync(extractionFolder, { recursive: true });
-		}
-
-		let currentTarPath = join(extractionFolder, `${currentHash}.tar`);
-		const latestTarPath = join(extractionFolder, `${latestHash}.tar`);
-
-		const seenHashes: string[] = [];
-		let patchesApplied = 0;
-		let usedPatchPath = false;
-
-		if (!(await Bun.file(latestTarPath).exists())) {
-			emitStatus(
-				"checking-local-tar",
-				`Checking for local tar file: ${currentHash.slice(0, 8)}`,
-				{ currentHash },
-			);
-
-			while (currentHash !== latestHash) {
-				seenHashes.push(currentHash);
-				const currentTar = Bun.file(currentTarPath);
-
-				if (!(await currentTar.exists())) {
-					// tar file of the current version not found
-					// so we can't patch it. We need the byte-for-byte tar file
-					// so break out and download the full version
-					emitStatus(
-						"local-tar-missing",
-						`Local tar not found for ${currentHash.slice(0, 8)}, will download full bundle`,
-						{ currentHash },
-					);
-					break;
-				}
-
-				emitStatus(
-					"local-tar-found",
-					`Found local tar for ${currentHash.slice(0, 8)}`,
-					{ currentHash },
-				);
-
-				// check if there's a patch file for it
-				const platformPrefix = getPlatformPrefix(
-					localInfo.channel,
-					currentOS,
-					currentArch,
-				);
-				const patchUrl = `${localInfo.baseUrl.replace(/\/+$/, "")}/${platformPrefix}-${currentHash}.patch`;
-				emitStatus(
-					"fetching-patch",
-					`Checking for patch: ${currentHash.slice(0, 8)}`,
-					{ currentHash, url: patchUrl },
-				);
-
-				const patchResponse = await fetch(patchUrl);
-
-				if (!patchResponse.ok) {
-					// patch not found
-					emitStatus(
-						"patch-not-found",
-						`No patch available for ${currentHash.slice(0, 8)}, will download full bundle`,
-						{ currentHash },
-					);
-					break;
-				}
-
-				emitStatus(
-					"patch-found",
-					`Patch found for ${currentHash.slice(0, 8)}`,
-					{ currentHash },
-				);
-				emitStatus(
-					"downloading-patch",
-					`Downloading patch for ${currentHash.slice(0, 8)}...`,
-					{ currentHash },
-				);
-
-				// The patch file's name is the hash of the "from" version
-				const patchFilePath = join(
-					appDataFolder,
-					"self-extraction",
-					`${currentHash}.patch`,
-				);
-				await Bun.write(patchFilePath, await patchResponse.arrayBuffer());
-				// patch it to a tmp name
-				const tmpPatchedTarFilePath = join(
-					appDataFolder,
-					"self-extraction",
-					`from-${currentHash}.tar`,
-				);
-
-				const bunBinDir = dirname(process.execPath);
-				const bspatchBinName = currentOS === "win" ? "bspatch.exe" : "bspatch";
-				const bspatchPath = join(bunBinDir, bspatchBinName);
-
-				emitStatus(
-					"applying-patch",
-					`Applying patch ${patchesApplied + 1} for ${currentHash.slice(0, 8)}...`,
-					{
-						currentHash,
-						patchNumber: patchesApplied + 1,
-					},
-				);
-
-				// Verify all files exist before invoking bspatch
-				if (!statSync(bspatchPath, { throwIfNoEntry: false })) {
-					emitStatus(
-						"patch-failed",
-						`bspatch binary not found at ${bspatchPath}`,
-						{
-							currentHash,
-							errorMessage: `bspatch not found: ${bspatchPath}`,
-						},
-					);
-					console.error("bspatch not found:", bspatchPath);
-					break;
-				}
-				if (!statSync(currentTarPath, { throwIfNoEntry: false })) {
-					emitStatus("patch-failed", `Old tar not found at ${currentTarPath}`, {
-						currentHash,
-						errorMessage: `old tar not found: ${currentTarPath}`,
-					});
-					console.error("old tar not found:", currentTarPath);
-					break;
-				}
-				if (!statSync(patchFilePath, { throwIfNoEntry: false })) {
-					emitStatus(
-						"patch-failed",
-						`Patch file not found at ${patchFilePath}`,
-						{
-							currentHash,
-							errorMessage: `patch not found: ${patchFilePath}`,
-						},
-					);
-					console.error("patch file not found:", patchFilePath);
-					break;
-				}
-
-				try {
-					const patchResult = Bun.spawnSync([
-						bspatchPath,
-						currentTarPath,
-						tmpPatchedTarFilePath,
-						patchFilePath,
-					]);
-
-					if (patchResult.exitCode !== 0 || patchResult.success === false) {
-						const stderr = patchResult.stderr
-							? patchResult.stderr.toString()
-							: "";
-						const stdout = patchResult.stdout
-							? patchResult.stdout.toString()
-							: "";
-						if (updateInfo) {
-							updateInfo.error =
-								stderr ||
-								`bspatch failed with exit code ${patchResult.exitCode}`;
-						}
-						emitStatus(
-							"patch-failed",
-							`Patch application failed: ${stderr || `exit code ${patchResult.exitCode}`}`,
-							{
-								currentHash,
-								errorMessage: stderr || `exit code ${patchResult.exitCode}`,
-							},
-						);
-						console.error("bspatch failed", {
-							exitCode: patchResult.exitCode,
-							stdout,
-							stderr,
-							bspatchPath,
-							oldTar: currentTarPath,
-							newTar: tmpPatchedTarFilePath,
-							patch: patchFilePath,
-						});
-						break;
-					}
-				} catch (error) {
-					emitStatus(
-						"patch-failed",
-						`Patch threw exception: ${(error as Error).message}`,
-						{
-							currentHash,
-							errorMessage: (error as Error).message,
-						},
-					);
-					console.error("bspatch threw", error, { bspatchPath });
-					break;
-				}
-
-				patchesApplied++;
-				emitStatus(
-					"patch-applied",
-					`Patch ${patchesApplied} applied successfully`,
-					{
-						currentHash,
-						patchNumber: patchesApplied,
-					},
-				);
-
-				emitStatus(
-					"extracting-version",
-					"Extracting version info from patched tar...",
-					{ currentHash },
-				);
-
-				let hashFilePath = "";
-
-				// Read the hash from the patched tar without full extraction:
-				// - macOS/Windows: Resources/version.json (inside the app bundle directory)
-				// - Linux: metadata.json (alongside the app bundle)
-				const resourcesDir = "Resources";
-				const patchedTarBytes = await Bun.file(
-					tmpPatchedTarFilePath,
-				).arrayBuffer();
-				const patchedArchive = new Bun.Archive(patchedTarBytes);
-				const patchedFiles = await patchedArchive.files();
-
-				for (const [filePath] of patchedFiles) {
-					if (
-						filePath.endsWith(`${resourcesDir}/version.json`) ||
-						filePath.endsWith("metadata.json")
-					) {
-						hashFilePath = filePath;
-						break;
-					}
-				}
-
-				if (!hashFilePath) {
-					emitStatus(
-						"error",
-						"Could not find version/metadata file in patched tar",
-						{ currentHash },
-					);
-					console.error(
-						"Neither Resources/version.json nor metadata.json found in patched tar:",
-						tmpPatchedTarFilePath,
-					);
-					break;
-				}
-
-				const hashFile = patchedFiles.get(hashFilePath);
-				const hashFileJson = JSON.parse(await hashFile!.text());
-				const nextHash = hashFileJson.hash;
-
-				if (seenHashes.includes(nextHash)) {
-					emitStatus(
-						"error",
-						"Cyclical update detected, falling back to full download",
-						{ currentHash: nextHash },
-					);
-					console.log("Warning: cyclical update detected");
-					break;
-				}
-
-				seenHashes.push(nextHash);
-
-				if (!nextHash) {
-					emitStatus(
-						"error",
-						"Could not determine next hash from patched tar",
-						{ currentHash },
-					);
-					break;
-				}
-				// Sync the patched tar file to the new hash
-				const updatedTarPath = join(
-					appDataFolder,
-					"self-extraction",
-					`${nextHash}.tar`,
-				);
-				renameSync(tmpPatchedTarFilePath, updatedTarPath);
-
-				// delete the old tar file
-				unlinkSync(currentTarPath);
-				unlinkSync(patchFilePath);
-
-				currentHash = nextHash;
-				currentTarPath = join(
-					appDataFolder,
-					"self-extraction",
-					`${currentHash}.tar`,
-				);
-
-				emitStatus(
-					"patch-applied",
-					`Patched to ${nextHash.slice(0, 8)}, checking for more patches...`,
-					{
-						currentHash: nextHash,
-						toHash: latestHash,
-						totalPatchesApplied: patchesApplied,
-					},
-				);
-				// loop through applying patches until we reach the latest version
-				// if we get stuck then exit and just download the full latest version
-			}
-
-			// Check if patch chain completed successfully
-			if (currentHash === latestHash && patchesApplied > 0) {
-				usedPatchPath = true;
-				emitStatus(
-					"patch-chain-complete",
-					`Patch chain complete! Applied ${patchesApplied} patches`,
-					{
-						totalPatchesApplied: patchesApplied,
-						currentHash: latestHash,
-						usedPatchPath: true,
-					},
-				);
-			}
-
-			// If we weren't able to apply patches to the current version,
-			// then just download it and unpack it
-			if (currentHash !== latestHash) {
-				emitStatus(
-					"downloading-full-bundle",
-					"Downloading full update bundle...",
-					{
-						currentHash,
-						latestHash,
-						usedPatchPath: false,
-					},
-				);
-
-				const cacheBuster = Math.random().toString(36).substring(7);
-				const platformPrefix = getPlatformPrefix(
-					localInfo.channel,
-					currentOS,
-					currentArch,
-				);
-				const tarballName = getTarballFileName(appFileName, currentOS);
-				const urlToLatestTarball = `${localInfo.baseUrl.replace(/\/+$/, "")}/${platformPrefix}-${tarballName}`;
-				const prevVersionCompressedTarballPath = join(
-					appDataFolder,
-					"self-extraction",
-					"latest.tar.zst",
-				);
-
-				emitStatus("download-progress", `Fetching ${tarballName}...`, {
-					url: urlToLatestTarball,
-				});
-				const response = await fetch(urlToLatestTarball + `?${cacheBuster}`);
-
-				if (response.ok && response.body) {
-					const contentLength = response.headers.get("content-length");
-					const totalBytes = contentLength
-						? parseInt(contentLength, 10)
-						: undefined;
-					let bytesDownloaded = 0;
-
-					const reader = response.body.getReader();
-					const writer = Bun.file(prevVersionCompressedTarballPath).writer();
-
-					while (true) {
-						const { done, value } = await reader.read();
-						if (done) break;
-						await writer.write(value);
-						bytesDownloaded += value.length;
-
-						// Emit progress every ~500KB or so
-						if (bytesDownloaded % 500000 < value.length) {
-							emitStatus(
-								"download-progress",
-								`Downloading: ${(bytesDownloaded / 1024 / 1024).toFixed(1)} MB`,
-								{
-									bytesDownloaded,
-									totalBytes,
-									progress: totalBytes
-										? Math.round((bytesDownloaded / totalBytes) * 100)
-										: undefined,
-								},
-							);
-						}
-					}
-					await writer.flush();
-					writer.end();
-
-					emitStatus(
-						"download-progress",
-						`Download complete: ${(bytesDownloaded / 1024 / 1024).toFixed(1)} MB`,
-						{
-							bytesDownloaded,
-							totalBytes,
-							progress: 100,
-						},
-					);
-				} else {
-					emitStatus("error", `Failed to download: ${urlToLatestTarball}`, {
-						url: urlToLatestTarball,
-					});
-					console.log("latest version not found at: ", urlToLatestTarball);
-				}
-
-				emitStatus("decompressing", "Decompressing update bundle...");
-				const bunBinDir = dirname(process.execPath);
-				const zstdBinName = currentOS === "win" ? "zig-zstd.exe" : "zig-zstd";
-				const zstdPath = join(bunBinDir, zstdBinName);
-
-				if (!statSync(zstdPath, { throwIfNoEntry: false })) {
-					updateInfo.error = `zig-zstd not found: ${zstdPath}`;
-					emitStatus("error", updateInfo.error, { zstdPath });
-					console.error("zig-zstd not found:", zstdPath);
-				} else {
-					const decompressResult = Bun.spawnSync(
-						[
-							zstdPath,
-							"decompress",
-							"-i",
-							prevVersionCompressedTarballPath,
-							"-o",
-							latestTarPath,
-							"--no-timing",
-						],
-						{
-							cwd: extractionFolder,
-							stdout: "inherit",
-							stderr: "inherit",
-						},
-					);
-					if (!decompressResult.success) {
-						updateInfo.error = `zig-zstd failed with exit code ${decompressResult.exitCode}`;
-						emitStatus("error", updateInfo.error, {
-							zstdPath,
-							exitCode: decompressResult.exitCode,
-						});
-						console.error("zig-zstd failed", {
-							exitCode: decompressResult.exitCode,
-							zstdPath,
-						});
-					} else {
-						emitStatus("decompressing", "Decompression complete");
-					}
-				}
-
-				unlinkSync(prevVersionCompressedTarballPath);
-			}
-		}
-
-		// Note: Bun.file().exists() caches the result, so we nee d an new instance of Bun.file() here
-		// to check again
-		if (await Bun.file(latestTarPath).exists()) {
-			// download patch for this version, apply it.
-			// check for patch from that tar and apply it, until it matches the latest version
-			// as a fallback it should just download and unpack the latest version
-			updateInfo.updateReady = true;
-			emitStatus(
-				"download-complete",
-				`Update ready to install (used ${usedPatchPath ? "patch" : "full download"} path)`,
-				{
-					latestHash,
-					usedPatchPath,
-					totalPatchesApplied: patchesApplied,
-				},
-			);
-		} else {
-			updateInfo.error = "Failed to download latest version";
-			emitStatus("error", "Failed to download latest version", { latestHash });
-		}
-
-		// Clean up stale files in the extraction folder (old tars, patches, backups, etc.)
-		cleanupExtractionFolder(extractionFolder, latestHash);
-	},
-
-	// todo (yoav): this should emit an event so app can cleanup or block the restart
-	// todo (yoav): rename this to quitAndApplyUpdate or something
-	applyUpdate: async () => {
-		if (updateInfo?.updateReady) {
-			emitStatus("applying", "Starting update installation...");
-			const appDataFolder = await Updater.appDataFolder();
-			const extractionFolder = join(appDataFolder, "self-extraction");
-			if (!(await Bun.file(extractionFolder).exists())) {
-				mkdirSync(extractionFolder, { recursive: true });
-			}
-
-			let latestHash = (await Updater.checkForUpdate()).hash;
-			const latestTarPath = join(extractionFolder, `${latestHash}.tar`);
-
-			let appBundleSubpath: string = "";
-
-			if (await Bun.file(latestTarPath).exists()) {
-				emitStatus(
-					"extracting",
-					`Extracting update to ${latestHash.slice(0, 8)}...`,
-					{ latestHash },
-				);
-
-				// Windows needs a temporary directory to avoid file locking issues
-				const extractionDir =
-					currentOS === "win"
-						? join(extractionFolder, `temp-${latestHash}`)
-						: extractionFolder;
-
-				if (currentOS === "win") {
-					mkdirSync(extractionDir, { recursive: true });
-				}
-
-				const latestTarBytes = await Bun.file(latestTarPath).arrayBuffer();
-				const latestArchive = new Bun.Archive(latestTarBytes);
-				await latestArchive.extract(extractionDir);
-
-				if (currentOS === "macos") {
-					// Find the .app bundle by scanning extracted directory
-					const extractedFiles = readdirSync(extractionDir);
-					for (const file of extractedFiles) {
-						if (file.endsWith('.app')) {
-							appBundleSubpath = file + "/";
-							break;
-						}
-					}
-				} else {
-					appBundleSubpath = "./";
-				}
-
-				console.log(
-					`Tar extraction completed. Found appBundleSubpath: ${appBundleSubpath}`,
-				);
-
-				if (!appBundleSubpath) {
-					console.error("Failed to find app in tarball");
-					return;
-				}
-
-				// Note: resolve here removes the extra trailing / that the tar file adds
-				const extractedAppPath = resolve(join(extractionDir, appBundleSubpath));
-
-				// Platform-specific path handling
-				let newAppBundlePath: string;
-				if (currentOS === "linux") {
-					// On Linux, the tarball contains a directory bundle
-					// Find the actual extracted app directory name instead of guessing
-					const extractedFiles = readdirSync(extractionDir);
-					const appBundleDir = extractedFiles.find(file => {
-						const filePath = join(extractionDir, file);
-						return statSync(filePath).isDirectory() && !file.endsWith('.tar');
-					});
-					
-					if (!appBundleDir) {
-						console.error("Could not find app bundle directory in extraction");
-						return;
-					}
-					
-					newAppBundlePath = join(extractionDir, appBundleDir);
-
-					// Verify the app bundle directory exists
-					const bundleStats = statSync(newAppBundlePath, { throwIfNoEntry: false });
-					if (!bundleStats || !bundleStats.isDirectory()) {
-						console.error(`App bundle directory not found at: ${newAppBundlePath}`);
-						console.log("Contents of extraction directory:");
-						try {
-							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);
-						}
-						return;
-					}
-				} else if (currentOS === "win") {
-					// On Windows, the actual app is inside a subdirectory.
-					// version.json's `name` field already contains the formatted app
-					// file name (e.g. "MyApp-canary" for non-stable, "MyApp" for stable),
-					// so don't re-apply getAppFileName or it doubles the channel suffix.
-					newAppBundlePath = join(extractionDir, localInfo.name);
-
-					// Verify the extracted app exists
-					if (!statSync(newAppBundlePath, { throwIfNoEntry: false })) {
-						console.error(`Extracted app not found at: ${newAppBundlePath}`);
-						console.log("Contents of extraction directory:");
-						try {
-							const files = readdirSync(extractionDir);
-							for (const file of files) {
-								console.log(`  - ${file}`);
-							}
-						} catch (e) {
-							console.log("Could not list directory contents:", e);
-						}
-						return;
-					}
-				} else {
-					// On macOS, use the extracted app path directly
-					newAppBundlePath = extractedAppPath;
-				}
-				// Platform-specific app path calculation
-				let runningAppBundlePath: string;
-				const appDataFolder = await Updater.appDataFolder();
-				
-				if (currentOS === "macos") {
-					// On macOS, executable is at Contents/MacOS/binary inside .app bundle
-					runningAppBundlePath = resolve(dirname(process.execPath), "..", "..");
-				} else if (currentOS === "linux" || currentOS === "win") {
-					// On Linux and Windows, use fixed 'app' folder to match extractor
-					runningAppBundlePath = join(appDataFolder, "app");
-				} else {
-					throw new Error(`Unsupported platform: ${currentOS}`);
-				}
-				try {
-					emitStatus("replacing-app", "Removing old version...");
-
-					if (currentOS === "macos") {
-						// Remove existing app before installing the new one
-						if (statSync(runningAppBundlePath, { throwIfNoEntry: false })) {
-							rmSync(runningAppBundlePath, { recursive: true });
-						}
-
-						emitStatus("replacing-app", "Installing new version...");
-						// 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, we now have directory bundles instead of AppImage files
-						// The app is stored in {appDataFolder}/app/
-						const appBundleDir = join(appDataFolder, "app");
-						
-						// Remove existing app directory if it exists
-						if (statSync(appBundleDir, { throwIfNoEntry: false })) {
-							rmSync(appBundleDir, { recursive: true });
-						}
-
-						// Move new app bundle directory to app location
-						renameSync(newAppBundlePath, appBundleDir);
-
-						// Ensure launcher binary is executable
-						const launcherPath = join(appBundleDir, "bin", "launcher");
-						if (statSync(launcherPath, { throwIfNoEntry: false })) {
-							execSync(`chmod +x "${launcherPath}"`);
-						}
-
-						// Also ensure other binaries are executable
-						const bunPath = join(appBundleDir, "bin", "bun");
-						if (statSync(bunPath, { throwIfNoEntry: false })) {
-							execSync(`chmod +x "${bunPath}"`);
-						}
-					}
-
-					// Clean up stale files in extraction folder
-					if (currentOS !== "win") {
-						cleanupExtractionFolder(extractionFolder, latestHash);
-					}
-
-					if (currentOS === "win") {
-						// 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 updateScriptPath = join(parentDir, "update.bat");
-						const launcherPath = join(
-							runningAppBundlePath,
-							"bin",
-							"launcher.exe",
-						);
-
-						// Convert paths to Windows format
-						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 and its helper processes to exit
-						// 2. Remove current app folder (with retries — CEF helpers may briefly
-						//    keep libcef.dll locked after launcher.exe exits)
-						// 3. Move new app to current location (only if old folder is fully gone,
-						//    otherwise `move` would put it inside as a subdirectory)
-						// 4. Launch the new app
-						// 5. Clean up
-						const updateScript = `@echo off
-setlocal
-
-:: Wait for the app and any CEF helper processes to fully exit.
-:: launcher.exe spawns bun.exe which spawns "bun Helper*.exe" processes that
-:: keep libcef.dll locked; if we proceed too early, rmdir partially fails.
-:waitloop
-tasklist /FI "IMAGENAME eq launcher.exe" 2>NUL | find /I /N "launcher.exe">NUL && goto waitsleep
-tasklist /FI "IMAGENAME eq bun.exe" 2>NUL | find /I /N "bun.exe">NUL && goto waitsleep
-tasklist /FI "IMAGENAME eq bun Helper.exe" 2>NUL | find /I /N "bun Helper.exe">NUL && goto waitsleep
-tasklist 2>NUL | find /I "bun Helper">NUL && goto waitsleep
-goto waitdone
-:waitsleep
-timeout /t 1 /nobreak >nul
-goto waitloop
-:waitdone
-
-:: Small extra delay to ensure all file handles are released
-timeout /t 2 /nobreak >nul
-
-:: Remove current app folder, retrying if rmdir fails (locked files etc.)
-set rmRetry=0
-:rmloop
-if not exist "${runningAppWin}" goto rmdone
-rmdir /s /q "${runningAppWin}" 2>nul
-if not exist "${runningAppWin}" goto rmdone
-set /a rmRetry=rmRetry+1
-if %rmRetry% GEQ 10 goto rmfailed
-timeout /t 2 /nobreak >nul
-goto rmloop
-:rmfailed
-echo Update failed: could not remove "${runningAppWin}" after retries.
-echo Files may still be locked by a helper process.
-pause
-exit /b 1
-:rmdone
-
-:: Move new app to current location (safe now that destination is gone)
-move "${newAppWin}" "${runningAppWin}"
-if not exist "${launcherPathWin}" (
-    echo Update failed: launcher not found at "${launcherPathWin}" after move.
-    pause
-    exit /b 1
-)
-
-:: 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(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) {
-					emitStatus(
-						"error",
-						`Failed to replace app: ${(error as Error).message}`,
-						{
-							errorMessage: (error as Error).message,
-						},
-					);
-					console.error("Failed to replace app with new version", error);
-					return;
-				}
-
-				emitStatus("launching-new-version", "Launching updated version...");
-
-				// Cross-platform app launch (Windows is handled above with its own update script)
-				if (currentOS === "macos") {
-					// Wait for the current process to fully exit before relaunching.
-					// macOS 'open' on an already-running app just activates the existing
-					// instance instead of launching a new one, so we must ensure the
-					// current process has exited first. The detached shell survives our
-					// exit and polls until the process is gone.
-					const pid = process.pid;
-					// eslint-disable-next-line @typescript-eslint/no-explicit-any
-					Bun.spawn(
-						[
-							"sh",
-							"-c",
-							`while kill -0 ${pid} 2>/dev/null; do sleep 0.5; done; sleep 1; open "${runningAppBundlePath}"`,
-						],
-						{
-							detached: true,
-							stdio: ["ignore", "ignore", "ignore"],
-						} as any,
-					);
-				} else if (currentOS === "linux") {
-					// On Linux, launch the launcher binary inside the app directory
-					const launcherPath = join(runningAppBundlePath, "bin", "launcher");
-					// eslint-disable-next-line @typescript-eslint/no-explicit-any
-					Bun.spawn(["sh", "-c", `"${launcherPath}" &`], {
-						detached: true,
-					} as any);
-				}
-
-				emitStatus("complete", "Update complete, restarting application...");
-				// Use quit() for graceful shutdown
-				quit();
-			}
-		}
-	},
-
-	channelBucketUrl: async () => {
-		await Updater.getLocalInfo();
-		// With flat prefix-based naming, channelBucketUrl is just the baseUrl
-		// Users can also use Updater.localInfo.baseUrl() directly
-		return localInfo.baseUrl;
-	},
-
-	appDataFolder: async () => {
-		await Updater.getLocalInfo();
-		// Use identifier + channel for the app data folder
-		// e.g., ~/Library/Application Support/sh.blackboard.myapp/canary/
-		const appDataFolder = join(
-			getAppDataDir(),
-			localInfo.identifier,
-			localInfo.channel,
-		);
-
-		return appDataFolder;
-	},
-
-	// TODO: consider moving this from "Updater.localInfo" to "BuildVars"
-	localInfo: {
-		version: async () => {
-			return (await Updater.getLocalInfo()).version;
-		},
-		hash: async () => {
-			return (await Updater.getLocalInfo()).hash;
-		},
-		channel: async () => {
-			return (await Updater.getLocalInfo()).channel;
-		},
-		baseUrl: async () => {
-			return (await Updater.getLocalInfo()).baseUrl;
-		},
-	},
-
-	getLocalInfo: async () => {
-		if (localInfo) {
-			return localInfo;
-		}
-
-		try {
-			const resourcesDir = "Resources"; // Always use capitalized Resources
-			localInfo = await Bun.file(`../${resourcesDir}/version.json`).json();
-			return localInfo;
-		} catch (error) {
-			console.error("Failed to read version.json", error);
-			localInfo = { identifier: "", channel: "", version: "", hash: "", baseUrl: "", name: "" };
-			return localInfo;
-			}
-		},
-		getLocallocalInfo: async () => {
-			console.error(
-				"[Electrobun] Updater.getLocallocalInfo() is deprecated. Use Updater.getLocalInfo() instead.",
-			);
-
-			return Updater.getLocalInfo();
-		},
-	};
-
-export { Updater };