electron-incremental-update 0.5.0 → 0.6.0

package/README.md

@@ -58,15 +58,15 @@ src
 import { createUpdater, getGithubReleaseCdnGroup, initApp, parseGithubCdnURL } from 'electron-incremental-update'
 import { name, repository } from '../package.json'
 
-const SIGNATURE_PUB = '' // auto generate RSA public key when start app
+const SIGNATURE_CERT = '' // auto generate certificate when start app
 
 // create updater when init, no need to set productName
-initApp({ name }, { SIGNATURE_PUB, repository })
+initApp({ name }, { SIGNATURE_CERT, repository })
 
 // or create updater manually
 const { cdnPrefix } = getGithubReleaseCdnGroup()[0]
 const updater = createUpdater({
-  SIGNATURE_PUB,
+  SIGNATURE_CERT,
   productName: name,
   repository,
   updateJsonURL: parseGithubCdnURL(repository, 'fastly.jsdelivr.net/gh', 'version.json'),
@@ -81,15 +81,15 @@ initApp({ name }).setUpdater(updater)
 ```ts
 // electron/main/index.ts
 import type { Updater } from 'electron-incremental-update'
-import { getAppAsarPath, getAppVersion, getEntryVersion } from 'electron-incremental-update'
+import { getEntryVersion, getProductAsarPath, getProductVersion } from 'electron-incremental-update'
 import { app } from 'electron'
 import { name } from '../../package.json'
 
 export default function (updater: Updater) {
   console.log('\ncurrent:')
-  console.log(`\tasar path: ${getAppAsarPath(name)}`)
+  console.log(`\tasar path: ${getProductAsarPath(name)}`)
   console.log(`\tentry:     ${getEntryVersion()}`)
-  console.log(`\tapp:       ${getAppVersion(name)}`)
+  console.log(`\tapp:       ${getProductVersion(name)}`)
   let size = 0
   updater.on('downloading', (progress) => {
     console.log(`${(progress / size).toFixed(2)}%`)
@@ -108,7 +108,7 @@ export default function (updater: Updater) {
         buttons: ['Download', 'Later'],
         message: 'Application update available!',
       })
-      response === 0 && console.log(await updater.downloadUpdate())
+      response === 0 && console.log(await updater.downloadAndInstall())
     }
   })
   // app logics

package/dist/chunk-VADH6AZA.mjs

@@ -0,0 +1,51 @@
+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');
+});
+
+// src/crypto.ts
+import { constants, createCipheriv, createDecipheriv, createHash, createSign, createVerify } from "node:crypto";
+import { Buffer as Buffer2 } from "node:buffer";
+var aesEncode = "base64url";
+function encrypt(plainText, key2, iv) {
+  const cipher = createCipheriv("aes-256-cbc", key2, iv);
+  let encrypted = cipher.update(plainText, "utf8", aesEncode);
+  encrypted += cipher.final(aesEncode);
+  return encrypted;
+}
+function decrypt(encryptedText, key2, iv) {
+  const decipher = createDecipheriv("aes-256-cbc", key2, iv);
+  let decrypted = decipher.update(encryptedText, aesEncode, "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+function key(data, length) {
+  const hash = createHash("SHA256").update(data).digest("binary");
+  return Buffer2.from(hash).subarray(0, length);
+}
+function signature(buffer, privateKey, cert, version) {
+  const sig = createSign("RSA-SHA256").update(buffer).sign({
+    key: privateKey,
+    padding: constants.RSA_PKCS1_PADDING,
+    saltLength: constants.RSA_PSS_SALTLEN_DIGEST
+  }, "base64");
+  return encrypt(`${sig}%${version}`, key(cert, 32), key(buffer, 16));
+}
+function verify(buffer, signature2, cert) {
+  try {
+    const [sig, version] = decrypt(signature2, key(cert, 32), key(buffer, 16)).split("%");
+    const result = createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+    return result ? version : false;
+  } catch (error) {
+    return false;
+  }
+}
+
+export {
+  __require,
+  signature,
+  verify
+};

package/dist/index.cjs

@@ -11,9 +11,9 @@ var __export = (target, all) => {
 };
 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 });
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
   }
   return to;
 };
@@ -31,45 +31,48 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   createUpdater: () => createUpdater,
-  getAppAsarPath: () => getAppAsarPath,
-  getAppVersion: () => getAppVersion,
   getEntryVersion: () => getEntryVersion,
   getGithubReleaseCdnGroup: () => getGithubReleaseCdnGroup,
+  getProductAsarPath: () => getProductAsarPath,
+  getProductVersion: () => getProductVersion,
   initApp: () => initApp,
+  isUpdateJSON: () => isUpdateJSON,
   parseGithubCdnURL: () => parseGithubCdnURL,
   requireNative: () => requireNative,
   restartApp: () => restartApp
 });
 module.exports = __toCommonJS(src_exports);
-var import_node_path2 = require("path");
+var import_node_path3 = require("path");
 var import_electron3 = require("electron");
 
 // src/updater/index.ts
 var import_node_events = require("events");
+var import_node_buffer3 = require("buffer");
 var import_node_zlib = require("zlib");
 var import_node_fs2 = require("fs");
 var import_promises = require("fs/promises");
+var import_node_path2 = require("path");
 var import_electron2 = require("electron");
 
 // src/crypto.ts
 var import_node_crypto = require("crypto");
 var import_node_buffer = require("buffer");
 var aesEncode = "base64url";
-function decrypt(encryptedText, key, iv) {
-  const decipher = (0, import_node_crypto.createDecipheriv)("aes-256-cbc", key, iv);
+function decrypt(encryptedText, key2, iv) {
+  const decipher = (0, import_node_crypto.createDecipheriv)("aes-256-cbc", key2, iv);
   let decrypted = decipher.update(encryptedText, aesEncode, "utf8");
   decrypted += decipher.final("utf8");
   return decrypted;
 }
-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");
+function key(data, length) {
+  const hash = (0, import_node_crypto.createHash)("SHA256").update(data).digest("binary");
   return import_node_buffer.Buffer.from(hash).subarray(0, length);
 }
-function verify(buffer, signature, publicKey, name) {
+function verify(buffer, signature, cert) {
   try {
-    const sig = decrypt(signature, generateKey(buffer, publicKey, 32), generateKey(buffer, name, 16));
-    return (0, import_node_crypto.createVerify)("RSA-SHA256").update(buffer).verify(publicKey, sig, "base64");
+    const [sig, version] = decrypt(signature, key(cert, 32), key(buffer, 16)).split("%");
+    const result = (0, import_node_crypto.createVerify)("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+    return result ? version : false;
   } catch (error) {
     return false;
   }
@@ -78,8 +81,15 @@ function verify(buffer, signature, publicKey, name) {
 // src/updater/defaultFunctions.ts
 var import_node_buffer2 = require("buffer");
 var import_node_https = __toESM(require("https"), 1);
+
+// src/updater/types.ts
+function isUpdateJSON(json) {
+  return "signature" in json && "version" in json && "size" in json;
+}
+
+// src/updater/defaultFunctions.ts
 function downloadJSONDefault(url, updater, headers) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     import_node_https.default.get(url, (res) => {
       let data = "";
       res.setEncoding("utf8");
@@ -88,8 +98,8 @@ function downloadJSONDefault(url, updater, headers) {
       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;
           }
@@ -104,7 +114,7 @@ function downloadJSONDefault(url, updater, headers) {
 }
 function downloadBufferDefault(url, updater, headers) {
   let progress = 0;
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     import_node_https.default.get(url, (res) => {
       let data = [];
       res.headers = headers;
@@ -114,7 +124,7 @@ function downloadBufferDefault(url, updater, headers) {
         data.push(chunk);
       });
       res.on("end", () => {
-        resolve2(import_node_buffer2.Buffer.concat(data));
+        resolve3(import_node_buffer2.Buffer.concat(data));
       });
     }).on("error", (e) => {
       reject(e);
@@ -148,14 +158,14 @@ function compareVersionDefault(oldVersion, newVersion) {
 var import_node_fs = require("fs");
 var import_node_path = require("path");
 var import_electron = require("electron");
-function getAppAsarPath(name) {
+function getProductAsarPath(name) {
   return import_electron.app.isPackaged ? (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getAppPath()), `${name}.asar`) : "dev";
 }
 function getEntryVersion() {
   return import_electron.app.getVersion();
 }
-function getAppVersion(name) {
-  return import_electron.app.isPackaged ? (0, import_node_fs.readFileSync)((0, import_node_path.join)(getAppAsarPath(name), "version"), "utf-8") : getEntryVersion();
+function getProductVersion(name) {
+  return import_electron.app.isPackaged ? (0, import_node_fs.readFileSync)((0, import_node_path.join)(getProductAsarPath(name), "version"), "utf-8") : getEntryVersion();
 }
 function requireNative(packageName) {
   const path = import_electron.app.isPackaged ? (0, import_node_path.join)(import_electron.app.getAppPath(), "node_modules", packageName) : packageName;
@@ -195,7 +205,7 @@ function restartApp() {
 
 // src/updater/index.ts
 function createUpdater({
-  SIGNATURE_PUB,
+  SIGNATURE_CERT,
   repository,
   productName,
   releaseAsarURL: _release,
@@ -206,94 +216,103 @@ function createUpdater({
 }) {
   const updater = new import_node_events.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") || !(0, import_node_fs2.existsSync)(gzipFilePath)) {
-      log("update .asar.gz file not exist");
-      return;
+  async function extractFile() {
+    if (!gzipPath.endsWith(".asar.gz") || !(0, import_node_fs2.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 = (0, import_node_zlib.createGunzip)();
-      const input = (0, import_node_fs2.createReadStream)(gzipFilePath);
-      const outputFilePath = gzipFilePath.replace(".tmp.gz", ".asar");
-      const output = (0, import_node_fs2.createWriteStream)(outputFilePath);
-      log(`outputFilePath: ${outputFilePath}`);
+      const input = (0, import_node_fs2.createReadStream)(gzipPath);
+      const output = (0, import_node_fs2.createWriteStream)(tmpFilePath);
+      log(`outputFilePath: ${tmpFilePath}`);
       input.pipe(gunzip).pipe(output).on("finish", async () => {
-        await (0, import_promises.rm)(gzipFilePath);
-        log(`${gzipFilePath} unzipped`);
-        resolve2(outputFilePath);
+        await (0, import_promises.rm)(gzipPath);
+        log(`${gzipPath} unzipped`);
+        resolve3(null);
       }).on("error", async (err) => {
-        await (0, import_promises.rm)(gzipFilePath);
+        await (0, import_promises.rm)(gzipPath);
         output.destroy(err);
         reject(err);
       });
     });
   }
-  function needUpdate(version2) {
+  function needUpdate(version) {
     if (!import_electron2.app.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 ((0, import_node_fs2.existsSync)(tmpFilePath)) {
+      log(`remove tmp file: ${tmpFilePath}`);
+      await (0, import_promises.rm)(tmpFilePath);
+    }
+    if ((0, import_node_fs2.existsSync)(gzipPath)) {
+      log(`remove .gz file: ${gzipPath}`);
+      await (0, import_promises.rm)(gzipPath);
+    }
+    if (typeof data === "object") {
+      if (format === "json" && isUpdateJSON(data) || format === "buffer" && import_node_buffer3.Buffer.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 ((0, import_node_fs2.existsSync)(tmpFile)) {
-        log(`remove tmp file: ${tmpFile}`);
-        await (0, import_promises.rm)(tmpFile);
-      }
-      if ((0, import_node_fs2.existsSync)(gzipPath)) {
-        log(`remove .gz file: ${gzipPath}`);
-        await (0, import_promises.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}`);
+      if (!await 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) {
@@ -301,30 +320,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, productName)) {
-        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 (!await needUpdate(version)) {
+        throw new Error(`update unavailable: ${version}`);
+      }
       log(`write file: ${gzipPath}`);
-      await (0, import_promises.writeFile)(gzipPath, src);
+      await (0, import_promises.writeFile)(gzipPath, buffer);
       log(`extract file: ${gzipPath}`);
-      await extractFile(gzipPath);
+      await extractFile();
+      const asarVersion = await (0, import_promises.readFile)((0, import_node_path2.resolve)(tmpFilePath, "version"), "utf8");
+      if (asarVersion !== version) {
+        (0, import_node_fs2.rmSync)(tmpFilePath);
+        throw new Error(`update failed: asar version is ${asarVersion}, but it should be ${version}`);
+      } else {
+        await (0, import_promises.rename)(tmpFilePath, asarPath);
+      }
       log(`update success, version: ${version}`);
+      signature = "";
       return true;
     } catch (error) {
       log(error);
@@ -342,7 +366,7 @@ function initApp(appOptions, updaterOptions) {
     mainPath = "main/index.js"
   } = appOptions ?? {};
   const mainDir = import_electron3.app.isPackaged ? `../${productName}.asar` : electronDistPath;
-  const entry = (0, import_node_path2.resolve)(__dirname, mainDir, mainPath);
+  const entry = (0, import_node_path3.resolve)(__dirname, mainDir, mainPath);
   if (updaterOptions) {
     require(entry)(
       createUpdater({ ...updaterOptions, productName })
@@ -358,11 +382,12 @@ function initApp(appOptions, updaterOptions) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createUpdater,
-  getAppAsarPath,
-  getAppVersion,
   getEntryVersion,
   getGithubReleaseCdnGroup,
+  getProductAsarPath,
+  getProductVersion,
   initApp,
+  isUpdateJSON,
   parseGithubCdnURL,
   requireNative,
   restartApp

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
@@ -148,7 +159,7 @@ declare function getGithubReleaseCdnGroup(): {
 }[];
 declare function restartApp(): void;
 
-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 +188,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 +213,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 };