electron-incremental-update 1.3.0 → 2.0.0-beta.10

package/dist/index.cjs

@@ -1,403 +1,202 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  ErrorInfo: () => ErrorInfo,
-  Updater: () => Updater,
-  UpdaterError: () => UpdaterError,
-  createUpdater: () => createUpdater,
-  downloadBufferDefault: () => downloadBufferDefault,
-  downloadJSONDefault: () => downloadJSONDefault,
-  initApp: () => initApp,
-  isLowerVersionDefault: () => isLowerVersionDefault,
-  startupWithUpdater: () => startupWithUpdater
-});
-module.exports = __toCommonJS(src_exports);
-var import_node_path2 = require("path");
-var import_node_fs4 = require("fs");
-var import_electron4 = require("electron");
+var fs3 = require('fs');
+var events = require('events');
+var electron = require('electron');
+var path = require('path');
 
-// src/updater/core.ts
-var import_node_fs3 = require("fs");
-var import_electron3 = require("electron");
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-// src/utils/electron.ts
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-var import_node_os = require("os");
-var import_electron = require("electron");
-var is = {
-  dev: !import_electron.app.isPackaged,
-  win: process.platform === "win32",
-  mac: process.platform === "darwin",
-  linux: process.platform === "linux"
-};
-function getPathFromAppNameAsar(...path) {
-  return is.dev ? "DEV.asar" : (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getAppPath()), `${import_electron.app.name}.asar`, ...path);
-}
-function getVersions() {
-  const platform = is.win ? "Windows" : is.mac ? "MacOS" : process.platform.toUpperCase();
-  return {
-    appVersion: is.dev ? import_electron.app.getVersion() : (0, import_node_fs.readFileSync)(getPathFromAppNameAsar("version"), "utf-8"),
-    entryVersion: import_electron.app.getVersion(),
-    electronVersion: process.versions.electron,
-    nodeVersion: process.versions.node,
-    systemVersion: `${platform} ${(0, import_node_os.release)()}`
-  };
-}
-function restartApp() {
-  import_electron.app.relaunch();
-  import_electron.app.quit();
-}
-function waitAppReady(timeout = 1e3) {
-  return import_electron.app.isReady() ? Promise.resolve() : new Promise((resolve2, reject) => {
-    const _ = setTimeout(() => {
-      reject(new Error("app is not ready"));
-    }, timeout);
-    import_electron.app.whenReady().then(() => {
-      clearTimeout(_);
-      resolve2();
-    });
-  });
-}
+var fs3__default = /*#__PURE__*/_interopDefault(fs3);
+var path__default = /*#__PURE__*/_interopDefault(path);
 
-// src/utils/zip.ts
-var import_node_fs2 = require("fs");
-var import_node_zlib = require("zlib");
-async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
-  if (!(0, import_node_fs2.existsSync)(gzipPath)) {
-    throw new Error(`path to zipped file not exist: ${gzipPath}`);
-  }
-  const compressedBuffer = (0, import_node_fs2.readFileSync)(gzipPath);
-  return new Promise((resolve2, reject) => {
-    (0, import_node_zlib.brotliDecompress)(compressedBuffer, (err, buffer) => {
-      (0, import_node_fs2.rmSync)(gzipPath);
-      if (err) {
-        reject(err);
-      }
-      (0, import_node_fs2.writeFileSync)(targetFilePath, buffer);
-      resolve2(null);
-    });
-  });
-}
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
-// src/utils/pure.ts
-function parseVersion(version) {
-  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z0-9.-]+))?/i.exec(version);
-  if (!match) {
-    throw new TypeError(`invalid version: ${version}`);
-  }
-  const [major, minor, patch] = match.slice(1, 4).map(Number);
-  const ret = {
-    major,
-    minor,
-    patch,
-    stage: "",
-    stageVersion: -1
-  };
-  if (match[4]) {
-    let [stage, _v] = match[4].split(".");
-    ret.stage = stage;
-    ret.stageVersion = Number(_v) || -1;
-  }
-  if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch) || Number.isNaN(ret.stageVersion)) {
-    throw new TypeError(`invalid version: ${version}`);
-  }
-  return ret;
-}
+// src/utils/version.ts
 function isUpdateJSON(json) {
-  const is2 = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
-  return is2(json) && is2(json?.beta);
+  const is = (j) => !!(j && j.minimumVersion && j.signature && j.version);
+  return is(json) && is(json?.beta);
 }
-
-// src/crypto/dec.ts
-var import_node_crypto2 = require("crypto");
-
-// src/crypto/utils.ts
-var import_node_crypto = require("crypto");
-function hashString(data, length) {
-  const hash = (0, import_node_crypto.createHash)("SHA256").update(data).digest("binary");
-  return Buffer.from(hash).subarray(0, length);
+var isDev = __EIU_IS_DEV__;
+process.platform === "win32";
+process.platform === "darwin";
+process.platform === "linux";
+function getPathFromAppNameAsar(...paths) {
+  return isDev ? "DEV.asar" : path__default.default.join(path__default.default.dirname(electron.app.getAppPath()), `${electron.app.name}.asar`, ...paths);
 }
-
-// src/crypto/dec.ts
-function decrypt(encryptedText, key, iv) {
-  const decipher = (0, import_node_crypto2.createDecipheriv)("aes-256-cbc", key, iv);
-  let decrypted = decipher.update(encryptedText, "base64url", "utf8");
-  decrypted += decipher.final("utf8");
-  return decrypted;
+function getAppVersion() {
+  return isDev ? getEntryVersion() : fs3__default.default.readFileSync(getPathFromAppNameAsar("version"), "utf-8");
+}
+function getEntryVersion() {
+  return electron.app.getVersion();
+}
+function restartApp() {
+  electron.app.relaunch();
+  electron.app.quit();
 }
-var verify = (buffer, signature, cert) => {
-  try {
-    const [sig, version] = decrypt(signature, hashString(cert, 32), hashString(buffer, 16)).split("%");
-    const result = (0, import_node_crypto2.createVerify)("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
-    return result ? version : false;
-  } catch (error) {
-    return false;
-  }
-};
-
-// src/crypto/enc.ts
-var import_node_crypto3 = require("crypto");
 
-// src/updater/types.ts
+// src/entry/types.ts
 var ErrorInfo = {
-  downlaod: "Download failed",
-  validate: "Validate failed",
-  param: "Missing params",
-  version: "Unsatisfied version"
+  download: "Download Failed",
+  validate: "Validate Failed",
+  param: "Missing Params",
+  network: "Network Error"
 };
 var UpdaterError = class extends Error {
+  code;
   constructor(msg, info) {
-    super(msg + ": " + info);
-  }
-};
-
-// src/updater/defaultFunctions/download.ts
-var import_electron2 = require("electron");
-async function downlaodFn(url, headers, onResponse) {
-  await waitAppReady();
-  return new Promise((resolve2, reject) => {
-    const request = import_electron2.net.request({ url, method: "GET", redirect: "follow" });
-    Object.keys(headers).forEach((key) => request.setHeader(key, headers[key]));
-    request.on("response", (res) => onResponse(res, resolve2, reject));
-    request.on("error", reject);
-    request.end();
-  });
-}
-var downloadJSONDefault = async (url, headers) => {
-  return await downlaodFn(url, headers, (resp, resolve2, reject) => {
-    let data = "";
-    resp.on("data", (chunk) => data += chunk);
-    resp.on("end", () => {
-      try {
-        const json = JSON.parse(data);
-        if (isUpdateJSON(json)) {
-          resolve2(json);
-        } else {
-          throw Error;
-        }
-      } catch (ignore) {
-        reject(new Error("invalid update json"));
-      }
-    });
-    resp.on("aborted", () => reject(new Error("aborted")));
-    resp.on("error", () => reject(new Error("download error")));
-  });
-};
-var downloadBufferDefault = async (url, headers, total, onDownloading) => {
-  let current = 0;
-  return await downlaodFn(url, headers, (resp, resolve2, reject) => {
-    let data = [];
-    resp.on("data", (chunk) => {
-      current += chunk.length;
-      onDownloading?.({ percent: `${+(current / total).toFixed(2) * 100}%`, total, current });
-      data.push(chunk);
-    });
-    resp.on("end", () => resolve2(Buffer.concat(data)));
-    resp.on("aborted", () => reject(new Error("aborted")));
-    resp.on("error", () => reject(new Error("download error")));
-  });
-};
-
-// src/updater/defaultFunctions/compareVersion.ts
-var isLowerVersionDefault = (version1, version2) => {
-  const oldV = parseVersion(version1);
-  const newV = parseVersion(version2);
-  function compareStrings(str1, str2) {
-    if (str1 === "") {
-      return str2 !== "";
-    } else if (str2 === "") {
-      return true;
-    }
-    return str1 < str2;
-  }
-  for (let key of Object.keys(oldV)) {
-    if (key === "stage" && compareStrings(oldV[key], newV[key])) {
-      return true;
-    } else if (oldV[key] !== newV[key]) {
-      return oldV[key] < newV[key];
-    }
+    super("[" + ErrorInfo[msg] + "] " + info);
+    this.code = msg;
   }
-  return false;
 };
 
-// src/updater/core.ts
-var Updater = class {
-  CERT = __SIGNATURE_CERT__;
+// src/entry/updater.ts
+var Updater = class extends events.EventEmitter {
+  CERT = __EIU_SIGNATURE_CERT__;
   info;
-  option;
-  asarPath;
-  gzipPath;
-  tmpFilePath;
+  provider;
   /**
-   * updater logger
+   * Updater logger
    */
   logger;
   /**
-   * downloading progress hook
-   * @param progress download progress
-   * @example
-   * updater.onDownloading = ({ percent, total, current }) => {
-   *   console.log(`download progress: ${percent}, total: ${total}, current: ${current}`)
-   * }
+   * Whether to receive beta update
    */
-  onDownloading;
+  receiveBeta;
   /**
-   * whether receive beta version
+   * Whether force update in DEV
    */
-  get receiveBeta() {
-    return !!this.option.receiveBeta;
-  }
-  set receiveBeta(receiveBeta) {
-    this.option.receiveBeta = receiveBeta;
-  }
+  forceUpdate;
   /**
-   * initialize incremental updater
-   * @param option UpdaterOption
+   * Initialize incremental updater
+   * @param options UpdaterOption
    */
-  constructor(option = {}) {
-    this.option = option;
-    if (option.SIGNATURE_CERT) {
-      this.CERT = option.SIGNATURE_CERT;
+  constructor(options = {}) {
+    super();
+    this.provider = options.provider;
+    this.receiveBeta = options.receiveBeta;
+    this.CERT = options.SIGNATURE_CERT || __EIU_SIGNATURE_CERT__;
+    this.logger = options.logger;
+    if (isDev && !this.logger) {
+      this.logger = {
+        info: (...args) => console.log("[EIU-INFO ]", ...args),
+        debug: (...args) => console.log("[EIU-DEBUG]", ...args),
+        warn: (...args) => console.log("[EIU-WARN ]", ...args),
+        error: (...args) => console.error("[EIU-ERROR]", ...args)
+      };
+      this.logger.info("no logger set, enable dev-only logger");
     }
-    this.asarPath = getPathFromAppNameAsar();
-    this.gzipPath = `${this.asarPath}.gz`;
-    this.tmpFilePath = `${this.asarPath}.tmp`;
-  }
-  async needUpdate(version, minVersion) {
-    const isLowerVersion = this.option.overrideFunctions?.isLowerVersion ?? isLowerVersionDefault;
-    const { appVersion, entryVersion } = getVersions();
-    if (await isLowerVersion(entryVersion, minVersion)) {
-      throw new UpdaterError(ErrorInfo.version, `entry version (${entryVersion}) < minimumVersion (${minVersion})`);
+    if (!this.provider) {
+      this.logger?.debug("No update provider, please setup provider before checking update");
     }
-    this.logger?.info(`check update: current version is ${appVersion}, new version is ${version}`);
-    return await isLowerVersion(appVersion, version);
   }
-  async parseData(format, data) {
-    if ((0, import_node_fs3.existsSync)(this.tmpFilePath)) {
-      this.logger?.warn(`remove tmp file: ${this.tmpFilePath}`);
-      (0, import_node_fs3.rmSync)(this.tmpFilePath);
-    }
-    if ((0, import_node_fs3.existsSync)(this.gzipPath)) {
-      this.logger?.warn(`remove .gz file: ${this.gzipPath}`);
-      (0, import_node_fs3.rmSync)(this.gzipPath);
+  checkProvider() {
+    if (!this.provider) {
+      throw new UpdaterError("param", "missing update provider");
     }
+  }
+  async fetch(format, data) {
     if (typeof data === "object") {
       if (format === "json" && isUpdateJSON(data) || format === "buffer" && Buffer.isBuffer(data)) {
         return data;
       } else {
-        throw new UpdaterError(ErrorInfo.param, `invalid type at format '${format}': ${JSON.stringify(data)}`);
+        this.err("invalid type", "param", `invalid type at format '${format}': ${JSON.stringify(data)}`);
+        return;
       }
     }
-    const ua = this.option.downloadConfig?.userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36";
-    const headers = {
-      Accept: `application/${format === "json" ? "json" : "octet-stream"}`,
-      UserAgent: ua,
-      ...this.option.downloadConfig?.extraHeader
-    };
-    this.logger?.debug(`download headers: ${JSON.stringify(headers)}`);
-    const config = format === "json" ? {
-      name: "updateJsonURL",
-      url: this.option.updateJsonURL,
-      repoFallback: `${this.option.repository?.replace("github.com", "raw.githubusercontent.com")}/master/version.json`,
-      fn: this.option.overrideFunctions?.downloadJSON ?? downloadJSONDefault
-    } : {
-      name: "releaseAsarURL",
-      url: this.option.releaseAsarURL,
-      repoFallback: `${this.option.repository}/releases/download/v${this.info?.version}/${import_electron3.app.name}-${this.info?.version}.asar.gz`,
-      fn: this.option.overrideFunctions?.downloadBuffer ?? downloadBufferDefault
-    };
-    data ??= config.url;
-    if (!data) {
-      this.logger?.debug(`no ${config.name}, fallback to use repository`);
-      if (!this.option.repository) {
-        throw new UpdaterError(ErrorInfo.param, `${config.name} or repository is not set`);
-      }
-      if (format === "buffer" && !this.info?.version) {
-        throw new UpdaterError(ErrorInfo.param, "version is not set");
-      }
-      data = config.repoFallback;
-    }
-    this.logger?.debug(`download ${format} from ${data}`);
+    this.logger?.debug(`download from ${this.provider.name}`);
     try {
-      const ret = format === "json" ? await config.fn(data, headers) : await config.fn(data, headers, this.info.size, this.onDownloading);
-      this.logger?.debug(`download ${format} success${format === "buffer" ? `, file size: ${ret.length}` : ""}`);
-      return ret;
+      const result = format === "json" ? await this.provider.downloadJSON(data ?? __EIU_VERSION_PATH__) : await this.provider.downloadAsar(electron.app.name, this.info, (data2) => this.emit("download-progress", data2));
+      this.logger?.debug(`download ${format} success${format === "buffer" ? `, file size: ${result.length}` : ""}`);
+      return result;
     } catch (e) {
-      throw new UpdaterError(ErrorInfo.downlaod, e.toString());
+      this.err(`fetch ${format} failed`, "network", `download ${format} failed: ${e}`);
     }
   }
+  /**
+   * Handle error message and emit error event
+   */
+  err(msg, code, errorInfo) {
+    const err = new UpdaterError(code, errorInfo);
+    this.logger?.error(msg, err);
+    this.emit("error", err);
+  }
   async checkUpdate(data) {
+    this.checkProvider();
+    const emitUnavailable = (msg) => {
+      this.logger?.info(msg);
+      this.emit("update-unavailable", msg);
+      return false;
+    };
+    const _data = await this.fetch("json", data);
+    if (!_data) {
+      return emitUnavailable("failed to get update info");
+    }
+    let { signature, version, minimumVersion, beta } = _data;
+    if (this.receiveBeta) {
+      version = beta.version;
+      signature = beta.signature;
+      minimumVersion = beta.minimumVersion;
+    }
+    this.logger?.debug(`checked update, version: ${version}, signature: ${signature}`);
+    if (isDev && !this.forceUpdate && !data) {
+      return emitUnavailable("skip check update in dev mode, to force update, set `updater.forceUpdate` to true or call checkUpdate with UpdateJSON");
+    }
+    const isLowerVersion = this.provider.isLowerVersion;
+    const entryVersion = getEntryVersion();
+    const appVersion = getAppVersion();
     try {
-      let { signature, size, version, minimumVersion, beta } = await this.parseData("json", data);
-      if (this.receiveBeta) {
-        version = beta.version;
-        signature = beta.signature;
-        minimumVersion = beta.minimumVersion;
-        size = beta.size;
+      if (isLowerVersion(entryVersion, minimumVersion)) {
+        return emitUnavailable(`entry version (${entryVersion}) < minimumVersion (${minimumVersion})`);
       }
-      this.logger?.debug(`checked version: ${version}, size: ${size}, signature: ${signature}`);
-      if (!await this.needUpdate(version, minimumVersion)) {
-        this.logger?.info(`update unavailable: ${version} is the latest version`);
-        return void 0;
-      } else {
-        this.logger?.info(`update available: ${version}`);
-        this.info = {
-          signature,
-          minimumVersion,
-          version,
-          size
-        };
-        return this.info;
+      this.logger?.info(`check update: current version is ${appVersion}, new version is ${version}`);
+      if (!isLowerVersion(appVersion, version)) {
+        return emitUnavailable(`current version (${appVersion}) < new version (${version})`);
       }
-    } catch (error) {
-      this.logger?.error("check update failed", error);
-      return error;
+      this.logger?.info(`update available: ${version}`);
+      this.info = { signature, minimumVersion, version };
+      this.emit("update-available", this.info);
+      return true;
+    } catch {
+      this.err("Fail to parse version", "validate", "fail to parse version string");
+      return false;
     }
   }
-  async download(data, sig) {
+  async downloadUpdate(data, info) {
+    this.checkProvider();
+    const _sig = info?.signature ?? this.info?.signature;
+    const _version = info?.version ?? this.info?.version;
+    if (!_sig || !_version) {
+      this.err("download failed", "param", "no update signature, please call `checkUpdate` first or manually setup params");
+      return false;
+    }
+    const buffer = await this.fetch("buffer", data ? Buffer.from(data) : void 0);
+    if (!buffer) {
+      this.err("download failed", "param", "no update asar file buffer");
+      return false;
+    }
+    this.logger?.debug("verify start");
+    if (!await this.provider.verifySignaure(buffer, _version, _sig, this.CERT)) {
+      this.err("download failed", "validate", "invalid update asar file");
+      return false;
+    }
+    this.logger?.debug("verify success");
     try {
-      const _sig = sig ?? this.info?.signature;
-      if (!_sig) {
-        throw new UpdaterError(ErrorInfo.param, "signature is empty");
-      }
-      const buffer = await this.parseData("buffer", data);
-      this.logger?.debug("verify start");
-      const _verify = this.option.overrideFunctions?.verifySignaure ?? verify;
-      const _ver = await _verify(buffer, _sig, this.CERT);
-      if (!_ver) {
-        throw new UpdaterError(ErrorInfo.validate, "invalid signature or certificate");
-      }
-      this.logger?.debug("verify success");
-      this.logger?.debug(`write to ${this.gzipPath}`);
-      (0, import_node_fs3.writeFileSync)(this.gzipPath, buffer);
-      this.logger?.debug(`extract to ${this.tmpFilePath}`);
-      await unzipFile(this.gzipPath, this.tmpFilePath);
-      this.logger?.info(`download success, version: ${_ver}`);
+      const tmpFilePath = getPathFromAppNameAsar() + ".tmp";
+      this.logger?.debug(`install to ${tmpFilePath}`);
+      fs3__default.default.writeFileSync(tmpFilePath, await this.provider.unzipFile(buffer));
+      this.logger?.info(`download success, version: ${_version}`);
       this.info = void 0;
+      this.emit("update-downloaded");
       return true;
     } catch (error) {
-      this.logger?.error("download asar failed", error);
-      return error;
+      this.err("download failed", "download", `fail to unwrap asar file, ${error}`);
+      return false;
     }
   }
   /**
@@ -408,13 +207,11 @@ var Updater = class {
     restartApp();
   }
 };
-
-// src/updater/index.ts
-function createUpdater(option) {
-  return new Updater(option);
+async function autoUpdate(updater) {
+  if (await updater.checkUpdate() && await updater.downloadUpdate()) {
+    updater.quitAndInstall();
+  }
 }
-
-// src/index.ts
 function startupWithUpdater(fn) {
   return fn;
 }
@@ -425,23 +222,13 @@ var defaultOnInstall = (install, _, __, logger) => {
 async function initApp(appOptions = {}) {
   const {
     updater,
-    electronDevDistPath = "../dist-electron",
-    mainPath = "main/index.js",
-    hooks
-  } = appOptions || {};
-  const {
     onInstall = defaultOnInstall,
     beforeStart,
     onStartError
-  } = hooks || {};
-  function handleError(err, logger2) {
-    console.error(err);
-    onStartError?.(err, logger2);
-    import_electron4.app.quit();
-  }
+  } = appOptions;
   let updaterInstance;
   if (typeof updater === "object" || !updater) {
-    updaterInstance = createUpdater(updater);
+    updaterInstance = new Updater(updater);
   } else {
     updaterInstance = await updater();
   }
@@ -449,27 +236,27 @@ async function initApp(appOptions = {}) {
   try {
     const appNameAsarPath = getPathFromAppNameAsar();
     const tempAsarPath = `${appNameAsarPath}.tmp`;
-    if ((0, import_node_fs4.existsSync)(tempAsarPath)) {
+    if (fs3__default.default.existsSync(tempAsarPath)) {
       logger?.info(`installing new asar: ${tempAsarPath}`);
-      await onInstall(() => (0, import_node_fs4.renameSync)(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
+      await onInstall(() => fs3__default.default.renameSync(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
     }
-    const mainDir = is.dev ? electronDevDistPath : appNameAsarPath;
-    const entry = (0, import_node_path2.resolve)(__dirname, mainDir, mainPath);
-    await beforeStart?.(entry, logger);
-    require(entry)(updaterInstance);
+    const mainFilePath = path__default.default.join(
+      isDev ? path__default.default.join(electron.app.getAppPath(), __EIU_MAIN_DEV_DIR__) : appNameAsarPath,
+      "main",
+      __EIU_MAIN_FILE__
+    );
+    await beforeStart?.(mainFilePath, logger);
+    __require(mainFilePath)(updaterInstance);
   } catch (error) {
-    handleError(error, logger);
+    logger?.error("startup error", error);
+    onStartError?.(error, logger);
+    electron.app.quit();
   }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ErrorInfo,
-  Updater,
-  UpdaterError,
-  createUpdater,
-  downloadBufferDefault,
-  downloadJSONDefault,
-  initApp,
-  isLowerVersionDefault,
-  startupWithUpdater
-});
+
+exports.ErrorInfo = ErrorInfo;
+exports.Updater = Updater;
+exports.UpdaterError = UpdaterError;
+exports.autoUpdate = autoUpdate;
+exports.initApp = initApp;
+exports.startupWithUpdater = startupWithUpdater;