electron-incremental-update 0.4.0 → 0.5.0

package/README.md

@@ -91,9 +91,12 @@ export default function (updater: Updater) {
   console.log(`\tentry:     ${getEntryVersion()}`)
   console.log(`\tapp:       ${getAppVersion(name)}`)
   let size = 0
-  let currentSize = 0
-  updater.on('checkResult', async (result) => {
-    if (result === false) {
+  updater.on('downloading', (progress) => {
+    console.log(`${(progress / size).toFixed(2)}%`)
+  })
+  updater.on('debug', data => console.log('[updater]:', data))
+  updater.checkUpdate().then(async (result) => {
+    if (result === undefined) {
       console.log('Update Unavailable')
     } else if (result instanceof Error) {
       console.error(result)
@@ -105,20 +108,9 @@ export default function (updater: Updater) {
         buttons: ['Download', 'Later'],
         message: 'Application update available!',
       })
-      response === 0 && await updater.downloadUpdate()
+      response === 0 && console.log(await updater.downloadUpdate())
     }
   })
-  updater.on('download', () => console.log('download start'))
-  updater.on('downloading', (len) => {
-    currentSize += len
-    console.log(`${(currentSize / size).toFixed(2)}%`)
-  })
-  updater.on('downloaded', () => console.log('download end'))
-  updater.on('donwnloadError', console.error)
-  // to debug, it need to set debug to true in updater options
-  updater.on('debug', data => console.log('[updater]:', data))
-  updater.checkUpdate()
-
   // app logics
   app.whenReady().then(() => {
     // ...

package/dist/chunk-SSJ6PDMK.mjs

@@ -0,0 +1,61 @@
+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');
+});
+
+// src/crypto.ts
+import { constants, createCipheriv, createDecipheriv, createHash, createSign, createVerify, generateKeyPairSync } from "node:crypto";
+import { Buffer as Buffer2 } from "node:buffer";
+var aesEncode = "base64url";
+function generateRSA(length = 2048) {
+  const pair = generateKeyPairSync("rsa", { modulusLength: length });
+  const privateKey = pair.privateKey.export({ type: "pkcs1", format: "pem" });
+  const publicKey = pair.publicKey.export({ type: "pkcs1", format: "pem" });
+  return {
+    privateKey,
+    publicKey
+  };
+}
+function encrypt(plainText, key, iv) {
+  const cipher = createCipheriv("aes-256-cbc", key, iv);
+  let encrypted = cipher.update(plainText, "utf8", aesEncode);
+  encrypted += cipher.final(aesEncode);
+  return encrypted;
+}
+function decrypt(encryptedText, key, iv) {
+  const decipher = createDecipheriv("aes-256-cbc", key, iv);
+  let decrypted = decipher.update(encryptedText, aesEncode, "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+function generateKey(buffer, str, length) {
+  str += createHash("md5").update(buffer.map((v, i) => i & length / 4 && v)).digest("hex");
+  const hash = createHash("SHA256").update(str).digest("binary");
+  return Buffer2.from(hash).subarray(0, length);
+}
+function signature(buffer, privateKey, publicKey, name) {
+  const sig = createSign("RSA-SHA256").update(buffer).sign({
+    key: privateKey,
+    padding: constants.RSA_PKCS1_PADDING,
+    saltLength: constants.RSA_PSS_SALTLEN_DIGEST
+  }, "base64");
+  return encrypt(sig, generateKey(buffer, publicKey, 32), generateKey(buffer, name, 16));
+}
+function verify(buffer, signature2, publicKey, name) {
+  try {
+    const sig = decrypt(signature2, generateKey(buffer, publicKey, 32), generateKey(buffer, name, 16));
+    return createVerify("RSA-SHA256").update(buffer).verify(publicKey, sig, "base64");
+  } catch (error) {
+    return false;
+  }
+}
+
+export {
+  __require,
+  generateRSA,
+  signature,
+  verify
+};

package/dist/index.cjs

@@ -46,14 +46,37 @@ var import_electron3 = require("electron");
 
 // 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/defaultFunctions.ts
+// src/crypto.ts
+var import_node_crypto = require("crypto");
 var import_node_buffer = require("buffer");
+var aesEncode = "base64url";
+function decrypt(encryptedText, key, iv) {
+  const decipher = (0, import_node_crypto.createDecipheriv)("aes-256-cbc", key, iv);
+  let decrypted = decipher.update(encryptedText, aesEncode, "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+function generateKey(buffer, str, length) {
+  str += (0, import_node_crypto.createHash)("md5").update(buffer.map((v, i) => i & length / 4 && v)).digest("hex");
+  const hash = (0, import_node_crypto.createHash)("SHA256").update(str).digest("binary");
+  return import_node_buffer.Buffer.from(hash).subarray(0, length);
+}
+function verify(buffer, signature, publicKey, name) {
+  try {
+    const sig = decrypt(signature, generateKey(buffer, publicKey, 32), generateKey(buffer, name, 16));
+    return (0, import_node_crypto.createVerify)("RSA-SHA256").update(buffer).verify(publicKey, sig, "base64");
+  } catch (error) {
+    return false;
+  }
+}
+
+// src/updater/defaultFunctions.ts
+var import_node_buffer2 = require("buffer");
 var import_node_https = __toESM(require("https"), 1);
 function downloadJSONDefault(url, updater, headers) {
   return new Promise((resolve2, reject) => {
@@ -80,16 +103,18 @@ function downloadJSONDefault(url, updater, headers) {
   });
 }
 function downloadBufferDefault(url, updater, headers) {
+  let progress = 0;
   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);
+        progress += chunk.length;
+        updater.emit("downloading", progress);
         data.push(chunk);
       });
       res.on("end", () => {
-        resolve2(import_node_buffer.Buffer.concat(data));
+        resolve2(import_node_buffer2.Buffer.concat(data));
       });
     }).on("error", (e) => {
       reject(e);
@@ -225,9 +250,6 @@ function createUpdater({
       });
     });
   }
-  function verify(buffer, signature2) {
-    return (0, import_node_crypto.createVerify)("RSA-SHA256").update(buffer).verify(SIGNATURE_PUB, signature2, "base64");
-  }
   function needUpdate(version2) {
     if (!import_electron2.app.isPackaged) {
       log("in dev mode, no need to update");
@@ -240,86 +262,75 @@ function createUpdater({
     const _compare = compareVersion ?? compareVersionDefault;
     return _compare(currentVersion, version2);
   }
-  async function checkUpdate(url) {
-    url ??= _update;
-    if (!url) {
-      log("no updateJsonURL, fallback to use repository");
-      if (!repository) {
-        throw new Error("updateJsonURL or repository are not set");
-      }
-      url = `${repository.replace("github.com", "raw.githubusercontent.com")}/master/version.json`;
-    }
-    if ((0, import_node_fs2.existsSync)(tmpFile)) {
-      log(`remove tmp file: ${tmpFile}`);
-      await (0, import_promises.rm)(tmpFile);
-    }
-    if ((0, import_node_fs2.existsSync)(gzipPath)) {
-      log(`remove .gz file: ${gzipPath}`);
-      await (0, import_promises.rm)(gzipPath);
-    }
-    const json = await download(url, "json");
-    const {
-      signature: _sig,
-      version: _v,
-      size
-    } = json;
-    log(`update info: ${JSON.stringify(json, null, 2)}`);
-    if (!await needUpdate(_v)) {
-      log(`update unavailable: ${_v}`);
-      return false;
-    } else {
-      log(`update available: ${_v}`);
-      signature = _sig;
-      version = _v;
-      return { size, version };
-    }
-  }
-  async function downloadUpdate(src) {
-    if (typeof src !== "object") {
-      let _url = src ?? _release;
-      if (!_url) {
-        log("no releaseAsarURL, fallback to use repository");
+  updater.checkUpdate = async (url) => {
+    try {
+      url ??= _update;
+      if (!url) {
+        log("no updateJsonURL, fallback to use repository");
         if (!repository) {
-          throw new Error("releaseAsarURL or repository are not set");
+          throw new Error("updateJsonURL or repository are not set");
         }
-        _url = `${repository}/releases/download/latest/${productName}.asar.gz`;
+        url = `${repository.replace("github.com", "raw.githubusercontent.com")}/master/version.json`;
+      }
+      if ((0, import_node_fs2.existsSync)(tmpFile)) {
+        log(`remove tmp file: ${tmpFile}`);
+        await (0, import_promises.rm)(tmpFile);
+      }
+      if ((0, import_node_fs2.existsSync)(gzipPath)) {
+        log(`remove .gz file: ${gzipPath}`);
+        await (0, import_promises.rm)(gzipPath);
+      }
+      const json = await download(url, "json");
+      const {
+        signature: _sig,
+        version: _v,
+        size
+      } = json;
+      log(`update info: ${JSON.stringify(json, null, 2)}`);
+      if (!await needUpdate(_v)) {
+        log(`update unavailable: ${_v}`);
+        return void 0;
+      } else {
+        log(`update available: ${_v}`);
+        signature = _sig;
+        version = _v;
+        return { size, version };
       }
-      src = await download(_url, "buffer");
-    }
-    log("verify start");
-    if (!verify(src, signature)) {
-      log("verify failed");
-      throw new Error("invalid signature");
-    }
-    log("verify success");
-    log(`write file: ${gzipPath}`);
-    await (0, import_promises.writeFile)(gzipPath, src);
-    log(`extract file: ${gzipPath}`);
-    await extractFile(gzipPath);
-    log(`update success, version: ${version}`);
-    updater.emit("downloaded");
-  }
-  const onCheck = async (url) => {
-    try {
-      const result = await checkUpdate(url);
-      updater.emit("checkResult", result);
     } catch (error) {
       log(error);
-      updater.emit("checkResult", error);
+      return error;
     }
   };
-  updater.on("check", onCheck);
-  updater.checkUpdate = onCheck;
-  const onDownload = async (src) => {
+  updater.downloadUpdate = async (src) => {
     try {
-      await downloadUpdate(src);
+      if (typeof src !== "object") {
+        let _url = src ?? _release;
+        if (!_url) {
+          log("no releaseAsarURL, fallback to use repository");
+          if (!repository) {
+            throw new Error("releaseAsarURL or repository are not set");
+          }
+          _url = `${repository}/releases/download/latest/${productName}.asar.gz`;
+        }
+        src = await download(_url, "buffer");
+      }
+      log("verify start");
+      if (!verify(src, signature, SIGNATURE_PUB, productName)) {
+        log("verify failed");
+        throw new Error("invalid signature");
+      }
+      log("verify success");
+      log(`write file: ${gzipPath}`);
+      await (0, import_promises.writeFile)(gzipPath, src);
+      log(`extract file: ${gzipPath}`);
+      await extractFile(gzipPath);
+      log(`update success, version: ${version}`);
+      return true;
     } catch (error) {
       log(error);
-      updater.emit("donwnloadError", error);
+      return error;
     }
   };
-  updater.on("download", onDownload);
-  updater.downloadUpdate = onDownload;
   return updater;
 }
 

package/dist/index.d.ts

@@ -1,13 +1,9 @@
 import { Buffer } from 'node:buffer';
 
-type CheckResultType = Error | false | Omit<UpdateJSON, 'signature'>;
+type CheckResultType = Omit<UpdateJSON, 'signature'> | undefined | Error;
+type DownloadResult = true | Error;
 type UpdateEvents = {
-    check: [url?: string];
-    checkResult: [data: CheckResultType];
-    download: [src?: string | Buffer];
-    downloading: [current: number];
-    downloaded: null;
-    donwnloadError: [error: unknown];
+    downloading: [progress: number];
     debug: [msg: string | Error];
 };
 type UpdateJSON = {
@@ -21,16 +17,19 @@ interface TypedUpdater<T extends Record<string | symbol, MaybeArray<any>>, Event
     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;
     /**
-     * - `undefined`: errror
+     * - `{size: number, version: string}`: available
      * - `false`: unavailable
-     * - `{size: number, version: string}`: success
+     * - `Error`: fail
      */
-    checkUpdate(url?: string): Promise<void>;
-    downloadUpdate(url?: string | Buffer): Promise<void>;
+    checkUpdate(url?: string): Promise<CheckResultType>;
+    /**
+     * - `true`: success
+     * - `Error`: fail
+     */
+    downloadUpdate(url?: string | Buffer): Promise<DownloadResult>;
 }
 type Updater = TypedUpdater<UpdateEvents>;
 interface UpdaterOption {
@@ -210,4 +209,4 @@ declare function initApp(appOptions: AppOption): {
  */
 declare function initApp(appOptions: AppOption, updaterOptions: InitUpdaterOptions): undefined;
 
-export { AppOption, CheckResultType, InitUpdaterOptions, UpdateJSON, Updater, UpdaterOption, createUpdater, getAppAsarPath, getAppVersion, getEntryVersion, getGithubReleaseCdnGroup, initApp, parseGithubCdnURL, requireNative, restartApp };
+export { AppOption, CheckResultType, DownloadResult, InitUpdaterOptions, UpdateJSON, Updater, UpdaterOption, createUpdater, getAppAsarPath, getAppVersion, getEntryVersion, getGithubReleaseCdnGroup, initApp, parseGithubCdnURL, requireNative, restartApp };

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import {
-  __require
-} from "./chunk-AKU6F3WT.mjs";
+  __require,
+  verify
+} from "./chunk-SSJ6PDMK.mjs";
 
 // src/index.ts
 import { resolve } from "node:path";
@@ -8,7 +9,6 @@ import { app as app3 } from "electron";
 
 // 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";
@@ -42,12 +42,14 @@ function downloadJSONDefault(url, updater, headers) {
   });
 }
 function downloadBufferDefault(url, updater, headers) {
+  let progress = 0;
   return new Promise((resolve2, reject) => {
     https.get(url, (res) => {
       let data = [];
       res.headers = headers;
       res.on("data", (chunk) => {
-        updater.emit("downloading", chunk.length);
+        progress += chunk.length;
+        updater.emit("downloading", progress);
         data.push(chunk);
       });
       res.on("end", () => {
@@ -187,9 +189,6 @@ function createUpdater({
       });
     });
   }
-  function verify(buffer, signature2) {
-    return createVerify("RSA-SHA256").update(buffer).verify(SIGNATURE_PUB, signature2, "base64");
-  }
   function needUpdate(version2) {
     if (!app2.isPackaged) {
       log("in dev mode, no need to update");
@@ -202,86 +201,75 @@ function createUpdater({
     const _compare = compareVersion ?? compareVersionDefault;
     return _compare(currentVersion, version2);
   }
-  async function checkUpdate(url) {
-    url ??= _update;
-    if (!url) {
-      log("no updateJsonURL, fallback to use repository");
-      if (!repository) {
-        throw new Error("updateJsonURL or repository are not set");
-      }
-      url = `${repository.replace("github.com", "raw.githubusercontent.com")}/master/version.json`;
-    }
-    if (existsSync(tmpFile)) {
-      log(`remove tmp file: ${tmpFile}`);
-      await rm(tmpFile);
-    }
-    if (existsSync(gzipPath)) {
-      log(`remove .gz file: ${gzipPath}`);
-      await rm(gzipPath);
-    }
-    const json = await download(url, "json");
-    const {
-      signature: _sig,
-      version: _v,
-      size
-    } = json;
-    log(`update info: ${JSON.stringify(json, null, 2)}`);
-    if (!await needUpdate(_v)) {
-      log(`update unavailable: ${_v}`);
-      return false;
-    } else {
-      log(`update available: ${_v}`);
-      signature = _sig;
-      version = _v;
-      return { size, version };
-    }
-  }
-  async function downloadUpdate(src) {
-    if (typeof src !== "object") {
-      let _url = src ?? _release;
-      if (!_url) {
-        log("no releaseAsarURL, fallback to use repository");
+  updater.checkUpdate = async (url) => {
+    try {
+      url ??= _update;
+      if (!url) {
+        log("no updateJsonURL, fallback to use repository");
         if (!repository) {
-          throw new Error("releaseAsarURL or repository are not set");
+          throw new Error("updateJsonURL or repository are not set");
         }
-        _url = `${repository}/releases/download/latest/${productName}.asar.gz`;
+        url = `${repository.replace("github.com", "raw.githubusercontent.com")}/master/version.json`;
+      }
+      if (existsSync(tmpFile)) {
+        log(`remove tmp file: ${tmpFile}`);
+        await rm(tmpFile);
+      }
+      if (existsSync(gzipPath)) {
+        log(`remove .gz file: ${gzipPath}`);
+        await rm(gzipPath);
+      }
+      const json = await download(url, "json");
+      const {
+        signature: _sig,
+        version: _v,
+        size
+      } = json;
+      log(`update info: ${JSON.stringify(json, null, 2)}`);
+      if (!await needUpdate(_v)) {
+        log(`update unavailable: ${_v}`);
+        return void 0;
+      } else {
+        log(`update available: ${_v}`);
+        signature = _sig;
+        version = _v;
+        return { size, version };
       }
-      src = await download(_url, "buffer");
-    }
-    log("verify start");
-    if (!verify(src, signature)) {
-      log("verify failed");
-      throw new Error("invalid signature");
-    }
-    log("verify success");
-    log(`write file: ${gzipPath}`);
-    await writeFile(gzipPath, src);
-    log(`extract file: ${gzipPath}`);
-    await extractFile(gzipPath);
-    log(`update success, version: ${version}`);
-    updater.emit("downloaded");
-  }
-  const onCheck = async (url) => {
-    try {
-      const result = await checkUpdate(url);
-      updater.emit("checkResult", result);
     } catch (error) {
       log(error);
-      updater.emit("checkResult", error);
+      return error;
     }
   };
-  updater.on("check", onCheck);
-  updater.checkUpdate = onCheck;
-  const onDownload = async (src) => {
+  updater.downloadUpdate = async (src) => {
     try {
-      await downloadUpdate(src);
+      if (typeof src !== "object") {
+        let _url = src ?? _release;
+        if (!_url) {
+          log("no releaseAsarURL, fallback to use repository");
+          if (!repository) {
+            throw new Error("releaseAsarURL or repository are not set");
+          }
+          _url = `${repository}/releases/download/latest/${productName}.asar.gz`;
+        }
+        src = await download(_url, "buffer");
+      }
+      log("verify start");
+      if (!verify(src, signature, SIGNATURE_PUB, productName)) {
+        log("verify failed");
+        throw new Error("invalid signature");
+      }
+      log("verify success");
+      log(`write file: ${gzipPath}`);
+      await writeFile(gzipPath, src);
+      log(`extract file: ${gzipPath}`);
+      await extractFile(gzipPath);
+      log(`update success, version: ${version}`);
+      return true;
     } catch (error) {
       log(error);
-      updater.emit("donwnloadError", error);
+      return error;
     }
   };
-  updater.on("download", onDownload);
-  updater.downloadUpdate = onDownload;
   return updater;
 }
 

package/dist/vite.cjs

@@ -36,11 +36,44 @@ module.exports = __toCommonJS(vite_exports);
 var import_vite = require("vite");
 
 // 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_zlib = __toESM(require("zlib"), 1);
-var import_ci_info = require("ci-info");
+
+// src/crypto.ts
+var import_node_crypto = require("crypto");
+var import_node_buffer = require("buffer");
+var aesEncode = "base64url";
+function generateRSA(length = 2048) {
+  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" });
+  return {
+    privateKey,
+    publicKey
+  };
+}
+function encrypt(plainText, key, iv) {
+  const cipher = (0, import_node_crypto.createCipheriv)("aes-256-cbc", key, iv);
+  let encrypted = cipher.update(plainText, "utf8", aesEncode);
+  encrypted += cipher.final(aesEncode);
+  return encrypted;
+}
+function generateKey(buffer, str, length) {
+  str += (0, import_node_crypto.createHash)("md5").update(buffer.map((v, i) => i & length / 4 && v)).digest("hex");
+  const hash = (0, import_node_crypto.createHash)("SHA256").update(str).digest("binary");
+  return import_node_buffer.Buffer.from(hash).subarray(0, length);
+}
+function signature(buffer, privateKey, publicKey, name) {
+  const sig = (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");
+  return encrypt(sig, generateKey(buffer, publicKey, 32), generateKey(buffer, name, 16));
+}
+
+// src/build-plugins/asar.ts
 function gzipFile(filePath) {
   return new Promise((resolve, reject) => {
     const gzip = import_node_zlib.default.createGzip();
@@ -49,13 +82,6 @@ function gzipFile(filePath) {
     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 {
@@ -76,47 +102,61 @@ async function pack(dir, target) {
 async function buildAsar({
   version,
   asarOutputPath,
-  privateKeyPath,
   electronDistPath,
-  rendererDistPath,
-  versionPath
+  rendererDistPath
 }) {
   await (0, import_promises.rename)(rendererDistPath, `${electronDistPath}/renderer`);
   await (0, import_promises.writeFile)(`${electronDistPath}/version`, version);
   await pack(electronDistPath, asarOutputPath);
   await gzipFile(asarOutputPath);
-  if (import_ci_info.isCI) {
-    return;
-  }
+}
+async function generateVersion({
+  asarOutputPath,
+  versionPath,
+  privateKey,
+  publicKey,
+  productName,
+  version
+}) {
   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,
+    signature: signature(buffer, privateKey, publicKey, productName),
     version,
     size: buffer.length
   }, null, 2));
 }
 
 // src/build-plugins/entry.ts
+var import_esbuild = require("esbuild");
+async function buildEntry({
+  entryPath,
+  entryOutputPath: outfile,
+  minify
+}) {
+  await (0, import_esbuild.build)({
+    entryPoints: [entryPath],
+    bundle: true,
+    platform: "node",
+    outfile,
+    minify,
+    external: ["electron"]
+  });
+}
+
+// src/build-plugins/key.ts
 var import_node_fs2 = require("fs");
 var import_node_path = require("path");
-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_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_promises2.writeFile)(privateKeyPath, privateKey);
-  await (0, import_promises2.writeFile)(publicKeyPath, publicKey);
+function generateKey2(privateKeyPath, publicKeyPath, length) {
+  const ret = generateRSA(length);
+  (0, import_node_fs2.writeFileSync)(privateKeyPath, ret.privateKey);
+  (0, import_node_fs2.writeFileSync)(publicKeyPath, ret.publicKey);
+  return ret;
 }
-async function writePublicKeyToMain(updatePath, publicKeyPath) {
-  const file = await (0, import_promises2.readFile)(updatePath, "utf-8");
-  const key = await (0, import_promises2.readFile)(publicKeyPath, "utf-8");
+function writePublicKeyToMain(entryPath, publicKey) {
+  const file = (0, import_node_fs2.readFileSync)(entryPath, "utf-8");
   const regex = /const SIGNATURE_PUB = ['`][\s\S]*?['`]/;
-  const replacement = `const SIGNATURE_PUB = \`${key}\``;
+  const replacement = `const SIGNATURE_PUB = \`${publicKey}\``;
   let replaced = file;
   const signaturePubExists = regex.test(file);
   if (signaturePubExists) {
@@ -136,33 +176,34 @@ async function writePublicKeyToMain(updatePath, publicKeyPath) {
     !isMatched && lines.push(r);
     replaced = lines.join(import_node_os.EOL);
   }
-  await (0, import_promises2.writeFile)(updatePath, replaced);
+  (0, import_node_fs2.writeFileSync)(entryPath, replaced);
 }
-async function buildEntry({
+function getKeys({
+  keyLength,
   privateKeyPath,
   publicKeyPath,
-  entryPath,
-  entryOutputPath: outfile,
-  minify,
-  keyLength
+  entryPath
 }) {
-  if (!import_ci_info2.isCI) {
-    const keysDir = (0, import_node_path.dirname)(privateKeyPath);
-    !(0, import_node_fs2.existsSync)(keysDir) && await (0, import_promises2.mkdir)(keysDir);
-    !(0, import_node_fs2.existsSync)(privateKeyPath) && await generateKey(privateKeyPath, publicKeyPath, keyLength);
-    await writePublicKeyToMain(entryPath, publicKeyPath);
+  const keysDir = (0, import_node_path.dirname)(privateKeyPath);
+  !(0, import_node_fs2.existsSync)(keysDir) && (0, import_node_fs2.mkdirSync)(keysDir);
+  let privateKey, publicKey;
+  if (!(0, import_node_fs2.existsSync)(privateKeyPath)) {
+    const keys = generateKey2(privateKeyPath, publicKeyPath, keyLength);
+    privateKey = keys.privateKey;
+    publicKey = keys.publicKey;
+  } else {
+    privateKey = (0, import_node_fs2.readFileSync)(privateKeyPath, "utf-8");
+    publicKey = (0, import_node_fs2.readFileSync)(publicKeyPath, "utf-8");
   }
-  await (0, import_esbuild.build)({
-    entryPoints: [entryPath],
-    bundle: true,
-    platform: "node",
-    outfile,
-    minify,
-    external: ["electron"]
-  });
+  writePublicKeyToMain(entryPath, publicKey);
+  return {
+    privateKey,
+    publicKey
+  };
 }
 
 // src/build-plugins/option.ts
+var import_ci_info = require("ci-info");
 function parseOptions(options) {
   const { isBuild, productName, version, minify = false, paths = {}, keys = {} } = options;
   const {
@@ -181,25 +222,37 @@ function parseOptions(options) {
   const buildAsarOption = {
     version,
     asarOutputPath,
-    privateKeyPath,
     electronDistPath,
-    rendererDistPath,
-    versionPath
+    rendererDistPath
   };
   const buildEntryOption = {
-    privateKeyPath,
-    publicKeyPath,
     entryPath,
     entryOutputPath,
-    minify,
-    keyLength
+    minify
   };
-  return { isBuild, buildAsarOption, buildEntryOption };
+  let buildVersionOption;
+  if (!import_ci_info.isCI) {
+    const { privateKey, publicKey } = getKeys({
+      keyLength,
+      privateKeyPath,
+      publicKeyPath,
+      entryPath
+    });
+    buildVersionOption = {
+      version,
+      asarOutputPath,
+      privateKey,
+      publicKey,
+      productName,
+      versionPath
+    };
+  }
+  return { isBuild, buildAsarOption, buildEntryOption, buildVersionOption };
 }
 
 // src/vite.ts
 function vite_default(options) {
-  const { isBuild, buildAsarOption, buildEntryOption } = parseOptions(options);
+  const { isBuild, buildAsarOption, buildEntryOption, buildVersionOption } = parseOptions(options);
   const { entryPath, entryOutputPath } = buildEntryOption;
   const { asarOutputPath } = buildAsarOption;
   const id = "electron-incremental-updater";
@@ -216,6 +269,7 @@ function vite_default(options) {
       }
       log.info("build asar start");
       await buildAsar(buildAsarOption);
+      buildVersionOption && await generateVersion(buildVersionOption);
       log.info(`build asar end, output to ${asarOutputPath}`);
     }
   };

package/dist/vite.mjs

@@ -1,14 +1,15 @@
-import "./chunk-AKU6F3WT.mjs";
+import {
+  generateRSA,
+  signature
+} from "./chunk-SSJ6PDMK.mjs";
 
 // src/vite.ts
 import { createLogger } from "vite";
 
 // src/build-plugins/asar.ts
-import { constants, createSign } from "node:crypto";
 import { createReadStream, createWriteStream } from "node:fs";
 import { readFile, rename, writeFile } from "node:fs/promises";
 import zlib from "node:zlib";
-import { isCI } from "ci-info";
 function gzipFile(filePath) {
   return new Promise((resolve, reject) => {
     const gzip = zlib.createGzip();
@@ -17,13 +18,6 @@ function gzipFile(filePath) {
     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 {
@@ -44,47 +38,61 @@ async function pack(dir, target) {
 async function buildAsar({
   version,
   asarOutputPath,
-  privateKeyPath,
   electronDistPath,
-  rendererDistPath,
-  versionPath
+  rendererDistPath
 }) {
   await rename(rendererDistPath, `${electronDistPath}/renderer`);
   await writeFile(`${electronDistPath}/version`, version);
   await pack(electronDistPath, asarOutputPath);
   await gzipFile(asarOutputPath);
-  if (isCI) {
-    return;
-  }
+}
+async function generateVersion({
+  asarOutputPath,
+  versionPath,
+  privateKey,
+  publicKey,
+  productName,
+  version
+}) {
   const buffer = await readFile(`${asarOutputPath}.gz`);
-  const signature = generateSignature(buffer, await readFile(privateKeyPath, "utf-8"));
   await writeFile(versionPath, JSON.stringify({
-    signature,
+    signature: signature(buffer, privateKey, publicKey, productName),
     version,
     size: buffer.length
   }, null, 2));
 }
 
 // src/build-plugins/entry.ts
-import { existsSync } from "node:fs";
+import { build } from "esbuild";
+async function buildEntry({
+  entryPath,
+  entryOutputPath: outfile,
+  minify
+}) {
+  await build({
+    entryPoints: [entryPath],
+    bundle: true,
+    platform: "node",
+    outfile,
+    minify,
+    external: ["electron"]
+  });
+}
+
+// src/build-plugins/key.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
-import { mkdir, 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);
+function generateKey(privateKeyPath, publicKeyPath, length) {
+  const ret = generateRSA(length);
+  writeFileSync(privateKeyPath, ret.privateKey);
+  writeFileSync(publicKeyPath, ret.publicKey);
+  return ret;
 }
-async function writePublicKeyToMain(updatePath, publicKeyPath) {
-  const file = await readFile2(updatePath, "utf-8");
-  const key = await readFile2(publicKeyPath, "utf-8");
+function writePublicKeyToMain(entryPath, publicKey) {
+  const file = readFileSync(entryPath, "utf-8");
   const regex = /const SIGNATURE_PUB = ['`][\s\S]*?['`]/;
-  const replacement = `const SIGNATURE_PUB = \`${key}\``;
+  const replacement = `const SIGNATURE_PUB = \`${publicKey}\``;
   let replaced = file;
   const signaturePubExists = regex.test(file);
   if (signaturePubExists) {
@@ -104,33 +112,34 @@ async function writePublicKeyToMain(updatePath, publicKeyPath) {
     !isMatched && lines.push(r);
     replaced = lines.join(EOL);
   }
-  await writeFile2(updatePath, replaced);
+  writeFileSync(entryPath, replaced);
 }
-async function buildEntry({
+function getKeys({
+  keyLength,
   privateKeyPath,
   publicKeyPath,
-  entryPath,
-  entryOutputPath: outfile,
-  minify,
-  keyLength
+  entryPath
 }) {
-  if (!isCI2) {
-    const keysDir = dirname(privateKeyPath);
-    !existsSync(keysDir) && await mkdir(keysDir);
-    !existsSync(privateKeyPath) && await generateKey(privateKeyPath, publicKeyPath, keyLength);
-    await writePublicKeyToMain(entryPath, publicKeyPath);
+  const keysDir = dirname(privateKeyPath);
+  !existsSync(keysDir) && mkdirSync(keysDir);
+  let privateKey, publicKey;
+  if (!existsSync(privateKeyPath)) {
+    const keys = generateKey(privateKeyPath, publicKeyPath, keyLength);
+    privateKey = keys.privateKey;
+    publicKey = keys.publicKey;
+  } else {
+    privateKey = readFileSync(privateKeyPath, "utf-8");
+    publicKey = readFileSync(publicKeyPath, "utf-8");
   }
-  await build({
-    entryPoints: [entryPath],
-    bundle: true,
-    platform: "node",
-    outfile,
-    minify,
-    external: ["electron"]
-  });
+  writePublicKeyToMain(entryPath, publicKey);
+  return {
+    privateKey,
+    publicKey
+  };
 }
 
 // src/build-plugins/option.ts
+import { isCI } from "ci-info";
 function parseOptions(options) {
   const { isBuild, productName, version, minify = false, paths = {}, keys = {} } = options;
   const {
@@ -149,25 +158,37 @@ function parseOptions(options) {
   const buildAsarOption = {
     version,
     asarOutputPath,
-    privateKeyPath,
     electronDistPath,
-    rendererDistPath,
-    versionPath
+    rendererDistPath
   };
   const buildEntryOption = {
-    privateKeyPath,
-    publicKeyPath,
     entryPath,
     entryOutputPath,
-    minify,
-    keyLength
+    minify
   };
-  return { isBuild, buildAsarOption, buildEntryOption };
+  let buildVersionOption;
+  if (!isCI) {
+    const { privateKey, publicKey } = getKeys({
+      keyLength,
+      privateKeyPath,
+      publicKeyPath,
+      entryPath
+    });
+    buildVersionOption = {
+      version,
+      asarOutputPath,
+      privateKey,
+      publicKey,
+      productName,
+      versionPath
+    };
+  }
+  return { isBuild, buildAsarOption, buildEntryOption, buildVersionOption };
 }
 
 // src/vite.ts
 function vite_default(options) {
-  const { isBuild, buildAsarOption, buildEntryOption } = parseOptions(options);
+  const { isBuild, buildAsarOption, buildEntryOption, buildVersionOption } = parseOptions(options);
   const { entryPath, entryOutputPath } = buildEntryOption;
   const { asarOutputPath } = buildAsarOption;
   const id = "electron-incremental-updater";
@@ -184,6 +205,7 @@ function vite_default(options) {
       }
       log.info("build asar start");
       await buildAsar(buildAsarOption);
+      buildVersionOption && await generateVersion(buildVersionOption);
       log.info(`build asar end, output to ${asarOutputPath}`);
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electron-incremental-update",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "electron incremental update tools, powered by vite",
   "scripts": {
     "build": "tsup",
@@ -63,4 +63,4 @@
   "dependencies": {
     "ci-info": "^3.8.0"
   }
-}
+}

package/dist/chunk-AKU6F3WT.mjs

@@ -1,11 +0,0 @@
-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
-};