craft-native 0.0.87 → 0.0.88

package/dist/index.cjs

@@ -52,6 +52,7 @@ __export(exports_src, {
   watch: () => watch,
   vueOptimizations: () => vueOptimizations,
   verifyPassword: () => verifyPassword,
+  verifyBundleTrust: () => verifyBundleTrust,
   variants: () => variants,
   uuid: () => uuid,
   updater: () => exports_updater,
@@ -70,6 +71,7 @@ __export(exports_src, {
   tahoeStyles: () => tahoeStyles,
   tahoeStyle: () => tahoeStyle,
   tahoeDemoData: () => tahoeDemoData,
+  swapBundle: () => swapBundle,
   svelteOptimizations: () => svelteOptimizations,
   submenu: () => submenu,
   styles: () => styles,
@@ -117,6 +119,7 @@ __export(exports_src, {
   registerShortcut: () => registerShortcut,
   readText: () => readText,
   readHTML: () => readHTML,
+  readBundleIdentity: () => readBundleIdentity,
   readBinaryFile: () => readBinaryFile,
   reactOptimizations: () => reactOptimizations,
   randomString: () => randomString,
@@ -184,9 +187,13 @@ __export(exports_src, {
   foregroundService: () => foregroundService,
   focusFilters: () => focusFilters,
   focus: () => focus,
+  extractBundleFromZip: () => extractBundleFromZip,
+  extractBundleFromDmg: () => extractBundleFromDmg,
+  extractBundle: () => extractBundle,
   exit: () => exit,
   exec: () => exec,
   env: () => env,
+  dittoBundle: () => dittoBundle,
   dialog: () => dialog,
   device: () => device,
   desktopWidgets: () => desktopWidgets,
@@ -217,8 +224,10 @@ __export(exports_src, {
   commonOptimizations: () => commonOptimizations,
   clsx: () => cx,
   clipboard: () => clipboard,
+  clearQuarantine: () => clearQuarantine,
   checkbox: () => checkbox,
   carplay: () => carplay,
+  canReplaceBundle: () => canReplaceBundle,
   canQuickLook: () => canQuickLook,
   camera: () => camera,
   buildMenu: () => buildMenu,
@@ -9983,24 +9992,236 @@ var commonOptimizations = {
 // src/updater/index.ts
 var exports_updater = {};
 __export(exports_updater, {
+  verifyBundleTrust: () => verifyBundleTrust,
   updaterCommand: () => updaterCommand,
+  swapBundle: () => swapBundle,
+  readBundleIdentity: () => readBundleIdentity,
+  isMacOS: () => isMacOS,
   generateUpdateManifest: () => generateUpdateManifest,
+  extractBundleFromZip: () => extractBundleFromZip,
+  extractBundleFromDmg: () => extractBundleFromDmg,
+  extractBundle: () => extractBundle,
+  dittoBundle: () => dittoBundle,
   default: () => updater_default,
+  clearQuarantine: () => clearQuarantine,
+  canReplaceBundle: () => canReplaceBundle,
   DeltaGenerator: () => DeltaGenerator,
   AutoUpdater: () => AutoUpdater
 });
-var import_fs3 = require("fs");
-var import_path2 = require("path");
-var import_child_process2 = require("child_process");
+var import_fs4 = require("fs");
+var import_path3 = require("path");
+var import_os3 = require("os");
+var import_child_process3 = require("child_process");
 var import_crypto3 = require("crypto");
 var import_events3 = require("events");
-function findFirstByName(root, namePattern, kind) {
-  const out = import_child_process2.execFileSync("find", [root, "-name", namePattern, "-type", kind, "-print0"]);
-  const nullByte = String.fromCharCode(0);
-  const parts = out.toString("utf-8").split(nullByte).filter((s) => s.length > 0);
-  return parts[0] ?? "";
+
+// src/updater/macos-bundle.ts
+var import_child_process2 = require("child_process");
+var import_fs3 = require("fs");
+var import_os2 = require("os");
+var import_path2 = require("path");
+var import_util = require("util");
+var execFileAsync = import_util.promisify(import_child_process2.execFile);
+function isMacOS() {
+  return process.platform === "darwin";
+}
+async function readBundleIdentity(appPath) {
+  const empty = { identifier: null, teamId: null, authority: null };
+  if (!isMacOS())
+    return empty;
+  let report;
+  try {
+    const { stderr, stdout } = await execFileAsync("codesign", ["-dv", "--verbose=4", appPath]);
+    report = `${stderr}
+${stdout}`;
+  } catch (error) {
+    const e = error;
+    report = `${e.stderr ?? ""}
+${e.stdout ?? ""}`;
+    if (!report.trim())
+      return empty;
+  }
+  const field = (name) => {
+    const match = report.match(new RegExp(`^${name}=(.+)$`, "m"));
+    if (!match)
+      return null;
+    const value = match[1].trim();
+    return value === "not set" || value.length === 0 ? null : value;
+  };
+  return {
+    identifier: field("Identifier"),
+    teamId: field("TeamIdentifier"),
+    authority: field("Authority")
+  };
+}
+async function verifyBundleTrust(appPath, policy = {}) {
+  const identity = await readBundleIdentity(appPath);
+  const requireNotarized = policy.requireNotarized ?? true;
+  if (!import_fs3.existsSync(appPath)) {
+    return { ok: false, identity, gatekeeperSource: null, reason: "unreadable", detail: `No such bundle: ${appPath}` };
+  }
+  try {
+    await execFileAsync("codesign", ["--verify", "--deep", "--strict", "--verbose=2", appPath]);
+  } catch (error) {
+    return {
+      ok: false,
+      identity,
+      gatekeeperSource: null,
+      reason: "codesign-invalid",
+      detail: describe(error)
+    };
+  }
+  let gatekeeperSource = null;
+  if (requireNotarized) {
+    try {
+      const { stderr, stdout } = await execFileAsync("spctl", ["-a", "-t", "exec", "-vv", appPath]);
+      const report = `${stderr}
+${stdout}`;
+      gatekeeperSource = report.match(/^source=(.+)$/m)?.[1]?.trim() ?? null;
+    } catch (error) {
+      return {
+        ok: false,
+        identity,
+        gatekeeperSource: null,
+        reason: "gatekeeper-rejected",
+        detail: describe(error)
+      };
+    }
+  }
+  if (policy.teamId && identity.teamId !== policy.teamId) {
+    return {
+      ok: false,
+      identity,
+      gatekeeperSource,
+      reason: "team-mismatch",
+      detail: `Expected Team ID ${policy.teamId}, bundle is signed by ${identity.teamId ?? "nobody"}`
+    };
+  }
+  return { ok: true, identity, gatekeeperSource };
+}
+async function clearQuarantine(appPath) {
+  if (!isMacOS())
+    return;
+  try {
+    await execFileAsync("xattr", ["-d", "-r", "com.apple.quarantine", appPath]);
+  } catch {}
+}
+async function dittoBundle(source, destination) {
+  await execFileAsync("ditto", [source, destination]);
+}
+function findTopLevelApp(root) {
+  const out = import_child_process2.execFileSync("find", [root, "-maxdepth", "2", "-name", "*.app", "-type", "d", "-print0"]);
+  const parts = out.toString("utf-8").split("\x00").filter((s) => s.length > 0);
+  parts.sort((a, b) => a.split("/").length - b.split("/").length);
+  return parts[0] ?? null;
+}
+async function extractBundleFromDmg(dmgPath, stagingDir) {
+  const staging = stagingDir ?? import_fs3.mkdtempSync(import_path2.join(import_os2.tmpdir(), "craft-update-"));
+  const mountPoint = import_fs3.mkdtempSync(import_path2.join(import_os2.tmpdir(), "craft-mount-"));
+  let mounted = false;
+  try {
+    await execFileAsync("hdiutil", ["attach", dmgPath, "-nobrowse", "-readonly", "-mountpoint", mountPoint]);
+    mounted = true;
+    const source = findTopLevelApp(mountPoint);
+    if (!source)
+      throw new Error(`No .app found in disk image: ${dmgPath}`);
+    const appPath = import_path2.join(staging, import_path2.basename(source));
+    await dittoBundle(source, appPath);
+    return { appPath, stagingDir: staging };
+  } finally {
+    if (mounted) {
+      try {
+        await execFileAsync("hdiutil", ["detach", mountPoint, "-force"]);
+      } catch {}
+    }
+    try {
+      import_fs3.rmSync(mountPoint, { recursive: true, force: true });
+    } catch {}
+  }
+}
+async function extractBundleFromZip(zipPath, stagingDir) {
+  const staging = stagingDir ?? import_fs3.mkdtempSync(import_path2.join(import_os2.tmpdir(), "craft-update-"));
+  const unpacked = import_path2.join(staging, "payload");
+  await execFileAsync("ditto", ["-x", "-k", zipPath, unpacked]);
+  const source = findTopLevelApp(unpacked);
+  if (!source)
+    throw new Error(`No .app found in archive: ${zipPath}`);
+  return { appPath: source, stagingDir: staging };
+}
+async function extractBundle(archivePath, stagingDir) {
+  if (archivePath.endsWith(".dmg"))
+    return extractBundleFromDmg(archivePath, stagingDir);
+  if (archivePath.endsWith(".zip"))
+    return extractBundleFromZip(archivePath, stagingDir);
+  throw new Error(`Cannot extract an app bundle from ${archivePath}`);
+}
+async function swapBundle(stagedPath, installedPath) {
+  if (!import_fs3.existsSync(stagedPath))
+    throw new Error(`Staged bundle is missing: ${stagedPath}`);
+  const parent = import_path2.dirname(installedPath);
+  const stamp = `${Date.now()}.${process.pid}`;
+  const incoming = import_path2.join(parent, `.${import_path2.basename(installedPath)}.${stamp}.incoming`);
+  const retired = import_path2.join(parent, `.${import_path2.basename(installedPath)}.${stamp}.retired`);
+  try {
+    import_fs3.renameSync(stagedPath, incoming);
+  } catch {
+    await dittoBundle(stagedPath, incoming);
+  }
+  const hadPrevious = import_fs3.existsSync(installedPath);
+  try {
+    if (hadPrevious)
+      import_fs3.renameSync(installedPath, retired);
+    try {
+      import_fs3.renameSync(incoming, installedPath);
+    } catch (error) {
+      if (hadPrevious) {
+        try {
+          import_fs3.renameSync(retired, installedPath);
+        } catch {}
+      }
+      throw error;
+    }
+  } catch (error) {
+    try {
+      import_fs3.rmSync(incoming, { recursive: true, force: true });
+    } catch {}
+    throw error;
+  }
+  if (hadPrevious) {
+    try {
+      import_fs3.rmSync(retired, { recursive: true, force: true });
+      return { previousPath: null };
+    } catch {
+      return { previousPath: retired };
+    }
+  }
+  return { previousPath: null };
+}
+function canReplaceBundle(installedPath) {
+  try {
+    const parent = import_path2.dirname(installedPath);
+    import_fs3.accessSync(parent, import_fs3.constants.W_OK);
+    if (import_fs3.existsSync(installedPath))
+      import_fs3.statSync(installedPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function describe(error) {
+  if (error && typeof error === "object") {
+    const e = error;
+    const stderr = e.stderr?.trim();
+    if (stderr)
+      return stderr;
+    if (e.message)
+      return e.message;
+  }
+  return String(error);
 }
 
+// src/updater/index.ts
+var PROGRESS_INTERVAL_MS = 100;
 class AutoUpdater extends import_events3.EventEmitter {
   config;
   updateInfo = null;
@@ -10009,12 +10230,22 @@ class AutoUpdater extends import_events3.EventEmitter {
   cachedEtag = null;
   cachedLastModified = null;
   cachedManifest = null;
+  lastError = null;
   emitError(error) {
+    this.lastError = error instanceof Error ? error : new Error(String(error));
     if (this.listenerCount("error") > 0)
       this.emit("error", error);
     else
       console.error("[Updater]", error);
   }
+  downloadDir() {
+    if (this.config.downloadDir)
+      return this.config.downloadDir;
+    return import_path3.join(import_os3.tmpdir(), "craft-updates", import_path3.basename(this.config.appPath) || "app");
+  }
+  getLastError() {
+    return this.lastError;
+  }
   constructor(config) {
     super();
     const url = config.updateUrl;
@@ -10048,6 +10279,7 @@ class AutoUpdater extends import_events3.EventEmitter {
   }
   async checkForUpdates() {
     this.emit("checking-for-update");
+    this.lastError = null;
     try {
       const platform = this.getPlatform();
       const url = `${this.config.updateUrl}?v=${this.config.currentVersion}&channel=${this.config.channel}&platform=${platform}`;
@@ -10096,20 +10328,21 @@ class AutoUpdater extends import_events3.EventEmitter {
     if (!this.updateInfo) {
       throw new Error("No update available");
     }
+    this.lastError = null;
     const platform = this.getPlatform();
     const platformUpdate = this.updateInfo.platforms[platform];
     if (!platformUpdate) {
       throw new Error(`No update available for platform: ${platform}`);
     }
-    const deltaUpdate = platformUpdate.delta?.find((d) => d.fromVersion === this.config.currentVersion);
+    const deltaUpdate = DeltaGenerator.isSupported() ? platformUpdate.delta?.find((d) => d.fromVersion === this.config.currentVersion) : undefined;
     const _updateSource = deltaUpdate || platformUpdate;
     const url = deltaUpdate?.url || platformUpdate.url;
     const expectedSize = deltaUpdate?.size || platformUpdate.size;
     const expectedHash = deltaUpdate?.sha256 || platformUpdate.sha256;
-    const downloadDir = import_path2.join(this.config.appPath, "..", ".craft-updates");
-    import_fs3.mkdirSync(downloadDir, { recursive: true });
-    const fileName = import_path2.basename(url);
-    this.downloadPath = import_path2.join(downloadDir, fileName);
+    const downloadDir = this.downloadDir();
+    import_fs4.mkdirSync(downloadDir, { recursive: true });
+    const fileName = import_path3.basename(url);
+    this.downloadPath = import_path3.join(downloadDir, fileName);
     try {
       const response = await fetch(url);
       if (!response.ok) {
@@ -10119,63 +10352,83 @@ class AutoUpdater extends import_events3.EventEmitter {
       const total = contentLength || expectedSize;
       let downloaded = 0;
       const startTime = Date.now();
-      const fileStream = import_fs3.createWriteStream(this.downloadPath);
+      const fileStream = import_fs4.createWriteStream(this.downloadPath);
       const reader = response.body?.getReader();
       if (!reader) {
         throw new Error("Failed to get response reader");
       }
+      const digest = import_crypto3.createHash("sha256");
+      let lastProgressAt = 0;
       while (true) {
         const { done, value } = await reader.read();
         if (done)
           break;
-        fileStream.write(value);
+        digest.update(value);
+        if (!fileStream.write(value)) {
+          await new Promise((resolve, reject) => {
+            const onDrain = () => {
+              fileStream.off("error", onError);
+              resolve();
+            };
+            const onError = (error) => {
+              fileStream.off("drain", onDrain);
+              reject(error);
+            };
+            fileStream.once("drain", onDrain);
+            fileStream.once("error", onError);
+          });
+        }
         downloaded += value.length;
-        const elapsed = (Date.now() - startTime) / 1000;
-        const speed = downloaded / elapsed;
-        const progress = {
-          phase: "downloading",
-          percent: Math.round(downloaded / total * 100),
-          bytesDownloaded: downloaded,
-          bytesTotal: total,
-          speed
-        };
-        this.emit("download-progress", progress);
+        const now = Date.now();
+        if (now - lastProgressAt >= PROGRESS_INTERVAL_MS || downloaded === total) {
+          lastProgressAt = now;
+          const elapsed = (now - startTime) / 1000;
+          const speed = elapsed > 0 ? downloaded / elapsed : 0;
+          const progress = {
+            phase: "downloading",
+            percent: total > 0 ? Math.round(downloaded / total * 100) : 0,
+            bytesDownloaded: downloaded,
+            bytesTotal: total,
+            speed
+          };
+          this.emit("download-progress", progress);
+        }
       }
       fileStream.end();
       await new Promise((resolve, reject) => {
         fileStream.once("finish", resolve);
         fileStream.once("error", reject);
       });
-      const hash = await this.computeFileHash(this.downloadPath);
+      const hash = digest.digest("hex");
       if (hash !== expectedHash) {
-        import_fs3.unlinkSync(this.downloadPath);
+        import_fs4.unlinkSync(this.downloadPath);
         throw new Error("Download verification failed: hash mismatch");
       }
       if (deltaUpdate) {
-        if (!import_fs3.statSync(this.config.appPath).isFile()) {
+        if (!import_fs4.statSync(this.config.appPath).isFile()) {
           throw new Error("Delta updates require appPath to point to the installed bundle file");
         }
         const patchPath = this.downloadPath;
-        const reconstructedPath = import_path2.join(downloadDir, `reconstructed-${import_path2.basename(platformUpdate.url)}`);
+        const reconstructedPath = import_path3.join(downloadDir, `reconstructed-${import_path3.basename(platformUpdate.url)}`);
         await DeltaGenerator.apply(this.config.appPath, patchPath, reconstructedPath);
         const reconstructedHash = await this.computeFileHash(reconstructedPath);
         if (reconstructedHash !== platformUpdate.sha256) {
           try {
-            import_fs3.unlinkSync(reconstructedPath);
+            import_fs4.unlinkSync(reconstructedPath);
           } catch {}
           throw new Error("Delta reconstruction failed: full bundle hash mismatch");
         }
-        import_fs3.unlinkSync(patchPath);
+        import_fs4.unlinkSync(patchPath);
         this.downloadPath = reconstructedPath;
       }
       if (this.config.publicKeyPem && !platformUpdate.signature) {
-        import_fs3.unlinkSync(this.downloadPath);
+        import_fs4.unlinkSync(this.downloadPath);
         throw new Error("Updater: publicKeyPem is configured but the manifest entry has no signature. " + "Refusing to install unsigned update.");
       }
       if (platformUpdate.signature) {
         const valid = await this.verifySignature(this.downloadPath, platformUpdate.signature);
         if (!valid) {
-          import_fs3.unlinkSync(this.downloadPath);
+          import_fs4.unlinkSync(this.downloadPath);
           throw new Error("Download verification failed: invalid signature");
         }
       }
@@ -10194,7 +10447,7 @@ class AutoUpdater extends import_events3.EventEmitter {
     }
   }
   async installUpdate(restartAfter = true) {
-    if (!this.downloadPath || !import_fs3.existsSync(this.downloadPath)) {
+    if (!this.downloadPath || !import_fs4.existsSync(this.downloadPath)) {
       throw new Error("No update downloaded");
     }
     if (this.updateInfo) {
@@ -10204,7 +10457,7 @@ class AutoUpdater extends import_events3.EventEmitter {
         const hash = await this.computeFileHash(this.downloadPath);
         if (hash !== platformUpdate.sha256) {
           try {
-            import_fs3.unlinkSync(this.downloadPath);
+            import_fs4.unlinkSync(this.downloadPath);
           } catch {}
           throw new Error(`Updater.installUpdate: pre-install hash mismatch on ${this.downloadPath}. ` + "The downloaded bundle changed between download and install — refusing to run installer.");
         }
@@ -10215,7 +10468,7 @@ class AutoUpdater extends import_events3.EventEmitter {
           const valid = await this.verifySignature(this.downloadPath, platformUpdate.signature);
           if (!valid) {
             try {
-              import_fs3.unlinkSync(this.downloadPath);
+              import_fs4.unlinkSync(this.downloadPath);
             } catch {}
             throw new Error("Updater.installUpdate: invalid signature on downloaded bundle");
           }
@@ -10238,14 +10491,17 @@ class AutoUpdater extends import_events3.EventEmitter {
           await this.installLinuxUpdate();
           break;
       }
-      if (this.downloadPath && import_fs3.existsSync(this.downloadPath)) {
-        import_fs3.unlinkSync(this.downloadPath);
+      if (this.downloadPath && import_fs4.existsSync(this.downloadPath)) {
+        import_fs4.unlinkSync(this.downloadPath);
       }
+      try {
+        import_fs4.rmdirSync(this.downloadDir());
+      } catch {}
       progress.phase = "done";
       progress.percent = 100;
       this.emit("download-progress", progress);
       if (restartAfter) {
-        this.restartApp();
+        await this.restartApp();
       }
     } catch (error) {
       progress.phase = "error";
@@ -10256,54 +10512,61 @@ class AutoUpdater extends import_events3.EventEmitter {
   async installMacOSUpdate() {
     const downloadPath = this.downloadPath;
     const appPath = this.config.appPath;
-    if (downloadPath.endsWith(".zip")) {
-      const tempDir2 = import_path2.join(import_path2.dirname(downloadPath), "extracted");
-      import_fs3.mkdirSync(tempDir2, { recursive: true });
-      import_child_process2.execFileSync("unzip", ["-o", downloadPath, "-d", tempDir2]);
-      const extractedApp = findFirstByName(tempDir2, "*.app", "d");
-      if (extractedApp) {
-        const { rmSync: rmSync3, renameSync } = await import("fs");
-        rmSync3(appPath, { recursive: true, force: true });
-        renameSync(extractedApp, appPath);
-      }
-      const { rmSync: rmSync2 } = await import("fs");
-      rmSync2(tempDir2, { recursive: true, force: true });
-    } else if (downloadPath.endsWith(".dmg")) {
-      const mountOutput = import_child_process2.execFileSync("hdiutil", ["attach", downloadPath, "-nobrowse"]).toString();
-      const mountPoint = mountOutput.match(/\/Volumes\/[^\n]+/)?.[0];
-      if (mountPoint) {
-        const dmgApp = findFirstByName(mountPoint, "*.app", "d");
-        if (dmgApp) {
-          const { rmSync: rmSync2, cpSync: cpSync2 } = await import("fs");
-          rmSync2(appPath, { recursive: true, force: true });
-          cpSync2(dmgApp, appPath, { recursive: true });
-        }
-        import_child_process2.execFileSync("hdiutil", ["detach", mountPoint]);
-      }
-    } else if (downloadPath.endsWith(".pkg")) {
+    if (downloadPath.endsWith(".pkg")) {
+      await this.installMacOSPackage(downloadPath);
+      return;
+    }
+    if (!canReplaceBundle(appPath)) {
+      throw new Error(`Cannot replace ${appPath}: ${import_path3.dirname(appPath)} is not writable by this user. ` + "Install the update manually, or move the app somewhere you own.");
+    }
+    const staged = await extractBundle(downloadPath);
+    try {
+      const trust = await this.assertBundleTrusted(staged.appPath);
+      await clearQuarantine(staged.appPath);
+      const { previousPath } = await swapBundle(staged.appPath, appPath);
+      this.emit("update-installed", {
+        path: appPath,
+        version: this.updateInfo?.version,
+        identity: trust.identity,
+        leftoverPath: previousPath
+      });
+    } finally {
       try {
-        import_child_process2.execFileSync("pkgutil", ["--check-signature", downloadPath], { stdio: "pipe" });
-      } catch (e) {
-        throw new Error(`Refusing to install ${downloadPath}: pkgutil --check-signature failed. The .pkg is not signed by a trusted Apple certificate chain. Underlying error: ${e.message}`);
-      }
-      import_child_process2.execFileSync("sudo", ["installer", "-pkg", downloadPath, "-target", "/"]);
+        import_fs4.rmSync(staged.stagingDir, { recursive: true, force: true });
+      } catch {}
+    }
+  }
+  async assertBundleTrusted(bundlePath) {
+    const policy = this.config.macos ?? {};
+    const trust = await verifyBundleTrust(bundlePath, policy);
+    if (!trust.ok) {
+      throw new Error(`Refusing to install ${bundlePath}: ${trust.reason} (${trust.detail ?? "no detail"}). ` + "The downloaded bundle is not one macOS will run as this application.");
+    }
+    return trust;
+  }
+  async installMacOSPackage(downloadPath) {
+    try {
+      import_child_process3.execFileSync("pkgutil", ["--check-signature", downloadPath], { stdio: "pipe" });
+    } catch (e) {
+      throw new Error(`Refusing to install ${downloadPath}: pkgutil --check-signature failed. ` + "The .pkg is not signed by a trusted Apple certificate chain. " + `Underlying error: ${e.message}`);
     }
+    import_child_process3.execFileSync("sudo", ["installer", "-pkg", downloadPath, "-target", "/"]);
   }
   async installWindowsUpdate() {
     const downloadPath = this.downloadPath;
     if (downloadPath.endsWith(".exe")) {
-      import_child_process2.spawn(downloadPath, ["/S", "/SILENT", "/VERYSILENT"], {
+      import_child_process3.spawn(downloadPath, ["/S", "/SILENT", "/VERYSILENT"], {
         detached: true,
         stdio: "ignore"
       });
     } else if (downloadPath.endsWith(".msi")) {
-      import_child_process2.spawn("msiexec", ["/i", downloadPath, "/quiet", "/norestart"], {
+      import_child_process3.spawn("msiexec", ["/i", downloadPath, "/quiet", "/norestart"], {
         detached: true,
         stdio: "ignore"
       });
     } else if (downloadPath.endsWith(".zip")) {
-      const appDir = import_path2.dirname(this.config.appPath);
-      import_child_process2.execFileSync("powershell", [
+      const appDir = import_path3.dirname(this.config.appPath);
+      import_child_process3.execFileSync("powershell", [
         "-NoProfile",
         "-NonInteractive",
         "-Command",
@@ -10316,30 +10579,31 @@ class AutoUpdater extends import_events3.EventEmitter {
   async installLinuxUpdate() {
     const downloadPath = this.downloadPath;
     if (downloadPath.endsWith(".AppImage")) {
-      import_child_process2.execFileSync("chmod", ["+x", downloadPath]);
-      const { renameSync } = await import("fs");
-      renameSync(downloadPath, this.config.appPath);
+      import_child_process3.execFileSync("chmod", ["+x", downloadPath]);
+      const { renameSync: renameSync2 } = await import("fs");
+      renameSync2(downloadPath, this.config.appPath);
     } else if (downloadPath.endsWith(".deb")) {
-      import_child_process2.execFileSync("sudo", ["dpkg", "-i", downloadPath]);
+      import_child_process3.execFileSync("sudo", ["dpkg", "-i", downloadPath]);
     } else if (downloadPath.endsWith(".rpm")) {
-      import_child_process2.execFileSync("sudo", ["rpm", "-U", downloadPath]);
+      import_child_process3.execFileSync("sudo", ["rpm", "-U", downloadPath]);
     } else if (downloadPath.endsWith(".tar.gz")) {
-      const appDir = import_path2.dirname(this.config.appPath);
-      import_child_process2.execFileSync("tar", ["-xzf", downloadPath, "-C", appDir]);
+      const appDir = import_path3.dirname(this.config.appPath);
+      import_child_process3.execFileSync("tar", ["-xzf", downloadPath, "-C", appDir]);
     }
   }
-  restartApp() {
-    const platform = this.getPlatform();
+  async restartApp() {
     const appPath = this.config.appPath;
-    switch (platform) {
+    if (this.config.relaunch) {
+      await this.config.relaunch(appPath);
+      return;
+    }
+    switch (this.getPlatform()) {
       case "darwin":
-        import_child_process2.spawn("open", ["-n", appPath], { detached: true, stdio: "ignore" });
+        import_child_process3.spawn("open", ["-n", appPath], { detached: true, stdio: "ignore" });
         break;
       case "win32":
-        import_child_process2.spawn(appPath, [], { detached: true, stdio: "ignore" });
-        break;
       case "linux":
-        import_child_process2.spawn(appPath, [], { detached: true, stdio: "ignore" });
+        import_child_process3.spawn(appPath, [], { detached: true, stdio: "ignore" });
         break;
     }
     process.exit(0);
@@ -10370,7 +10634,7 @@ class AutoUpdater extends import_events3.EventEmitter {
   async computeFileHash(filePath) {
     return new Promise((resolve, reject) => {
       const hash = import_crypto3.createHash("sha256");
-      const stream = import_fs3.createReadStream(filePath);
+      const stream = import_fs4.createReadStream(filePath);
       stream.on("data", (chunk) => hash.update(chunk));
       stream.on("end", () => resolve(hash.digest("hex")));
       stream.on("error", reject);
@@ -10395,7 +10659,7 @@ class AutoUpdater extends import_events3.EventEmitter {
     } catch {
       return false;
     }
-    const data = import_fs3.readFileSync(filePath);
+    const data = import_fs4.readFileSync(filePath);
     if (algo === "ed25519") {
       return verify(null, data, publicKey, sigBytes);
     }
@@ -10413,18 +10677,32 @@ class AutoUpdater extends import_events3.EventEmitter {
 }
 
 class DeltaGenerator {
+  static supported = null;
+  static isSupported() {
+    if (DeltaGenerator.supported !== null)
+      return DeltaGenerator.supported;
+    DeltaGenerator.supported = ["bspatch", "xdelta3"].some((tool) => {
+      try {
+        import_child_process3.execFileSync("command", ["-v", tool], { stdio: "ignore", shell: true });
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    return DeltaGenerator.supported;
+  }
   static async generate(oldPath, newPath, outputPath) {
     try {
-      import_child_process2.execFileSync("bsdiff", [oldPath, newPath, outputPath]);
-      const stats = import_fs3.statSync(outputPath);
+      import_child_process3.execFileSync("bsdiff", [oldPath, newPath, outputPath]);
+      const stats = import_fs4.statSync(outputPath);
       const hash = await DeltaGenerator.computeHash(outputPath);
       return {
         size: stats.size,
         sha256: hash
       };
     } catch {
-      import_child_process2.execFileSync("xdelta3", ["-e", "-s", oldPath, newPath, outputPath]);
-      const stats = import_fs3.statSync(outputPath);
+      import_child_process3.execFileSync("xdelta3", ["-e", "-s", oldPath, newPath, outputPath]);
+      const stats = import_fs4.statSync(outputPath);
       const hash = await DeltaGenerator.computeHash(outputPath);
       return {
         size: stats.size,
@@ -10434,15 +10712,15 @@ class DeltaGenerator {
   }
   static async apply(basePath, deltaPath, outputPath) {
     try {
-      import_child_process2.execFileSync("bspatch", [basePath, outputPath, deltaPath]);
+      import_child_process3.execFileSync("bspatch", [basePath, outputPath, deltaPath]);
     } catch {
-      import_child_process2.execFileSync("xdelta3", ["-d", "-s", basePath, deltaPath, outputPath]);
+      import_child_process3.execFileSync("xdelta3", ["-d", "-s", basePath, deltaPath, outputPath]);
     }
   }
   static async computeHash(filePath) {
     return new Promise((resolve, reject) => {
       const hash = import_crypto3.createHash("sha256");
-      const stream = import_fs3.createReadStream(filePath);
+      const stream = import_fs4.createReadStream(filePath);
       stream.on("data", (chunk) => hash.update(chunk));
       stream.on("end", () => resolve(hash.digest("hex")));
       stream.on("error", reject);
@@ -10459,7 +10737,7 @@ function generateUpdateManifest(options) {
   for (const [platform, info] of Object.entries(options.platforms)) {
     if (!info)
       continue;
-    const bytes = import_fs3.readFileSync(info.path);
+    const bytes = import_fs4.readFileSync(info.path);
     const hash = import_crypto3.createHash("sha256").update(bytes).digest("hex");
     manifest.platforms[platform] = {
       url: info.url,
@@ -10469,7 +10747,7 @@ function generateUpdateManifest(options) {
     };
     const platformDeltas = options.deltas?.filter((d) => d.platform === platform) || [];
     for (const delta of platformDeltas) {
-      const deltaBytes = import_fs3.readFileSync(delta.path);
+      const deltaBytes = import_fs4.readFileSync(delta.path);
       const deltaHash = import_crypto3.createHash("sha256").update(deltaBytes).digest("hex");
       manifest.platforms[platform].delta.push({
         fromVersion: delta.fromVersion,
@@ -10538,7 +10816,7 @@ ${update.releaseNotes}`);
         releaseDate: new Date().toISOString(),
         platforms: {}
       };
-      import_fs3.writeFileSync(outputPath, JSON.stringify(manifest, null, 2));
+      import_fs4.writeFileSync(outputPath, JSON.stringify(manifest, null, 2));
       console.log(`Manifest generated: ${outputPath}`);
       console.log("Edit the file to add platform-specific update URLs");
       break;
@@ -10564,7 +10842,7 @@ Examples:
 var updater_default = AutoUpdater;
 
 // src/index.ts
-var execFileAsync = import_node_util.promisify(import_node_child_process.execFile);
+var execFileAsync2 = import_node_util.promisify(import_node_child_process.execFile);
 var versionMismatchWarned = false;
 function getSdkVersion() {
   try {
@@ -10578,7 +10856,7 @@ async function probeBinaryVersion(craftPath) {
   if (versionMismatchWarned)
     return;
   try {
-    const { stdout } = await execFileAsync(craftPath, ["--version"], { timeout: 2000 });
+    const { stdout } = await execFileAsync2(craftPath, ["--version"], { timeout: 2000 });
     const nativeVersion = parseCraftVersionOutput(stdout);
     const sdkVersion = getSdkVersion();
     if (sdkVersion !== "unknown" && nativeVersion && nativeVersion !== sdkVersion) {