electron-incremental-update 0.3.0 → 0.5.0

package/README.md

@@ -16,6 +16,8 @@ using RSA + Signature to sign the new `main.asar` downloaded from remote and rep
 
 develop with [vite-plugin-electron](https://github.com/electron-vite/vite-plugin-electron), and may be effect in other electron vite frameworks
 
+**all options are documented in the jsdoc**
+
 ## install
 
 ### npm
@@ -50,21 +52,28 @@ src
 
 ### setup app
 
-more example see comment on `initApp()`
 
 ```ts
 // electron/app.ts
-import { createUpdater, initApp } from 'electron-incremental-update'
+import { createUpdater, getGithubReleaseCdnGroup, initApp, parseGithubCdnURL } from 'electron-incremental-update'
 import { name, repository } from '../package.json'
 
 const SIGNATURE_PUB = '' // auto generate RSA public key when start app
 
+// create updater when init, no need to set productName
+initApp({ name }, { SIGNATURE_PUB, repository })
+
+// or create updater manually
+const { cdnPrefix } = getGithubReleaseCdnGroup()[0]
 const updater = createUpdater({
   SIGNATURE_PUB,
-  repository,
   productName: name,
+  repository,
+  updateJsonURL: parseGithubCdnURL(repository, 'fastly.jsdelivr.net/gh', 'version.json'),
+  releaseAsarURL: parseGithubCdnURL(repository, cdnPrefix, `download/latest/${name}.asar.gz`),
+  debug: true,
 })
-initApp(name, updater)
+initApp({ name }).setUpdater(updater)
 ```
 
 ### setup main
@@ -72,44 +81,36 @@ initApp(name, updater)
 ```ts
 // electron/main/index.ts
 import type { Updater } from 'electron-incremental-update'
-import { getAppAsarPath, getAppVersion, getElectronVersion } from 'electron-incremental-update'
+import { getAppAsarPath, getAppVersion, getEntryVersion } from 'electron-incremental-update'
 import { app } from 'electron'
 import { name } from '../../package.json'
 
 export default function (updater: Updater) {
   console.log('\ncurrent:')
-  console.log(`\telectron:  ${getElectronVersion()}`)
   console.log(`\tasar path: ${getAppAsarPath(name)}`)
+  console.log(`\tentry:     ${getEntryVersion()}`)
   console.log(`\tapp:       ${getAppVersion(name)}`)
-
-  updater.checkUpdate()
-  updater.on('checkResult', async (result, err) => {
-    switch (result) {
-      case 'success':
-        await dialog.showMessageBox({
-          type: 'info',
-          buttons: ['Restart', 'Later'],
-          message: 'Application successfully updated!',
-        }).then(({ response }) => {
-          if (response === 0) {
-            app.relaunch()
-            app.quit()
-          }
-        })
-        break
-      case 'unavailable':
-        console.log('Update Unavailable')
-        break
-      case 'fail':
-        console.error(err)
-        break
+  let size = 0
+  updater.on('downloading', (progress) => {
+    console.log(`${(progress / size).toFixed(2)}%`)
+  })
+  updater.on('debug', data => console.log('[updater]:', data))
+  updater.checkUpdate().then(async (result) => {
+    if (result === undefined) {
+      console.log('Update Unavailable')
+    } else if (result instanceof Error) {
+      console.error(result)
+    } else {
+      size = result.size
+      console.log('new version: ', result.version)
+      const { response } = await dialog.showMessageBox({
+        type: 'info',
+        buttons: ['Download', 'Later'],
+        message: 'Application update available!',
+      })
+      response === 0 && console.log(await updater.downloadUpdate())
     }
   })
-  updater.on('downloadStart', console.log)
-  updater.on('downloading', console.log)
-  updater.on('downloadEnd', console.log)
-  updater.on('donwnloadError', console.error)
-
   // app logics
   app.whenReady().then(() => {
     // ...
@@ -144,7 +145,12 @@ db.close()
 
 ### setup vite.config.ts
 
+make sure the plugin is set in the **last** build task plugin option
+
+- set it to preload task plugin, as the end of build task
+
 ```ts
+// vite.config.ts
 export default defineConfig(({ command }) => {
 
   const isBuild = command === 'build'
@@ -162,7 +168,7 @@ export default defineConfig(({ command }) => {
           // ...
           vite: {
             plugins: [
-              updater({ // !make sure the plugin run pack asar after all build finish
+              updater({
                 productName: pkg.name,
                 version: pkg.version,
                 isBuild,
@@ -179,90 +185,6 @@ export default defineConfig(({ command }) => {
 })
 ```
 
-#### plugin options
-
-```ts
-type Options = {
-  /**
-   * whether is in build mode
-   */
-  isBuild: boolean
-  /**
-   * the name of you application
-   *
-   * you can set as 'name' in package.json
-  */
-  productName: string
-  /**
-   * the version of you application
-   *
-   * you can set as 'version' in package.json
-   */
-  version: string
-  /**
-   * Whether to minify
-   */
-  minify?: boolean
-  /**
-   * path config
-   */
-  paths?: {
-    /**
-     * Path to app entry file
-     * @default 'electron/app.ts'
-     */
-    entryPath?: string
-    /**
-     * Path to app entry output file
-     * @default 'app.js'
-     */
-    entryOutputPath?: string
-    /**
-     * Path to asar file
-     * @default `release/${ProductName}.asar`
-     */
-    asarOutputPath?: string
-    /**
-     * Path to electron build output
-     * @default `dist-electron`
-     */
-    electronDistPath?: string
-    /**
-     * Path to renderer build output
-     * @default `dist`
-     */
-    rendererDistPath?: string
-    /**
-     * Path to version info output
-     * @default `version.json`
-     */
-    versionPath?: string
-  }
-  /**
-   * signature config
-   */
-  keys?: {
-    /**
-     * Path to the pem file that contains private key
-     * if not ended with .pem, it will be appended
-     * @default 'public/private.pem'
-     */
-    privateKeyPath?: string
-    /**
-     * Path to the pem file that contains public key
-     * if not ended with .pem, it will be appended
-     * @default 'public/public.pem'
-     */
-    publicKeyPath?: string
-    /**
-     * Length of the key
-     * @default 2048
-     */
-    keyLength?: number
-  }
-}
-```
-
 ### electron-builder config
 
 ```js

package/dist/chunk-SSJ6PDMK.mjs

@@ -0,0 +1,61 @@
+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 new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/crypto.ts
+import { constants, createCipheriv, createDecipheriv, createHash, createSign, createVerify, generateKeyPairSync } from "node:crypto";
+import { Buffer as Buffer2 } from "node:buffer";
+var aesEncode = "base64url";
+function generateRSA(length = 2048) {
+  const pair = generateKeyPairSync("rsa", { modulusLength: length });
+  const privateKey = pair.privateKey.export({ type: "pkcs1", format: "pem" });
+  const publicKey = pair.publicKey.export({ type: "pkcs1", format: "pem" });
+  return {
+    privateKey,
+    publicKey
+  };
+}
+function encrypt(plainText, key, iv) {
+  const cipher = createCipheriv("aes-256-cbc", key, iv);
+  let encrypted = cipher.update(plainText, "utf8", aesEncode);
+  encrypted += cipher.final(aesEncode);
+  return encrypted;
+}
+function decrypt(encryptedText, key, iv) {
+  const decipher = createDecipheriv("aes-256-cbc", key, iv);
+  let decrypted = decipher.update(encryptedText, aesEncode, "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+function generateKey(buffer, str, length) {
+  str += createHash("md5").update(buffer.map((v, i) => i & length / 4 && v)).digest("hex");
+  const hash = createHash("SHA256").update(str).digest("binary");
+  return Buffer2.from(hash).subarray(0, length);
+}
+function signature(buffer, privateKey, publicKey, name) {
+  const sig = createSign("RSA-SHA256").update(buffer).sign({
+    key: privateKey,
+    padding: constants.RSA_PKCS1_PADDING,
+    saltLength: constants.RSA_PSS_SALTLEN_DIGEST
+  }, "base64");
+  return encrypt(sig, generateKey(buffer, publicKey, 32), generateKey(buffer, name, 16));
+}
+function verify(buffer, signature2, publicKey, name) {
+  try {
+    const sig = decrypt(signature2, generateKey(buffer, publicKey, 32), generateKey(buffer, name, 16));
+    return createVerify("RSA-SHA256").update(buffer).verify(publicKey, sig, "base64");
+  } catch (error) {
+    return false;
+  }
+}
+
+export {
+  __require,
+  generateRSA,
+  signature,
+  verify
+};

package/dist/index.cjs

@@ -46,14 +46,37 @@ var import_electron3 = require("electron");
 
 // src/updater/index.ts
 var import_node_events = require("events");
-var import_node_crypto = require("crypto");
 var import_node_zlib = require("zlib");
 var import_node_fs2 = require("fs");
 var import_promises = require("fs/promises");
 var import_electron2 = require("electron");
 
-// src/updater/defaultFunctions.ts
+// 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);
+  let decrypted = decipher.update(encryptedText, aesEncode, "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+function generateKey(buffer, str, length) {
+  str += (0, import_node_crypto.createHash)("md5").update(buffer.map((v, i) => i & length / 4 && v)).digest("hex");
+  const hash = (0, import_node_crypto.createHash)("SHA256").update(str).digest("binary");
+  return import_node_buffer.Buffer.from(hash).subarray(0, length);
+}
+function verify(buffer, signature, publicKey, name) {
+  try {
+    const sig = decrypt(signature, generateKey(buffer, publicKey, 32), generateKey(buffer, name, 16));
+    return (0, import_node_crypto.createVerify)("RSA-SHA256").update(buffer).verify(publicKey, sig, "base64");
+  } catch (error) {
+    return false;
+  }
+}
+
+// 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) => {
@@ -63,11 +86,15 @@ function downloadJSONDefault(url, updater, headers) {
       res.headers = headers;
       res.on("data", (chunk) => data += chunk);
       res.on("end", () => {
-        const json = JSON.parse(data);
-        if ("signature" in json && "version" in json && "size" in json) {
-          resolve2(json);
-        } else {
-          throw new Error("invalid update json");
+        try {
+          const json = JSON.parse(data);
+          if ("signature" in json && "version" in json && "size" in json) {
+            resolve2(json);
+          } else {
+            throw Error;
+          }
+        } catch (e) {
+          reject(new Error("invalid json"));
         }
       });
     }).on("error", (e) => {
@@ -76,16 +103,18 @@ function downloadJSONDefault(url, updater, headers) {
   });
 }
 function downloadBufferDefault(url, updater, headers) {
+  let progress = 0;
   return new Promise((resolve2, reject) => {
     import_node_https.default.get(url, (res) => {
       let data = [];
       res.headers = headers;
       res.on("data", (chunk) => {
-        updater.emit("downloading", chunk.length);
+        progress += chunk.length;
+        updater.emit("downloading", progress);
         data.push(chunk);
       });
       res.on("end", () => {
-        resolve2(import_node_buffer.Buffer.concat(data));
+        resolve2(import_node_buffer2.Buffer.concat(data));
       });
     }).on("error", (e) => {
       reject(e);
@@ -177,6 +206,7 @@ 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 { downloadBuffer, downloadJSON, extraHeader, userAgent } = downloadConfig || {};
@@ -190,12 +220,16 @@ function createUpdater({
       UserAgent: ua,
       ...extraHeader
     };
-    log(`headers: ${headers}`);
+    log(`download headers: ${JSON.stringify(headers, null, 2)}`);
     const downloadFn = format === "json" ? downloadJSON ?? downloadJSONDefault : downloadBuffer ?? downloadBufferDefault;
-    return await downloadFn(url, updater, headers);
+    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;
     }
     gzipFilePath = gzipFilePath.replace(".asar.gz", ".tmp.gz");
@@ -207,121 +241,119 @@ function createUpdater({
       log(`outputFilePath: ${outputFilePath}`);
       input.pipe(gunzip).pipe(output).on("finish", async () => {
         await (0, import_promises.rm)(gzipFilePath);
-        log("finish");
+        log(`${gzipFilePath} unzipped`);
         resolve2(outputFilePath);
       }).on("error", async (err) => {
         await (0, import_promises.rm)(gzipFilePath);
-        log(`error: ${err}`);
         output.destroy(err);
         reject(err);
       });
     });
   }
-  function verify(buffer, signature2) {
-    log(`signature: ${signature2}`);
-    return (0, import_node_crypto.createVerify)("RSA-SHA256").update(buffer).verify(SIGNATURE_PUB, signature2, "base64");
-  }
-  function needUpdate(version) {
-    if (!version || !import_electron2.app.isPackaged) {
+  function needUpdate(version2) {
+    if (!import_electron2.app.isPackaged) {
+      log("in dev mode, no need to update");
       return false;
     }
     const currentVersion = getEntryVersion();
-    log(`currentVersion: ${currentVersion}`);
-    log(`newVersion: ${version}`);
+    log(`check update:
+    current version is ${currentVersion},
+    new version is ${version2}`);
     const _compare = compareVersion ?? compareVersionDefault;
-    return _compare(currentVersion, version);
+    return _compare(currentVersion, version2);
   }
-  async function checkUpdate(url) {
-    url ??= _update;
-    if (!url) {
-      log("no updateJsonURL, use repository");
-      if (!repository) {
-        throw new Error("updateJsonURL or repository are not set");
-      }
-      url = `${repository.replace("github.com", "raw.githubusercontent.com")}/version.json`;
-    }
-    log(`updateJsonURL: ${url}`);
-    if ((0, import_node_fs2.existsSync)(tmpFile)) {
-      log(`remove tmp file: ${tmpFile}`);
-      await (0, import_promises.rm)(tmpFile);
-    }
-    const json = await download(url, "json");
-    const {
-      signature: _sig,
-      version,
-      size
-    } = json;
-    log(`UpdateJSON: ${JSON.stringify(json, null, 2)}`);
-    if (!needUpdate(version)) {
-      return false;
-    } else {
-      signature = _sig;
-      return { size, version };
-    }
-  }
-  async function downloadUpdate(src) {
-    if (typeof src !== "object") {
-      let _url = src ?? _release;
-      if (!_url) {
-        log("no releaseAsarURL, use repository");
+  updater.checkUpdate = async (url) => {
+    try {
+      url ??= _update;
+      if (!url) {
+        log("no updateJsonURL, fallback to use repository");
         if (!repository) {
-          throw new Error("releaseAsarURL or repository are not set");
+          throw new Error("updateJsonURL or repository are not set");
         }
-        _url = `${repository}/releases/download/latest/${productName}.asar.gz`;
+        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);
+      }
+      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}`);
+        return void 0;
+      } else {
+        log(`update available: ${_v}`);
+        signature = _sig;
+        version = _v;
+        return { size, version };
       }
-      log(`releaseAsarURL: ${_url}`);
-      src = await download(_url, "buffer");
-    }
-    log("start verify");
-    if (!verify(src, signature)) {
-      throw new Error("file broken, invalid signature!");
-    }
-    log(`write file: ${gzipPath}`);
-    await (0, import_promises.writeFile)(gzipPath, src);
-    log(`extract file: ${gzipPath}`);
-    await extractFile(gzipPath);
-    updater.emit("downloaded");
-  }
-  const onCheck = async (url) => {
-    try {
-      const result = await checkUpdate(url);
-      updater.emit("checkResult", result);
     } catch (error) {
       log(error);
-      updater.emit("checkResult", error);
+      return error;
     }
   };
-  updater.on("check", onCheck);
-  updater.checkUpdate = onCheck;
-  const onDownload = async (src) => {
+  updater.downloadUpdate = async (src) => {
     try {
-      await downloadUpdate(src);
+      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");
+      }
+      log("verify start");
+      if (!verify(src, signature, SIGNATURE_PUB, productName)) {
+        log("verify failed");
+        throw new Error("invalid signature");
+      }
+      log("verify success");
+      log(`write file: ${gzipPath}`);
+      await (0, import_promises.writeFile)(gzipPath, src);
+      log(`extract file: ${gzipPath}`);
+      await extractFile(gzipPath);
+      log(`update success, version: ${version}`);
+      return true;
     } catch (error) {
       log(error);
-      updater.emit("donwnloadError", error);
+      return error;
     }
   };
-  updater.on("download", onDownload);
-  updater.downloadUpdate = onDownload;
   return updater;
 }
 
 // src/index.ts
-function initApp(productName, updater, option) {
+function initApp(appOptions, updaterOptions) {
   const {
+    name: productName,
     electronDistPath = "dist-electron",
     mainPath = "main/index.js"
-  } = option ?? {};
+  } = appOptions ?? {};
   const mainDir = import_electron3.app.isPackaged ? `../${productName}.asar` : electronDistPath;
   const entry = (0, import_node_path2.resolve)(__dirname, mainDir, mainPath);
-  let _updater;
-  if ("SIGNATURE_PUB" in updater) {
-    const _option = updater.productName ? updater : { ...updater, productName };
-    _updater = createUpdater(_option);
+  if (updaterOptions) {
+    require(entry)(
+      createUpdater({ ...updaterOptions, productName })
+    );
   } else {
-    _updater = updater;
+    return {
+      setUpdater(updater) {
+        require(entry)(updater);
+      }
+    };
   }
-  return require(entry)(_updater);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {