electron-incremental-update 1.3.0 → 2.0.0-beta.1

package/dist/provider.d.ts

@@ -0,0 +1,37 @@
+import { i as isLowerVersionDefault, U as UpdateJSON, a as UpdateInfo } from './version-CffZWDhZ.js';
+import { v as verifySignatureDefault } from './decrypt-BNBcodiO.js';
+import { U as URLHandler, I as IProvider, D as DownloadingInfo, O as OnDownloading } from './types-seJf3Wbc.js';
+import '@subframe7536/type-utils';
+
+interface GitHubProviderOptions {
+    /**
+     * github repo root url
+     * @example 'https://github.com/electron/electron'
+     */
+    url: string;
+    extraHeaders?: Record<string, string>;
+    /**
+     * custom url handler
+     *
+     * for Github, there are some {@link https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L34 public CDN links}
+     */
+    urlHandler?: URLHandler;
+}
+declare class GitHubProvider implements IProvider {
+    private ua;
+    name: string;
+    urlHandler?: URLHandler;
+    private url;
+    private extraHeaders?;
+    constructor(options: GitHubProviderOptions);
+    private parseURL;
+    isLowerVersion: typeof isLowerVersionDefault;
+    verifySignaure: typeof verifySignatureDefault;
+    downloadJSON(versionPath: string): Promise<UpdateJSON>;
+    downloadBuffer(name: string, { version, size }: UpdateInfo, onDownloading?: (info: DownloadingInfo) => void): Promise<Buffer>;
+}
+
+declare function downloadUpdateJSONDefault(url: string, headers: Record<string, any>): Promise<UpdateJSON>;
+declare function downloadAsarBufferDefault(url: string, headers: Record<string, any>, total: number, onDownloading?: OnDownloading): Promise<Buffer>;
+
+export { DownloadingInfo, GitHubProvider, type GitHubProviderOptions, IProvider, OnDownloading, URLHandler, downloadAsarBufferDefault, downloadUpdateJSONDefault };

package/dist/provider.js

@@ -0,0 +1,98 @@
+import {
+  isLowerVersionDefault,
+  isUpdateJSON,
+  verifySignatureDefault,
+  waitAppReady
+} from "./chunk-RSLOPAIZ.js";
+
+// src/provider/download.ts
+import { net } from "electron";
+async function downlaodFn(url, headers, onResponse) {
+  await waitAppReady();
+  return new Promise((resolve, reject) => {
+    const request = net.request({ url, method: "GET", redirect: "follow" });
+    Object.keys(headers).forEach((key) => request.setHeader(key, headers[key]));
+    request.on("response", (resp) => {
+      resp.on("aborted", () => reject(new Error("aborted")));
+      resp.on("error", () => reject(new Error("download error")));
+      onResponse(resp, resolve, reject);
+    });
+    request.on("error", reject);
+    request.end();
+  });
+}
+async function downloadUpdateJSONDefault(url, headers) {
+  return await downlaodFn(url, headers, (resp, resolve, reject) => {
+    let data = "";
+    resp.on("data", (chunk) => data += chunk);
+    resp.on("end", () => {
+      try {
+        const json = JSON.parse(data);
+        if (isUpdateJSON(json)) {
+          resolve(json);
+        } else {
+          throw Error;
+        }
+      } catch (ignore) {
+        reject(new Error("invalid update json"));
+      }
+    });
+  });
+}
+async function downloadAsarBufferDefault(url, headers, total, onDownloading) {
+  let current = 0;
+  return await downlaodFn(url, headers, (resp, resolve) => {
+    let data = [];
+    resp.on("data", (chunk) => {
+      current += chunk.length;
+      onDownloading?.({ percent: `${+(current / total).toFixed(2) * 100}%`, total, current });
+      data.push(chunk);
+    });
+    resp.on("end", () => resolve(Buffer.concat(data)));
+  });
+}
+
+// src/provider/github.ts
+var GitHubProvider = class {
+  ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36";
+  name = "GithubProvider";
+  urlHandler;
+  url;
+  extraHeaders;
+  constructor(options) {
+    this.url = new URL(options.url);
+    this.extraHeaders = options.extraHeaders;
+    this.urlHandler = options.urlHandler;
+    if (this.url.host !== "github.com") {
+      throw new Error(`${this.name}: invalid github url: ${options.url}`);
+    }
+    if (!this.url.pathname.endsWith("/")) {
+      this.url.pathname += "/";
+    }
+  }
+  parseURL(isDownloadAsar, path) {
+    const url = this.url.href + path;
+    return this.urlHandler ? this.urlHandler(url, isDownloadAsar) : url;
+  }
+  isLowerVersion = isLowerVersionDefault;
+  verifySignaure = verifySignatureDefault;
+  async downloadJSON(versionPath) {
+    return await downloadUpdateJSONDefault(
+      this.parseURL(false, `HEAD/${versionPath}`),
+      { userAgent: this.ua, accept: "application/json", ...this.extraHeaders }
+    );
+  }
+  async downloadBuffer(name, { version, size }, onDownloading) {
+    return await downloadAsarBufferDefault(
+      this.parseURL(true, `releases/download/v${version}/${name}-${version}.asar.gz`),
+      { userAgent: this.ua, accept: "application/octet-stream", ...this.extraHeaders },
+      size,
+      onDownloading
+    );
+  }
+};
+export {
+  GitHubProvider,
+  downloadAsarBufferDefault,
+  downloadUpdateJSONDefault
+};

package/dist/types-DxPmQmaq.d.cts

@@ -0,0 +1,61 @@
+import { Promisable } from '@subframe7536/type-utils';
+import { U as UpdateJSON, a as UpdateInfo } from './version-CffZWDhZ.cjs';
+
+type URLHandler = (url: string, isDownloadAsar: boolean) => string;
+type OnDownloading = (progress: DownloadingInfo) => void;
+interface DownloadingInfo {
+    /**
+     * downloaded percent, 0% - 100%
+     */
+    percent: `${number}%`;
+    /**
+     * total size
+     */
+    total: number;
+    /**
+     * downloaded size
+     */
+    current: number;
+}
+interface IProvider {
+    /**
+     * provider name
+     */
+    name: string;
+    /**
+     * custom url handler
+     *
+     * for Github, there are some {@link https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L34 public CDN links}
+     */
+    urlHandler?: URLHandler;
+    onDownloading?: OnDownloading;
+    /**
+     * download update json
+     * @param versionPath parsed version path
+     */
+    downloadJSON: (versionPath: string) => Promise<UpdateJSON>;
+    /**
+     * download update asar
+     * @param name app name
+     * @param updateInfo existing update info
+     * @param onDownloading hook for on downloading
+     */
+    downloadBuffer: (name: string, updateInfo: UpdateInfo, onDownloading?: (info: DownloadingInfo) => void) => Promise<Buffer>;
+    /**
+     * compare version
+     * @param oldVer old version string
+     * @param newVer new version string
+     * @returns if version1 < version2
+     */
+    isLowerVersion: (oldVer: string, newVer: string) => Promisable<boolean>;
+    /**
+     * verify asar signature
+     * @param buffer file buffer
+     * @param signature signature
+     * @param cert certificate
+     * @returns if signature is valid, returns the version, otherwise returns `undefined`
+     */
+    verifySignaure: (buffer: Buffer, signature: string, cert: string) => Promisable<string | undefined>;
+}
+
+export type { DownloadingInfo as D, IProvider as I, OnDownloading as O, URLHandler as U };

package/dist/types-seJf3Wbc.d.ts

@@ -0,0 +1,61 @@
+import { Promisable } from '@subframe7536/type-utils';
+import { U as UpdateJSON, a as UpdateInfo } from './version-CffZWDhZ.js';
+
+type URLHandler = (url: string, isDownloadAsar: boolean) => string;
+type OnDownloading = (progress: DownloadingInfo) => void;
+interface DownloadingInfo {
+    /**
+     * downloaded percent, 0% - 100%
+     */
+    percent: `${number}%`;
+    /**
+     * total size
+     */
+    total: number;
+    /**
+     * downloaded size
+     */
+    current: number;
+}
+interface IProvider {
+    /**
+     * provider name
+     */
+    name: string;
+    /**
+     * custom url handler
+     *
+     * for Github, there are some {@link https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L34 public CDN links}
+     */
+    urlHandler?: URLHandler;
+    onDownloading?: OnDownloading;
+    /**
+     * download update json
+     * @param versionPath parsed version path
+     */
+    downloadJSON: (versionPath: string) => Promise<UpdateJSON>;
+    /**
+     * download update asar
+     * @param name app name
+     * @param updateInfo existing update info
+     * @param onDownloading hook for on downloading
+     */
+    downloadBuffer: (name: string, updateInfo: UpdateInfo, onDownloading?: (info: DownloadingInfo) => void) => Promise<Buffer>;
+    /**
+     * compare version
+     * @param oldVer old version string
+     * @param newVer new version string
+     * @returns if version1 < version2
+     */
+    isLowerVersion: (oldVer: string, newVer: string) => Promisable<boolean>;
+    /**
+     * verify asar signature
+     * @param buffer file buffer
+     * @param signature signature
+     * @param cert certificate
+     * @returns if signature is valid, returns the version, otherwise returns `undefined`
+     */
+    verifySignaure: (buffer: Buffer, signature: string, cert: string) => Promisable<string | undefined>;
+}
+
+export type { DownloadingInfo as D, IProvider as I, OnDownloading as O, URLHandler as U };

package/dist/utils.cjs

@@ -20,21 +20,33 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
+  decrypt: () => decrypt,
   disableHWAccForWin7: () => disableHWAccForWin7,
+  encrypt: () => encrypt,
+  getAppVersion: () => getAppVersion,
+  getEntryVersion: () => getEntryVersion,
   getPathFromAppNameAsar: () => getPathFromAppNameAsar,
-  getPaths: () => getPaths,
-  getVersions: () => getVersions,
+  getPathFromEntryAsar: () => getPathFromEntryAsar,
+  getPathFromPreload: () => getPathFromPreload,
+  getPathFromPublic: () => getPathFromPublic,
   handleUnexpectedErrors: () => handleUnexpectedErrors,
-  is: () => is,
+  hashString: () => hashString,
+  isDev: () => isDev,
+  isLinux: () => isLinux,
+  isLowerVersionDefault: () => isLowerVersionDefault,
+  isMac: () => isMac,
   isUpdateJSON: () => isUpdateJSON,
-  loadNativeModuleFromEntry: () => loadNativeModuleFromEntry,
-  parseGithubCdnURL: () => parseGithubCdnURL,
+  isWin: () => isWin,
+  loadPage: () => loadPage,
   parseVersion: () => parseVersion,
+  requireNative: () => requireNative,
   restartApp: () => restartApp,
   setAppUserModelId: () => setAppUserModelId,
   setPortableAppDataPath: () => setPortableAppDataPath,
+  signature: () => signature,
   singleInstance: () => singleInstance,
   unzipFile: () => unzipFile,
+  verifySignatureDefault: () => verifySignatureDefault,
   waitAppReady: () => waitAppReady,
   zipFile: () => zipFile
 });
@@ -43,46 +55,32 @@ module.exports = __toCommonJS(utils_exports);
 // src/utils/electron.ts
 var import_node_fs = require("fs");
 var import_node_path = require("path");
-var import_node_os = require("os");
 var import_electron = require("electron");
-var is = {
-  dev: !import_electron.app.isPackaged,
-  win: process.platform === "win32",
-  mac: process.platform === "darwin",
-  linux: process.platform === "linux"
-};
+var isDev = __EIU_IS_DEV__;
+var isWin = process.platform === "win32";
+var isMac = process.platform === "darwin";
+var isLinux = process.platform === "linux";
 function getPathFromAppNameAsar(...path) {
-  return is.dev ? "DEV.asar" : (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getAppPath()), `${import_electron.app.name}.asar`, ...path);
+  return isDev ? "DEV.asar" : (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getAppPath()), `${import_electron.app.name}.asar`, ...path);
 }
-function getVersions() {
-  const platform = is.win ? "Windows" : is.mac ? "MacOS" : process.platform.toUpperCase();
-  return {
-    appVersion: is.dev ? import_electron.app.getVersion() : (0, import_node_fs.readFileSync)(getPathFromAppNameAsar("version"), "utf-8"),
-    entryVersion: import_electron.app.getVersion(),
-    electronVersion: process.versions.electron,
-    nodeVersion: process.versions.node,
-    systemVersion: `${platform} ${(0, import_node_os.release)()}`
-  };
+function getAppVersion() {
+  return isDev ? getEntryVersion() : (0, import_node_fs.readFileSync)(getPathFromAppNameAsar("version"), "utf-8");
 }
-function loadNativeModuleFromEntry(devEntryDirPath = "../../dist-entry", entryDirPath = (0, import_node_path.join)(import_electron.app.getAppPath(), (0, import_node_path.basename)(devEntryDirPath))) {
-  const path = is.dev ? devEntryDirPath : entryDirPath;
-  return (moduleName) => {
-    try {
-      return require((0, import_node_path.join)(path, moduleName));
-    } catch (error) {
-      console.error("fail to load module", error);
-    }
-  };
+function getEntryVersion() {
+  return import_electron.app.getVersion();
+}
+function requireNative(moduleName) {
+  return require((0, import_node_path.join)(import_electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, moduleName));
 }
 function restartApp() {
   import_electron.app.relaunch();
   import_electron.app.quit();
 }
 function setAppUserModelId(id) {
-  import_electron.app.setAppUserModelId(is.dev ? process.execPath : id ?? `org.${import_electron.app.name}`);
+  isWin && import_electron.app.setAppUserModelId(id ?? `org.${import_electron.app.name}`);
 }
 function disableHWAccForWin7() {
-  if ((0, import_node_os.release)().startsWith("6.1")) {
+  if (require("os").release().startsWith("6.1")) {
     import_electron.app.disableHardwareAcceleration();
   }
 }
@@ -117,105 +115,59 @@ function waitAppReady(timeout = 1e3) {
     });
   });
 }
-function getPaths(entryDirName = "dist-entry") {
-  const root = (0, import_node_path.join)(__dirname, "..");
-  const mainDirPath = (0, import_node_path.join)(root, "main");
-  const preloadDirPath = (0, import_node_path.join)(root, "preload");
-  const rendererDirPath = (0, import_node_path.join)(root, "renderer");
-  const devServerURL = process.env.VITE_DEV_SERVER_URL;
-  const indexHTMLPath = (0, import_node_path.join)(rendererDirPath, "index.html");
-  const publicDirPath = devServerURL ? (0, import_node_path.join)(root, "../public") : rendererDirPath;
-  return {
-    /**
-     * @example
-     * ```ts
-     * devServerURL && win.loadURL(devServerURL)
-     * ```
-     */
-    devServerURL,
-    /**
-     * @example
-     * ```ts
-     * win.loadFile(indexHTMLPath)
-     * ```
-     */
-    indexHTMLPath,
-    /**
-     * get path inside entry asar
-     * @param paths joined path
-     */
-    getPathFromEntryAsar(...paths) {
-      return (0, import_node_path.join)(import_electron.app.getAppPath(), entryDirName, ...paths);
-    },
-    /**
-     * get path inside `${electron.app.name}.asar/main`
-     * @param paths joined path
-     */
-    getPathFromMain(...paths) {
-      return (0, import_node_path.join)(mainDirPath, ...paths);
-    },
-    /**
-     * get path inside `${electron.app.name}.asar/preload`
-     * @param paths joined path
-     */
-    getPathFromPreload(...paths) {
-      return (0, import_node_path.join)(preloadDirPath, ...paths);
-    },
-    /**
-     * get path inside public dir
-     * @param paths joined path
-     */
-    getPathFromPublic(...paths) {
-      return (0, import_node_path.join)(publicDirPath, ...paths);
-    }
-  };
+function loadPage(win, htmlFilePath = "index.html") {
+  isDev ? win.loadURL(process.env.VITE_DEV_SERVER_URL + htmlFilePath) : win.loadFile(getPathFromAppNameAsar("renderer", htmlFilePath));
+}
+function getPathFromPreload(...paths) {
+  return isDev ? (0, import_node_path.join)(import_electron.app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "preload", ...paths) : getPathFromAppNameAsar("preload", ...paths);
+}
+function getPathFromPublic(...paths) {
+  return isDev ? (0, import_node_path.join)(import_electron.app.getAppPath(), "public", ...paths) : getPathFromAppNameAsar("renderer", ...paths);
+}
+function getPathFromEntryAsar(...paths) {
+  return (0, import_node_path.join)(import_electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, ...paths);
 }
 
 // src/utils/zip.ts
 var import_node_fs2 = require("fs");
 var import_node_zlib = require("zlib");
-async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
-  if (!(0, import_node_fs2.existsSync)(gzipPath)) {
-    throw new Error(`path to zipped file not exist: ${gzipPath}`);
+async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
+  if (!(0, import_node_fs2.existsSync)(filePath)) {
+    throw new Error(`path to be zipped not exist: ${filePath}`);
   }
-  const compressedBuffer = (0, import_node_fs2.readFileSync)(gzipPath);
+  const buffer = (0, import_node_fs2.readFileSync)(filePath);
   return new Promise((resolve, reject) => {
-    (0, import_node_zlib.brotliDecompress)(compressedBuffer, (err, buffer) => {
-      (0, import_node_fs2.rmSync)(gzipPath);
+    (0, import_node_zlib.brotliCompress)(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
       }
-      (0, import_node_fs2.writeFileSync)(targetFilePath, buffer);
+      (0, import_node_fs2.writeFileSync)(targetFilePath, buffer2);
       resolve(null);
     });
   });
 }
-async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
-  if (!(0, import_node_fs2.existsSync)(filePath)) {
-    throw new Error(`path to be zipped not exist: ${filePath}`);
+
+// src/utils/unzip.ts
+var import_node_fs3 = require("fs");
+var import_node_zlib2 = require("zlib");
+async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
+  if (!(0, import_node_fs3.existsSync)(gzipPath)) {
+    throw new Error(`path to zipped file not exist: ${gzipPath}`);
   }
-  const buffer = (0, import_node_fs2.readFileSync)(filePath);
+  const compressedBuffer = (0, import_node_fs3.readFileSync)(gzipPath);
   return new Promise((resolve, reject) => {
-    (0, import_node_zlib.brotliCompress)(buffer, (err, buffer2) => {
+    (0, import_node_zlib2.brotliDecompress)(compressedBuffer, (err, buffer) => {
+      (0, import_node_fs3.rmSync)(gzipPath);
       if (err) {
         reject(err);
       }
-      (0, import_node_fs2.writeFileSync)(targetFilePath, buffer2);
+      (0, import_node_fs3.writeFileSync)(targetFilePath, buffer);
       resolve(null);
     });
   });
 }
 
-// src/utils/pure.ts
-function parseGithubCdnURL(originRepoURL, cdnPrefix, relativeFilePath) {
-  if (!originRepoURL.startsWith("https://github.com/")) {
-    throw new Error("origin url must start with https://github.com/");
-  }
-  originRepoURL = originRepoURL.trim().replace(/\/?$/, "/").trim();
-  relativeFilePath = relativeFilePath.trim().replace(/^\/|\/?$/g, "").trim();
-  cdnPrefix = cdnPrefix.trim().replace(/^\/?|\/?$/g, "").trim();
-  return originRepoURL.replace("github.com", cdnPrefix) + relativeFilePath;
-}
+// src/utils/version.ts
 function handleUnexpectedErrors(callback) {
   process.on("uncaughtException", callback);
   process.on("unhandledRejection", callback);
@@ -243,27 +195,99 @@ function parseVersion(version) {
   }
   return ret;
 }
+function isLowerVersionDefault(oldVer, newVer) {
+  const oldV = parseVersion(oldVer);
+  const newV = parseVersion(newVer);
+  function compareStrings(str1, str2) {
+    if (str1 === "") {
+      return str2 !== "";
+    } else if (str2 === "") {
+      return true;
+    }
+    return str1 < str2;
+  }
+  for (let key of Object.keys(oldV)) {
+    if (key === "stage" && compareStrings(oldV[key], newV[key])) {
+      return true;
+    } else if (oldV[key] !== newV[key]) {
+      return oldV[key] < newV[key];
+    }
+  }
+  return false;
+}
 function isUpdateJSON(json) {
-  const is2 = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
-  return is2(json) && is2(json?.beta);
+  const is = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
+  return is(json) && is(json?.beta);
+}
+
+// src/utils/crypto/decrypt.ts
+var import_node_crypto2 = require("crypto");
+
+// src/utils/crypto/utils.ts
+var import_node_crypto = require("crypto");
+function hashString(data, length) {
+  const hash = (0, import_node_crypto.createHash)("SHA256").update(data).digest("binary");
+  return Buffer.from(hash).subarray(0, length);
+}
+
+// src/utils/crypto/decrypt.ts
+function decrypt(encryptedText, key, iv) {
+  const decipher = (0, import_node_crypto2.createDecipheriv)("aes-256-cbc", key, iv);
+  let decrypted = decipher.update(encryptedText, "base64url", "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+function verifySignatureDefault(buffer, signature2, cert) {
+  try {
+    const [sig, version] = decrypt(signature2, hashString(cert, 32), hashString(buffer, 16)).split("%");
+    const result = (0, import_node_crypto2.createVerify)("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+    return result ? version : void 0;
+  } catch (error) {
+    return void 0;
+  }
+}
+
+// src/utils/crypto/encrypt.ts
+var import_node_crypto3 = require("crypto");
+function encrypt(plainText, key, iv) {
+  const cipher = (0, import_node_crypto3.createCipheriv)("aes-256-cbc", key, iv);
+  let encrypted = cipher.update(plainText, "utf8", "base64url");
+  encrypted += cipher.final("base64url");
+  return encrypted;
+}
+function signature(buffer, privateKey, cert, version) {
+  const sig = (0, import_node_crypto3.createSign)("RSA-SHA256").update(buffer).sign((0, import_node_crypto3.createPrivateKey)(privateKey), "base64");
+  return encrypt(`${sig}%${version}`, hashString(cert, 32), hashString(buffer, 16));
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  decrypt,
   disableHWAccForWin7,
+  encrypt,
+  getAppVersion,
+  getEntryVersion,
   getPathFromAppNameAsar,
-  getPaths,
-  getVersions,
+  getPathFromEntryAsar,
+  getPathFromPreload,
+  getPathFromPublic,
   handleUnexpectedErrors,
-  is,
+  hashString,
+  isDev,
+  isLinux,
+  isLowerVersionDefault,
+  isMac,
   isUpdateJSON,
-  loadNativeModuleFromEntry,
-  parseGithubCdnURL,
+  isWin,
+  loadPage,
   parseVersion,
+  requireNative,
   restartApp,
   setAppUserModelId,
   setPortableAppDataPath,
+  signature,
   singleInstance,
   unzipFile,
+  verifySignatureDefault,
   waitAppReady,
   zipFile
 });