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

package/dist/provider.cjs

@@ -0,0 +1,232 @@
+'use strict';
+
+var url = require('url');
+var electron = require('electron');
+var crypto = require('crypto');
+var zlib = require('zlib');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var zlib__default = /*#__PURE__*/_interopDefault(zlib);
+
+// src/provider/github.ts
+
+// 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 defaultIsLowerVersion(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.version);
+  return is(json) && is(json?.beta);
+}
+
+// src/provider/download.ts
+function getHeader(headers, key) {
+  const value = headers[key];
+  if (Array.isArray(value)) {
+    return value.length === 0 ? null : value[value.length - 1];
+  } else {
+    return value;
+  }
+}
+async function downloadFn(url, headers, onResponse) {
+  await electron.app.whenReady();
+  return new Promise((resolve, reject) => {
+    const request = electron.net.request({ url, method: "GET", redirect: "follow", headers });
+    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 defaultDownloadUpdateJSON(url, headers) {
+  return await downloadFn(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 {
+        reject(new Error("invalid update json"));
+      }
+    });
+  });
+}
+async function defaultDownloadAsar(url, headers, onDownloading) {
+  let transferred = 0;
+  let time = Date.now();
+  return await downloadFn(url, headers, (resp, resolve) => {
+    const total = getHeader(resp.headers, "content-length") || -1;
+    let data = [];
+    resp.on("data", (chunk) => {
+      const delta = chunk.length;
+      transferred += delta;
+      const current = Date.now();
+      onDownloading?.({
+        percent: +(transferred / total).toFixed(2) * 100,
+        total,
+        transferred,
+        delta,
+        bps: delta / ((current - time) * 1e3)
+      });
+      time = current;
+      data.push(chunk);
+    });
+    resp.on("end", () => resolve(Buffer.concat(data)));
+  });
+}
+function hashBuffer(data, length) {
+  const hash = crypto__default.default.createHash("SHA256").update(data).digest("binary");
+  return Buffer.from(hash).subarray(0, length);
+}
+function aesDecrypt(encryptedText, key, iv) {
+  const decipher = crypto__default.default.createDecipheriv("aes-256-cbc", key, iv);
+  return decipher.update(encryptedText, "base64url", "utf8") + decipher.final("utf8");
+}
+function defaultVerifySignature(buffer, version, signature, cert) {
+  try {
+    const [sig, ver] = aesDecrypt(signature, hashBuffer(cert, 32), hashBuffer(buffer, 16)).split("%");
+    if (ver !== version) {
+      return false;
+    }
+    return crypto__default.default.createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+  } catch {
+    return false;
+  }
+}
+async function defaultUnzipFile(buffer) {
+  return new Promise((resolve, reject) => {
+    zlib__default.default.brotliDecompress(buffer, (err, buffer2) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(buffer2);
+      }
+    });
+  });
+}
+
+// src/provider/base.ts
+var BaseProvider = class {
+  name = "BaseProvider";
+  /**
+   * @inheritdoc
+   */
+  isLowerVersion = defaultIsLowerVersion;
+  /**
+   * @inheritdoc
+   */
+  verifySignaure = defaultVerifySignature;
+  /**
+   * @inheritdoc
+   */
+  unzipFile = defaultUnzipFile;
+};
+
+// src/provider/github.ts
+var GitHubProvider = class extends BaseProvider {
+  name = "GithubProvider";
+  options;
+  /**
+   * Update Provider for Github repo
+   * - download update json from `https://raw.githubusercontent.com/{user}/{repo}/HEAD/{versionPath}`
+   * - download update asar from `https://github.com/{user}/{repo}/releases/download/v{version}/{name}-{version}.asar.gz`
+   *
+   * you can setup `urlHandler` in {@link GitHubProviderOptions} or `Updater` to modify url before request
+   * @param options provider options
+   */
+  constructor(options) {
+    super();
+    this.options = options;
+    if (!options.branch) {
+      this.options.branch = "HEAD";
+    }
+  }
+  get urlHandler() {
+    return this.options.urlHandler;
+  }
+  set urlHandler(handler) {
+    this.options.urlHandler = handler;
+  }
+  async parseURL(isDownloadAsar, extraPath) {
+    const url$1 = new url.URL(
+      `/${this.options.username}/${this.options.repo}/${extraPath}`,
+      "https://" + (isDownloadAsar ? "github.com" : "raw.githubusercontent.com")
+    );
+    return (await this.urlHandler?.(url$1, isDownloadAsar) || url$1).toString();
+  }
+  /**
+   * @inheritdoc
+   */
+  async downloadJSON(versionPath) {
+    return await defaultDownloadUpdateJSON(
+      await this.parseURL(false, `${this.options.branch}/${versionPath}`),
+      { Accept: "application/json", ...this.options.extraHeaders }
+    );
+  }
+  /**
+   * @inheritdoc
+   */
+  async downloadAsar(name, info, onDownloading) {
+    return await defaultDownloadAsar(
+      await this.parseURL(true, `releases/download/v${info.version}/${name}-${info.version}.asar.gz`),
+      { Accept: "application/octet-stream", ...this.options.extraHeaders },
+      onDownloading
+    );
+  }
+};
+
+exports.BaseProvider = BaseProvider;
+exports.GitHubProvider = GitHubProvider;
+exports.defaultDownloadAsar = defaultDownloadAsar;
+exports.defaultDownloadUpdateJSON = defaultDownloadUpdateJSON;
+exports.getHeader = getHeader;

package/dist/provider.d.cts

@@ -0,0 +1,109 @@
+import { d as defaultIsLowerVersion, a as UpdateJSON, U as UpdateInfo } from './version-C4tF_trh.cjs';
+import { I as IProvider, D as DownloadingInfo, U as URLHandler, O as OnDownloading } from './types-DEYw5VrL.cjs';
+import { f as defaultVerifySignature, a as defaultUnzipFile } from './zip-rm9ED9nU.cjs';
+import { Arrayable } from '@subframe7536/type-utils';
+
+declare abstract class BaseProvider implements IProvider {
+    name: string;
+    /**
+     * @inheritdoc
+     */
+    isLowerVersion: typeof defaultIsLowerVersion;
+    /**
+     * @inheritdoc
+     */
+    verifySignaure: typeof defaultVerifySignature;
+    /**
+     * @inheritdoc
+     */
+    unzipFile: typeof defaultUnzipFile;
+    /**
+     * @inheritdoc
+     */
+    abstract downloadJSON(versionPath: string): Promise<UpdateJSON>;
+    /**
+     * @inheritdoc
+     */
+    abstract downloadAsar(name: string, info: UpdateInfo, onDownloading?: (info: DownloadingInfo) => void): Promise<Buffer>;
+}
+
+interface GitHubProviderOptions {
+    /**
+     * Github user name
+     */
+    username: string;
+    /**
+     * Github repo name
+     */
+    repo: string;
+    /**
+     * Github branch name that fetch version
+     * @default 'HEAD'
+     */
+    branch?: string;
+    /**
+     * Extra headers
+     */
+    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#L40 public CDN links}
+     * @example
+     * (url, isDownloadAsar) => {
+     *   if (isDownloadAsar) {
+     *     url.hostname = 'mirror.ghproxy.com'
+     *     url.pathname = 'https://github.com' + url.pathname
+     *     return url
+     *   }
+     * }
+     */
+    urlHandler?: URLHandler;
+}
+declare class GitHubProvider extends BaseProvider {
+    name: string;
+    private options;
+    /**
+     * Update Provider for Github repo
+     * - download update json from `https://raw.githubusercontent.com/{user}/{repo}/HEAD/{versionPath}`
+     * - download update asar from `https://github.com/{user}/{repo}/releases/download/v{version}/{name}-{version}.asar.gz`
+     *
+     * you can setup `urlHandler` in {@link GitHubProviderOptions} or `Updater` to modify url before request
+     * @param options provider options
+     */
+    constructor(options: GitHubProviderOptions);
+    get urlHandler(): URLHandler | undefined;
+    set urlHandler(handler: URLHandler);
+    private parseURL;
+    /**
+     * @inheritdoc
+     */
+    downloadJSON(versionPath: string): Promise<UpdateJSON>;
+    /**
+     * @inheritdoc
+     */
+    downloadAsar(name: string, info: UpdateInfo, onDownloading?: (info: DownloadingInfo) => void): Promise<Buffer>;
+}
+
+/**
+ * Safe get value from header
+ * @param headers response header
+ * @param key target header key
+ */
+declare function getHeader(headers: Record<string, Arrayable<string>>, key: any): any;
+/**
+ * Default function to download json and parse to UpdateJson
+ * @param url target url
+ * @param headers extra headers
+ */
+declare function defaultDownloadUpdateJSON(url: string, headers: Record<string, any>): Promise<UpdateJSON>;
+/**
+ * Default function to download asar buffer,
+ * get total size from `Content-Length` header
+ * @param url target url
+ * @param headers extra headers
+ * @param onDownloading on downloading callback
+ */
+declare function defaultDownloadAsar(url: string, headers: Record<string, any>, onDownloading?: OnDownloading): Promise<Buffer>;
+
+export { BaseProvider, DownloadingInfo, GitHubProvider, type GitHubProviderOptions, IProvider, OnDownloading, URLHandler, defaultDownloadAsar, defaultDownloadUpdateJSON, getHeader };

package/dist/provider.d.ts

@@ -0,0 +1,109 @@
+import { d as defaultIsLowerVersion, a as UpdateJSON, U as UpdateInfo } from './version-C4tF_trh.js';
+import { I as IProvider, D as DownloadingInfo, U as URLHandler, O as OnDownloading } from './types-Bnc4jz6R.js';
+import { f as defaultVerifySignature, a as defaultUnzipFile } from './zip-rm9ED9nU.js';
+import { Arrayable } from '@subframe7536/type-utils';
+
+declare abstract class BaseProvider implements IProvider {
+    name: string;
+    /**
+     * @inheritdoc
+     */
+    isLowerVersion: typeof defaultIsLowerVersion;
+    /**
+     * @inheritdoc
+     */
+    verifySignaure: typeof defaultVerifySignature;
+    /**
+     * @inheritdoc
+     */
+    unzipFile: typeof defaultUnzipFile;
+    /**
+     * @inheritdoc
+     */
+    abstract downloadJSON(versionPath: string): Promise<UpdateJSON>;
+    /**
+     * @inheritdoc
+     */
+    abstract downloadAsar(name: string, info: UpdateInfo, onDownloading?: (info: DownloadingInfo) => void): Promise<Buffer>;
+}
+
+interface GitHubProviderOptions {
+    /**
+     * Github user name
+     */
+    username: string;
+    /**
+     * Github repo name
+     */
+    repo: string;
+    /**
+     * Github branch name that fetch version
+     * @default 'HEAD'
+     */
+    branch?: string;
+    /**
+     * Extra headers
+     */
+    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#L40 public CDN links}
+     * @example
+     * (url, isDownloadAsar) => {
+     *   if (isDownloadAsar) {
+     *     url.hostname = 'mirror.ghproxy.com'
+     *     url.pathname = 'https://github.com' + url.pathname
+     *     return url
+     *   }
+     * }
+     */
+    urlHandler?: URLHandler;
+}
+declare class GitHubProvider extends BaseProvider {
+    name: string;
+    private options;
+    /**
+     * Update Provider for Github repo
+     * - download update json from `https://raw.githubusercontent.com/{user}/{repo}/HEAD/{versionPath}`
+     * - download update asar from `https://github.com/{user}/{repo}/releases/download/v{version}/{name}-{version}.asar.gz`
+     *
+     * you can setup `urlHandler` in {@link GitHubProviderOptions} or `Updater` to modify url before request
+     * @param options provider options
+     */
+    constructor(options: GitHubProviderOptions);
+    get urlHandler(): URLHandler | undefined;
+    set urlHandler(handler: URLHandler);
+    private parseURL;
+    /**
+     * @inheritdoc
+     */
+    downloadJSON(versionPath: string): Promise<UpdateJSON>;
+    /**
+     * @inheritdoc
+     */
+    downloadAsar(name: string, info: UpdateInfo, onDownloading?: (info: DownloadingInfo) => void): Promise<Buffer>;
+}
+
+/**
+ * Safe get value from header
+ * @param headers response header
+ * @param key target header key
+ */
+declare function getHeader(headers: Record<string, Arrayable<string>>, key: any): any;
+/**
+ * Default function to download json and parse to UpdateJson
+ * @param url target url
+ * @param headers extra headers
+ */
+declare function defaultDownloadUpdateJSON(url: string, headers: Record<string, any>): Promise<UpdateJSON>;
+/**
+ * Default function to download asar buffer,
+ * get total size from `Content-Length` header
+ * @param url target url
+ * @param headers extra headers
+ * @param onDownloading on downloading callback
+ */
+declare function defaultDownloadAsar(url: string, headers: Record<string, any>, onDownloading?: OnDownloading): Promise<Buffer>;
+
+export { BaseProvider, DownloadingInfo, GitHubProvider, type GitHubProviderOptions, IProvider, OnDownloading, URLHandler, defaultDownloadAsar, defaultDownloadUpdateJSON, getHeader };

package/dist/provider.js

@@ -0,0 +1,139 @@
+import { defaultVerifySignature, defaultUnzipFile } from './chunk-KZSYEXLO.js';
+import { defaultIsLowerVersion, isUpdateJSON } from './chunk-72ZAJ7AF.js';
+import { URL } from 'node:url';
+import { app, net } from 'electron';
+
+function getHeader(headers, key) {
+  const value = headers[key];
+  if (Array.isArray(value)) {
+    return value.length === 0 ? null : value[value.length - 1];
+  } else {
+    return value;
+  }
+}
+async function downloadFn(url, headers, onResponse) {
+  await app.whenReady();
+  return new Promise((resolve, reject) => {
+    const request = net.request({ url, method: "GET", redirect: "follow", headers });
+    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 defaultDownloadUpdateJSON(url, headers) {
+  return await downloadFn(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 {
+        reject(new Error("invalid update json"));
+      }
+    });
+  });
+}
+async function defaultDownloadAsar(url, headers, onDownloading) {
+  let transferred = 0;
+  let time = Date.now();
+  return await downloadFn(url, headers, (resp, resolve) => {
+    const total = getHeader(resp.headers, "content-length") || -1;
+    let data = [];
+    resp.on("data", (chunk) => {
+      const delta = chunk.length;
+      transferred += delta;
+      const current = Date.now();
+      onDownloading?.({
+        percent: +(transferred / total).toFixed(2) * 100,
+        total,
+        transferred,
+        delta,
+        bps: delta / ((current - time) * 1e3)
+      });
+      time = current;
+      data.push(chunk);
+    });
+    resp.on("end", () => resolve(Buffer.concat(data)));
+  });
+}
+
+// src/provider/base.ts
+var BaseProvider = class {
+  name = "BaseProvider";
+  /**
+   * @inheritdoc
+   */
+  isLowerVersion = defaultIsLowerVersion;
+  /**
+   * @inheritdoc
+   */
+  verifySignaure = defaultVerifySignature;
+  /**
+   * @inheritdoc
+   */
+  unzipFile = defaultUnzipFile;
+};
+
+// src/provider/github.ts
+var GitHubProvider = class extends BaseProvider {
+  name = "GithubProvider";
+  options;
+  /**
+   * Update Provider for Github repo
+   * - download update json from `https://raw.githubusercontent.com/{user}/{repo}/HEAD/{versionPath}`
+   * - download update asar from `https://github.com/{user}/{repo}/releases/download/v{version}/{name}-{version}.asar.gz`
+   *
+   * you can setup `urlHandler` in {@link GitHubProviderOptions} or `Updater` to modify url before request
+   * @param options provider options
+   */
+  constructor(options) {
+    super();
+    this.options = options;
+    if (!options.branch) {
+      this.options.branch = "HEAD";
+    }
+  }
+  get urlHandler() {
+    return this.options.urlHandler;
+  }
+  set urlHandler(handler) {
+    this.options.urlHandler = handler;
+  }
+  async parseURL(isDownloadAsar, extraPath) {
+    const url = new URL(
+      `/${this.options.username}/${this.options.repo}/${extraPath}`,
+      "https://" + (isDownloadAsar ? "github.com" : "raw.githubusercontent.com")
+    );
+    return (await this.urlHandler?.(url, isDownloadAsar) || url).toString();
+  }
+  /**
+   * @inheritdoc
+   */
+  async downloadJSON(versionPath) {
+    return await defaultDownloadUpdateJSON(
+      await this.parseURL(false, `${this.options.branch}/${versionPath}`),
+      { Accept: "application/json", ...this.options.extraHeaders }
+    );
+  }
+  /**
+   * @inheritdoc
+   */
+  async downloadAsar(name, info, onDownloading) {
+    return await defaultDownloadAsar(
+      await this.parseURL(true, `releases/download/v${info.version}/${name}-${info.version}.asar.gz`),
+      { Accept: "application/octet-stream", ...this.options.extraHeaders },
+      onDownloading
+    );
+  }
+};
+
+export { BaseProvider, GitHubProvider, defaultDownloadAsar, defaultDownloadUpdateJSON, getHeader };

package/dist/types-Bnc4jz6R.d.ts

@@ -0,0 +1,78 @@
+import { Promisable } from '@subframe7536/type-utils';
+import { a as UpdateJSON, U as UpdateInfo } from './version-C4tF_trh.js';
+
+type URLHandler = (url: URL, isDownloadAsar: boolean) => Promisable<URL | string | undefined | null>;
+type OnDownloading = (progress: DownloadingInfo) => void;
+interface DownloadingInfo {
+    /**
+     * Download buffer delta
+     */
+    delta: number;
+    /**
+     * Downloaded percent, 0 ~ 100
+     *
+     * If no `Content-Length` header, will be nagative
+     */
+    percent: number;
+    /**
+     * Total size
+     *
+     * If not `Content-Length` header, will be -1
+     */
+    total: number;
+    /**
+     * Downloaded size
+     */
+    transferred: number;
+    /**
+     * Download speed, bytes per second
+     */
+    bps: 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 in project
+     */
+    downloadJSON: (versionPath: string) => Promise<UpdateJSON>;
+    /**
+     * Download update asar
+     * @param name app name
+     * @param updateInfo existing update info
+     * @param onDownloading hook for on downloading
+     */
+    downloadAsar: (name: string, updateInfo: UpdateInfo, onDownloading?: (info: DownloadingInfo) => void) => Promise<Buffer>;
+    /**
+     * Check the old version is less than new version
+     * @param oldVer old version string
+     * @param newVer new version string
+     */
+    isLowerVersion: (oldVer: string, newVer: string) => boolean;
+    /**
+     * Function to decompress file using brotli
+     * @param buffer compressed file buffer
+     */
+    unzipFile: (buffer: Buffer) => Promise<Buffer>;
+    /**
+     * Verify asar signature,
+     * if signature is valid, returns the version, otherwise returns `undefined`
+     * @param buffer file buffer
+     * @param version target version
+     * @param signature signature
+     * @param cert certificate
+     */
+    verifySignaure: (buffer: Buffer, version: string, signature: string, cert: string) => Promisable<boolean>;
+}
+
+export type { DownloadingInfo as D, IProvider as I, OnDownloading as O, URLHandler as U };