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

package/dist/index.js

@@ -1,43 +1,30 @@
-import {
-  __require,
-  getAppVersion,
-  getEntryVersion,
-  getPathFromAppNameAsar,
-  isDev,
-  isUpdateJSON,
-  restartApp,
-  unzipFile
-} from "./chunk-RSLOPAIZ.js";
-
-// 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";
+import { isDev, getPathFromAppNameAsar, getEntryVersion, getAppVersion, restartApp } from './chunk-PNYRQYFC.js';
+import { isUpdateJSON, __require } from './chunk-BVFQWBLK.js';
+import { join } from 'node:path';
+import { existsSync, rmSync, renameSync } from 'node:fs';
+import { app } from 'electron';
+import { EventEmitter } from 'node:events';
 
 // src/updater/types.ts
 var ErrorInfo = {
   download: "Download failed",
   validate: "Validate failed",
   param: "Missing params",
-  version: "Unsatisfied version"
+  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 {
+var Updater = class extends EventEmitter {
   CERT = __EIU_SIGNATURE_CERT__;
   info;
-  options;
   asarPath;
-  gzipPath;
   tmpFilePath;
   provider;
   /**
@@ -45,141 +32,134 @@ var Updater = class {
    */
   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;
   /**
-   * 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 force update in DEV
    */
-  handleURL;
-  /**
-   * whether receive beta version
-   */
-  get receiveBeta() {
-    return !!this.options.receiveBeta;
-  }
-  set receiveBeta(receiveBeta) {
-    this.options.receiveBeta = receiveBeta;
-  }
+  forceUpdate;
   /**
    * initialize incremental updater
    * @param provider update provider
    * @param option UpdaterOption
    */
   constructor(provider, option = {}) {
+    super();
     this.provider = provider;
-    this.options = option;
+    this.receiveBeta = option.receiveBeta;
     if (option.SIGNATURE_CERT) {
       this.CERT = option.SIGNATURE_CERT;
     }
     if (option.logger) {
       this.logger = option.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) {
-    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})`);
-    }
-    this.logger?.info(`check update: current version is ${appVersion}, new version is ${version}`);
-    return await isLowerVersion(appVersion, version);
-  }
-  async parseData(format, data) {
+  async fetch(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);
-    }
     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) {
-    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;
-      }
-      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 };
-      }
-    } catch (error) {
-      this.logger?.error("check update failed", error);
-      return {
-        success: false,
-        data: error instanceof UpdaterError ? error : new UpdaterError(ErrorInfo.download, error.toString())
-      };
+    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, size, version, minimumVersion, beta } = _data;
+    if (this.receiveBeta) {
+      version = beta.version;
+      signature = beta.signature;
+      minimumVersion = beta.minimumVersion;
+      size = beta.size;
+    }
+    this.logger?.debug(`checked update, version: ${version}, size: ${size}, 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();
+    if (isLowerVersion(entryVersion, minimumVersion)) {
+      return emitUnavailable(`entry version (${entryVersion}) < minimumVersion (${minimumVersion})`);
+    }
+    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})`);
     }
+    this.logger?.info(`update available: ${version}`);
+    this.info = { signature, minimumVersion, version, size };
+    this.emit("update-available", this.info);
+    return true;
   }
   async download(data, sig) {
+    const _sig = sig ?? this.info?.signature;
+    if (!_sig) {
+      this.err("download failed", "param", "no update signature, please call `checkUpdate` first");
+      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");
+    const _ver = await this.provider.verifySignaure(buffer, _sig, this.CERT);
+    if (!_ver) {
+      this.err("download failed", "validate", "invalid signature / certificate pair");
+      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);
+      await this.provider.unzipFile(buffer, this.tmpFilePath);
       this.logger?.info(`download success, version: ${_ver}`);
       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;
     }
   }
   /**
@@ -189,6 +169,19 @@ var Updater = class {
     this.logger?.info("quit and install");
     restartApp();
   }
+  /**
+   * setup provider URL handler
+   *
+   * @example
+   * updater.setURLHandler((url, isDownloadingAsar) => {
+   *   if (isDownloadingAsar) {
+   *     return url.replace('https://raw.githubusercontent.com', 'https://cdn.jsdelivr.net/gh')
+   *   }
+   * })
+   */
+  setURLHandler(handler) {
+    this.provider.urlHandler = handler;
+  }
 };
 
 // src/entry.ts
@@ -197,7 +190,7 @@ function startupWithUpdater(fn) {
 }
 var defaultOnInstall = (install, _, __, logger) => {
   install();
-  logger.info(`update success!`);
+  logger?.info(`update success!`);
 };
 async function initApp(appOptions) {
   const {
@@ -213,31 +206,34 @@ async function initApp(appOptions) {
   } else {
     updaterInstance = await updater();
   }
-  const logger = updaterInstance.logger || console;
+  let logger = updaterInstance.logger;
+  if (isDev && !logger) {
+    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)
+    };
+  }
   try {
     const appNameAsarPath = getPathFromAppNameAsar();
     const tempAsarPath = `${appNameAsarPath}.tmp`;
-    if (existsSync2(tempAsarPath)) {
-      logger.info(`installing new asar: ${tempAsarPath}`);
+    if (existsSync(tempAsarPath)) {
+      logger?.info(`installing new asar: ${tempAsarPath}`);
       await onInstall(() => renameSync(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
     }
     const mainFilePath = join(
-      isDev ? join(app2.getAppPath(), __EIU_MAIN_DEV_DIR__) : appNameAsarPath,
+      isDev ? 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, initApp, startupWithUpdater };

package/dist/provider.cjs

@@ -1,58 +1,11 @@
-"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);
-
-// src/provider/index.ts
-var provider_exports = {};
-__export(provider_exports, {
-  GitHubProvider: () => GitHubProvider,
-  downloadAsarBufferDefault: () => downloadAsarBufferDefault,
-  downloadUpdateJSONDefault: () => downloadUpdateJSONDefault
-});
-module.exports = __toCommonJS(provider_exports);
-
-// src/utils/electron.ts
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-var import_electron = require("electron");
-var isDev = __EIU_IS_DEV__;
-var isWin = process.platform === "win32";
-var isMac = process.platform === "darwin";
-var isLinux = process.platform === "linux";
-function waitAppReady(timeout = 1e3) {
-  return import_electron.app.isReady() ? Promise.resolve() : new Promise((resolve, reject) => {
-    const _ = setTimeout(() => {
-      reject(new Error("app is not ready"));
-    }, timeout);
-    import_electron.app.whenReady().then(() => {
-      clearTimeout(_);
-      resolve();
-    });
-  });
-}
+'use strict';
 
-// src/utils/zip.ts
-var import_node_fs2 = require("fs");
-var import_node_zlib = require("zlib");
+var electron = require('electron');
+var crypto = require('crypto');
+var fs = require('fs');
+var zlib = require('zlib');
 
-// src/utils/unzip.ts
-var import_node_fs3 = require("fs");
-var import_node_zlib2 = require("zlib");
+// src/provider/download.ts
 
 // src/utils/version.ts
 function parseVersion(version) {
@@ -78,7 +31,7 @@ function parseVersion(version) {
   }
   return ret;
 }
-function isLowerVersionDefault(oldVer, newVer) {
+function defaultIsLowerVersion(oldVer, newVer) {
   const oldV = parseVersion(oldVer);
   const newV = parseVersion(newVer);
   function compareStrings(str1, str2) {
@@ -103,42 +56,11 @@ function isUpdateJSON(json) {
   return is(json) && is(json?.beta);
 }
 
-// src/utils/crypto/decrypt.ts
-var import_node_crypto2 = require("crypto");
-
-// src/utils/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);
-}
-
-// src/utils/crypto/decrypt.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 verifySignatureDefault(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 : void 0;
-  } catch (error) {
-    return void 0;
-  }
-}
-
-// src/utils/crypto/encrypt.ts
-var import_node_crypto3 = require("crypto");
-
 // src/provider/download.ts
-var import_electron2 = require("electron");
-async function downlaodFn(url, headers, onResponse) {
-  await waitAppReady();
+async function downloadFn(url, headers, onResponse) {
+  await electron.app.whenReady();
   return new Promise((resolve, reject) => {
-    const request = import_electron2.net.request({ url, method: "GET", redirect: "follow" });
+    const request = electron.net.request({ url, method: "GET", redirect: "follow" });
     Object.keys(headers).forEach((key) => request.setHeader(key, headers[key]));
     request.on("response", (resp) => {
       resp.on("aborted", () => reject(new Error("aborted")));
@@ -149,8 +71,8 @@ async function downlaodFn(url, headers, onResponse) {
     request.end();
   });
 }
-async function downloadUpdateJSONDefault(url, headers) {
-  return await downlaodFn(url, headers, (resp, resolve, reject) => {
+async function defaultDownloadUpdateJSON(url, headers) {
+  return await downloadFn(url, headers, (resp, resolve, reject) => {
     let data = "";
     resp.on("data", (chunk) => data += chunk);
     resp.on("end", () => {
@@ -161,67 +83,120 @@ async function downloadUpdateJSONDefault(url, headers) {
         } else {
           throw Error;
         }
-      } catch (ignore) {
+      } catch {
         reject(new Error("invalid update json"));
       }
     });
   });
 }
-async function downloadAsarBufferDefault(url, headers, total, onDownloading) {
-  let current = 0;
-  return await downlaodFn(url, headers, (resp, resolve) => {
+async function defaultDownloadAsar(url, headers, total, onDownloading) {
+  let transferred = 0;
+  let time = Date.now();
+  return await downloadFn(url, headers, (resp, resolve) => {
     let data = [];
     resp.on("data", (chunk) => {
-      current += chunk.length;
-      onDownloading?.({ percent: `${+(current / total).toFixed(2) * 100}%`, total, current });
+      transferred += chunk.length;
+      const current = Date.now();
+      onDownloading?.({
+        percent: +(transferred / total).toFixed(2) * 100,
+        total,
+        transferred,
+        delta: chunk.length,
+        bps: chunk.length / ((current - time) * 1e3)
+      });
+      time = current;
       data.push(chunk);
     });
     resp.on("end", () => resolve(Buffer.concat(data)));
   });
 }
+function hashBuffer(data, length) {
+  const hash = crypto.createHash("SHA256").update(data).digest("binary");
+  return Buffer.from(hash).subarray(0, length);
+}
+function aesDecrypt(encryptedText, key, iv) {
+  const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+  return decipher.update(encryptedText, "base64url", "utf8") + decipher.final("utf8");
+}
+function defaultVerify(buffer, signature, cert) {
+  try {
+    const [sig, version] = aesDecrypt(signature, hashBuffer(cert, 32), hashBuffer(buffer, 16)).split("%");
+    const result = crypto.createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+    return result ? version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function defaultUnzipFile(buffer, targetFilePath) {
+  return new Promise((resolve, reject) => {
+    zlib.brotliDecompress(buffer, (err, buffer2) => {
+      if (err) {
+        reject(err);
+      }
+      fs.writeFileSync(targetFilePath, buffer2);
+      resolve();
+    });
+  });
+}
+
+// src/provider/base.ts
+var BaseProvider = class {
+  name = "BaseProvider";
+  isLowerVersion = defaultIsLowerVersion;
+  verifySignaure = defaultVerify;
+  unzipFile = defaultUnzipFile;
+};
 
 // src/provider/github.ts
-var GitHubProvider = class {
+var GitHubProvider = class extends BaseProvider {
   ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36";
   name = "GithubProvider";
   urlHandler;
   url;
   extraHeaders;
+  /**
+   * Update Provider for Github repo
+   * - download update json from `https://raw.githubusercontent.com/{user}/{repo}/HEAD/{versionPath}`
+   * - download update asar from `https://github.com/{user}/{repo}/releases/download/v{version}/{name}-{version}.asar.gz`
+   *
+   * you can setup `urlHandler` in {@link GitHubProviderOptions} or `Updater` to modify url before request
+   * @param options provider options
+   */
   constructor(options) {
-    this.url = new URL(options.url);
+    super();
     this.extraHeaders = options.extraHeaders;
     this.urlHandler = options.urlHandler;
-    if (this.url.host !== "github.com") {
+    if (!options.url.startsWith("https://github.com")) {
       throw new Error(`${this.name}: invalid github url: ${options.url}`);
     }
-    if (!this.url.pathname.endsWith("/")) {
-      this.url.pathname += "/";
+    this.url = options.url;
+    if (!this.url.endsWith("/")) {
+      this.url += "/";
     }
   }
-  parseURL(isDownloadAsar, path) {
-    const url = this.url.href + path;
-    return this.urlHandler ? this.urlHandler(url, isDownloadAsar) : url;
+  async parseURL(isDownloadAsar, extraPath) {
+    const _url = new URL(this.url);
+    _url.hostname = isDownloadAsar ? "github.com" : "raw.githubusercontent.com";
+    _url.pathname += extraPath;
+    return (await this.urlHandler?.(_url, isDownloadAsar) || _url).toString();
   }
-  isLowerVersion = isLowerVersionDefault;
-  verifySignaure = verifySignatureDefault;
   async downloadJSON(versionPath) {
-    return await downloadUpdateJSONDefault(
-      this.parseURL(false, `HEAD/${versionPath}`),
+    return await defaultDownloadUpdateJSON(
+      await this.parseURL(false, `HEAD/${versionPath}`),
       { userAgent: this.ua, accept: "application/json", ...this.extraHeaders }
     );
   }
-  async downloadBuffer(name, { version, size }, onDownloading) {
-    return await downloadAsarBufferDefault(
-      this.parseURL(true, `releases/download/v${version}/${name}-${version}.asar.gz`),
+  async downloadAsar(name, { version, size }, onDownloading) {
+    return await defaultDownloadAsar(
+      await this.parseURL(true, `releases/download/v${version}/${name}-${version}.asar.gz`),
       { userAgent: this.ua, accept: "application/octet-stream", ...this.extraHeaders },
       size,
       onDownloading
     );
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  GitHubProvider,
-  downloadAsarBufferDefault,
-  downloadUpdateJSONDefault
-});
+
+exports.BaseProvider = BaseProvider;
+exports.GitHubProvider = GitHubProvider;
+exports.defaultDownloadAsar = defaultDownloadAsar;
+exports.defaultDownloadUpdateJSON = defaultDownloadUpdateJSON;