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

package/README.md

@@ -10,6 +10,8 @@ The new `${electron.app.name}.asar`, which can download from remote or load from
 
 All **native modules** should be packaged into `app.asar` to reduce `${electron.app.name}.asar` file size, [see usage](#use-native-modules). Therefore, auto upgrade of portable app is possible.
 
+Support bytecode protection, [see details](#bytecode-protection)
+
 No `vite-plugin-electron-renderer` config
 
 - inspired by [Obsidian](https://obsidian.md/)'s upgrade strategy
@@ -179,7 +181,7 @@ initApp({
 in `electron/main/index.ts`
 
 ```ts
-import { startupWithUpdater } from 'electron-incremental-update'
+import { UpdaterError, startupWithUpdater } from 'electron-incremental-update'
 import { getPathFromAppNameAsar, getVersions } from 'electron-incremental-update/utils'
 import { app } from 'electron'
 
@@ -196,10 +198,12 @@ export default startupWithUpdater((updater) => {
     console.log(percent)
   }
   updater.logger = console
+  updater.receiveBeta = true
+
   updater.checkUpdate().then(async (result) => {
     if (result === undefined) {
       console.log('Update Unavailable')
-    } else if (result instanceof Error) {
+    } else if (result instanceof UpdaterError) {
       console.error(result)
     } else {
       console.log('new version: ', result.version)
@@ -272,7 +276,7 @@ import Database from 'better-sqlite3'
 
 const db = new Database(':memory:', { nativeBinding: './better_sqlite3.node' })
 
-export function test() {
+export function test(): void {
   db.exec(
     'DROP TABLE IF EXISTS employees; '
     + 'CREATE TABLE IF NOT EXISTS employees (name TEXT, salary INTEGER)',

package/dist/chunk-4MH6ZXCY.js

@@ -0,0 +1,81 @@
+import { __require } from './chunk-72ZAJ7AF.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { app } from 'electron';
+
+var isDev = __EIU_IS_DEV__;
+var isWin = process.platform === "win32";
+var isMac = process.platform === "darwin";
+var isLinux = process.platform === "linux";
+function getPathFromAppNameAsar(...paths) {
+  return isDev ? "DEV.asar" : path.join(path.dirname(app.getAppPath()), `${app.name}.asar`, ...paths);
+}
+function getAppVersion() {
+  return isDev ? getEntryVersion() : fs.readFileSync(getPathFromAppNameAsar("version"), "utf-8");
+}
+function getEntryVersion() {
+  return app.getVersion();
+}
+function requireNative(moduleName) {
+  return __require(path.join(app.getAppPath(), __EIU_ENTRY_DIST_PATH__, moduleName));
+}
+function restartApp() {
+  app.relaunch();
+  app.quit();
+}
+function setAppUserModelId(id) {
+  if (isWin) {
+    app.setAppUserModelId(id ?? `org.${app.name}`);
+  }
+}
+function disableHWAccForWin7() {
+  if (__require("node:os").release().startsWith("6.1")) {
+    app.disableHardwareAcceleration();
+  }
+}
+function singleInstance(window) {
+  const result = app.requestSingleInstanceLock();
+  if (result) {
+    app.on("second-instance", () => {
+      if (window) {
+        window.show();
+        if (window.isMinimized()) {
+          window.restore();
+        }
+        window.focus();
+      }
+    });
+  } else {
+    app.quit();
+  }
+  return result;
+}
+function setPortableAppDataPath(dirName = "data") {
+  const portablePath = path.join(path.dirname(app.getPath("exe")), dirName);
+  if (!fs.existsSync(portablePath)) {
+    fs.mkdirSync(portablePath);
+  }
+  app.setPath("appData", portablePath);
+}
+function loadPage(win, htmlFilePath = "index.html") {
+  if (isDev) {
+    win.loadURL(process.env.VITE_DEV_SERVER_URL + htmlFilePath);
+  } else {
+    win.loadFile(getPathFromAppNameAsar("renderer", htmlFilePath));
+  }
+}
+function getPathFromPreload(...paths) {
+  return isDev ? path.join(app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "preload", ...paths) : getPathFromAppNameAsar("preload", ...paths);
+}
+function getPathFromPublic(...paths) {
+  return isDev ? path.join(app.getAppPath(), "public", ...paths) : getPathFromAppNameAsar("renderer", ...paths);
+}
+function getPathFromEntryAsar(...paths) {
+  return path.join(app.getAppPath(), __EIU_ENTRY_DIST_PATH__, ...paths);
+}
+function handleUnexpectedErrors(callback) {
+  process.on("uncaughtException", callback);
+  process.on("unhandledRejection", callback);
+}
+
+export { disableHWAccForWin7, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, handleUnexpectedErrors, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance };

package/dist/chunk-72ZAJ7AF.js

@@ -0,0 +1,70 @@
+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 Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/utils/version.ts
+function parseVersion(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z0-9.-]+))?/i.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 (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch) || Number.isNaN(ret.stageVersion)) {
+    throw new TypeError(`invalid version: ${version}`);
+  }
+  return ret;
+}
+function defaultIsLowerVersion(oldVer, newVer) {
+  const oldV = parseVersion(oldVer);
+  const newV = parseVersion(newVer);
+  function compareStrings(str1, str2) {
+    if (str1 === "") {
+      return str2 !== "";
+    } else if (str2 === "") {
+      return true;
+    }
+    return str1 < str2;
+  }
+  for (let key of Object.keys(oldV)) {
+    if (key === "stage" && compareStrings(oldV[key], newV[key])) {
+      return true;
+    } else if (oldV[key] !== newV[key]) {
+      return oldV[key] < newV[key];
+    }
+  }
+  return false;
+}
+function isUpdateJSON(json) {
+  const is = (j) => !!(j && j.minimumVersion && j.signature && j.version);
+  return is(json) && is(json?.beta);
+}
+function defaultVersionJsonGenerator(existingJson, signature, version, minimumVersion) {
+  existingJson.beta = {
+    version,
+    minimumVersion,
+    signature
+  };
+  if (!parseVersion(version).stage) {
+    existingJson.version = version;
+    existingJson.minimumVersion = minimumVersion;
+    existingJson.signature = signature;
+  }
+  return existingJson;
+}
+
+export { __require, defaultIsLowerVersion, defaultVersionJsonGenerator, isUpdateJSON, parseVersion };

package/dist/chunk-KZSYEXLO.js

@@ -0,0 +1,55 @@
+import zlib from 'node:zlib';
+import crypto from 'node:crypto';
+
+// src/utils/zip.ts
+async function defaultZipFile(buffer) {
+  return new Promise((resolve, reject) => {
+    zlib.brotliCompress(buffer, (err, buffer2) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(buffer2);
+      }
+    });
+  });
+}
+async function defaultUnzipFile(buffer) {
+  return new Promise((resolve, reject) => {
+    zlib.brotliDecompress(buffer, (err, buffer2) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(buffer2);
+      }
+    });
+  });
+}
+function hashBuffer(data, length) {
+  const hash = crypto.createHash("SHA256").update(data).digest("binary");
+  return Buffer.from(hash).subarray(0, length);
+}
+function aesEncrypt(plainText, key, iv) {
+  const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
+  return cipher.update(plainText, "utf8", "base64url") + cipher.final("base64url");
+}
+function defaultSignature(buffer, privateKey, cert, version) {
+  const sig = crypto.createSign("RSA-SHA256").update(buffer).sign(crypto.createPrivateKey(privateKey), "base64");
+  return aesEncrypt(`${sig}%${version}`, hashBuffer(cert, 32), hashBuffer(buffer, 16));
+}
+function aesDecrypt(encryptedText, key, iv) {
+  const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+  return decipher.update(encryptedText, "base64url", "utf8") + decipher.final("utf8");
+}
+function defaultVerifySignature(buffer, version, signature, cert) {
+  try {
+    const [sig, ver] = aesDecrypt(signature, hashBuffer(cert, 32), hashBuffer(buffer, 16)).split("%");
+    if (ver !== version) {
+      return false;
+    }
+    return crypto.createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+  } catch {
+    return false;
+  }
+}
+
+export { aesDecrypt, aesEncrypt, defaultSignature, defaultUnzipFile, defaultVerifySignature, defaultZipFile, hashBuffer };