electron-incremental-update 0.7.7 → 0.7.9

package/dist/index.js

@@ -20,6 +20,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  IncrementalUpdater: () => IncrementalUpdater,
+  MinimumVersionError: () => MinimumVersionError,
+  VerifyFailedError: () => VerifyFailedError,
   createUpdater: () => createUpdater,
   initApp: () => initApp
 });
@@ -29,34 +32,10 @@ var import_node_fs3 = require("fs");
 var import_electron3 = require("electron");
 
 // src/updater/index.ts
-var import_node_events = require("events");
-var import_node_buffer3 = require("buffer");
 var import_node_fs2 = require("fs");
+var import_node_buffer3 = require("buffer");
 var import_promises = require("fs/promises");
 
-// src/crypto.ts
-var import_node_crypto = require("crypto");
-var import_node_buffer = require("buffer");
-function decrypt(encryptedText, key2, iv) {
-  const decipher = (0, import_node_crypto.createDecipheriv)("aes-256-cbc", key2, iv);
-  let decrypted = decipher.update(encryptedText, "base64url", "utf8");
-  decrypted += decipher.final("utf8");
-  return decrypted;
-}
-function key(data, length) {
-  const hash = (0, import_node_crypto.createHash)("SHA256").update(data).digest("binary");
-  return import_node_buffer.Buffer.from(hash).subarray(0, length);
-}
-var verify = (buffer, signature, cert) => {
-  try {
-    const [sig, version] = decrypt(signature, key(cert, 32), key(buffer, 16)).split("%");
-    const result = (0, import_node_crypto.createVerify)("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
-    return result ? version : false;
-  } catch (error) {
-    return false;
-  }
-};
-
 // src/utils.ts
 var import_node_fs = require("fs");
 var import_node_path = require("path");
@@ -68,6 +47,9 @@ function getProductAsarPath(name) {
 function getEntryVersion() {
   return import_electron.app.getVersion();
 }
+function getProductVersion(name) {
+  return import_electron.app.isPackaged ? (0, import_node_fs.readFileSync)((0, import_node_path.join)(getProductAsarPath(name), "version"), "utf-8") : getEntryVersion();
+}
 function waitAppReady(duration = 1e3) {
   return new Promise((resolve2, reject) => {
     const timeout = setTimeout(() => {
@@ -75,11 +57,11 @@ function waitAppReady(duration = 1e3) {
     }, duration);
     import_electron.app.whenReady().then(() => {
       clearTimeout(timeout);
-      resolve2(null);
+      resolve2();
     });
   });
 }
-async function unzipFile(gzipPath, targetFilePath) {
+async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
   if (!(0, import_node_fs.existsSync)(gzipPath)) {
     throw new Error(`path to zipped file not exist: ${gzipPath}`);
   }
@@ -95,18 +77,64 @@ async function unzipFile(gzipPath, targetFilePath) {
     });
   });
 }
+function parseVersion(version) {
+  const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9\.-]+))?/i;
+  const match = semver.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 (isNaN(major) || isNaN(minor) || isNaN(patch) || isNaN(ret.stageVersion)) {
+    throw new TypeError(`invalid version: ${version}`);
+  }
+  return ret;
+}
 
-// src/updater/defaultFunctions.ts
-var import_node_buffer2 = require("buffer");
-var import_electron2 = require("electron");
+// src/crypto.ts
+var import_node_crypto = require("crypto");
+var import_node_buffer = require("buffer");
+function decrypt(encryptedText, key2, iv) {
+  const decipher = (0, import_node_crypto.createDecipheriv)("aes-256-cbc", key2, iv);
+  let decrypted = decipher.update(encryptedText, "base64url", "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+function key(data, length) {
+  const hash = (0, import_node_crypto.createHash)("SHA256").update(data).digest("binary");
+  return import_node_buffer.Buffer.from(hash).subarray(0, length);
+}
+var verify = (buffer, signature, cert) => {
+  try {
+    const [sig, version] = decrypt(signature, key(cert, 32), key(buffer, 16)).split("%");
+    const result = (0, import_node_crypto.createVerify)("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+    return result ? version : false;
+  } catch (error) {
+    return false;
+  }
+};
 
-// src/updater/types.ts
+// src/updateJson.ts
 function isUpdateJSON(json) {
-  return "signature" in json && "version" in json && "size" in json;
+  const is = (j) => "signature" in j && "version" in j && "size" in j && "minimumVersion" in j;
+  return is(json) && "beta" in json && is(json.beta);
 }
 
 // src/updater/defaultFunctions.ts
-async function downloadJSONDefault(url, updater, headers) {
+var import_node_buffer2 = require("buffer");
+var import_electron2 = require("electron");
+var downloadJSONDefault = async (url, headers) => {
   await waitAppReady();
   return new Promise((resolve2, reject) => {
     const request = import_electron2.net.request({
@@ -138,10 +166,10 @@ async function downloadJSONDefault(url, updater, headers) {
     });
     request.end();
   });
-}
-async function downloadBufferDefault(url, updater, headers) {
+};
+var downloadBufferDefault = async (url, headers, total, onDownloading) => {
   await waitAppReady();
-  let progress = 0;
+  let current = 0;
   return new Promise((resolve2, reject) => {
     const request = import_electron2.net.request({
       url,
@@ -154,8 +182,12 @@ async function downloadBufferDefault(url, updater, headers) {
     request.on("response", (res) => {
       let data = [];
       res.on("data", (chunk) => {
-        progress += chunk.length;
-        updater.emit("downloading", progress);
+        current += chunk.length;
+        onDownloading?.({
+          percent: `${+(current / total).toFixed(2) * 100}%`,
+          total,
+          current
+        });
         data.push(chunk);
       });
       res.on("end", () => {
@@ -166,168 +198,192 @@ async function downloadBufferDefault(url, updater, headers) {
     });
     request.end();
   });
-}
-var compareVersionDefault = (oldVersion, newVersion) => {
-  if (!oldVersion || !newVersion || typeof oldVersion !== "string" || typeof newVersion !== "string") {
-    throw new TypeError("invalid version");
-  }
-  const parseVersion = (version) => {
-    const [versionNumber, stage] = version.split("-", 2);
-    if (!versionNumber || !versionNumber.includes(".")) {
-      throw new TypeError("invalid version");
-    }
-    const [major, minor, patch] = versionNumber.split(".").map(Number);
-    if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
-      throw new TypeError("invalid version");
+};
+var compareVersionDefault = (version1, version2) => {
+  const oldV = parseVersion(version1);
+  const newV = parseVersion(version2);
+  function compareStrings(str1, str2) {
+    if (str1 === "") {
+      return str2 !== "";
+    } else if (str2 === "") {
+      return true;
     }
-    return { major, minor, patch, stage };
-  };
-  const oldV = parseVersion(oldVersion);
-  const newV = parseVersion(newVersion);
-  if (oldV.major < newV.major || oldV.major === newV.major && oldV.minor < newV.minor || oldV.major === newV.major && oldV.minor === newV.minor && oldV.patch < newV.patch) {
-    return true;
+    return str1 < str2;
   }
-  if (oldV.stage < newV.stage || !newV.stage && oldV.stage) {
-    return true;
+  for (let key2 of Object.keys(oldV)) {
+    if (key2 === "stage" && compareStrings(oldV[key2], newV[key2])) {
+      return true;
+    } else if (oldV[key2] !== newV[key2]) {
+      return oldV[key2] < newV[key2];
+    }
   }
   return false;
 };
 
 // src/updater/index.ts
-function createUpdater(updaterOptions) {
-  const {
-    SIGNATURE_CERT,
-    repository,
-    productName,
-    releaseAsarURL: _release,
-    updateJsonURL: _update,
-    debug = false,
-    downloadConfig: { extraHeader, userAgent } = {},
-    overrideFunctions: {
-      compareVersion,
-      verifySignaure,
-      downloadBuffer,
-      downloadJSON
-    } = {}
-  } = updaterOptions;
-  const updater = new import_node_events.EventEmitter();
-  let signature;
-  let version;
-  const asarPath = getProductAsarPath(productName);
-  const gzipPath = `${asarPath}.gz`;
-  const tmpFilePath = `${asarPath}.tmp`;
-  function log(msg) {
-    debug && updater.emit("debug", msg);
+var MinimumVersionError = class extends Error {
+  currentVersion;
+  minVersion;
+  constructor(version, minimumVersion) {
+    super(`current entry version is ${version}, less than the minimumVersion ${minimumVersion}`);
+    this.currentVersion = version;
+    this.minVersion = minimumVersion;
+  }
+};
+var VerifyFailedError = class extends Error {
+  signature;
+  cert;
+  constructor(signature, cert) {
+    super("verify failed, invalid signature or certificate");
+    this.signature = signature;
+    this.cert = cert;
+  }
+};
+var IncrementalUpdater = class {
+  info;
+  option;
+  asarPath;
+  gzipPath;
+  tmpFilePath;
+  logger;
+  onDownloading;
+  get productName() {
+    return this.option.productName;
+  }
+  set productName(name) {
+    this.option.productName = name;
   }
-  function needUpdate(version2) {
-    const currentVersion = getEntryVersion();
-    log(`check update: current version is ${currentVersion}, new version is ${version2}`);
-    const _compare = compareVersion ?? compareVersionDefault;
-    return _compare(currentVersion, version2);
+  get receiveBeta() {
+    return !!this.option.receiveBeta;
   }
-  async function parseData(format, data, version2) {
-    if ((0, import_node_fs2.existsSync)(tmpFilePath)) {
-      log(`remove tmp file: ${tmpFilePath}`);
-      await (0, import_promises.rm)(tmpFilePath);
+  set receiveBeta(receiveBeta) {
+    this.option.receiveBeta = receiveBeta;
+  }
+  constructor(option) {
+    this.option = option;
+    this.asarPath = getProductAsarPath(this.productName);
+    this.gzipPath = `${this.asarPath}.gz`;
+    this.tmpFilePath = `${this.asarPath}.tmp`;
+  }
+  async needUpdate(version, minVersion) {
+    const compare = this.option.overrideFunctions?.compareVersion ?? compareVersionDefault;
+    const productVersion = getProductVersion(this.option.productName);
+    const entryVersion = getEntryVersion();
+    if (await compare(entryVersion, minVersion)) {
+      throw new MinimumVersionError(entryVersion, minVersion);
+    }
+    this.logger?.info(`check update: current version is ${productVersion}, new version is ${version}`);
+    return await compare(productVersion, version);
+  }
+  async parseData(format, data) {
+    if ((0, import_node_fs2.existsSync)(this.tmpFilePath)) {
+      this.logger?.warn(`remove tmp file: ${this.tmpFilePath}`);
+      await (0, import_promises.rm)(this.tmpFilePath);
+    }
+    if ((0, import_node_fs2.existsSync)(this.gzipPath)) {
+      this.logger?.warn(`remove .gz file: ${this.gzipPath}`);
+      await (0, import_promises.rm)(this.gzipPath);
+    }
+    if (!["string", "object", "undefined"].includes(typeof data)) {
+      throw new TypeError(`invalid type at format '${format}': ${data}`);
     }
-    if ((0, import_node_fs2.existsSync)(gzipPath)) {
-      log(`remove .gz file: ${gzipPath}`);
-      await (0, import_promises.rm)(gzipPath);
+    if (typeof data === "object" && (format === "json" && isUpdateJSON(data) || format === "buffer" && import_node_buffer3.Buffer.isBuffer(data))) {
+      return data;
     }
     if (typeof data === "object") {
-      if (format === "json" && isUpdateJSON(data) || format === "buffer" && import_node_buffer3.Buffer.isBuffer(data)) {
-        return data;
-      } else {
-        throw new Error(`invalid type at format '${format}': ${data}`);
-      }
-    } else if (["string", "undefined"].includes(typeof data)) {
-      const ua = 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,
-        ...extraHeader
-      };
-      log(`download headers: ${JSON.stringify(headers, null, 2)}`);
-      const info = format === "json" ? {
-        name: "updateJsonURL",
-        url: _update,
-        repoFallback: `${repository.replace("github.com", "raw.githubusercontent.com")}/master/version.json`,
-        fn: downloadJSON ?? downloadJSONDefault
-      } : {
-        name: "releaseAsarURL",
-        url: _release,
-        repoFallback: `${repository}/releases/download/v${version2}/${productName}-${version2}.asar.gz`,
-        fn: downloadBuffer ?? downloadBufferDefault
-      };
-      data ??= info.url;
-      if (!data) {
-        log(`no ${info.name}, fallback to use repository`);
-        if (!repository) {
-          throw new Error(`${info.name} or repository are not set`);
-        }
-        if (format === "buffer" && !version2) {
-          throw new Error("version are not set");
-        }
-        data = info.repoFallback;
+      throw new TypeError(`invalid type at format '${format}': ${data}`);
+    }
+    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?.info(`download headers: ${JSON.stringify(headers, null, 2)}`);
+    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}/${this.productName}-${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 Error(`${config.name} or repository are not set`);
       }
-      log(`download ${format} from ${data}`);
-      const ret = await info.fn(data, updater, headers);
-      log(`download ${format} success${format === "buffer" ? `, file size: ${ret.length}` : ""}`);
-      if (format === "buffer") {
-        updater.emit("downloadBuffer", ret);
+      if (format === "buffer" && !this.info?.version) {
+        throw new Error("version are not set");
       }
-      return ret;
-    } else {
-      throw new Error(`invalid type at format '${format}': ${data}`);
+      data = config.repoFallback;
     }
+    this.logger?.info(`download ${format} from ${data}`);
+    const ret = format === "json" ? await config.fn(data, headers) : await config.fn(data, headers, this.info.size, this.onDownloading);
+    this.logger?.info(`download ${format} success${format === "buffer" ? `, file size: ${ret.length}` : ""}`);
+    return ret;
   }
-  updater.productName = productName;
-  updater.debugMode = debug;
-  updater.checkUpdate = async (data) => {
+  async checkUpdate(data) {
     try {
-      const { signature: _sig, size, version: _ver } = await parseData("json", data);
-      log(`checked version: ${_ver}, size: ${size}, signature: ${_sig}`);
-      if (!needUpdate(_ver)) {
-        log(`update unavailable: ${_ver}`);
+      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?.info(`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 {
-        log(`update available: ${_ver}`);
-        signature = _sig;
-        version = _ver;
-        return { size, version: _ver };
+        this.logger?.info(`update available: ${version}`);
+        this.info = {
+          signature,
+          minimumVersion,
+          version,
+          size
+        };
+        return { size, version };
       }
     } catch (error) {
-      log(error);
+      this.logger?.error("check update failed", error);
       return error;
     }
-  };
-  updater.download = async (data, sig) => {
+  }
+  async download(data, sig) {
     try {
-      const _sig = sig ?? signature;
+      const _sig = sig ?? this.info?.signature;
       if (!_sig) {
         throw new Error("signature are not set, please checkUpdate first or set the second parameter");
       }
-      const buffer = await parseData("buffer", data, version);
-      log("verify start");
-      const _verify = verifySignaure ?? verify;
-      const _ver = _verify(buffer, _sig, SIGNATURE_CERT);
+      const buffer = await this.parseData("buffer", data);
+      this.logger?.info("verify start");
+      const _verify = this.option.overrideFunctions?.verifySignaure ?? verify;
+      const _ver = await _verify(buffer, _sig, this.option.SIGNATURE_CERT);
       if (!_ver) {
-        throw new Error("verify failed, invalid signature");
+        throw new VerifyFailedError(_sig, this.option.SIGNATURE_CERT);
       }
-      log("verify success");
-      log(`write to ${gzipPath}`);
-      await (0, import_promises.writeFile)(gzipPath, buffer);
-      log(`extract to ${tmpFilePath}`);
-      await unzipFile(gzipPath, tmpFilePath);
-      log(`download success, version: ${_ver}`);
-      signature = "";
+      this.logger?.info("verify success");
+      this.logger?.info(`write to ${this.gzipPath}`);
+      await (0, import_promises.writeFile)(this.gzipPath, buffer);
+      this.logger?.info(`extract to ${this.tmpFilePath}`);
+      await unzipFile(this.gzipPath, this.tmpFilePath);
+      this.logger?.info(`download success${typeof _ver === "string" ? `, version: ${_ver}` : ""}`);
+      this.info = void 0;
       return true;
     } catch (error) {
-      log(error);
+      this.logger?.error("download asar failed", error);
       return error;
     }
-  };
-  return updater;
+  }
+};
+function createUpdater(option) {
+  return new IncrementalUpdater(option);
 }
 
 // src/index.ts
@@ -374,6 +430,9 @@ function initApp(appOptions) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  IncrementalUpdater,
+  MinimumVersionError,
+  VerifyFailedError,
   createUpdater,
   initApp
 });