electron-incremental-update 0.1.2 → 0.1.4

package/README.md

@@ -1,25 +1,37 @@
 ## electron incremental updater
 
-inspired by Obsidian's update strategy, using RSA + Signature to sign the update asar and replace the old one when verified
+provider a vite plugin and useful functions to generate updater and split entry file and real app
+
+### principle
+
+using two asar, `app.asar` and `main.asar` (if "main" is your app's name)
+
+the `app.asar` is used to load `main.asar` and initialize the updater
+
+using RSA + Signature to sign the new `main.asar` downloaded from remote and replace the old one when verified
+
+- inspired by Obsidian's update strategy
+
+### notice
 
 develop with [vite-plugin-electron](https://github.com/electron-vite/vite-plugin-electron), and may be effect in other electron vite frameworks
 
-### install
+## install
 
-#### npm
+### npm
 ```bash
 npm install electron-incremental-update
 ```
-#### yarn
+### yarn
 ```bash
 yarn add electron-incremental-update
 ```
-#### pnpm
+### pnpm
 ```bash
 pnpm add electron-incremental-update
 ```
 
-### usage
+## usage
 
 base on [electron-vite-vue](https://github.com/electron-vite/electron-vite-vue)
 
@@ -36,7 +48,7 @@ src
 └── ...
 ```
 
-#### setup app
+### setup app
 
 ```ts
 // electron/app.ts
@@ -53,7 +65,7 @@ const updater = createUpdater({
 initApp(name, updater)
 ```
 
-#### setup main
+### setup main
 
 ```ts
 // electron/main/index.ts
@@ -103,7 +115,7 @@ export default function (updater: Updater) {
 }
 ```
 
-#### use native modules
+### use native modules
 
 ```ts
 // db.ts
@@ -128,7 +140,7 @@ console.log(r)
 db.close()
 ```
 
-#### setup vite.config.ts
+### setup vite.config.ts
 
 ```ts
 import { rmSync } from 'node:fs'
@@ -189,7 +201,7 @@ export default defineConfig(({ command }) => {
 })
 ```
 
-##### option
+#### option
 
 ```ts
 type Options = {
@@ -213,6 +225,9 @@ type Options = {
    * Whether to minify
    */
   minify?: boolean
+  /**
+   * path config
+   */
   paths?: {
     /**
      * Path to app entry file
@@ -225,7 +240,7 @@ type Options = {
      */
     entryOutputPath?: string
     /**
-     * Path to app entry file
+     * Path to asar file
      * @default `release/${ProductName}.asar`
      */
     asarOutputPath?: string
@@ -239,7 +254,15 @@ type Options = {
      * @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
@@ -262,7 +285,7 @@ type Options = {
 }
 ```
 
-#### electron-builder config
+### electron-builder config
 
 ```js
 const { name } = require('./package.json')

package/dist/index.cjs

@@ -42,7 +42,62 @@ module.exports = __toCommonJS(src_exports);
 var import_node_path2 = require("path");
 var import_electron3 = require("electron");
 
-// src/utils.ts
+// 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/download.ts
+var import_node_buffer = require("buffer");
+var import_node_https = __toESM(require("https"), 1);
+function downloadJSONDefault(url, updater, headers) {
+  return new Promise((resolve2, reject) => {
+    import_node_https.default.get(url, (res) => {
+      let data = "";
+      res.setEncoding("utf8");
+      res.headers = headers;
+      res.on("data", (chunk) => data += chunk);
+      res.on("end", () => {
+        updater.emit("downloadEnd", true);
+        const json = JSON.parse(data);
+        if ("signature" in json && "version" in json && "size" in json) {
+          resolve2(json);
+        } else {
+          throw new Error("invalid update json");
+        }
+      });
+    }).on("error", (e) => {
+      e && updater.emit("donwnloadError", e);
+      updater.emit("downloadEnd", false);
+      reject(e);
+    });
+  });
+}
+function downloadBufferDefault(url, updater, headers) {
+  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);
+        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);
+      updater.emit("downloadEnd", false);
+      reject(e);
+    });
+  });
+}
+
+// src/updater/utils.ts
 var import_node_fs = require("fs");
 var import_node_path = require("path");
 var import_electron = require("electron");
@@ -80,64 +135,26 @@ function getReleaseDnsPrefix() {
   ];
 }
 
-// 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");
+// src/updater/index.ts
 function createUpdater({
   SIGNATURE_PUB,
   repository,
   productName,
   releaseAsarURL: _release,
   updateJsonURL: _update,
-  userAgent,
-  extraHeader
+  downloadConfig
 }) {
   const updater = new import_node_events.EventEmitter();
+  const { downloadBuffer, downloadJSON, extraHeader, userAgent } = downloadConfig || {};
   async function download(url, format) {
     const ua = userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36";
-    const commonHeader = {
+    const headers = {
+      Accept: `application/${format === "json" ? "json" : "octet-stream"}`,
       UserAgent: ua,
       ...extraHeader
     };
-    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",
-            ...commonHeader
-          };
-          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",
-            ...commonHeader
-          };
-          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);
-      });
-    });
+    const downloadFn = format === "json" ? downloadJSON ?? downloadJSONDefault : downloadBuffer ?? downloadBufferDefault;
+    return await downloadFn(url, updater, headers);
   }
   async function extractFile(gzipFilePath) {
     if (!gzipFilePath.endsWith(".asar.gz") || !(0, import_node_fs2.existsSync)(gzipFilePath)) {
@@ -174,11 +191,13 @@ function createUpdater({
       updateJsonURL = _update,
       releaseAsarURL = _release
     } = option || {};
-    if ((!updateJsonURL || !releaseAsarURL) && !repository) {
-      throw new Error("updateJsonURL or releaseAsarURL are not set");
+    if (!updateJsonURL || !releaseAsarURL) {
+      if (!repository) {
+        throw new Error("updateJsonURL or releaseAsarURL are not set");
+      }
+      updateJsonURL = `${repository.replace("github.com", "raw.githubusercontent.com")}/version.json`;
+      releaseAsarURL = `${repository}/releases/download/latest/${productName}.asar.gz`;
     }
-    updateJsonURL ??= `${repository}/version.json`;
-    releaseAsarURL ??= `${repository}/releases/download/latest/${productName}.asar.gz`;
     const gzipPath = `../${productName}.asar.gz`;
     const tmpFile = gzipPath.replace(".asar.gz", ".tmp.gz");
     if ((0, import_node_fs2.existsSync)(tmpFile)) {

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { Buffer } from 'node:buffer';
+
 type CheckResultType = 'success' | 'fail' | 'unavailable';
 type UpdateEvents = {
     check: null;
@@ -7,11 +9,16 @@ type UpdateEvents = {
     downloadEnd: [success: boolean];
     donwnloadError: [error: unknown];
 };
+type UpdateJSON = {
+    signature: string;
+    version: string;
+    size: number;
+};
 type MaybeArray<T> = T extends undefined | null | never ? [] : T extends any[] ? T['length'] extends 1 ? [data: T[0]] : T : [data: T];
 interface UpdateOption {
     /**
      * URL of version info json
-     * @default `${repository}/version.json`
+     * @default `${repository.replace('github.com', 'raw.githubusercontent.com')}/version.json`
      * @throws if `updateJsonURL` and `repository` are all not set
      */
     updateJsonURL?: string;
@@ -53,29 +60,46 @@ interface Options extends UpdateOption {
     /**
      * product name
      *
-     * you can use the `name` in package.json
+     * you can use the `name` in `package.json`
      */
     productName: string;
     /**
      * repository url, e.g. `https://github.com/electron/electron`
      *
-     * you can use the `repository` in package.json
+     * you can use the `repository` in `package.json`
      *
      * if `updateJsonURL` or `releaseAsarURL` are absent,
      * `repository` will be used to determine the url
      */
     repository?: string;
-    /**
-     * 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>;
+    downloadConfig?: {
+        /**
+         * 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>;
+        /**
+         * download JSON function
+         * @param url download url
+         * @param updater updater, emit events
+         * @param header download header
+         * @returns `UpdateJSON`
+         */
+        downloadJSON?: (url: string, updater: Updater, headers: Record<string, any>) => Promise<UpdateJSON>;
+        /**
+         * download buffer function
+         * @param url download url
+         * @param updater updater, emit events
+         * @param header download header
+         * @returns `Buffer`
+         */
+        downloadBuffer?: (url: string, updater: Updater, headers: Record<string, any>) => Promise<Buffer>;
+    };
 }
-declare function createUpdater({ SIGNATURE_PUB, repository, productName, releaseAsarURL: _release, updateJsonURL: _update, userAgent, extraHeader, }: Options): Updater;
 
 declare function getAppAsarPath(name: string): string;
 declare function getElectronVersion(): string;
@@ -86,6 +110,8 @@ declare function getReleaseDnsPrefix(): {
     maintainer: string;
 }[];
 
+declare function createUpdater({ SIGNATURE_PUB, repository, productName, releaseAsarURL: _release, updateJsonURL: _update, downloadConfig, }: Options): Updater;
+
 interface PathConfig {
     /**
      * path of electron output dist
@@ -107,4 +133,4 @@ interface PathConfig {
  */
 declare function initApp(productName: string, updater: Updater, option?: PathConfig): any;
 
-export { Options, Updater, createUpdater, getAppAsarPath, getAppVersion, getElectronVersion, getReleaseDnsPrefix, initApp, requireNative };
+export { CheckResultType, Options, UpdateJSON, UpdateOption, Updater, createUpdater, getAppAsarPath, getAppVersion, getElectronVersion, getReleaseDnsPrefix, initApp, requireNative };

package/dist/index.mjs

@@ -6,7 +6,62 @@ import {
 import { resolve } from "node:path";
 import { app as app3 } from "electron";
 
-// src/utils.ts
+// src/updater/index.ts
+import { EventEmitter } from "node:events";
+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 { app as app2 } from "electron";
+
+// src/updater/download.ts
+import { Buffer } from "node:buffer";
+import https from "node:https";
+function downloadJSONDefault(url, updater, headers) {
+  return new Promise((resolve2, reject) => {
+    https.get(url, (res) => {
+      let data = "";
+      res.setEncoding("utf8");
+      res.headers = headers;
+      res.on("data", (chunk) => data += chunk);
+      res.on("end", () => {
+        updater.emit("downloadEnd", true);
+        const json = JSON.parse(data);
+        if ("signature" in json && "version" in json && "size" in json) {
+          resolve2(json);
+        } else {
+          throw new Error("invalid update json");
+        }
+      });
+    }).on("error", (e) => {
+      e && updater.emit("donwnloadError", e);
+      updater.emit("downloadEnd", false);
+      reject(e);
+    });
+  });
+}
+function downloadBufferDefault(url, updater, headers) {
+  return new Promise((resolve2, reject) => {
+    https.get(url, (res) => {
+      let data = [];
+      res.headers = headers;
+      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);
+      updater.emit("downloadEnd", false);
+      reject(e);
+    });
+  });
+}
+
+// src/updater/utils.ts
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { app } from "electron";
@@ -44,64 +99,26 @@ function getReleaseDnsPrefix() {
   ];
 }
 
-// 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";
+// src/updater/index.ts
 function createUpdater({
   SIGNATURE_PUB,
   repository,
   productName,
   releaseAsarURL: _release,
   updateJsonURL: _update,
-  userAgent,
-  extraHeader
+  downloadConfig
 }) {
   const updater = new EventEmitter();
+  const { downloadBuffer, downloadJSON, extraHeader, userAgent } = downloadConfig || {};
   async function download(url, format) {
     const ua = userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36";
-    const commonHeader = {
+    const headers = {
+      Accept: `application/${format === "json" ? "json" : "octet-stream"}`,
       UserAgent: ua,
       ...extraHeader
     };
-    return await new Promise((resolve2, reject) => {
-      https.get(url, (res) => {
-        if (format === "json") {
-          let data = "";
-          res.setEncoding("utf8");
-          res.headers = {
-            Accept: "application/json",
-            ...commonHeader
-          };
-          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",
-            ...commonHeader
-          };
-          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);
-      });
-    });
+    const downloadFn = format === "json" ? downloadJSON ?? downloadJSONDefault : downloadBuffer ?? downloadBufferDefault;
+    return await downloadFn(url, updater, headers);
   }
   async function extractFile(gzipFilePath) {
     if (!gzipFilePath.endsWith(".asar.gz") || !existsSync(gzipFilePath)) {
@@ -138,11 +155,13 @@ function createUpdater({
       updateJsonURL = _update,
       releaseAsarURL = _release
     } = option || {};
-    if ((!updateJsonURL || !releaseAsarURL) && !repository) {
-      throw new Error("updateJsonURL or releaseAsarURL are not set");
+    if (!updateJsonURL || !releaseAsarURL) {
+      if (!repository) {
+        throw new Error("updateJsonURL or releaseAsarURL are not set");
+      }
+      updateJsonURL = `${repository.replace("github.com", "raw.githubusercontent.com")}/version.json`;
+      releaseAsarURL = `${repository}/releases/download/latest/${productName}.asar.gz`;
     }
-    updateJsonURL ??= `${repository}/version.json`;
-    releaseAsarURL ??= `${repository}/releases/download/latest/${productName}.asar.gz`;
     const gzipPath = `../${productName}.asar.gz`;
     const tmpFile = gzipPath.replace(".asar.gz", ".tmp.gz");
     if (existsSync(tmpFile)) {

package/dist/vite.cjs

@@ -35,23 +35,85 @@ __export(vite_exports, {
 module.exports = __toCommonJS(vite_exports);
 var import_vite = require("vite");
 
-// src/build-entry.ts
+// src/build-plugins/asar.ts
+var import_node_crypto = require("crypto");
 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_node_zlib = __toESM(require("zlib"), 1);
 var import_ci_info = require("ci-info");
+function gzipFile(filePath) {
+  return new Promise((resolve, reject) => {
+    const gzip = import_node_zlib.default.createGzip();
+    const input = (0, import_node_fs.createReadStream)(filePath);
+    const output = (0, import_node_fs.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_crypto.createSign)("RSA-SHA256").update(buffer).sign({
+    key: privateKey,
+    padding: import_node_crypto.constants.RSA_PKCS1_PADDING,
+    saltLength: import_node_crypto.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,
+  versionPath
+}) {
+  await (0, import_promises.rename)(rendererDistPath, `${electronDistPath}/renderer`);
+  await (0, import_promises.writeFile)(`${electronDistPath}/version`, version);
+  await pack(electronDistPath, asarOutputPath);
+  if (import_ci_info.isCI) {
+    return;
+  }
+  await gzipFile(asarOutputPath);
+  const buffer = await (0, import_promises.readFile)(`${asarOutputPath}.gz`);
+  const signature = generateSignature(buffer, await (0, import_promises.readFile)(privateKeyPath, "utf-8"));
+  await (0, import_promises.writeFile)(versionPath, JSON.stringify({
+    signature,
+    version,
+    size: buffer.length
+  }, null, 2));
+}
+
+// src/build-plugins/entry.ts
+var import_node_fs2 = require("fs");
+var import_promises2 = require("fs/promises");
+var import_node_crypto2 = require("crypto");
+var import_node_os = require("os");
+var import_ci_info2 = 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 pair = (0, import_node_crypto2.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);
+  await (0, import_promises2.writeFile)(privateKeyPath, privateKey);
+  await (0, import_promises2.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 file = await (0, import_promises2.readFile)(updatePath, "utf-8");
+  const key = await (0, import_promises2.readFile)(publicKeyPath, "utf-8");
   const regex = /const SIGNATURE_PUB = ['`][\s\S]*?['`]/;
   const replacement = `const SIGNATURE_PUB = \`${key}\``;
   let replaced = file;
@@ -73,7 +135,7 @@ async function writePublicKeyToMain(updatePath, publicKeyPath) {
     !isMatched && lines.push(r);
     replaced = lines.join(import_node_os.EOL);
   }
-  await (0, import_promises.writeFile)(updatePath, replaced);
+  await (0, import_promises2.writeFile)(updatePath, replaced);
 }
 async function buildEntry({
   privateKeyPath,
@@ -83,8 +145,8 @@ async function buildEntry({
   minify,
   keyLength
 }) {
-  if (!import_ci_info.isCI) {
-    !(0, import_node_fs.existsSync)(privateKeyPath) && await generateKey(privateKeyPath, publicKeyPath, keyLength);
+  if (!import_ci_info2.isCI) {
+    !(0, import_node_fs2.existsSync)(privateKeyPath) && await generateKey(privateKeyPath, publicKeyPath, keyLength);
     await writePublicKeyToMain(entryPath, publicKeyPath);
   }
   await (0, import_esbuild.build)({
@@ -97,69 +159,7 @@ async function buildEntry({
   });
 }
 
-// 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,
-  versionPath
-}) {
-  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)(versionPath, JSON.stringify({
-    signature,
-    version,
-    size: buffer.length
-  }, null, 2));
-}
-
-// src/option.ts
+// src/build-plugins/option.ts
 function parseOptions(options) {
   const { isBuild, productName, version, minify = false, paths = {}, keys = {} } = options;
   const {

package/dist/vite.d.ts

@@ -8,19 +8,22 @@ type Options = {
     /**
      * the name of you application
      *
-     * you can set as 'name' in package.json
+     * you can set as 'name' in `package.json`
     */
     productName: string;
     /**
      * the version of you application
      *
-     * you can set as 'version' in package.json
+     * you can set as 'version' in `package.json`
      */
     version: string;
     /**
-     * Whether to minify
+     * Whether to minify entry file
      */
     minify?: boolean;
+    /**
+     * paths config
+     */
     paths?: {
         /**
          * Path to app entry file
@@ -33,7 +36,7 @@ type Options = {
          */
         entryOutputPath?: string;
         /**
-         * Path to app entry file
+         * Path to asar file
          * @default `release/${ProductName}.asar`
          */
         asarOutputPath?: string;
@@ -53,6 +56,9 @@ type Options = {
          */
         versionPath?: string;
     };
+    /**
+     * signature config
+     */
     keys?: {
         /**
          * Path to the pem file that contains private key

package/dist/vite.mjs

@@ -3,74 +3,12 @@ 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
+// src/build-plugins/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 { readFile, rename, writeFile } from "node:fs/promises";
 import zlib from "node:zlib";
-import { isCI as isCI2 } from "ci-info";
+import { isCI } from "ci-info";
 function gzipFile(filePath) {
   return new Promise((resolve, reject) => {
     const gzip = zlib.createGzip();
@@ -112,22 +50,84 @@ async function buildAsar({
   versionPath
 }) {
   await rename(rendererDistPath, `${electronDistPath}/renderer`);
-  await writeFile2(`${electronDistPath}/version`, version);
+  await writeFile(`${electronDistPath}/version`, version);
   await pack(electronDistPath, asarOutputPath);
-  if (isCI2) {
+  if (isCI) {
     return;
   }
   await gzipFile(asarOutputPath);
-  const buffer = await readFile2(`${asarOutputPath}.gz`);
-  const signature = generateSignature(buffer, await readFile2(privateKeyPath, "utf-8"));
-  await writeFile2(versionPath, JSON.stringify({
+  const buffer = await readFile(`${asarOutputPath}.gz`);
+  const signature = generateSignature(buffer, await readFile(privateKeyPath, "utf-8"));
+  await writeFile(versionPath, JSON.stringify({
     signature,
     version,
     size: buffer.length
   }, null, 2));
 }
 
-// src/option.ts
+// src/build-plugins/entry.ts
+import { existsSync } from "node:fs";
+import { readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { generateKeyPairSync } from "node:crypto";
+import { EOL } from "node:os";
+import { isCI as isCI2 } 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 writeFile2(privateKeyPath, privateKey);
+  await writeFile2(publicKeyPath, publicKey);
+}
+async function writePublicKeyToMain(updatePath, publicKeyPath) {
+  const file = await readFile2(updatePath, "utf-8");
+  const key = await readFile2(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 writeFile2(updatePath, replaced);
+}
+async function buildEntry({
+  privateKeyPath,
+  publicKeyPath,
+  entryPath,
+  entryOutputPath: outfile,
+  minify,
+  keyLength
+}) {
+  if (!isCI2) {
+    !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-plugins/option.ts
 function parseOptions(options) {
   const { isBuild, productName, version, minify = false, paths = {}, keys = {} } = options;
   const {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electron-incremental-update",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "electron incremental update tools, powered by vite",
   "scripts": {
     "build": "tsup",