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

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-BG22XZAB.js

@@ -0,0 +1,257 @@
+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/electron.ts
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } 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(...path) {
+  return isDev ? "DEV.asar" : join(dirname(app.getAppPath()), `${app.name}.asar`, ...path);
+}
+function getAppVersion() {
+  return isDev ? getEntryVersion() : readFileSync(getPathFromAppNameAsar("version"), "utf-8");
+}
+function getEntryVersion() {
+  return app.getVersion();
+}
+function requireNative(moduleName) {
+  return __require(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 = join(dirname(app.getPath("exe")), dirName);
+  if (!existsSync(portablePath)) {
+    mkdirSync(portablePath);
+  }
+  app.setPath("appData", portablePath);
+}
+function waitAppReady(timeout = 1e3) {
+  return app.isReady() ? Promise.resolve() : new Promise((resolve, reject) => {
+    const _ = setTimeout(() => {
+      reject(new Error("app is not ready"));
+    }, timeout);
+    app.whenReady().then(() => {
+      clearTimeout(_);
+      resolve();
+    });
+  });
+}
+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 ? join(app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "preload", ...paths) : getPathFromAppNameAsar("preload", ...paths);
+}
+function getPathFromPublic(...paths) {
+  return isDev ? join(app.getAppPath(), "public", ...paths) : getPathFromAppNameAsar("renderer", ...paths);
+}
+function getPathFromEntryAsar(...paths) {
+  return join(app.getAppPath(), __EIU_ENTRY_DIST_PATH__, ...paths);
+}
+
+// src/utils/zip.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { brotliCompress } from "node:zlib";
+async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
+  if (!existsSync2(filePath)) {
+    throw new Error(`path to be zipped not exist: ${filePath}`);
+  }
+  const buffer = readFileSync2(filePath);
+  return new Promise((resolve, reject) => {
+    brotliCompress(buffer, (err, buffer2) => {
+      if (err) {
+        reject(err);
+      }
+      writeFileSync(targetFilePath, buffer2);
+      resolve();
+    });
+  });
+}
+
+// src/utils/unzip.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { brotliDecompress } from "node:zlib";
+async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
+  if (!existsSync3(gzipPath)) {
+    throw new Error(`path to zipped file not exist: ${gzipPath}`);
+  }
+  const compressedBuffer = readFileSync3(gzipPath);
+  return new Promise((resolve, reject) => {
+    brotliDecompress(compressedBuffer, (err, buffer) => {
+      rmSync(gzipPath);
+      if (err) {
+        reject(err);
+      }
+      writeFileSync2(targetFilePath, buffer);
+      resolve();
+    });
+  });
+}
+
+// src/utils/version.ts
+function handleUnexpectedErrors(callback) {
+  process.on("uncaughtException", callback);
+  process.on("unhandledRejection", callback);
+}
+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 isLowerVersionDefault(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.size && j.version);
+  return is(json) && is(json?.beta);
+}
+
+// src/utils/crypto/decrypt.ts
+import { createDecipheriv, createVerify } from "node:crypto";
+
+// src/utils/crypto/utils.ts
+import { createHash } from "node:crypto";
+function hashString(data, length) {
+  const hash = 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 = createDecipheriv("aes-256-cbc", key, iv);
+  let decrypted = decipher.update(encryptedText, "base64url", "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+function verifySignatureDefault(buffer, signature2, cert) {
+  try {
+    const [sig, version] = decrypt(signature2, hashString(cert, 32), hashString(buffer, 16)).split("%");
+    const result = createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+    return result ? version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/utils/crypto/encrypt.ts
+import { createCipheriv, createPrivateKey, createSign } from "node:crypto";
+function encrypt(plainText, key, iv) {
+  const cipher = createCipheriv("aes-256-cbc", key, iv);
+  let encrypted = cipher.update(plainText, "utf8", "base64url");
+  encrypted += cipher.final("base64url");
+  return encrypted;
+}
+function signature(buffer, privateKey, cert, version) {
+  const sig = createSign("RSA-SHA256").update(buffer).sign(createPrivateKey(privateKey), "base64");
+  return encrypt(`${sig}%${version}`, hashString(cert, 32), hashString(buffer, 16));
+}
+
+export {
+  __require,
+  handleUnexpectedErrors,
+  parseVersion,
+  isLowerVersionDefault,
+  isUpdateJSON,
+  isDev,
+  isWin,
+  isMac,
+  isLinux,
+  getPathFromAppNameAsar,
+  getAppVersion,
+  getEntryVersion,
+  requireNative,
+  restartApp,
+  setAppUserModelId,
+  disableHWAccForWin7,
+  singleInstance,
+  setPortableAppDataPath,
+  waitAppReady,
+  loadPage,
+  getPathFromPreload,
+  getPathFromPublic,
+  getPathFromEntryAsar,
+  unzipFile,
+  zipFile,
+  hashString,
+  decrypt,
+  verifySignatureDefault,
+  encrypt,
+  signature
+};

package/dist/decrypt-D9WdXYjH.d.cts

@@ -0,0 +1,4 @@
+declare function decrypt(encryptedText: string, key: Buffer, iv: Buffer): string;
+declare function verifySignatureDefault(buffer: Buffer, signature: string, cert: string): string | undefined;
+
+export { decrypt as d, verifySignatureDefault as v };

package/dist/decrypt-D9WdXYjH.d.ts

@@ -0,0 +1,4 @@
+declare function decrypt(encryptedText: string, key: Buffer, iv: Buffer): string;
+declare function verifySignatureDefault(buffer: Buffer, signature: string, cert: string): string | undefined;
+
+export { decrypt as d, verifySignatureDefault as v };