electron-incremental-update 0.5.1 → 0.6.1

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { Buffer } from 'node:buffer';
 
 type CheckResultType = Omit<UpdateJSON, 'signature'> | undefined | Error;
-type DownloadResult = true | Error;
+type InstallResult = true | Error;
 type UpdateEvents = {
     downloading: [progress: number];
     debug: [msg: string | Error];
@@ -11,25 +11,36 @@ type UpdateJSON = {
     version: string;
     size: number;
 };
+declare function isUpdateJSON(json: any): json is UpdateJSON;
 type MaybeArray<T> = T extends undefined | null | never ? [] : T extends any[] ? T['length'] extends 1 ? [data: T[0]] : T : [data: T];
 interface TypedUpdater<T extends Record<string | symbol, MaybeArray<any>>, Event extends Exclude<keyof T, number> = Exclude<keyof T, number>> {
     removeAllListeners<E extends Event>(event?: E): this;
     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: (...data: 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;
     /**
+     * check update info
+     * @param data update json url
+     * @returns
      * - `{size: number, version: string}`: available
      * - `false`: unavailable
      * - `Error`: fail
      */
-    checkUpdate(url?: string): Promise<CheckResultType>;
+    checkUpdate(data?: string | UpdateJSON): Promise<CheckResultType>;
     /**
+     * download update and install
+     *
+     * if you want to update **offline**, you can set both `src` and `sig` to verify and install
+     * @param data asar download url or buffer
+     * @param sig signature
+     * @returns
      * - `true`: success
      * - `Error`: fail
      */
-    downloadUpdate(url?: string | Buffer): Promise<DownloadResult>;
+    downloadAndInstall(data?: string | Buffer, sig?: string): Promise<InstallResult>;
 }
 type Updater = TypedUpdater<UpdateEvents>;
 interface UpdaterOption {
@@ -40,15 +51,15 @@ interface UpdaterOption {
      * @example
      * ```ts
      * // auto filled by plugin
-     * const SIGNATURE_PUB = ''
+     * const SIGNATURE_CERT = ''
      *
      * const updater = createUpdater({
-     *   SIGNATURE_PUB,
+     *   SIGNATURE_CERT,
      *   ...
      * })
      * ```
      */
-    SIGNATURE_PUB: string;
+    SIGNATURE_CERT: string;
     /**
      * name of your application
      *
@@ -86,7 +97,7 @@ interface UpdaterOption {
      * @param newVersion new version string
      * @returns whether to update
      */
-    compareVersion?: (oldVersion: string, newVersion: string) => boolean | Promise<boolean>;
+    compareVersion?: (oldVersion: string, newVersion: string) => boolean;
     downloadConfig?: {
         /**
          * download user agent
@@ -120,7 +131,7 @@ interface UpdaterOption {
  * get the application asar absolute path
  * @param name The name of the application
  */
-declare function getAppAsarPath(name: string): string;
+declare function getProductAsarPath(name: string): string;
 /**
  * get the version of entry (app.asar)
  */
@@ -129,7 +140,7 @@ declare function getEntryVersion(): string;
  * get the version of application (name.asar)
  * @param name - The name of the application
  */
-declare function getAppVersion(name: string): string;
+declare function getProductVersion(name: string): string;
 /**
  * require native package from app.asar
  * @param packageName native package name
@@ -147,8 +158,9 @@ declare function getGithubReleaseCdnGroup(): {
     maintainer: string;
 }[];
 declare function restartApp(): void;
+declare function waitAppReady(duration?: number): Promise<unknown>;
 
-declare function createUpdater({ SIGNATURE_PUB, repository, productName, releaseAsarURL: _release, updateJsonURL: _update, debug, downloadConfig, compareVersion, }: UpdaterOption): Updater;
+declare function createUpdater({ SIGNATURE_CERT, repository, productName, releaseAsarURL: _release, updateJsonURL: _update, debug, downloadConfig, compareVersion, }: UpdaterOption): Updater;
 
 type AppOption = {
     /**
@@ -177,11 +189,11 @@ type InitUpdaterOptions = OptionalProperty<UpdaterOption, 'productName'>;
  * import { createUpdater, getGithubReleaseCdnGroup, initApp, parseGithubCdnURL } from 'electron-incremental-update'
  * import { name, repository } from '../package.json'
  *
- * const SIGNATURE_PUB = '' // auto generate
+ * const SIGNATURE_CERT = '' // auto generate
  *
  * const { cdnPrefix } = getGithubReleaseCdnGroup()[0]
  * const updater = createUpdater({
- *   SIGNATURE_PUB,
+ *   SIGNATURE_CERT,
  *   productName: name,
  *   repository,
  *   updateJsonURL: parseGithubCdnURL(repository, 'fastly.jsdelivr.net/gh', 'version.json'),
@@ -202,11 +214,11 @@ declare function initApp(appOptions: AppOption): {
  * import { initApp } from 'electron-incremental-update'
  * import { name, repository } from '../package.json'
  *
- * const SIGNATURE_PUB = '' // auto generate
+ * const SIGNATURE_CERT = '' // auto generate
  *
- * initApp({ name }, { SIGNATURE_PUB, repository })
+ * initApp({ name }, { SIGNATURE_CERT, repository })
  * ```
  */
 declare function initApp(appOptions: AppOption, updaterOptions: InitUpdaterOptions): undefined;
 
-export { AppOption, CheckResultType, DownloadResult, InitUpdaterOptions, UpdateJSON, Updater, UpdaterOption, createUpdater, getAppAsarPath, getAppVersion, getEntryVersion, getGithubReleaseCdnGroup, initApp, parseGithubCdnURL, requireNative, restartApp };
+export { AppOption, CheckResultType, InitUpdaterOptions, InstallResult, UpdateJSON, Updater, UpdaterOption, createUpdater, getEntryVersion, getGithubReleaseCdnGroup, getProductAsarPath, getProductVersion, initApp, isUpdateJSON, parseGithubCdnURL, requireNative, restartApp, waitAppReady };

package/dist/index.mjs

@@ -1,34 +1,110 @@
 import {
   __require,
   verify
-} from "./chunk-OBERMV66.mjs";
+} from "./chunk-VADH6AZA.mjs";
 
 // src/index.ts
-import { resolve } from "node:path";
+import { resolve as resolve2 } from "node:path";
 import { app as app3 } from "electron";
 
 // src/updater/index.ts
 import { EventEmitter } from "node:events";
+import { Buffer as Buffer2 } from "node:buffer";
 import { createGunzip } from "node:zlib";
-import { createReadStream, createWriteStream, existsSync } from "node:fs";
-import { rm, writeFile } from "node:fs/promises";
+import { createReadStream, createWriteStream, existsSync, rmSync } from "node:fs";
+import { readFile, rename, rm, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
 import { app as app2 } from "electron";
 
 // src/updater/defaultFunctions.ts
 import { Buffer } from "node:buffer";
-import https from "node:https";
-function downloadJSONDefault(url, updater, headers) {
-  return new Promise((resolve2, reject) => {
-    https.get(url, (res) => {
+import { net } from "electron";
+
+// src/updater/types.ts
+function isUpdateJSON(json) {
+  return "signature" in json && "version" in json && "size" in json;
+}
+
+// src/updater/utils.ts
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { app } from "electron";
+function getProductAsarPath(name) {
+  return app.isPackaged ? join(dirname(app.getAppPath()), `${name}.asar`) : "dev";
+}
+function getEntryVersion() {
+  return app.getVersion();
+}
+function getProductVersion(name) {
+  return app.isPackaged ? readFileSync(join(getProductAsarPath(name), "version"), "utf-8") : getEntryVersion();
+}
+function requireNative(packageName) {
+  const path = app.isPackaged ? join(app.getAppPath(), "node_modules", packageName) : packageName;
+  return __require(path);
+}
+function parseGithubCdnURL(repository, cdnPrefix, relativeFilePath) {
+  if (!repository.startsWith("https://github.com/")) {
+    throw new Error("url must start with https://github.com/");
+  }
+  repository = repository.trim().replace(/\/?$/, "/").trim();
+  relativeFilePath = relativeFilePath.trim().replace(/^\/|\/?$/g, "").trim();
+  cdnPrefix = cdnPrefix.trim().replace(/^\/?|\/?$/g, "").trim();
+  return repository.replace("github.com", cdnPrefix) + relativeFilePath;
+}
+function getGithubReleaseCdnGroup() {
+  return [
+    { cdnPrefix: "gh.gh2233.ml", maintainer: "@X.I.U/XIU2" },
+    { cdnPrefix: "ghproxy.com", maintainer: "gh-proxy" },
+    { cdnPrefix: "gh.ddlc.top", maintainer: "@mtr-static-official" },
+    { cdnPrefix: "ghdl.feizhuqwq.cf", maintainer: "feizhuqwq.com" },
+    { cdnPrefix: "slink.ltd", maintainer: "\u77E5\u4E86\u5C0F\u7AD9" },
+    { cdnPrefix: "git.xfj0.cn", maintainer: "anonymous1" },
+    { cdnPrefix: "gh.con.sh", maintainer: "anonymous2" },
+    { cdnPrefix: "ghps.cc", maintainer: "anonymous3" },
+    { cdnPrefix: "cors.isteed.cc/github.com", maintainer: "Lufs's" },
+    { cdnPrefix: "hub.gitmirror.com", maintainer: "GitMirror" },
+    { cdnPrefix: "js.xxooo.ml", maintainer: "\u996D\u592A\u786C" },
+    { cdnPrefix: "download.njuu.cf", maintainer: "LibraryCloud-njuu" },
+    { cdnPrefix: "download.yzuu.cf", maintainer: "LibraryCloud-yzuu" },
+    { cdnPrefix: "download.nuaa.cf", maintainer: "LibraryCloud-nuaa" }
+  ];
+}
+function restartApp() {
+  app.relaunch();
+  app.quit();
+}
+function waitAppReady(duration = 1e3) {
+  return new Promise((resolve3, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error("app is not ready"));
+    }, duration);
+    app.whenReady().then(() => {
+      clearTimeout(timeout);
+      resolve3(null);
+    });
+  });
+}
+
+// src/updater/defaultFunctions.ts
+async function downloadJSONDefault(url, updater, headers) {
+  await waitAppReady();
+  return new Promise((resolve3, reject) => {
+    const request = net.request({
+      url,
+      method: "GET",
+      redirect: "follow"
+    });
+    Object.keys(headers).forEach((key) => {
+      request.setHeader(key, headers[key]);
+    });
+    request.on("response", (res) => {
       let data = "";
-      res.setEncoding("utf8");
-      res.headers = headers;
       res.on("data", (chunk) => data += chunk);
       res.on("end", () => {
         try {
           const json = JSON.parse(data);
-          if ("signature" in json && "version" in json && "size" in json) {
-            resolve2(json);
+          if (isUpdateJSON(json)) {
+            resolve3(json);
           } else {
             throw Error;
           }
@@ -36,28 +112,39 @@ function downloadJSONDefault(url, updater, headers) {
           reject(new Error("invalid json"));
         }
       });
-    }).on("error", (e) => {
+    });
+    request.on("error", (e) => {
       reject(e);
     });
+    request.end();
   });
 }
-function downloadBufferDefault(url, updater, headers) {
+async function downloadBufferDefault(url, updater, headers) {
+  await waitAppReady();
   let progress = 0;
-  return new Promise((resolve2, reject) => {
-    https.get(url, (res) => {
+  return new Promise((resolve3, reject) => {
+    const request = net.request({
+      url,
+      method: "GET",
+      redirect: "follow"
+    });
+    Object.keys(headers).forEach((key) => {
+      request.setHeader(key, headers[key]);
+    });
+    request.on("response", (res) => {
       let data = [];
-      res.headers = headers;
       res.on("data", (chunk) => {
         progress += chunk.length;
         updater.emit("downloading", progress);
         data.push(chunk);
       });
       res.on("end", () => {
-        resolve2(Buffer.concat(data));
+        resolve3(Buffer.concat(data));
       });
     }).on("error", (e) => {
       reject(e);
     });
+    request.end();
   });
 }
 function compareVersionDefault(oldVersion, newVersion) {
@@ -83,58 +170,9 @@ function compareVersionDefault(oldVersion, newVersion) {
   return false;
 }
 
-// src/updater/utils.ts
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { app } from "electron";
-function getAppAsarPath(name) {
-  return app.isPackaged ? join(dirname(app.getAppPath()), `${name}.asar`) : "dev";
-}
-function getEntryVersion() {
-  return app.getVersion();
-}
-function getAppVersion(name) {
-  return app.isPackaged ? readFileSync(join(getAppAsarPath(name), "version"), "utf-8") : getEntryVersion();
-}
-function requireNative(packageName) {
-  const path = app.isPackaged ? join(app.getAppPath(), "node_modules", packageName) : packageName;
-  return __require(path);
-}
-function parseGithubCdnURL(repository, cdnPrefix, relativeFilePath) {
-  if (!repository.startsWith("https://github.com/")) {
-    throw new Error("url must start with https://github.com/");
-  }
-  repository = repository.trim().replace(/\/?$/, "/").trim();
-  relativeFilePath = relativeFilePath.trim().replace(/^\/|\/?$/g, "").trim();
-  cdnPrefix = cdnPrefix.trim().replace(/^\/?|\/?$/g, "").trim();
-  return repository.replace("github.com", cdnPrefix) + relativeFilePath;
-}
-function getGithubReleaseCdnGroup() {
-  return [
-    { cdnPrefix: "gh.gh2233.ml", maintainer: "@X.I.U/XIU2" },
-    { cdnPrefix: "ghproxy.com", maintainer: "gh-proxy" },
-    { cdnPrefix: "gh.ddlc.top", maintainer: "@mtr-static-official" },
-    { cdnPrefix: "ghdl.feizhuqwq.cf", maintainer: "feizhuqwq.com" },
-    { cdnPrefix: "slink.ltd", maintainer: "\u77E5\u4E86\u5C0F\u7AD9" },
-    { cdnPrefix: "git.xfj0.cn", maintainer: "anonymous1" },
-    { cdnPrefix: "gh.con.sh", maintainer: "anonymous2" },
-    { cdnPrefix: "ghps.cc", maintainer: "anonymous3" },
-    { cdnPrefix: "cors.isteed.cc/github.com", maintainer: "Lufs's" },
-    { cdnPrefix: "hub.gitmirror.com", maintainer: "GitMirror" },
-    { cdnPrefix: "js.xxooo.ml", maintainer: "\u996D\u592A\u786C" },
-    { cdnPrefix: "download.njuu.cf", maintainer: "LibraryCloud-njuu" },
-    { cdnPrefix: "download.yzuu.cf", maintainer: "LibraryCloud-yzuu" },
-    { cdnPrefix: "download.nuaa.cf", maintainer: "LibraryCloud-nuaa" }
-  ];
-}
-function restartApp() {
-  app.relaunch();
-  app.quit();
-}
-
 // src/updater/index.ts
 function createUpdater({
-  SIGNATURE_PUB,
+  SIGNATURE_CERT,
   repository,
   productName,
   releaseAsarURL: _release,
@@ -145,94 +183,103 @@ function createUpdater({
 }) {
   const updater = new EventEmitter();
   let signature = "";
-  let version = "";
-  const gzipPath = `../${productName}.asar.gz`;
-  const tmpFile = gzipPath.replace(".asar.gz", ".tmp.gz");
+  const asarPath = getProductAsarPath(productName);
+  const gzipPath = `${asarPath}.gz`;
+  const tmpFilePath = gzipPath.replace(".asar.gz", ".tmp.asar");
   const { downloadBuffer, downloadJSON, extraHeader, userAgent } = downloadConfig || {};
   function log(msg) {
     debug && updater.emit("debug", msg);
   }
-  async function download(url, format) {
-    const ua = userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36";
-    const headers = {
-      Accept: `application/${format === "json" ? "json" : "octet-stream"}`,
-      UserAgent: ua,
-      ...extraHeader
-    };
-    log(`download headers: ${JSON.stringify(headers, null, 2)}`);
-    const downloadFn = format === "json" ? downloadJSON ?? downloadJSONDefault : downloadBuffer ?? downloadBufferDefault;
-    log(`download ${format} from ${url}`);
-    const ret = await downloadFn(url, updater, headers);
-    log(`download ${format} success`);
-    return ret;
-  }
-  async function extractFile(gzipFilePath) {
-    if (!gzipFilePath.endsWith(".asar.gz") || !existsSync(gzipFilePath)) {
-      log("update .asar.gz file not exist");
-      return;
+  async function extractFile() {
+    if (!gzipPath.endsWith(".asar.gz") || !existsSync(gzipPath)) {
+      throw new Error(".asar.gz file not exist");
     }
-    gzipFilePath = gzipFilePath.replace(".asar.gz", ".tmp.gz");
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const gunzip = createGunzip();
-      const input = createReadStream(gzipFilePath);
-      const outputFilePath = gzipFilePath.replace(".tmp.gz", ".asar");
-      const output = createWriteStream(outputFilePath);
-      log(`outputFilePath: ${outputFilePath}`);
+      const input = createReadStream(gzipPath);
+      const output = createWriteStream(tmpFilePath);
+      log(`outputFilePath: ${tmpFilePath}`);
       input.pipe(gunzip).pipe(output).on("finish", async () => {
-        await rm(gzipFilePath);
-        log(`${gzipFilePath} unzipped`);
-        resolve2(outputFilePath);
+        await rm(gzipPath);
+        log(`${gzipPath} unzipped`);
+        resolve3(null);
       }).on("error", async (err) => {
-        await rm(gzipFilePath);
+        await rm(gzipPath);
         output.destroy(err);
         reject(err);
       });
     });
   }
-  function needUpdate(version2) {
+  function needUpdate(version) {
     if (!app2.isPackaged) {
       log("in dev mode, no need to update");
       return false;
     }
     const currentVersion = getEntryVersion();
-    log(`check update:
-    current version is ${currentVersion},
-    new version is ${version2}`);
+    log(`check update: current version is ${currentVersion}, new version is ${version}`);
     const _compare = compareVersion ?? compareVersionDefault;
-    return _compare(currentVersion, version2);
+    return _compare(currentVersion, version);
   }
-  updater.checkUpdate = async (url) => {
-    try {
-      url ??= _update;
-      if (!url) {
-        log("no updateJsonURL, fallback to use repository");
+  async function parseData(format, data) {
+    if (existsSync(tmpFilePath)) {
+      log(`remove tmp file: ${tmpFilePath}`);
+      await rm(tmpFilePath);
+    }
+    if (existsSync(gzipPath)) {
+      log(`remove .gz file: ${gzipPath}`);
+      await rm(gzipPath);
+    }
+    if (typeof data === "object") {
+      if (format === "json" && isUpdateJSON(data) || format === "buffer" && Buffer2.isBuffer(data)) {
+        return data;
+      } else {
+        throw new Error(`invalid type at format '${format}': ${data}`);
+      }
+    } else if (["string", "undefined"].includes(typeof data)) {
+      const ua = userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36";
+      const headers = {
+        Accept: `application/${format === "json" ? "json" : "octet-stream"}`,
+        UserAgent: ua,
+        ...extraHeader
+      };
+      log(`download headers: ${JSON.stringify(headers, null, 2)}`);
+      const info = format === "json" ? {
+        name: "updateJsonURL",
+        url: _update,
+        repoFallback: `${repository.replace("github.com", "raw.githubusercontent.com")}/master/version.json`,
+        fn: downloadJSON ?? downloadJSONDefault
+      } : {
+        name: "releaseAsarURL",
+        url: _release,
+        repoFallback: `${repository}/releases/download/latest/${productName}.asar.gz`,
+        fn: downloadBuffer ?? downloadBufferDefault
+      };
+      data ??= info.url;
+      if (!data) {
+        log(`no ${info.name}, fallback to use repository`);
         if (!repository) {
-          throw new Error("updateJsonURL or repository are not set");
+          throw new Error(`${info.name} or repository are not set`);
         }
-        url = `${repository.replace("github.com", "raw.githubusercontent.com")}/master/version.json`;
+        data = info.repoFallback;
       }
-      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}`);
+      log(`download ${format} from ${data}`);
+      const ret = await info.fn(data, updater, headers);
+      log(`download ${format} success`);
+      return ret;
+    } else {
+      throw new Error(`invalid type at format '${format}': ${data}`);
+    }
+  }
+  updater.checkUpdate = async (data) => {
+    try {
+      const { signature: _sig, size, version } = await parseData("json", data);
+      log(`checked version: ${version}, size: ${size}, signature: ${_sig}`);
+      if (!needUpdate(version)) {
+        log(`update unavailable: ${version}`);
         return void 0;
       } else {
-        log(`update available: ${_v}`);
+        log(`update available: ${version}`);
         signature = _sig;
-        version = _v;
         return { size, version };
       }
     } catch (error) {
@@ -240,30 +287,35 @@ function createUpdater({
       return error;
     }
   };
-  updater.downloadUpdate = async (src) => {
+  updater.downloadAndInstall = async (data, sig) => {
     try {
-      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");
+      const _sig = sig ?? signature;
+      if (!_sig) {
+        throw new Error("signature are not set, please checkUpdate first or set the second parameter");
       }
+      const buffer = await parseData("buffer", data);
       log("verify start");
-      if (!verify(src, signature, SIGNATURE_PUB)) {
-        log("verify failed");
-        throw new Error("invalid signature");
+      const version = verify(buffer, _sig, SIGNATURE_CERT);
+      if (!version) {
+        throw new Error("verify failed, invalid signature");
       }
       log("verify success");
+      if (!needUpdate(version)) {
+        throw new Error(`update unavailable: ${version}`);
+      }
       log(`write file: ${gzipPath}`);
-      await writeFile(gzipPath, src);
+      await writeFile(gzipPath, buffer);
       log(`extract file: ${gzipPath}`);
-      await extractFile(gzipPath);
+      await extractFile();
+      const asarVersion = await readFile(resolve(tmpFilePath, "version"), "utf8");
+      if (asarVersion !== version) {
+        rmSync(tmpFilePath);
+        throw new Error(`update failed: asar version is ${asarVersion}, but it should be ${version}`);
+      } else {
+        await rename(tmpFilePath, asarPath);
+      }
       log(`update success, version: ${version}`);
+      signature = "";
       return true;
     } catch (error) {
       log(error);
@@ -281,7 +333,7 @@ function initApp(appOptions, updaterOptions) {
     mainPath = "main/index.js"
   } = appOptions ?? {};
   const mainDir = app3.isPackaged ? `../${productName}.asar` : electronDistPath;
-  const entry = resolve(__dirname, mainDir, mainPath);
+  const entry = resolve2(__dirname, mainDir, mainPath);
   if (updaterOptions) {
     __require(entry)(
       createUpdater({ ...updaterOptions, productName })
@@ -296,12 +348,14 @@ function initApp(appOptions, updaterOptions) {
 }
 export {
   createUpdater,
-  getAppAsarPath,
-  getAppVersion,
   getEntryVersion,
   getGithubReleaseCdnGroup,
+  getProductAsarPath,
+  getProductVersion,
   initApp,
+  isUpdateJSON,
   parseGithubCdnURL,
   requireNative,
-  restartApp
+  restartApp,
+  waitAppReady
 };