electron-incremental-update 0.5.1 → 0.6.1

package/dist/index.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -11,64 +9,61 @@ var __export = (target, all) => {
 };
 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 });
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
   createUpdater: () => createUpdater,
-  getAppAsarPath: () => getAppAsarPath,
-  getAppVersion: () => getAppVersion,
   getEntryVersion: () => getEntryVersion,
   getGithubReleaseCdnGroup: () => getGithubReleaseCdnGroup,
+  getProductAsarPath: () => getProductAsarPath,
+  getProductVersion: () => getProductVersion,
   initApp: () => initApp,
+  isUpdateJSON: () => isUpdateJSON,
   parseGithubCdnURL: () => parseGithubCdnURL,
   requireNative: () => requireNative,
-  restartApp: () => restartApp
+  restartApp: () => restartApp,
+  waitAppReady: () => waitAppReady
 });
 module.exports = __toCommonJS(src_exports);
-var import_node_path2 = require("path");
-var import_electron3 = require("electron");
+var import_node_path3 = require("path");
+var import_electron4 = require("electron");
 
 // src/updater/index.ts
 var import_node_events = require("events");
+var import_node_buffer3 = require("buffer");
 var import_node_zlib = require("zlib");
 var import_node_fs2 = require("fs");
 var import_promises = require("fs/promises");
-var import_electron2 = require("electron");
+var import_node_path2 = require("path");
+var import_electron3 = require("electron");
 
 // src/crypto.ts
 var import_node_crypto = require("crypto");
 var import_node_buffer = require("buffer");
 var aesEncode = "base64url";
-function decrypt(encryptedText, key, iv) {
-  const decipher = (0, import_node_crypto.createDecipheriv)("aes-256-cbc", key, iv);
+function decrypt(encryptedText, key2, iv) {
+  const decipher = (0, import_node_crypto.createDecipheriv)("aes-256-cbc", key2, iv);
   let decrypted = decipher.update(encryptedText, aesEncode, "utf8");
   decrypted += decipher.final("utf8");
   return decrypted;
 }
-function generateKey(data, length) {
+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);
 }
-function verify(buffer, signature, publicKey) {
+function verify(buffer, signature, cert) {
   try {
-    const sig = decrypt(signature, generateKey(publicKey, 32), generateKey(buffer, 16));
-    return (0, import_node_crypto.createVerify)("RSA-SHA256").update(buffer).verify(publicKey, sig, "base64");
+    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;
   }
@@ -76,19 +71,93 @@ function verify(buffer, signature, publicKey) {
 
 // src/updater/defaultFunctions.ts
 var import_node_buffer2 = require("buffer");
-var import_node_https = __toESM(require("https"), 1);
-function downloadJSONDefault(url, updater, headers) {
-  return new Promise((resolve2, reject) => {
-    import_node_https.default.get(url, (res) => {
+var import_electron2 = require("electron");
+
+// src/updater/types.ts
+function isUpdateJSON(json) {
+  return "signature" in json && "version" in json && "size" in json;
+}
+
+// src/updater/utils.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_electron = require("electron");
+function getProductAsarPath(name) {
+  return import_electron.app.isPackaged ? (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getAppPath()), `${name}.asar`) : "dev";
+}
+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 requireNative(packageName) {
+  const path = import_electron.app.isPackaged ? (0, import_node_path.join)(import_electron.app.getAppPath(), "node_modules", packageName) : packageName;
+  return require(path);
+}
+function parseGithubCdnURL(repository, cdnPrefix, relativeFilePath) {
+  if (!repository.startsWith("https://github.com/")) {
+    throw new Error("url must start with https://github.com/");
+  }
+  repository = repository.trim().replace(/\/?$/, "/").trim();
+  relativeFilePath = relativeFilePath.trim().replace(/^\/|\/?$/g, "").trim();
+  cdnPrefix = cdnPrefix.trim().replace(/^\/?|\/?$/g, "").trim();
+  return repository.replace("github.com", cdnPrefix) + relativeFilePath;
+}
+function getGithubReleaseCdnGroup() {
+  return [
+    { cdnPrefix: "gh.gh2233.ml", maintainer: "@X.I.U/XIU2" },
+    { cdnPrefix: "ghproxy.com", maintainer: "gh-proxy" },
+    { cdnPrefix: "gh.ddlc.top", maintainer: "@mtr-static-official" },
+    { cdnPrefix: "ghdl.feizhuqwq.cf", maintainer: "feizhuqwq.com" },
+    { cdnPrefix: "slink.ltd", maintainer: "\u77E5\u4E86\u5C0F\u7AD9" },
+    { cdnPrefix: "git.xfj0.cn", maintainer: "anonymous1" },
+    { cdnPrefix: "gh.con.sh", maintainer: "anonymous2" },
+    { cdnPrefix: "ghps.cc", maintainer: "anonymous3" },
+    { cdnPrefix: "cors.isteed.cc/github.com", maintainer: "Lufs's" },
+    { cdnPrefix: "hub.gitmirror.com", maintainer: "GitMirror" },
+    { cdnPrefix: "js.xxooo.ml", maintainer: "\u996D\u592A\u786C" },
+    { cdnPrefix: "download.njuu.cf", maintainer: "LibraryCloud-njuu" },
+    { cdnPrefix: "download.yzuu.cf", maintainer: "LibraryCloud-yzuu" },
+    { cdnPrefix: "download.nuaa.cf", maintainer: "LibraryCloud-nuaa" }
+  ];
+}
+function restartApp() {
+  import_electron.app.relaunch();
+  import_electron.app.quit();
+}
+function waitAppReady(duration = 1e3) {
+  return new Promise((resolve3, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error("app is not ready"));
+    }, duration);
+    import_electron.app.whenReady().then(() => {
+      clearTimeout(timeout);
+      resolve3(null);
+    });
+  });
+}
+
+// src/updater/defaultFunctions.ts
+async function downloadJSONDefault(url, updater, headers) {
+  await waitAppReady();
+  return new Promise((resolve3, reject) => {
+    const request = import_electron2.net.request({
+      url,
+      method: "GET",
+      redirect: "follow"
+    });
+    Object.keys(headers).forEach((key2) => {
+      request.setHeader(key2, headers[key2]);
+    });
+    request.on("response", (res) => {
       let data = "";
-      res.setEncoding("utf8");
-      res.headers = headers;
       res.on("data", (chunk) => data += chunk);
       res.on("end", () => {
         try {
           const json = JSON.parse(data);
-          if ("signature" in json && "version" in json && "size" in json) {
-            resolve2(json);
+          if (isUpdateJSON(json)) {
+            resolve3(json);
           } else {
             throw Error;
           }
@@ -96,28 +165,39 @@ function downloadJSONDefault(url, updater, headers) {
           reject(new Error("invalid json"));
         }
       });
-    }).on("error", (e) => {
+    });
+    request.on("error", (e) => {
       reject(e);
     });
+    request.end();
   });
 }
-function downloadBufferDefault(url, updater, headers) {
+async function downloadBufferDefault(url, updater, headers) {
+  await waitAppReady();
   let progress = 0;
-  return new Promise((resolve2, reject) => {
-    import_node_https.default.get(url, (res) => {
+  return new Promise((resolve3, reject) => {
+    const request = import_electron2.net.request({
+      url,
+      method: "GET",
+      redirect: "follow"
+    });
+    Object.keys(headers).forEach((key2) => {
+      request.setHeader(key2, headers[key2]);
+    });
+    request.on("response", (res) => {
       let data = [];
-      res.headers = headers;
       res.on("data", (chunk) => {
         progress += chunk.length;
         updater.emit("downloading", progress);
         data.push(chunk);
       });
       res.on("end", () => {
-        resolve2(import_node_buffer2.Buffer.concat(data));
+        resolve3(import_node_buffer2.Buffer.concat(data));
       });
     }).on("error", (e) => {
       reject(e);
     });
+    request.end();
   });
 }
 function compareVersionDefault(oldVersion, newVersion) {
@@ -143,58 +223,9 @@ function compareVersionDefault(oldVersion, newVersion) {
   return false;
 }
 
-// src/updater/utils.ts
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-var import_electron = require("electron");
-function getAppAsarPath(name) {
-  return import_electron.app.isPackaged ? (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getAppPath()), `${name}.asar`) : "dev";
-}
-function getEntryVersion() {
-  return import_electron.app.getVersion();
-}
-function getAppVersion(name) {
-  return import_electron.app.isPackaged ? (0, import_node_fs.readFileSync)((0, import_node_path.join)(getAppAsarPath(name), "version"), "utf-8") : getEntryVersion();
-}
-function requireNative(packageName) {
-  const path = import_electron.app.isPackaged ? (0, import_node_path.join)(import_electron.app.getAppPath(), "node_modules", packageName) : packageName;
-  return require(path);
-}
-function parseGithubCdnURL(repository, cdnPrefix, relativeFilePath) {
-  if (!repository.startsWith("https://github.com/")) {
-    throw new Error("url must start with https://github.com/");
-  }
-  repository = repository.trim().replace(/\/?$/, "/").trim();
-  relativeFilePath = relativeFilePath.trim().replace(/^\/|\/?$/g, "").trim();
-  cdnPrefix = cdnPrefix.trim().replace(/^\/?|\/?$/g, "").trim();
-  return repository.replace("github.com", cdnPrefix) + relativeFilePath;
-}
-function getGithubReleaseCdnGroup() {
-  return [
-    { cdnPrefix: "gh.gh2233.ml", maintainer: "@X.I.U/XIU2" },
-    { cdnPrefix: "ghproxy.com", maintainer: "gh-proxy" },
-    { cdnPrefix: "gh.ddlc.top", maintainer: "@mtr-static-official" },
-    { cdnPrefix: "ghdl.feizhuqwq.cf", maintainer: "feizhuqwq.com" },
-    { cdnPrefix: "slink.ltd", maintainer: "\u77E5\u4E86\u5C0F\u7AD9" },
-    { cdnPrefix: "git.xfj0.cn", maintainer: "anonymous1" },
-    { cdnPrefix: "gh.con.sh", maintainer: "anonymous2" },
-    { cdnPrefix: "ghps.cc", maintainer: "anonymous3" },
-    { cdnPrefix: "cors.isteed.cc/github.com", maintainer: "Lufs's" },
-    { cdnPrefix: "hub.gitmirror.com", maintainer: "GitMirror" },
-    { cdnPrefix: "js.xxooo.ml", maintainer: "\u996D\u592A\u786C" },
-    { cdnPrefix: "download.njuu.cf", maintainer: "LibraryCloud-njuu" },
-    { cdnPrefix: "download.yzuu.cf", maintainer: "LibraryCloud-yzuu" },
-    { cdnPrefix: "download.nuaa.cf", maintainer: "LibraryCloud-nuaa" }
-  ];
-}
-function restartApp() {
-  import_electron.app.relaunch();
-  import_electron.app.quit();
-}
-
 // src/updater/index.ts
 function createUpdater({
-  SIGNATURE_PUB,
+  SIGNATURE_CERT,
   repository,
   productName,
   releaseAsarURL: _release,
@@ -205,94 +236,103 @@ function createUpdater({
 }) {
   const updater = new import_node_events.EventEmitter();
   let signature = "";
-  let version = "";
-  const gzipPath = `../${productName}.asar.gz`;
-  const tmpFile = gzipPath.replace(".asar.gz", ".tmp.gz");
+  const asarPath = getProductAsarPath(productName);
+  const gzipPath = `${asarPath}.gz`;
+  const tmpFilePath = gzipPath.replace(".asar.gz", ".tmp.asar");
   const { downloadBuffer, downloadJSON, extraHeader, userAgent } = downloadConfig || {};
   function log(msg) {
     debug && updater.emit("debug", msg);
   }
-  async function download(url, format) {
-    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 downloadFn = format === "json" ? downloadJSON ?? downloadJSONDefault : downloadBuffer ?? downloadBufferDefault;
-    log(`download ${format} from ${url}`);
-    const ret = await downloadFn(url, updater, headers);
-    log(`download ${format} success`);
-    return ret;
-  }
-  async function extractFile(gzipFilePath) {
-    if (!gzipFilePath.endsWith(".asar.gz") || !(0, import_node_fs2.existsSync)(gzipFilePath)) {
-      log("update .asar.gz file not exist");
-      return;
+  async function extractFile() {
+    if (!gzipPath.endsWith(".asar.gz") || !(0, import_node_fs2.existsSync)(gzipPath)) {
+      throw new Error(".asar.gz file not exist");
     }
-    gzipFilePath = gzipFilePath.replace(".asar.gz", ".tmp.gz");
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const gunzip = (0, import_node_zlib.createGunzip)();
-      const input = (0, import_node_fs2.createReadStream)(gzipFilePath);
-      const outputFilePath = gzipFilePath.replace(".tmp.gz", ".asar");
-      const output = (0, import_node_fs2.createWriteStream)(outputFilePath);
-      log(`outputFilePath: ${outputFilePath}`);
+      const input = (0, import_node_fs2.createReadStream)(gzipPath);
+      const output = (0, import_node_fs2.createWriteStream)(tmpFilePath);
+      log(`outputFilePath: ${tmpFilePath}`);
       input.pipe(gunzip).pipe(output).on("finish", async () => {
-        await (0, import_promises.rm)(gzipFilePath);
-        log(`${gzipFilePath} unzipped`);
-        resolve2(outputFilePath);
+        await (0, import_promises.rm)(gzipPath);
+        log(`${gzipPath} unzipped`);
+        resolve3(null);
       }).on("error", async (err) => {
-        await (0, import_promises.rm)(gzipFilePath);
+        await (0, import_promises.rm)(gzipPath);
         output.destroy(err);
         reject(err);
       });
     });
   }
-  function needUpdate(version2) {
-    if (!import_electron2.app.isPackaged) {
+  function needUpdate(version) {
+    if (!import_electron3.app.isPackaged) {
       log("in dev mode, no need to update");
       return false;
     }
     const currentVersion = getEntryVersion();
-    log(`check update:
-    current version is ${currentVersion},
-    new version is ${version2}`);
+    log(`check update: current version is ${currentVersion}, new version is ${version}`);
     const _compare = compareVersion ?? compareVersionDefault;
-    return _compare(currentVersion, version2);
+    return _compare(currentVersion, version);
   }
-  updater.checkUpdate = async (url) => {
-    try {
-      url ??= _update;
-      if (!url) {
-        log("no updateJsonURL, fallback to use repository");
+  async function parseData(format, data) {
+    if ((0, import_node_fs2.existsSync)(tmpFilePath)) {
+      log(`remove tmp file: ${tmpFilePath}`);
+      await (0, import_promises.rm)(tmpFilePath);
+    }
+    if ((0, import_node_fs2.existsSync)(gzipPath)) {
+      log(`remove .gz file: ${gzipPath}`);
+      await (0, import_promises.rm)(gzipPath);
+    }
+    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/latest/${productName}.asar.gz`,
+        fn: downloadBuffer ?? downloadBufferDefault
+      };
+      data ??= info.url;
+      if (!data) {
+        log(`no ${info.name}, fallback to use repository`);
         if (!repository) {
-          throw new Error("updateJsonURL or repository are not set");
+          throw new Error(`${info.name} or repository are not set`);
         }
-        url = `${repository.replace("github.com", "raw.githubusercontent.com")}/master/version.json`;
-      }
-      if ((0, import_node_fs2.existsSync)(tmpFile)) {
-        log(`remove tmp file: ${tmpFile}`);
-        await (0, import_promises.rm)(tmpFile);
-      }
-      if ((0, import_node_fs2.existsSync)(gzipPath)) {
-        log(`remove .gz file: ${gzipPath}`);
-        await (0, import_promises.rm)(gzipPath);
+        data = info.repoFallback;
       }
-      const json = await download(url, "json");
-      const {
-        signature: _sig,
-        version: _v,
-        size
-      } = json;
-      log(`update info: ${JSON.stringify(json, null, 2)}`);
-      if (!await needUpdate(_v)) {
-        log(`update unavailable: ${_v}`);
+      log(`download ${format} from ${data}`);
+      const ret = await info.fn(data, updater, headers);
+      log(`download ${format} success`);
+      return ret;
+    } else {
+      throw new Error(`invalid type at format '${format}': ${data}`);
+    }
+  }
+  updater.checkUpdate = async (data) => {
+    try {
+      const { signature: _sig, size, version } = await parseData("json", data);
+      log(`checked version: ${version}, size: ${size}, signature: ${_sig}`);
+      if (!needUpdate(version)) {
+        log(`update unavailable: ${version}`);
         return void 0;
       } else {
-        log(`update available: ${_v}`);
+        log(`update available: ${version}`);
         signature = _sig;
-        version = _v;
         return { size, version };
       }
     } catch (error) {
@@ -300,30 +340,35 @@ function createUpdater({
       return error;
     }
   };
-  updater.downloadUpdate = async (src) => {
+  updater.downloadAndInstall = async (data, sig) => {
     try {
-      if (typeof src !== "object") {
-        let _url = src ?? _release;
-        if (!_url) {
-          log("no releaseAsarURL, fallback to use repository");
-          if (!repository) {
-            throw new Error("releaseAsarURL or repository are not set");
-          }
-          _url = `${repository}/releases/download/latest/${productName}.asar.gz`;
-        }
-        src = await download(_url, "buffer");
+      const _sig = sig ?? signature;
+      if (!_sig) {
+        throw new Error("signature are not set, please checkUpdate first or set the second parameter");
       }
+      const buffer = await parseData("buffer", data);
       log("verify start");
-      if (!verify(src, signature, SIGNATURE_PUB)) {
-        log("verify failed");
-        throw new Error("invalid signature");
+      const version = verify(buffer, _sig, SIGNATURE_CERT);
+      if (!version) {
+        throw new Error("verify failed, invalid signature");
       }
       log("verify success");
+      if (!needUpdate(version)) {
+        throw new Error(`update unavailable: ${version}`);
+      }
       log(`write file: ${gzipPath}`);
-      await (0, import_promises.writeFile)(gzipPath, src);
+      await (0, import_promises.writeFile)(gzipPath, buffer);
       log(`extract file: ${gzipPath}`);
-      await extractFile(gzipPath);
+      await extractFile();
+      const asarVersion = await (0, import_promises.readFile)((0, import_node_path2.resolve)(tmpFilePath, "version"), "utf8");
+      if (asarVersion !== version) {
+        (0, import_node_fs2.rmSync)(tmpFilePath);
+        throw new Error(`update failed: asar version is ${asarVersion}, but it should be ${version}`);
+      } else {
+        await (0, import_promises.rename)(tmpFilePath, asarPath);
+      }
       log(`update success, version: ${version}`);
+      signature = "";
       return true;
     } catch (error) {
       log(error);
@@ -340,8 +385,8 @@ function initApp(appOptions, updaterOptions) {
     electronDistPath = "dist-electron",
     mainPath = "main/index.js"
   } = appOptions ?? {};
-  const mainDir = import_electron3.app.isPackaged ? `../${productName}.asar` : electronDistPath;
-  const entry = (0, import_node_path2.resolve)(__dirname, mainDir, mainPath);
+  const mainDir = import_electron4.app.isPackaged ? `../${productName}.asar` : electronDistPath;
+  const entry = (0, import_node_path3.resolve)(__dirname, mainDir, mainPath);
   if (updaterOptions) {
     require(entry)(
       createUpdater({ ...updaterOptions, productName })
@@ -357,12 +402,14 @@ function initApp(appOptions, updaterOptions) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createUpdater,
-  getAppAsarPath,
-  getAppVersion,
   getEntryVersion,
   getGithubReleaseCdnGroup,
+  getProductAsarPath,
+  getProductVersion,
   initApp,
+  isUpdateJSON,
   parseGithubCdnURL,
   requireNative,
-  restartApp
+  restartApp,
+  waitAppReady
 });