electron-incremental-update 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 subframe7536
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,299 @@
+## electron incremental updater
+
+inspired by Obsidian's update strategy, using RSA + Signature to sign the update asar and replace the old one when verified
+
+develop with [vite-plugin-electron](https://github.com/electron-vite/vite-plugin-electron), and may be effect in other electron vite frameworks
+
+### install
+
+#### npm
+```bash
+npm install electron-incremental-update
+```
+#### yarn
+```bash
+yarn add electron-incremental-update
+```
+#### pnpm
+```bash
+pnpm add electron-incremental-update
+```
+
+### usage
+
+base on [electron-vite-vue](https://github.com/electron-vite/electron-vite-vue)
+
+```
+electron
+├── app.ts // <- add app entry file
+├── electron-env.d.ts
+├── main
+│   ├── db.ts
+│   ├── index.ts
+└── preload
+    └── index.ts
+src
+└── ...
+```
+
+#### setup app
+
+```ts
+// electron/app.ts
+import { createUpdater, initApp } from 'electron-incremental-update'
+import { name, repository } from '../package.json'
+
+const SIGNATURE_PUB = '' // auto generate RSA public key when start app
+
+const updater = createUpdater({
+  SIGNATURE_PUB,
+  githubRepository: repository,
+  productName: name,
+})
+initApp(name, updater)
+```
+
+#### setup main
+
+```ts
+// electron/main/index.ts
+import type { Updater } from 'electron-incremental-update'
+import { getAppAsarPath, getAppVersion, getElectronVersion } 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(`\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
+    }
+  })
+  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(() => {
+    // ...
+  })
+}
+```
+
+#### use native modules
+
+```ts
+// db.ts
+import { requireNative } from 'electron-incremental-update'
+
+const Database = requireNative<typeof import('better-sqlite3')>('better-sqlite3')
+const db = new Database(':memory:')
+db.exec(
+  'DROP TABLE IF EXISTS employees; '
+    + 'CREATE TABLE IF NOT EXISTS employees (name TEXT, salary INTEGER)',
+)
+
+db.prepare('INSERT INTO employees VALUES (:n, :s)').run({
+  n: 'James',
+  s: 50000,
+})
+
+const r = db.prepare('SELECT * from employees').all()
+console.log(r)
+// [ { name: 'James', salary: 50000 } ]
+
+db.close()
+```
+
+#### setup vite.config.ts
+
+```ts
+import { rmSync } from 'node:fs'
+import { defineConfig } from 'vite'
+import electron from 'vite-plugin-electron'
+import updater from 'electron-incremental-update/vite'
+import pkg from './package.json'
+
+// https://vitejs.dev/config/
+
+export default defineConfig(({ command }) => {
+  rmSync('dist-electron', { recursive: true, force: true })
+
+  const isServe = command === 'serve'
+  const isBuild = command === 'build'
+  const sourcemap = isServe || !!process.env.VSCODE_DEBUG
+
+  return {
+    plugins: [
+      electron([
+        {
+          // Main-Process entry file of the Electron App.
+          entry: ['electron/main/index.ts'],
+          onstart(options) {
+            if (process.env.VSCODE_DEBUG) {
+              console.log(/* For `.vscode/.debug.script.mjs` */'[startup] Electron App')
+            } else {
+              options.startup()
+            }
+          },
+          vite: {
+            plugins: [
+              updater({ // options see below
+                productName: pkg.name,
+                version: pkg.version,
+                isBuild,
+              }),
+            ],
+            build: {
+              sourcemap,
+              minify: false,
+              outDir: 'dist-electron/main',
+              rollupOptions: {
+                external: Object.keys('dependencies' in pkg ? pkg.dependencies : {}),
+                treeshake: true,
+              },
+            },
+          },
+        },
+        {
+          // ...preload
+        },
+      ]),
+      // ... other plugins
+    ],
+    // ... other config
+  }
+})
+```
+
+##### option
+
+```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
+  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 app entry 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
+  }
+  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
+const { name } = require('./package.json')
+
+const target = `${name}.asar`
+/**
+ * @type {import('electron-builder').Configuration}
+ */
+module.exports = {
+  appId: 'YourAppID',
+  productName: name,
+  files: [
+    'app.js', // <- app entry file
+    '!**/{.eslintignore,.eslintrc.cjs,.editorconfig,.prettierignore,.prettierrc.yaml,dev-app-update.yml,LICENSE,.nvmrc,.npmrc}',
+    '!**/{tsconfig.json,tsconfig.node.json,tsconfig.web.json}',
+    '!**/*debug*.*',
+    '!**/*.{md,zip,map}',
+    '!**/*.{c,cpp,h,hpp,cc,hh,cxx,hxx,gypi,gyp,sh}',
+    '!**/.{github,vscode}',
+    '!node_modules/**/better-sqlite3/deps/**',
+  ],
+  asarUnpack: [
+    '**/*.{node,dll}',
+  ],
+  directories: {
+    output: 'release',
+  },
+  extraResources: [
+    { from: `release/${target}`, to: target }, // <- asar file
+  ],
+  publish: null,
+  // ...
+}
+```

package/dist/chunk-AKU6F3WT.mjs

@@ -0,0 +1,11 @@
+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');
+});
+
+export {
+  __require
+};

package/dist/index.cjs

@@ -0,0 +1,228 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 });
+  }
+  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,
+  getElectronVersion: () => getElectronVersion,
+  getReleaseDnsPrefix: () => getReleaseDnsPrefix,
+  initApp: () => initApp,
+  requireNative: () => requireNative
+});
+module.exports = __toCommonJS(src_exports);
+var import_node_path2 = require("path");
+var import_electron3 = require("electron");
+
+// src/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 getElectronVersion() {
+  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").trim() : getElectronVersion();
+}
+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 getReleaseDnsPrefix() {
+  const hub = "https://github.com";
+  return [
+    { urlPrefix: `https://gh.gh2233.ml/${hub}`, maintainer: "@X.I.U/XIU2" },
+    { urlPrefix: `https://ghproxy.com/${hub}`, maintainer: "gh-proxy" },
+    { urlPrefix: `https://gh.ddlc.top/${hub}`, maintainer: "@mtr-static-official" },
+    { urlPrefix: `https://ghdl.feizhuqwq.cf/${hub}`, maintainer: "feizhuqwq.com" },
+    { urlPrefix: `https://slink.ltd/${hub}`, maintainer: "\u77E5\u4E86\u5C0F\u7AD9" },
+    { urlPrefix: `https://git.xfj0.cn/${hub}`, maintainer: "anonymous1" },
+    { urlPrefix: `https://gh.con.sh/${hub}`, maintainer: "anonymous2" },
+    { urlPrefix: `https://ghps.cc/${hub}`, maintainer: "anonymous3" },
+    { urlPrefix: "https://cors.isteed.cc/github.com", maintainer: "Lufs's" },
+    { urlPrefix: `https://hub.gitmirror.com/${hub}`, maintainer: "GitMirror" },
+    { urlPrefix: `https://js.xxooo.ml/${hub}`, maintainer: "\u996D\u592A\u786C" },
+    { urlPrefix: `https://proxy.freecdn.ml/?url=${hub}`, maintainer: "anonymous4" },
+    { urlPrefix: "https://download.njuu.cf", maintainer: "LibraryCloud-njuu" },
+    { urlPrefix: "https://download.yzuu.cf", maintainer: "LibraryCloud-yzuu" },
+    { urlPrefix: "https://download.nuaa.cf", maintainer: "LibraryCloud-nuaa" }
+  ];
+}
+
+// src/updater.ts
+var import_node_events = require("events");
+var import_node_buffer = require("buffer");
+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_node_https = __toESM(require("https"), 1);
+var import_electron2 = require("electron");
+function createUpdater({
+  SIGNATURE_PUB,
+  githubRepository: repository,
+  productName,
+  releaseCdnPrefix
+}) {
+  const updater = new import_node_events.EventEmitter();
+  async function download(url, format) {
+    const ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36";
+    return await new Promise((resolve2, reject) => {
+      import_node_https.default.get(url, (res) => {
+        if (format === "json") {
+          let data = "";
+          res.setEncoding("utf8");
+          res.headers = {
+            Accept: "application/json",
+            UserAgent: ua
+          };
+          res.on("data", (chunk) => data += chunk);
+          res.on("end", () => {
+            resolve2(JSON.parse(data));
+          });
+        } else if (format === "buffer") {
+          let data = [];
+          res.headers = {
+            Accept: "application/octet-stream",
+            UserAgent: ua
+          };
+          res.on("data", (chunk) => {
+            updater.emit("downloading", chunk.length);
+            data.push(chunk);
+          });
+          res.on("end", () => {
+            updater.emit("downloadEnd", true);
+            resolve2(import_node_buffer.Buffer.concat(data));
+          });
+        }
+      }).on("error", (e) => {
+        e && updater.emit("donwnloadError", e);
+        reject(e);
+      });
+    });
+  }
+  async function extractFile(gzipFilePath) {
+    if (!gzipFilePath.endsWith(".asar.gz") || !(0, import_node_fs2.existsSync)(gzipFilePath)) {
+      return;
+    }
+    gzipFilePath = gzipFilePath.replace(".asar.gz", ".tmp.gz");
+    return new Promise((resolve2, 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);
+      input.pipe(gunzip).pipe(output).on("finish", async () => {
+        await (0, import_promises.rm)(gzipFilePath);
+        resolve2(outputFilePath);
+      }).on("error", async (err) => {
+        await (0, import_promises.rm)(gzipFilePath);
+        output.destroy(err);
+        reject(err);
+      });
+    });
+  }
+  function verify(buffer, signature) {
+    return (0, import_node_crypto.createVerify)("RSA-SHA256").update(buffer).verify(SIGNATURE_PUB, signature, "base64");
+  }
+  function needUpdate(version) {
+    const parseVersion = (version2) => {
+      const [major, minor, patch] = version2.split(".");
+      return ~~major * 100 + ~~minor * 10 + ~~patch;
+    };
+    return import_electron2.app.isPackaged && parseVersion(import_electron2.app.getVersion()) < parseVersion(version);
+  }
+  async function checkUpdate(releaseCdnPrefix2) {
+    const gzipPath = `../${productName}.asar.gz`;
+    const tmpFile = gzipPath.replace(".asar.gz", ".tmp.gz");
+    const base = repository.replace("https://github.com", "");
+    const updateJSONUrl = `https://cdn.jsdelivr.net/gh/${base}/version.json`;
+    const downloadUrl = `${releaseCdnPrefix2 ? `${releaseCdnPrefix2}/${base}` : repository}/releases/download/latest/${productName}.asar.gz`;
+    if ((0, import_node_fs2.existsSync)(tmpFile)) {
+      await (0, import_promises.rm)(tmpFile);
+    }
+    const json = await download(updateJSONUrl, "json");
+    if (!json) {
+      throw new Error("fetch update json failed");
+    }
+    const {
+      signature,
+      version,
+      size
+    } = json;
+    console.log(version, size, signature);
+    if (!needUpdate(version)) {
+      return "unavailable";
+    }
+    updater.emit("downloadStart", size);
+    const buffer = await download(downloadUrl, "buffer");
+    if (!verify(buffer, signature)) {
+      throw new Error("file broken, invalid signature!");
+    }
+    await (0, import_promises.writeFile)(gzipPath, buffer);
+    await extractFile(gzipPath);
+    return "success";
+  }
+  const onCheck = async () => {
+    try {
+      const result = await checkUpdate(releaseCdnPrefix);
+      updater.emit("checkResult", result);
+    } catch (error) {
+      updater.emit("checkResult", "fail", error);
+    }
+  };
+  updater.on("check", onCheck);
+  updater.checkUpdate = onCheck;
+  return updater;
+}
+
+// src/index.ts
+function initApp(productName, updater, option) {
+  const {
+    electronDistPath = "dist-electron",
+    mainPath = "main/index.js"
+  } = option ?? {};
+  const mainDir = import_electron3.app.isPackaged ? `../${productName}.asar` : electronDistPath;
+  const entry = (0, import_node_path2.resolve)(__dirname, mainDir, mainPath);
+  return require(entry)(updater);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createUpdater,
+  getAppAsarPath,
+  getAppVersion,
+  getElectronVersion,
+  getReleaseDnsPrefix,
+  initApp,
+  requireNative
+});

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+type CheckResultType = 'success' | 'fail' | 'unavailable';
+type UpdateEvents = {
+    check: null;
+    checkResult: [data: CheckResultType, err?: unknown];
+    downloadStart: [size: number];
+    downloading: [current: number];
+    downloadEnd: [success: boolean];
+    donwnloadError: [error: unknown];
+};
+type MaybeArray<T> = T extends undefined | null | never ? [] : T extends any[] ? T['length'] extends 1 ? [data: T[0]] : T : [data: T];
+interface TypedUpdater<T extends Record<string | symbol, MaybeArray<any>>, Event extends Exclude<keyof T, number> = Exclude<keyof T, number>> {
+    removeAllListeners<E extends Event>(event?: E): this;
+    listeners<E extends Event>(eventName: E): Function[];
+    eventNames(): (Event)[];
+    on<E extends Event>(eventName: E, listener: (...data: MaybeArray<T[E]>) => void): this;
+    once<E extends Event>(eventName: E, listener: (...args: MaybeArray<T[E]>) => void): this;
+    emit<E extends Event>(eventName: E, ...args: MaybeArray<T[E]>): boolean;
+    off<E extends Event>(eventName: E, listener: (...args: MaybeArray<T[E]>) => void): this;
+    checkUpdate(releaseCdnPrefix?: string): Promise<void>;
+}
+type Updater = TypedUpdater<UpdateEvents>;
+interface Options {
+    SIGNATURE_PUB: string;
+    productName: string;
+    githubRepository: string;
+    releaseCdnPrefix?: string;
+}
+declare function createUpdater({ SIGNATURE_PUB, githubRepository: repository, productName, releaseCdnPrefix, }: Options): Updater;
+
+declare function getAppAsarPath(name: string): string;
+declare function getElectronVersion(): string;
+declare function getAppVersion(name: string): string;
+declare function requireNative<T = any>(packageName: string): T;
+declare function getReleaseDnsPrefix(): {
+    urlPrefix: string;
+    maintainer: string;
+}[];
+
+interface PathConfig {
+    /**
+     * path of electron output dist
+     * @default 'dist-electron'
+     */
+    electronDistPath?: string;
+    /**
+     * relative path of main entry in electron dist
+     * @default 'main/index.js'
+     */
+    mainPath?: string;
+}
+/**
+ * Initialize application
+ * @param productName name of your application
+ * @param updater updater
+ * @param option options for entry, will be used to generate electron main path, default: `dist-electron/main/index.js`
+ * @returns a function to init your application with a updater
+ */
+declare function initApp(productName: string, updater: Updater, option?: PathConfig): any;
+
+export { Options, Updater, createUpdater, getAppAsarPath, getAppVersion, getElectronVersion, getReleaseDnsPrefix, initApp, requireNative };

package/dist/index.mjs

@@ -0,0 +1,191 @@
+import {
+  __require
+} from "./chunk-AKU6F3WT.mjs";
+
+// src/index.ts
+import { resolve } from "node:path";
+import { app as app3 } from "electron";
+
+// src/utils.ts
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { app } from "electron";
+function getAppAsarPath(name) {
+  return app.isPackaged ? join(dirname(app.getAppPath()), `${name}.asar`) : "dev";
+}
+function getElectronVersion() {
+  return app.getVersion();
+}
+function getAppVersion(name) {
+  return app.isPackaged ? readFileSync(join(getAppAsarPath(name), "version"), "utf-8").trim() : getElectronVersion();
+}
+function requireNative(packageName) {
+  const path = app.isPackaged ? join(app.getAppPath(), "node_modules", packageName) : packageName;
+  return __require(path);
+}
+function getReleaseDnsPrefix() {
+  const hub = "https://github.com";
+  return [
+    { urlPrefix: `https://gh.gh2233.ml/${hub}`, maintainer: "@X.I.U/XIU2" },
+    { urlPrefix: `https://ghproxy.com/${hub}`, maintainer: "gh-proxy" },
+    { urlPrefix: `https://gh.ddlc.top/${hub}`, maintainer: "@mtr-static-official" },
+    { urlPrefix: `https://ghdl.feizhuqwq.cf/${hub}`, maintainer: "feizhuqwq.com" },
+    { urlPrefix: `https://slink.ltd/${hub}`, maintainer: "\u77E5\u4E86\u5C0F\u7AD9" },
+    { urlPrefix: `https://git.xfj0.cn/${hub}`, maintainer: "anonymous1" },
+    { urlPrefix: `https://gh.con.sh/${hub}`, maintainer: "anonymous2" },
+    { urlPrefix: `https://ghps.cc/${hub}`, maintainer: "anonymous3" },
+    { urlPrefix: "https://cors.isteed.cc/github.com", maintainer: "Lufs's" },
+    { urlPrefix: `https://hub.gitmirror.com/${hub}`, maintainer: "GitMirror" },
+    { urlPrefix: `https://js.xxooo.ml/${hub}`, maintainer: "\u996D\u592A\u786C" },
+    { urlPrefix: `https://proxy.freecdn.ml/?url=${hub}`, maintainer: "anonymous4" },
+    { urlPrefix: "https://download.njuu.cf", maintainer: "LibraryCloud-njuu" },
+    { urlPrefix: "https://download.yzuu.cf", maintainer: "LibraryCloud-yzuu" },
+    { urlPrefix: "https://download.nuaa.cf", maintainer: "LibraryCloud-nuaa" }
+  ];
+}
+
+// src/updater.ts
+import { EventEmitter } from "node:events";
+import { Buffer } from "node:buffer";
+import { createVerify } from "node:crypto";
+import { createGunzip } from "node:zlib";
+import { createReadStream, createWriteStream, existsSync } from "node:fs";
+import { rm, writeFile } from "node:fs/promises";
+import https from "node:https";
+import { app as app2 } from "electron";
+function createUpdater({
+  SIGNATURE_PUB,
+  githubRepository: repository,
+  productName,
+  releaseCdnPrefix
+}) {
+  const updater = new EventEmitter();
+  async function download(url, format) {
+    const ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36";
+    return await new Promise((resolve2, reject) => {
+      https.get(url, (res) => {
+        if (format === "json") {
+          let data = "";
+          res.setEncoding("utf8");
+          res.headers = {
+            Accept: "application/json",
+            UserAgent: ua
+          };
+          res.on("data", (chunk) => data += chunk);
+          res.on("end", () => {
+            resolve2(JSON.parse(data));
+          });
+        } else if (format === "buffer") {
+          let data = [];
+          res.headers = {
+            Accept: "application/octet-stream",
+            UserAgent: ua
+          };
+          res.on("data", (chunk) => {
+            updater.emit("downloading", chunk.length);
+            data.push(chunk);
+          });
+          res.on("end", () => {
+            updater.emit("downloadEnd", true);
+            resolve2(Buffer.concat(data));
+          });
+        }
+      }).on("error", (e) => {
+        e && updater.emit("donwnloadError", e);
+        reject(e);
+      });
+    });
+  }
+  async function extractFile(gzipFilePath) {
+    if (!gzipFilePath.endsWith(".asar.gz") || !existsSync(gzipFilePath)) {
+      return;
+    }
+    gzipFilePath = gzipFilePath.replace(".asar.gz", ".tmp.gz");
+    return new Promise((resolve2, reject) => {
+      const gunzip = createGunzip();
+      const input = createReadStream(gzipFilePath);
+      const outputFilePath = gzipFilePath.replace(".tmp.gz", ".asar");
+      const output = createWriteStream(outputFilePath);
+      input.pipe(gunzip).pipe(output).on("finish", async () => {
+        await rm(gzipFilePath);
+        resolve2(outputFilePath);
+      }).on("error", async (err) => {
+        await rm(gzipFilePath);
+        output.destroy(err);
+        reject(err);
+      });
+    });
+  }
+  function verify(buffer, signature) {
+    return createVerify("RSA-SHA256").update(buffer).verify(SIGNATURE_PUB, signature, "base64");
+  }
+  function needUpdate(version) {
+    const parseVersion = (version2) => {
+      const [major, minor, patch] = version2.split(".");
+      return ~~major * 100 + ~~minor * 10 + ~~patch;
+    };
+    return app2.isPackaged && parseVersion(app2.getVersion()) < parseVersion(version);
+  }
+  async function checkUpdate(releaseCdnPrefix2) {
+    const gzipPath = `../${productName}.asar.gz`;
+    const tmpFile = gzipPath.replace(".asar.gz", ".tmp.gz");
+    const base = repository.replace("https://github.com", "");
+    const updateJSONUrl = `https://cdn.jsdelivr.net/gh/${base}/version.json`;
+    const downloadUrl = `${releaseCdnPrefix2 ? `${releaseCdnPrefix2}/${base}` : repository}/releases/download/latest/${productName}.asar.gz`;
+    if (existsSync(tmpFile)) {
+      await rm(tmpFile);
+    }
+    const json = await download(updateJSONUrl, "json");
+    if (!json) {
+      throw new Error("fetch update json failed");
+    }
+    const {
+      signature,
+      version,
+      size
+    } = json;
+    console.log(version, size, signature);
+    if (!needUpdate(version)) {
+      return "unavailable";
+    }
+    updater.emit("downloadStart", size);
+    const buffer = await download(downloadUrl, "buffer");
+    if (!verify(buffer, signature)) {
+      throw new Error("file broken, invalid signature!");
+    }
+    await writeFile(gzipPath, buffer);
+    await extractFile(gzipPath);
+    return "success";
+  }
+  const onCheck = async () => {
+    try {
+      const result = await checkUpdate(releaseCdnPrefix);
+      updater.emit("checkResult", result);
+    } catch (error) {
+      updater.emit("checkResult", "fail", error);
+    }
+  };
+  updater.on("check", onCheck);
+  updater.checkUpdate = onCheck;
+  return updater;
+}
+
+// src/index.ts
+function initApp(productName, updater, option) {
+  const {
+    electronDistPath = "dist-electron",
+    mainPath = "main/index.js"
+  } = option ?? {};
+  const mainDir = app3.isPackaged ? `../${productName}.asar` : electronDistPath;
+  const entry = resolve(__dirname, mainDir, mainPath);
+  return __require(entry)(updater);
+}
+export {
+  createUpdater,
+  getAppAsarPath,
+  getAppVersion,
+  getElectronVersion,
+  getReleaseDnsPrefix,
+  initApp,
+  requireNative
+};

package/dist/vite.cjs

@@ -0,0 +1,223 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 });
+  }
+  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/vite.ts
+var vite_exports = {};
+__export(vite_exports, {
+  default: () => vite_default
+});
+module.exports = __toCommonJS(vite_exports);
+var import_vite = require("vite");
+
+// src/build-entry.ts
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_crypto = require("crypto");
+var import_node_os = require("os");
+var import_ci_info = require("ci-info");
+var import_esbuild = require("esbuild");
+async function generateKey(privateKeyPath, publicKeyPath, length) {
+  const pair = (0, import_node_crypto.generateKeyPairSync)("rsa", { modulusLength: length });
+  const privateKey = pair.privateKey.export({ type: "pkcs1", format: "pem" });
+  const publicKey = pair.publicKey.export({ type: "pkcs1", format: "pem" });
+  await (0, import_promises.writeFile)(privateKeyPath, privateKey);
+  await (0, import_promises.writeFile)(publicKeyPath, publicKey);
+}
+async function writePublicKeyToMain(updatePath, publicKeyPath) {
+  const file = await (0, import_promises.readFile)(updatePath, "utf-8");
+  const key = await (0, import_promises.readFile)(publicKeyPath, "utf-8");
+  const regex = /const SIGNATURE_PUB = ['`][\s\S]*?['`]/;
+  const replacement = `const SIGNATURE_PUB = \`${key}\``;
+  let replaced = file;
+  const signaturePubExists = regex.test(file);
+  if (signaturePubExists) {
+    replaced = file.replace(regex, replacement);
+  } else {
+    const lines = file.split(import_node_os.EOL);
+    const r = `${import_node_os.EOL}${replacement}${import_node_os.EOL}`;
+    let isMatched = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line.startsWith("import") && !line.startsWith("/")) {
+        lines.splice(i, 0, r);
+        isMatched = true;
+        break;
+      }
+    }
+    !isMatched && lines.push(r);
+    replaced = lines.join(import_node_os.EOL);
+  }
+  await (0, import_promises.writeFile)(updatePath, replaced);
+}
+async function buildEntry({
+  privateKeyPath,
+  publicKeyPath,
+  entryPath,
+  entryOutputPath: outfile,
+  minify,
+  keyLength
+}) {
+  if (!import_ci_info.isCI) {
+    !(0, import_node_fs.existsSync)(privateKeyPath) && await generateKey(privateKeyPath, publicKeyPath, keyLength);
+    await writePublicKeyToMain(entryPath, publicKeyPath);
+  }
+  await (0, import_esbuild.build)({
+    entryPoints: [entryPath],
+    bundle: true,
+    platform: "node",
+    outfile,
+    minify,
+    external: ["electron"]
+  });
+}
+
+// src/build-asar.ts
+var import_node_crypto2 = require("crypto");
+var import_node_fs2 = require("fs");
+var import_promises2 = require("fs/promises");
+var import_node_zlib = __toESM(require("zlib"), 1);
+var import_ci_info2 = require("ci-info");
+function gzipFile(filePath) {
+  return new Promise((resolve, reject) => {
+    const gzip = import_node_zlib.default.createGzip();
+    const input = (0, import_node_fs2.createReadStream)(filePath);
+    const output = (0, import_node_fs2.createWriteStream)(`${filePath}.gz`);
+    input.pipe(gzip).pipe(output).on("finish", () => resolve(null)).on("error", (err) => reject(err));
+  });
+}
+function generateSignature(buffer, privateKey) {
+  return (0, import_node_crypto2.createSign)("RSA-SHA256").update(buffer).sign({
+    key: privateKey,
+    padding: import_node_crypto2.constants.RSA_PKCS1_PADDING,
+    saltLength: import_node_crypto2.constants.RSA_PSS_SALTLEN_DIGEST
+  }, "base64");
+}
+async function pack(dir, target) {
+  let asar = null;
+  try {
+    asar = await import("asar");
+  } catch (ignore) {
+  }
+  if (!asar) {
+    try {
+      asar = await import("@electron/asar");
+    } catch (ignore) {
+    }
+  }
+  if (!asar) {
+    throw new Error("no asar, please install @electron/asar");
+  }
+  await asar.createPackage(dir, target);
+}
+async function buildAsar({
+  version,
+  asarOutputPath,
+  privateKeyPath,
+  electronDistPath,
+  rendererDistPath
+}) {
+  await (0, import_promises2.rename)(rendererDistPath, `${electronDistPath}/renderer`);
+  await (0, import_promises2.writeFile)(`${electronDistPath}/version`, version);
+  await pack(electronDistPath, asarOutputPath);
+  if (import_ci_info2.isCI) {
+    return;
+  }
+  await gzipFile(asarOutputPath);
+  const buffer = await (0, import_promises2.readFile)(`${asarOutputPath}.gz`);
+  const signature = generateSignature(buffer, await (0, import_promises2.readFile)(privateKeyPath, "utf-8"));
+  await (0, import_promises2.writeFile)("version.json", JSON.stringify({
+    signature,
+    version,
+    size: buffer.length
+  }, null, 2));
+}
+
+// src/option.ts
+function parseOptions(options) {
+  const { isBuild, productName, version, minify = false, paths = {}, keys = {} } = options;
+  const {
+    entryPath = "electron/app.ts",
+    entryOutputPath = "app.js",
+    asarOutputPath = `release/${productName}.asar`,
+    electronDistPath = "dist-electron",
+    rendererDistPath = "dist"
+  } = paths;
+  const {
+    privateKeyPath = "public/private.pem",
+    publicKeyPath = "public/public.pem",
+    keyLength = 2048
+  } = keys;
+  const buildAsarOption = {
+    version,
+    productName,
+    asarOutputPath,
+    privateKeyPath,
+    electronDistPath,
+    rendererDistPath
+  };
+  const buildEntryOption = {
+    privateKeyPath,
+    publicKeyPath,
+    entryPath,
+    entryOutputPath,
+    minify,
+    keyLength
+  };
+  return { isBuild, buildAsarOption, buildEntryOption };
+}
+
+// src/vite.ts
+function vite_default(options) {
+  const { isBuild, buildAsarOption, buildEntryOption } = parseOptions(options);
+  const { entryPath, entryOutputPath } = buildEntryOption;
+  const { asarOutputPath } = buildAsarOption;
+  const id = "electron-incremental-updater";
+  const log = (0, import_vite.createLogger)("info", { prefix: `[${id}]` });
+  return [
+    {
+      name: `vite-plugin-${id}-entry`,
+      async buildStart() {
+        log.info("build entry start");
+        await buildEntry(buildEntryOption);
+        log.info(`build entry end, ${entryPath} -> ${entryOutputPath}`);
+      }
+    },
+    {
+      name: `vite-plugin-${id}-asar`,
+      async closeBundle() {
+        if (!isBuild) {
+          return;
+        }
+        log.info("build asar start");
+        await buildAsar(buildAsarOption);
+        log.info(`build asar end, output to ${asarOutputPath}`);
+      }
+    }
+  ];
+}

package/dist/vite.d.ts

@@ -0,0 +1,74 @@
+import { Plugin } from 'vite';
+
+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;
+    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 app entry 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;
+    };
+    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;
+    };
+};
+
+declare function export_default(options: Options): Plugin[];
+
+export { export_default as default };

package/dist/vite.mjs

@@ -0,0 +1,194 @@
+import "./chunk-AKU6F3WT.mjs";
+
+// src/vite.ts
+import { createLogger } from "vite";
+
+// src/build-entry.ts
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { generateKeyPairSync } from "node:crypto";
+import { EOL } from "node:os";
+import { isCI } from "ci-info";
+import { build } from "esbuild";
+async function generateKey(privateKeyPath, publicKeyPath, length) {
+  const pair = generateKeyPairSync("rsa", { modulusLength: length });
+  const privateKey = pair.privateKey.export({ type: "pkcs1", format: "pem" });
+  const publicKey = pair.publicKey.export({ type: "pkcs1", format: "pem" });
+  await writeFile(privateKeyPath, privateKey);
+  await writeFile(publicKeyPath, publicKey);
+}
+async function writePublicKeyToMain(updatePath, publicKeyPath) {
+  const file = await readFile(updatePath, "utf-8");
+  const key = await readFile(publicKeyPath, "utf-8");
+  const regex = /const SIGNATURE_PUB = ['`][\s\S]*?['`]/;
+  const replacement = `const SIGNATURE_PUB = \`${key}\``;
+  let replaced = file;
+  const signaturePubExists = regex.test(file);
+  if (signaturePubExists) {
+    replaced = file.replace(regex, replacement);
+  } else {
+    const lines = file.split(EOL);
+    const r = `${EOL}${replacement}${EOL}`;
+    let isMatched = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line.startsWith("import") && !line.startsWith("/")) {
+        lines.splice(i, 0, r);
+        isMatched = true;
+        break;
+      }
+    }
+    !isMatched && lines.push(r);
+    replaced = lines.join(EOL);
+  }
+  await writeFile(updatePath, replaced);
+}
+async function buildEntry({
+  privateKeyPath,
+  publicKeyPath,
+  entryPath,
+  entryOutputPath: outfile,
+  minify,
+  keyLength
+}) {
+  if (!isCI) {
+    !existsSync(privateKeyPath) && await generateKey(privateKeyPath, publicKeyPath, keyLength);
+    await writePublicKeyToMain(entryPath, publicKeyPath);
+  }
+  await build({
+    entryPoints: [entryPath],
+    bundle: true,
+    platform: "node",
+    outfile,
+    minify,
+    external: ["electron"]
+  });
+}
+
+// src/build-asar.ts
+import { constants, createSign } from "node:crypto";
+import { createReadStream, createWriteStream } from "node:fs";
+import { readFile as readFile2, rename, writeFile as writeFile2 } from "node:fs/promises";
+import zlib from "node:zlib";
+import { isCI as isCI2 } from "ci-info";
+function gzipFile(filePath) {
+  return new Promise((resolve, reject) => {
+    const gzip = zlib.createGzip();
+    const input = createReadStream(filePath);
+    const output = createWriteStream(`${filePath}.gz`);
+    input.pipe(gzip).pipe(output).on("finish", () => resolve(null)).on("error", (err) => reject(err));
+  });
+}
+function generateSignature(buffer, privateKey) {
+  return createSign("RSA-SHA256").update(buffer).sign({
+    key: privateKey,
+    padding: constants.RSA_PKCS1_PADDING,
+    saltLength: constants.RSA_PSS_SALTLEN_DIGEST
+  }, "base64");
+}
+async function pack(dir, target) {
+  let asar = null;
+  try {
+    asar = await import("asar");
+  } catch (ignore) {
+  }
+  if (!asar) {
+    try {
+      asar = await import("@electron/asar");
+    } catch (ignore) {
+    }
+  }
+  if (!asar) {
+    throw new Error("no asar, please install @electron/asar");
+  }
+  await asar.createPackage(dir, target);
+}
+async function buildAsar({
+  version,
+  asarOutputPath,
+  privateKeyPath,
+  electronDistPath,
+  rendererDistPath
+}) {
+  await rename(rendererDistPath, `${electronDistPath}/renderer`);
+  await writeFile2(`${electronDistPath}/version`, version);
+  await pack(electronDistPath, asarOutputPath);
+  if (isCI2) {
+    return;
+  }
+  await gzipFile(asarOutputPath);
+  const buffer = await readFile2(`${asarOutputPath}.gz`);
+  const signature = generateSignature(buffer, await readFile2(privateKeyPath, "utf-8"));
+  await writeFile2("version.json", JSON.stringify({
+    signature,
+    version,
+    size: buffer.length
+  }, null, 2));
+}
+
+// src/option.ts
+function parseOptions(options) {
+  const { isBuild, productName, version, minify = false, paths = {}, keys = {} } = options;
+  const {
+    entryPath = "electron/app.ts",
+    entryOutputPath = "app.js",
+    asarOutputPath = `release/${productName}.asar`,
+    electronDistPath = "dist-electron",
+    rendererDistPath = "dist"
+  } = paths;
+  const {
+    privateKeyPath = "public/private.pem",
+    publicKeyPath = "public/public.pem",
+    keyLength = 2048
+  } = keys;
+  const buildAsarOption = {
+    version,
+    productName,
+    asarOutputPath,
+    privateKeyPath,
+    electronDistPath,
+    rendererDistPath
+  };
+  const buildEntryOption = {
+    privateKeyPath,
+    publicKeyPath,
+    entryPath,
+    entryOutputPath,
+    minify,
+    keyLength
+  };
+  return { isBuild, buildAsarOption, buildEntryOption };
+}
+
+// src/vite.ts
+function vite_default(options) {
+  const { isBuild, buildAsarOption, buildEntryOption } = parseOptions(options);
+  const { entryPath, entryOutputPath } = buildEntryOption;
+  const { asarOutputPath } = buildAsarOption;
+  const id = "electron-incremental-updater";
+  const log = createLogger("info", { prefix: `[${id}]` });
+  return [
+    {
+      name: `vite-plugin-${id}-entry`,
+      async buildStart() {
+        log.info("build entry start");
+        await buildEntry(buildEntryOption);
+        log.info(`build entry end, ${entryPath} -> ${entryOutputPath}`);
+      }
+    },
+    {
+      name: `vite-plugin-${id}-asar`,
+      async closeBundle() {
+        if (!isBuild) {
+          return;
+        }
+        log.info("build asar start");
+        await buildAsar(buildAsarOption);
+        log.info(`build asar end, output to ${asarOutputPath}`);
+      }
+    }
+  ];
+}
+export {
+  vite_default as default
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "electron-incremental-update",
+  "version": "0.1.0",
+  "description": "electron incremental update tools, powered by vite",
+  "scripts": {
+    "build": "tsup",
+    "release": "bumpp"
+  },
+  "type": "module",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
+    },
+    "./vite": {
+      "require": "./dist/vite.cjs",
+      "import": "./dist/vite.mjs"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "dist/updater.d.ts"
+      ],
+      "vite": [
+        "dist/vite.d.ts"
+      ]
+    }
+  },
+  "keywords": [
+    "electron",
+    "incremental update",
+    "updater"
+  ],
+  "author": "",
+  "devDependencies": {
+    "@electron/asar": "^3.2.4",
+    "@subframe7536/eslint-config": "^0.1.9",
+    "@types/node": "^20.2.5",
+    "asar": "^3.2.0",
+    "bumpp": "^9.1.1",
+    "electron": "^25.0.1",
+    "eslint": "^8.42.0",
+    "fs-jetpack": "^5.1.0",
+    "tsup": "^6.7.0",
+    "typescript": "^5.1.3",
+    "vite": "^4.3.9"
+  },
+  "dependencies": {
+    "ci-info": "^3.8.0"
+  },
+  "peerDependencies": {
+    "@electron/asar": "*",
+    "asar": "*"
+  }
+}