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

package/dist/index.js

@@ -1,185 +1,167 @@
-import {
-  __require,
-  getAppVersion,
-  getEntryVersion,
-  getPathFromAppNameAsar,
-  isDev,
-  isUpdateJSON,
-  restartApp,
-  unzipFile
-} from "./chunk-RSLOPAIZ.js";
+import { isDev, getEntryVersion, getAppVersion, getPathFromAppNameAsar, restartApp } from './chunk-4MH6ZXCY.js';
+import { isUpdateJSON, __require } from './chunk-72ZAJ7AF.js';
+import fs2 from 'node:fs';
+import { EventEmitter } from 'node:events';
+import { app } from 'electron';
+import path from 'node:path';
 
-// src/entry.ts
-import { join } from "node:path";
-import { existsSync as existsSync2, renameSync } from "node:fs";
-import { app as app2 } from "electron";
-
-// src/updater/core.ts
-import { existsSync, rmSync, writeFileSync } from "node:fs";
-import { app } from "electron";
-
-// src/updater/types.ts
+// src/entry/types.ts
 var ErrorInfo = {
-  download: "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);
+    super("[" + ErrorInfo[msg] + "] " + info);
+    this.code = msg;
   }
 };
 
-// src/updater/core.ts
-var Updater = class {
+// src/entry/updater.ts
+var Updater = class extends EventEmitter {
   CERT = __EIU_SIGNATURE_CERT__;
   info;
-  options;
-  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}`)
-   * }
-   */
-  onDownloading;
-  /**
-   * URL handler hook
-   *
-   * for Github, there are some {@link https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L34 public CDN links}
-   * @param url source url
-   * @param isDownloadAsar whether is download asar
+   * Whether to receive beta update
    */
-  handleURL;
+  receiveBeta;
   /**
-   * whether receive beta version
+   * Whether force update in DEV
    */
-  get receiveBeta() {
-    return !!this.options.receiveBeta;
-  }
-  set receiveBeta(receiveBeta) {
-    this.options.receiveBeta = receiveBeta;
-  }
+  forceUpdate;
   /**
-   * initialize incremental updater
-   * @param provider update provider
-   * @param option UpdaterOption
+   * Initialize incremental updater
+   * @param options UpdaterOption
    */
-  constructor(provider, option = {}) {
-    this.provider = provider;
-    this.options = 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");
     }
-    if (option.logger) {
-      this.logger = option.logger;
+    if (!this.provider) {
+      this.logger?.debug("No update provider, please setup provider before checking update");
     }
-    this.asarPath = getPathFromAppNameAsar();
-    this.gzipPath = `${this.asarPath}.gz`;
-    this.tmpFilePath = `${this.asarPath}.tmp`;
   }
-  async needUpdate(version, minVersion) {
-    if (isDev) {
-      this.logger?.warn(`in dev mode, skip check update`);
-      return false;
-    }
-    const isLowerVersion = this.provider.isLowerVersion;
-    const entryVersion = getEntryVersion();
-    const appVersion = getAppVersion();
-    if (await isLowerVersion(entryVersion, minVersion)) {
-      throw new UpdaterError(ErrorInfo.version, `entry version (${entryVersion}) < minimumVersion (${minVersion})`);
+  checkProvider() {
+    if (!this.provider) {
+      throw new UpdaterError("param", "missing update provider");
     }
-    this.logger?.info(`check update: current version is ${appVersion}, new version is ${version}`);
-    return await isLowerVersion(appVersion, version);
   }
-  async parseData(format, data) {
-    if (existsSync(this.tmpFilePath)) {
-      this.logger?.warn(`remove tmp file: ${this.tmpFilePath}`);
-      rmSync(this.tmpFilePath);
-    }
-    if (existsSync(this.gzipPath)) {
-      this.logger?.warn(`remove .gz file: ${this.gzipPath}`);
-      rmSync(this.gzipPath);
-    }
+  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;
       }
     }
     this.logger?.debug(`download from ${this.provider.name}`);
     try {
-      const result = format === "json" ? await this.provider.downloadJSON(data ?? __EIU_VERSION_PATH__) : await this.provider.downloadBuffer(app.name, this.info, this.onDownloading);
+      const result = format === "json" ? await this.provider.downloadJSON(data ?? __EIU_VERSION_PATH__) : await this.provider.downloadAsar(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) {
-      this.logger?.warn(`download ${format} failed: ${e}`);
-      throw new UpdaterError(ErrorInfo.download, `download ${format} failed: ${e}`);
+      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 update, version: ${version}, size: ${size}, signature: ${signature}`);
-      if (!await this.needUpdate(version, minimumVersion)) {
-        this.logger?.info(`update unavailable: ${version} is the latest version`);
-        return { success: false, data: version };
-      } else {
-        this.logger?.info(`update available: ${version}`);
-        this.info = { signature, minimumVersion, version, size };
-        return { success: true, data: 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 {
-        success: false,
-        data: error instanceof UpdaterError ? error : new UpdaterError(ErrorInfo.download, error.toString())
-      };
+      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 {
-      if (!this.info) {
-        throw new UpdaterError(ErrorInfo.param, "no update info");
-      }
-      const _sig = sig ?? this.info.signature;
-      const buffer = await this.parseData("buffer", data);
-      this.logger?.debug("verify start");
-      const _ver = await this.provider.verifySignaure(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}`);
-      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}`);
+      fs2.writeFileSync(tmpFilePath, await this.provider.unzipFile(buffer));
+      this.logger?.info(`download success, version: ${_version}`);
       this.info = void 0;
-      return { success: true };
+      this.emit("update-downloaded");
+      return true;
     } catch (error) {
-      this.logger?.error("download asar failed", error);
-      return {
-        success: false,
-        data: error instanceof UpdaterError ? error : new UpdaterError(ErrorInfo.download, error.toString())
-      };
+      this.err("download failed", "download", `fail to unwrap asar file, ${error}`);
+      return false;
     }
   }
   /**
@@ -190,18 +172,20 @@ var Updater = class {
     restartApp();
   }
 };
-
-// src/entry.ts
+async function autoUpdate(updater) {
+  if (await updater.checkUpdate() && await updater.downloadUpdate()) {
+    updater.quitAndInstall();
+  }
+}
 function startupWithUpdater(fn) {
   return fn;
 }
 var defaultOnInstall = (install, _, __, logger) => {
   install();
-  logger.info(`update success!`);
+  logger?.info(`update success!`);
 };
-async function initApp(appOptions) {
+async function initApp(appOptions = {}) {
   const {
-    provider,
     updater,
     onInstall = defaultOnInstall,
     beforeStart,
@@ -209,35 +193,30 @@ async function initApp(appOptions) {
   } = appOptions;
   let updaterInstance;
   if (typeof updater === "object" || !updater) {
-    updaterInstance = new Updater(provider, updater);
+    updaterInstance = new Updater(updater);
   } else {
     updaterInstance = await updater();
   }
-  const logger = updaterInstance.logger || console;
+  const logger = updaterInstance.logger;
   try {
     const appNameAsarPath = getPathFromAppNameAsar();
     const tempAsarPath = `${appNameAsarPath}.tmp`;
-    if (existsSync2(tempAsarPath)) {
-      logger.info(`installing new asar: ${tempAsarPath}`);
-      await onInstall(() => renameSync(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
+    if (fs2.existsSync(tempAsarPath)) {
+      logger?.info(`installing new asar: ${tempAsarPath}`);
+      await onInstall(() => fs2.renameSync(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
     }
-    const mainFilePath = join(
-      isDev ? join(app2.getAppPath(), __EIU_MAIN_DEV_DIR__) : appNameAsarPath,
+    const mainFilePath = path.join(
+      isDev ? path.join(app.getAppPath(), __EIU_MAIN_DEV_DIR__) : appNameAsarPath,
       "main",
       __EIU_MAIN_FILE__
     );
     await beforeStart?.(mainFilePath, logger);
     __require(mainFilePath)(updaterInstance);
   } catch (error) {
-    logger.error("startup error", error);
+    logger?.error("startup error", error);
     onStartError?.(error, logger);
-    app2.quit();
+    app.quit();
   }
 }
-export {
-  ErrorInfo,
-  Updater,
-  UpdaterError,
-  initApp,
-  startupWithUpdater
-};
+
+export { ErrorInfo, Updater, UpdaterError, autoUpdate, initApp, startupWithUpdater };