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

package/dist/provider.cjs

@@ -0,0 +1,227 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/provider/index.ts
+var provider_exports = {};
+__export(provider_exports, {
+  GitHubProvider: () => GitHubProvider,
+  downloadAsarBufferDefault: () => downloadAsarBufferDefault,
+  downloadUpdateJSONDefault: () => downloadUpdateJSONDefault
+});
+module.exports = __toCommonJS(provider_exports);
+
+// src/utils/electron.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_electron = require("electron");
+var isDev = __EIU_IS_DEV__;
+var isWin = process.platform === "win32";
+var isMac = process.platform === "darwin";
+var isLinux = process.platform === "linux";
+function waitAppReady(timeout = 1e3) {
+  return import_electron.app.isReady() ? Promise.resolve() : new Promise((resolve, reject) => {
+    const _ = setTimeout(() => {
+      reject(new Error("app is not ready"));
+    }, timeout);
+    import_electron.app.whenReady().then(() => {
+      clearTimeout(_);
+      resolve();
+    });
+  });
+}
+
+// src/utils/zip.ts
+var import_node_fs2 = require("fs");
+var import_node_zlib = require("zlib");
+
+// src/utils/unzip.ts
+var import_node_fs3 = require("fs");
+var import_node_zlib2 = require("zlib");
+
+// src/utils/version.ts
+function parseVersion(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z0-9.-]+))?/i.exec(version);
+  if (!match) {
+    throw new TypeError(`invalid version: ${version}`);
+  }
+  const [major, minor, patch] = match.slice(1, 4).map(Number);
+  const ret = {
+    major,
+    minor,
+    patch,
+    stage: "",
+    stageVersion: -1
+  };
+  if (match[4]) {
+    let [stage, _v] = match[4].split(".");
+    ret.stage = stage;
+    ret.stageVersion = Number(_v) || -1;
+  }
+  if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch) || Number.isNaN(ret.stageVersion)) {
+    throw new TypeError(`invalid version: ${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 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, signature, cert) {
+  try {
+    const [sig, version] = decrypt(signature, 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");
+
+// src/provider/download.ts
+var import_electron2 = require("electron");
+async function downlaodFn(url, headers, onResponse) {
+  await waitAppReady();
+  return new Promise((resolve, reject) => {
+    const request = import_electron2.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
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GitHubProvider,
+  downloadAsarBufferDefault,
+  downloadUpdateJSONDefault
+});

package/dist/provider.d.cts

@@ -0,0 +1,37 @@
+import { i as isLowerVersionDefault, U as UpdateJSON, a as UpdateInfo } from './version-CffZWDhZ.cjs';
+import { v as verifySignatureDefault } from './decrypt-BNBcodiO.cjs';
+import { U as URLHandler, I as IProvider, D as DownloadingInfo, O as OnDownloading } from './types-DxPmQmaq.cjs';
+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.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 };