electron-incremental-update 1.1.0 → 1.3.0

package/README.md

@@ -10,7 +10,7 @@ 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.
 
-no `vite-plugin-electron-renderer` config
+No `vite-plugin-electron-renderer` config
 
 - inspired by [Obsidian](https://obsidian.md/)'s upgrade strategy
 
@@ -57,16 +57,17 @@ import { initApp } from 'electron-incremental-update'
 import { parseGithubCdnURL } from 'electron-incremental-update/utils'
 import { repository } from '../package.json'
 
-const SIGNATURE_CERT = '' // auto generate certificate when start app
-
-initApp({ onStart: console.log })
-  .setUpdater({
-    SIGNATURE_CERT,
-    // repository,
-    // updateJsonURL: parseGithubCdnURL(repository, 'https://your.cdn.url/', 'version.json'),
-    // releaseAsarURL: parseGithubCdnURL(repository, 'https://your.cdn.url/', `download/latest/${name}.asar.gz`),
-    // receiveBeta: true
-  })
+initApp({
+  // can be updater option or function that return updater
+  updater: {
+    SIGNATURE_CERT: 'custom certificate',
+    repository,
+    updateJsonURL: parseGithubCdnURL(repository, jsonPrefix, 'version.json'),
+    releaseAsarURL: parseGithubCdnURL(repository, asarPrefix, `download/latest/${app.name}.asar.gz`),
+    receiveBeta: true,
+  },
+  onStart: console.log
+})
 ```
 
 - [some CDN resources](https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L34):
@@ -83,14 +84,12 @@ in `vite.config.mts`
 ```ts
 import { defineConfig } from 'vite'
 import { debugStartup, electronWithUpdater } from 'electron-incremental-update/vite'
-import pkg from './package.json'
 
 export default defineConfig(async ({ command }) => {
   const isBuild = command === 'build'
   return {
     plugins: [
       electronWithUpdater({
-        pkg,
         isBuild,
         logParsedOptions: true,
         main: {
@@ -160,12 +159,23 @@ module.exports = {
 
 ### Use in main process
 
-To use electron's `net` module for updating, the `checkUpdate` and `download` functions must be called after the app is ready by default.
-
-However, you have the option to customize the download function when creating the updater.
+To use electron's `net` module for updating, the `checkUpdate` and `download` functions must be called after the app is ready by default. You have the option to customize the download function when creating the updater.
 
 **NOTE: There should only one function and should be default export in the entry file**
 
+in `electron/entry.ts`
+
+```ts
+initApp({
+  updater: {
+    overrideFunctions: {
+      downloadJSON: (url: string, headers: Record<string, any>) => {}
+      // ...
+    }
+  },
+})
+```
+
 in `electron/main/index.ts`
 
 ```ts
@@ -214,7 +224,16 @@ export default startupWithUpdater((updater) => {
 
 All the **native modules** should be set as `dependency` in `package.json`. `electron-rebuild` only check dependencies inside `dependency` field.
 
-If you are using `electron-builder` to build distributions, all the native modules with its **large relavent `node_modiles`** will be packaged into `app.asar` by default. You can setup `nativeModuleEntryMap` option to prebundle all the native modules and skip bundled by `electron-builder`
+If you are using `electron-builder` to build distributions, all the native modules with its **large relavent `node_modiles`** will be packaged into `app.asar` by default.
+
+Luckily, `Esbuild` can bundle all the dependencies. Just follow the steps:
+
+1. setup `nativeModuleEntryMap` option
+2. Manually copy the native binaries in `postBuild` callback
+3. Exclude all the dependencies in `electron-builder`'s config
+4. call the native functions with `loadNativeModuleFromEntry` in your code
+
+#### Example
 
 in `vite.config.ts`
 
@@ -225,6 +244,7 @@ const plugin = electronWithUpdater({
     entry: {
       nativeModuleEntryMap: {
         db: './electron/native/db.ts',
+        img: './electron/native/img.ts',
       },
       postBuild: async ({ copyToEntryOutputDir }) => {
         // for better-sqlite3
@@ -249,9 +269,8 @@ in `electron/native/db.ts`
 
 ```ts
 import Database from 'better-sqlite3'
-import { getPaths } from 'electron-incremental-update/utils'
 
-const db = new Database(':memory:', { nativeBinding: getPaths().getPathFromEntryAsar('better_sqlite3.node') })
+const db = new Database(':memory:', { nativeBinding: './better_sqlite3.node' })
 
 export function test() {
   db.exec(
@@ -296,14 +315,119 @@ module.exports = {
 
 ### Bytecode protection
 
-WIP
+From v1.2, the vite plugin is able to generate bytecode to protect your application.
 
-plan to use [electron-vite](https://github.com/alex8088/electron-vite/blob/master/src/plugins/bytecode.ts), but fail to load the default function in `${electron.app.name}.asar/dist-electron/index.js`.
+It will automatically protect your `SIGNATURE_CERT` by default.
 
-try to wrap with [`Module.wrap`](https://github.com/bytenode/bytenode?tab=readme-ov-file#bytenodecompileelectroncodejavascriptcode-options--promisebuffer), but still fail.
+credit to [electron-vite](https://github.com/alex8088/electron-vite/blob/master/src/plugins/bytecode.ts), and improve the string protection (see [original issue](https://github.com/alex8088/electron-vite/issues/552))
+
+```ts
+electronWithUpdater({
+  // ...
+  bytecode: true,
+})
+```
+
+#### Limitation
+
+- only support commonjs
+- only for main process by default, if you want to use in preload script, please use `electronWithUpdater({ bytecode: { enablePreload: true } })` and set `sandbox: false` when creating window
 
 ### Types
 
+#### Updater
+
+```ts
+export interface UpdaterOption {
+  /**
+   * public key of signature, which will be auto generated by plugin,
+   * generate by `selfsigned` if not set
+   */
+  SIGNATURE_CERT?: string
+  /**
+   * repository url, e.g. `https://github.com/electron/electron`
+   *
+   * you can use the `repository` in `package.json`
+   *
+   * if `updateJsonURL` or `releaseAsarURL` are absent,
+   * `repository` will be used to determine the url
+   */
+  repository?: string
+  /**
+   * URL of version info json
+   * @default `${repository.replace('github.com', 'raw.githubusercontent.com')}/master/version.json`
+   * @throws if `updateJsonURL` and `repository` are all not set
+   */
+  updateJsonURL?: string
+  /**
+   * URL of release asar.gz
+   * @default `${repository}/releases/download/v${version}/${app.name}-${version}.asar.gz`
+   * @throws if `releaseAsarURL` and `repository` are all not set
+   */
+  releaseAsarURL?: string
+  /**
+   * whether to receive beta update
+   */
+  receiveBeta?: boolean
+  overrideFunctions?: UpdaterOverrideFunctions
+  downloadConfig?: UpdaterDownloadConfig
+}
+export type Logger = {
+  info: (msg: string) => void
+  debug: (msg: string) => void
+  warn: (msg: string) => void
+  error: (msg: string, e?: Error) => void
+}
+
+export type UpdaterOverrideFunctions = {
+  /**
+   * custom version compare function
+   * @param version1 old version string
+   * @param version2 new version string
+   * @returns if version1 < version2
+   */
+  isLowerVersion?: (version1: string, version2: string) => boolean | Promise<boolean>
+  /**
+   * custom verify signature function
+   * @param buffer file buffer
+   * @param signature signature
+   * @param cert certificate
+   * @returns if signature is valid, returns the version or `true` , otherwise returns `false`
+   */
+  verifySignaure?: (buffer: Buffer, signature: string, cert: string) => string | false | Promise<string | false>
+  /**
+   * custom download JSON function
+   * @param url download url
+   * @param header download header
+   * @returns `UpdateJSON`
+   */
+  downloadJSON?: (url: string, headers: Record<string, any>) => Promise<UpdateJSON>
+  /**
+   * custom download buffer function
+   * @param url download url
+   * @param headers download header
+   * @param total precaculated file total size
+   * @param onDownloading on downloading callback
+   * @returns `Buffer`
+   */
+  downloadBuffer?: (url: string, headers: Record<string, any>, total: number, onDownloading?: (progress: DownloadingInfo) => void) => Promise<Buffer>
+}
+
+export type UpdaterDownloadConfig = {
+  /**
+   * download user agent
+   * @default 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36'
+   */
+  userAgent?: string
+  /**
+   * extra download header, `accept` and `user-agent` is set by default
+   */
+  extraHeader?: Record<string, string>
+}
+```
+
+#### Plugin
+
 ```ts
 type ElectronWithUpdaterOptions = {
   /**
@@ -316,7 +440,7 @@ type ElectronWithUpdaterOptions = {
    */
   isBuild: boolean
   /**
-   * manullay setup package.json, read name, version and main
+   * manually setup package.json, read name, version and main
    * ```ts
    * import pkg from './package.json'
    * ```
@@ -330,6 +454,14 @@ type ElectronWithUpdaterOptions = {
    * whether to minify the code
    */
   minify?: boolean
+  /**
+   * whether to generate bytecode
+   *
+   * **only support commonjs**
+   *
+   * only main process by default, if you want to use in preload script, please use `electronWithUpdater({ bytecode: { enablePreload: true } })` and set `sandbox: false` when creating window
+   */
+  bytecode?: boolean | BytecodeOptions
   /**
    * use NotBundle() plugin in main
    * @default true
@@ -337,8 +469,10 @@ type ElectronWithUpdaterOptions = {
   useNotBundle?: boolean
   /**
    * Whether to log parsed options
+   *
+   * to show certificate and private keys, set `logParsedOptions: { showKeys: true }`
    */
-  logParsedOptions?: boolean
+  logParsedOptions?: boolean | { showKeys: boolean }
   /**
    * main options
    */
@@ -471,7 +605,7 @@ type BuildEntryOption = {
    */
   nativeModuleEntryMap?: Record<string, string>
   /**
-   * custom options for esbuild
+   * override options for esbuild
    * ```ts
    * // default options
    * const options = {
@@ -490,6 +624,9 @@ type BuildEntryOption = {
    *   loader: {
    *     '.node': 'empty',
    *   },
+   *   define: {
+   *     __SIGNATURE_CERT__: JSON.stringify(cert),
+   *   },
    * }
    * ```
    */

package/dist/chunk-7ET4GMTZ.js

@@ -0,0 +1,236 @@
+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 { basename, dirname, join } from "node:path";
+import { release } from "node:os";
+import { app } from "electron";
+var is = {
+  dev: !app.isPackaged,
+  win: process.platform === "win32",
+  mac: process.platform === "darwin",
+  linux: process.platform === "linux"
+};
+function getPathFromAppNameAsar(...path) {
+  return is.dev ? "DEV.asar" : join(dirname(app.getAppPath()), `${electron.app.name}.asar`, ...path);
+}
+function getVersions() {
+  const platform = is.win ? "Windows" : is.mac ? "MacOS" : process.platform.toUpperCase();
+  return {
+    appVersion: is.dev ? app.getVersion() : readFileSync(getPathFromAppNameAsar("version"), "utf-8"),
+    entryVersion: app.getVersion(),
+    electronVersion: process.versions.electron,
+    nodeVersion: process.versions.node,
+    systemVersion: `${platform} ${release()}`
+  };
+}
+function loadNativeModuleFromEntry(devEntryDirPath = "../../dist-entry", entryDirPath = join(app.getAppPath(), basename(devEntryDirPath))) {
+  const path = is.dev ? devEntryDirPath : entryDirPath;
+  return (moduleName) => {
+    try {
+      return __require(join(path, moduleName));
+    } catch (error) {
+      console.error("fail to load module", error);
+    }
+  };
+}
+function restartApp() {
+  app.relaunch();
+  app.quit();
+}
+function setAppUserModelId(id) {
+  app.setAppUserModelId(is.dev ? process.execPath : id ?? `org.${electron.app.name}`);
+}
+function disableHWAccForWin7() {
+  if (release().startsWith("6.1")) {
+    app.disableHardwareAcceleration();
+  }
+}
+function singleInstance(window) {
+  const result = app.requestSingleInstanceLock();
+  result ? app.on("second-instance", () => {
+    if (window) {
+      window.show();
+      if (window.isMinimized()) {
+        window.restore();
+      }
+      window.focus();
+    }
+  }) : 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 getPaths(entryDirName = "dist-entry") {
+  const root = join(__dirname, "..");
+  const mainDirPath = join(root, "main");
+  const preloadDirPath = join(root, "preload");
+  const rendererDirPath = join(root, "renderer");
+  const devServerURL = process.env.VITE_DEV_SERVER_URL;
+  const indexHTMLPath = join(rendererDirPath, "index.html");
+  const publicDirPath = devServerURL ? join(root, "../public") : rendererDirPath;
+  return {
+    /**
+     * @example
+     * ```ts
+     * devServerURL && win.loadURL(devServerURL)
+     * ```
+     */
+    devServerURL,
+    /**
+     * @example
+     * ```ts
+     * win.loadFile(indexHTMLPath)
+     * ```
+     */
+    indexHTMLPath,
+    /**
+     * get path inside entry asar
+     * @param paths joined path
+     */
+    getPathFromEntryAsar(...paths) {
+      return join(app.getAppPath(), entryDirName, ...paths);
+    },
+    /**
+     * get path inside `${electron.app.name}.asar/main`
+     * @param paths joined path
+     */
+    getPathFromMain(...paths) {
+      return join(mainDirPath, ...paths);
+    },
+    /**
+     * get path inside `${electron.app.name}.asar/preload`
+     * @param paths joined path
+     */
+    getPathFromPreload(...paths) {
+      return join(preloadDirPath, ...paths);
+    },
+    /**
+     * get path inside public dir
+     * @param paths joined path
+     */
+    getPathFromPublic(...paths) {
+      return join(publicDirPath, ...paths);
+    }
+  };
+}
+
+// src/utils/zip.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, rmSync, writeFileSync } from "node:fs";
+import { brotliCompress, brotliDecompress } from "node:zlib";
+async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
+  if (!existsSync2(gzipPath)) {
+    throw new Error(`path to zipped file not exist: ${gzipPath}`);
+  }
+  const compressedBuffer = readFileSync2(gzipPath);
+  return new Promise((resolve, reject) => {
+    brotliDecompress(compressedBuffer, (err, buffer) => {
+      rmSync(gzipPath);
+      if (err) {
+        reject(err);
+      }
+      writeFileSync(targetFilePath, buffer);
+      resolve(null);
+    });
+  });
+}
+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(null);
+    });
+  });
+}
+
+// src/utils/pure.ts
+function parseGithubCdnURL(originRepoURL, cdnPrefix, relativeFilePath) {
+  if (!originRepoURL.startsWith("https://github.com/")) {
+    throw new Error("origin url must start with https://github.com/");
+  }
+  originRepoURL = originRepoURL.trim().replace(/\/?$/, "/").trim();
+  relativeFilePath = relativeFilePath.trim().replace(/^\/|\/?$/g, "").trim();
+  cdnPrefix = cdnPrefix.trim().replace(/^\/?|\/?$/g, "").trim();
+  return originRepoURL.replace("github.com", cdnPrefix) + relativeFilePath;
+}
+function handleUnexpectedErrors(callback) {
+  process.on("uncaughtException", callback);
+  process.on("unhandledRejection", callback);
+}
+function parseVersion(version) {
+  const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-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 (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch) || Number.isNaN(ret.stageVersion)) {
+    throw new TypeError(`invalid version: ${version}`);
+  }
+  return ret;
+}
+function isUpdateJSON(json) {
+  const is2 = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
+  return is2(json) && is2(json?.beta);
+}
+
+export {
+  __require,
+  is,
+  getPathFromAppNameAsar,
+  getVersions,
+  loadNativeModuleFromEntry,
+  restartApp,
+  setAppUserModelId,
+  disableHWAccForWin7,
+  singleInstance,
+  setPortableAppDataPath,
+  waitAppReady,
+  getPaths,
+  unzipFile,
+  zipFile,
+  parseGithubCdnURL,
+  handleUnexpectedErrors,
+  parseVersion,
+  isUpdateJSON
+};