electron-incremental-update 0.3.0 → 0.5.0

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.3.0",
+  "version": "0.5.0",
   "description": "electron incremental update tools, powered by vite",
   "scripts": {
     "build": "tsup",

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
-};