electron-incremental-update 0.2.2 → 0.4.0

package/README.md

@@ -16,6 +16,8 @@ using RSA + Signature to sign the new `main.asar` downloaded from remote and rep
 
 develop with [vite-plugin-electron](https://github.com/electron-vite/vite-plugin-electron), and may be effect in other electron vite frameworks
 
+**all options are documented in the jsdoc**
+
 ## install
 
 ### npm
@@ -50,21 +52,28 @@ src
 
 ### setup app
 
-more example see comment on `initApp()`
 
 ```ts
 // electron/app.ts
-import { createUpdater, initApp } from 'electron-incremental-update'
+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
 
+// create updater when init, no need to set productName
+initApp({ name }, { SIGNATURE_PUB, repository })
+
+// or create updater manually
+const { cdnPrefix } = getGithubReleaseCdnGroup()[0]
 const updater = createUpdater({
   SIGNATURE_PUB,
-  repository,
   productName: name,
+  repository,
+  updateJsonURL: parseGithubCdnURL(repository, 'fastly.jsdelivr.net/gh', 'version.json'),
+  releaseAsarURL: parseGithubCdnURL(repository, cdnPrefix, `download/latest/${name}.asar.gz`),
+  debug: true,
 })
-initApp(name, updater)
+initApp({ name }).setUpdater(updater)
 ```
 
 ### setup main
@@ -72,43 +81,43 @@ initApp(name, updater)
 ```ts
 // electron/main/index.ts
 import type { Updater } from 'electron-incremental-update'
-import { getAppAsarPath, getAppVersion, getElectronVersion } from 'electron-incremental-update'
+import { getAppAsarPath, getAppVersion, getEntryVersion } from 'electron-incremental-update'
 import { app } from 'electron'
 import { name } from '../../package.json'
 
 export default function (updater: Updater) {
   console.log('\ncurrent:')
-  console.log(`\telectron:  ${getElectronVersion()}`)
   console.log(`\tasar path: ${getAppAsarPath(name)}`)
+  console.log(`\tentry:     ${getEntryVersion()}`)
   console.log(`\tapp:       ${getAppVersion(name)}`)
-
-  updater.checkUpdate()
-  updater.on('checkResult', async (result, err) => {
-    switch (result) {
-      case 'success':
-        await dialog.showMessageBox({
-          type: 'info',
-          buttons: ['Restart', 'Later'],
-          message: 'Application successfully updated!',
-        }).then(({ response }) => {
-          if (response === 0) {
-            app.relaunch()
-            app.quit()
-          }
-        })
-        break
-      case 'unavailable':
-        console.log('Update Unavailable')
-        break
-      case 'fail':
-        console.error(err)
-        break
+  let size = 0
+  let currentSize = 0
+  updater.on('checkResult', async (result) => {
+    if (result === false) {
+      console.log('Update Unavailable')
+    } else if (result instanceof Error) {
+      console.error(result)
+    } else {
+      size = result.size
+      console.log('new version: ', result.version)
+      const { response } = await dialog.showMessageBox({
+        type: 'info',
+        buttons: ['Download', 'Later'],
+        message: 'Application update available!',
+      })
+      response === 0 && await updater.downloadUpdate()
     }
   })
-  updater.on('downloadStart', console.log)
-  updater.on('downloading', console.log)
-  updater.on('downloadEnd', console.log)
+  updater.on('download', () => console.log('download start'))
+  updater.on('downloading', (len) => {
+    currentSize += len
+    console.log(`${(currentSize / size).toFixed(2)}%`)
+  })
+  updater.on('downloaded', () => console.log('download end'))
   updater.on('donwnloadError', console.error)
+  // to debug, it need to set debug to true in updater options
+  updater.on('debug', data => console.log('[updater]:', data))
+  updater.checkUpdate()
 
   // app logics
   app.whenReady().then(() => {
@@ -144,7 +153,12 @@ db.close()
 
 ### setup vite.config.ts
 
+make sure the plugin is set in the **last** build task plugin option
+
+- set it to preload task plugin, as the end of build task
+
 ```ts
+// vite.config.ts
 export default defineConfig(({ command }) => {
 
   const isBuild = command === 'build'
@@ -162,7 +176,7 @@ export default defineConfig(({ command }) => {
           // ...
           vite: {
             plugins: [
-              updater({ // !make sure the plugin run pack asar after all build finish
+              updater({
                 productName: pkg.name,
                 version: pkg.version,
                 isBuild,
@@ -179,90 +193,6 @@ export default defineConfig(({ command }) => {
 })
 ```
 
-#### plugin options
-
-```ts
-type Options = {
-  /**
-   * whether is in build mode
-   */
-  isBuild: boolean
-  /**
-   * the name of you application
-   *
-   * you can set as 'name' in package.json
-  */
-  productName: string
-  /**
-   * the version of you application
-   *
-   * you can set as 'version' in package.json
-   */
-  version: string
-  /**
-   * Whether to minify
-   */
-  minify?: boolean
-  /**
-   * path config
-   */
-  paths?: {
-    /**
-     * Path to app entry file
-     * @default 'electron/app.ts'
-     */
-    entryPath?: string
-    /**
-     * Path to app entry output file
-     * @default 'app.js'
-     */
-    entryOutputPath?: string
-    /**
-     * Path to asar file
-     * @default `release/${ProductName}.asar`
-     */
-    asarOutputPath?: string
-    /**
-     * Path to electron build output
-     * @default `dist-electron`
-     */
-    electronDistPath?: string
-    /**
-     * Path to renderer build output
-     * @default `dist`
-     */
-    rendererDistPath?: string
-    /**
-     * Path to version info output
-     * @default `version.json`
-     */
-    versionPath?: string
-  }
-  /**
-   * signature config
-   */
-  keys?: {
-    /**
-     * Path to the pem file that contains private key
-     * if not ended with .pem, it will be appended
-     * @default 'public/private.pem'
-     */
-    privateKeyPath?: string
-    /**
-     * Path to the pem file that contains public key
-     * if not ended with .pem, it will be appended
-     * @default 'public/public.pem'
-     */
-    publicKeyPath?: string
-    /**
-     * Length of the key
-     * @default 2048
-     */
-    keyLength?: number
-  }
-}
-```
-
 ### electron-builder config
 
 ```js

package/dist/index.cjs

@@ -37,7 +37,8 @@ __export(src_exports, {
   getGithubReleaseCdnGroup: () => getGithubReleaseCdnGroup,
   initApp: () => initApp,
   parseGithubCdnURL: () => parseGithubCdnURL,
-  requireNative: () => requireNative
+  requireNative: () => requireNative,
+  restartApp: () => restartApp
 });
 module.exports = __toCommonJS(src_exports);
 var import_node_path2 = require("path");
@@ -62,17 +63,18 @@ function downloadJSONDefault(url, updater, headers) {
       res.headers = headers;
       res.on("data", (chunk) => data += chunk);
       res.on("end", () => {
-        updater.emit("downloadEnd", true);
-        const json = JSON.parse(data);
-        if ("signature" in json && "version" in json && "size" in json) {
-          resolve2(json);
-        } else {
-          throw new Error("invalid update json");
+        try {
+          const json = JSON.parse(data);
+          if ("signature" in json && "version" in json && "size" in json) {
+            resolve2(json);
+          } else {
+            throw Error;
+          }
+        } catch (e) {
+          reject(new Error("invalid json"));
         }
       });
     }).on("error", (e) => {
-      e && updater.emit("donwnloadError", e);
-      updater.emit("downloadEnd", false);
       reject(e);
     });
   });
@@ -87,12 +89,9 @@ function downloadBufferDefault(url, updater, headers) {
         data.push(chunk);
       });
       res.on("end", () => {
-        updater.emit("downloadEnd", true);
         resolve2(import_node_buffer.Buffer.concat(data));
       });
     }).on("error", (e) => {
-      e && updater.emit("donwnloadError", e);
-      updater.emit("downloadEnd", false);
       reject(e);
     });
   });
@@ -164,6 +163,10 @@ function getGithubReleaseCdnGroup() {
     { cdnPrefix: "download.nuaa.cf", maintainer: "LibraryCloud-nuaa" }
   ];
 }
+function restartApp() {
+  import_electron.app.relaunch();
+  import_electron.app.quit();
+}
 
 // src/updater/index.ts
 function createUpdater({
@@ -177,9 +180,13 @@ function createUpdater({
   compareVersion
 }) {
   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 { downloadBuffer, downloadJSON, extraHeader, userAgent } = downloadConfig || {};
-  function log(...args) {
-    debug && console.log(...args);
+  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";
@@ -188,12 +195,16 @@ function createUpdater({
       UserAgent: ua,
       ...extraHeader
     };
-    log("[updater] headers", headers);
+    log(`download headers: ${JSON.stringify(headers, null, 2)}`);
     const downloadFn = format === "json" ? downloadJSON ?? downloadJSONDefault : downloadBuffer ?? downloadBufferDefault;
-    return await downloadFn(url, updater, headers);
+    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;
     }
     gzipFilePath = gzipFilePath.replace(".asar.gz", ".tmp.gz");
@@ -202,108 +213,136 @@ function createUpdater({
       const input = (0, import_node_fs2.createReadStream)(gzipFilePath);
       const outputFilePath = gzipFilePath.replace(".tmp.gz", ".asar");
       const output = (0, import_node_fs2.createWriteStream)(outputFilePath);
-      log("[updater] outputFilePath", outputFilePath);
+      log(`outputFilePath: ${outputFilePath}`);
       input.pipe(gunzip).pipe(output).on("finish", async () => {
         await (0, import_promises.rm)(gzipFilePath);
-        log("[updater] finish");
+        log(`${gzipFilePath} unzipped`);
         resolve2(outputFilePath);
       }).on("error", async (err) => {
         await (0, import_promises.rm)(gzipFilePath);
-        log("[updater] error", err);
         output.destroy(err);
         reject(err);
       });
     });
   }
-  function verify(buffer, signature) {
-    log("[updater] signature", signature);
-    return (0, import_node_crypto.createVerify)("RSA-SHA256").update(buffer).verify(SIGNATURE_PUB, signature, "base64");
+  function verify(buffer, signature2) {
+    return (0, import_node_crypto.createVerify)("RSA-SHA256").update(buffer).verify(SIGNATURE_PUB, signature2, "base64");
   }
-  function needUpdate(version) {
-    if (!version || !import_electron2.app.isPackaged) {
+  function needUpdate(version2) {
+    if (!import_electron2.app.isPackaged) {
+      log("in dev mode, no need to update");
       return false;
     }
     const currentVersion = getEntryVersion();
-    log("[updater] currentVersion", currentVersion);
-    log("[updater] newVersion", version);
+    log(`check update:
+    current version is ${currentVersion},
+    new version is ${version2}`);
     const _compare = compareVersion ?? compareVersionDefault;
-    return _compare(currentVersion, version);
+    return _compare(currentVersion, version2);
   }
-  async function checkUpdate(option) {
-    let {
-      updateJsonURL = _update,
-      releaseAsarURL = _release
-    } = option || {};
-    if (!updateJsonURL || !releaseAsarURL) {
-      log("[updater] no updateJsonURL or releaseAsarURL, use repository");
+  async function checkUpdate(url) {
+    url ??= _update;
+    if (!url) {
+      log("no updateJsonURL, fallback to use repository");
       if (!repository) {
-        throw new Error("updateJsonURL or releaseAsarURL are not set");
+        throw new Error("updateJsonURL or repository are not set");
       }
-      updateJsonURL = `${repository.replace("github.com", "raw.githubusercontent.com")}/version.json`;
-      releaseAsarURL = `${repository}/releases/download/latest/${productName}.asar.gz`;
+      url = `${repository.replace("github.com", "raw.githubusercontent.com")}/master/version.json`;
     }
-    log("[updater] updateJsonURL", updateJsonURL);
-    log("[updater] releaseAsarURL", releaseAsarURL);
-    const gzipPath = `../${productName}.asar.gz`;
-    const tmpFile = gzipPath.replace(".asar.gz", ".tmp.gz");
     if ((0, import_node_fs2.existsSync)(tmpFile)) {
-      log("[updater] remove tmp file", tmpFile);
+      log(`remove tmp file: ${tmpFile}`);
       await (0, import_promises.rm)(tmpFile);
     }
-    const json = await download(updateJsonURL, "json");
-    if (!json) {
-      throw new Error("fetch update json failed");
+    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,
-      version,
+      signature: _sig,
+      version: _v,
       size
     } = json;
-    log("[updater] UpdateJSON", json);
-    if (!needUpdate(version)) {
-      return "unavailable";
+    log(`update info: ${JSON.stringify(json, null, 2)}`);
+    if (!await needUpdate(_v)) {
+      log(`update unavailable: ${_v}`);
+      return false;
+    } else {
+      log(`update available: ${_v}`);
+      signature = _sig;
+      version = _v;
+      return { size, version };
+    }
+  }
+  async function downloadUpdate(src) {
+    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");
     }
-    updater.emit("downloadStart", size);
-    const buffer = await download(releaseAsarURL, "buffer");
-    log("[updater] start verify");
-    if (!verify(buffer, signature)) {
-      throw new Error("file broken, invalid signature!");
+    log("verify start");
+    if (!verify(src, signature)) {
+      log("verify failed");
+      throw new Error("invalid signature");
     }
-    log("[updater] write file", gzipPath);
-    await (0, import_promises.writeFile)(gzipPath, buffer);
-    log("[updater] extract file", gzipPath);
+    log("verify success");
+    log(`write file: ${gzipPath}`);
+    await (0, import_promises.writeFile)(gzipPath, src);
+    log(`extract file: ${gzipPath}`);
     await extractFile(gzipPath);
-    return "success";
+    log(`update success, version: ${version}`);
+    updater.emit("downloaded");
   }
-  const onCheck = async (option) => {
+  const onCheck = async (url) => {
     try {
-      const result = await checkUpdate(option);
+      const result = await checkUpdate(url);
       updater.emit("checkResult", result);
     } catch (error) {
-      updater.emit("checkResult", "fail", error);
+      log(error);
+      updater.emit("checkResult", error);
     }
   };
   updater.on("check", onCheck);
   updater.checkUpdate = onCheck;
+  const onDownload = async (src) => {
+    try {
+      await downloadUpdate(src);
+    } catch (error) {
+      log(error);
+      updater.emit("donwnloadError", error);
+    }
+  };
+  updater.on("download", onDownload);
+  updater.downloadUpdate = onDownload;
   return updater;
 }
 
 // src/index.ts
-function initApp(productName, updater, option) {
+function initApp(appOptions, updaterOptions) {
   const {
+    name: productName,
     electronDistPath = "dist-electron",
     mainPath = "main/index.js"
-  } = option ?? {};
+  } = appOptions ?? {};
   const mainDir = import_electron3.app.isPackaged ? `../${productName}.asar` : electronDistPath;
   const entry = (0, import_node_path2.resolve)(__dirname, mainDir, mainPath);
-  let _updater;
-  if ("SIGNATURE_PUB" in updater) {
-    const _option = updater.productName ? updater : { ...updater, productName };
-    _updater = createUpdater(_option);
+  if (updaterOptions) {
+    require(entry)(
+      createUpdater({ ...updaterOptions, productName })
+    );
   } else {
-    _updater = updater;
+    return {
+      setUpdater(updater) {
+        require(entry)(updater);
+      }
+    };
   }
-  return require(entry)(_updater);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -314,5 +353,6 @@ function initApp(productName, updater, option) {
   getGithubReleaseCdnGroup,
   initApp,
   parseGithubCdnURL,
-  requireNative
+  requireNative,
+  restartApp
 });

package/dist/index.d.ts

@@ -1,13 +1,14 @@
 import { Buffer } from 'node:buffer';
 
-type CheckResultType = 'success' | 'fail' | 'unavailable';
+type CheckResultType = Error | false | Omit<UpdateJSON, 'signature'>;
 type UpdateEvents = {
-    check: null;
-    checkResult: [data: CheckResultType, err?: unknown];
-    downloadStart: [size: number];
+    check: [url?: string];
+    checkResult: [data: CheckResultType];
+    download: [src?: string | Buffer];
     downloading: [current: number];
-    downloadEnd: [success: boolean];
+    downloaded: null;
     donwnloadError: [error: unknown];
+    debug: [msg: string | Error];
 };
 type UpdateJSON = {
     signature: string;
@@ -15,20 +16,6 @@ type UpdateJSON = {
     size: number;
 };
 type MaybeArray<T> = T extends undefined | null | never ? [] : T extends any[] ? T['length'] extends 1 ? [data: T[0]] : T : [data: T];
-interface BaseOption {
-    /**
-     * URL of version info json
-     * @default `${repository.replace('github.com', 'raw.githubusercontent.com')}/version.json`
-     * @throws if `updateJsonURL` and `repository` are all not set
-     */
-    updateJsonURL?: string;
-    /**
-     * URL of release asar.gz
-     * @default `${repository}/releases/download/latest/${productName}.asar.gz`
-     * @throws if `releaseAsarURL` and `repository` are all not set
-     */
-    releaseAsarURL?: string;
-}
 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[];
@@ -37,10 +24,16 @@ interface TypedUpdater<T extends Record<string | symbol, MaybeArray<any>>, Event
     once<E extends Event>(eventName: E, listener: (...args: 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;
-    checkUpdate(options?: BaseOption): Promise<void>;
+    /**
+     * - `undefined`: errror
+     * - `false`: unavailable
+     * - `{size: number, version: string}`: success
+     */
+    checkUpdate(url?: string): Promise<void>;
+    downloadUpdate(url?: string | Buffer): Promise<void>;
 }
 type Updater = TypedUpdater<UpdateEvents>;
-interface UpdaterOption extends BaseOption {
+interface UpdaterOption {
     /**
      * public key of signature
      *
@@ -58,7 +51,7 @@ interface UpdaterOption extends BaseOption {
      */
     SIGNATURE_PUB: string;
     /**
-     * product name
+     * name of your application
      *
      * you can use the `name` in `package.json`
      */
@@ -72,8 +65,29 @@ interface UpdaterOption extends BaseOption {
      * `repository` will be used to determine the url
      */
     repository?: string;
+    /**
+     * URL of version info json
+     * @default `${repository.replace('github.com', 'raw.githubusercontent.com')}/master/version.json`
+     * @throws if `updateJsonURL` and `repository` are all not set
+     */
+    updateJsonURL?: string;
+    /**
+     * URL of release asar.gz
+     * @default `${repository}/releases/download/latest/${productName}.asar.gz`
+     * @throws if `releaseAsarURL` and `repository` are all not set
+     */
+    releaseAsarURL?: string;
+    /**
+     * whether to enable debug listener
+     */
     debug?: boolean;
-    compareVersion?: (oldVersion: string, newVersion: string) => boolean;
+    /**
+     * custom version compare function
+     * @param oldVersion old version string
+     * @param newVersion new version string
+     * @returns whether to update
+     */
+    compareVersion?: (oldVersion: string, newVersion: string) => boolean | Promise<boolean>;
     downloadConfig?: {
         /**
          * download user agent
@@ -87,7 +101,7 @@ interface UpdaterOption extends BaseOption {
         /**
          * download JSON function
          * @param url download url
-         * @param updater updater, emit events
+         * @param updater updater, to trigger events
          * @param header download header
          * @returns `UpdateJSON`
          */
@@ -95,7 +109,7 @@ interface UpdaterOption extends BaseOption {
         /**
          * download buffer function
          * @param url download url
-         * @param updater updater, emit events
+         * @param updater updater, to trigger events
          * @param header download header
          * @returns `Buffer`
          */
@@ -133,64 +147,67 @@ declare function getGithubReleaseCdnGroup(): {
     cdnPrefix: string;
     maintainer: string;
 }[];
+declare function restartApp(): void;
 
 declare function createUpdater({ SIGNATURE_PUB, repository, productName, releaseAsarURL: _release, updateJsonURL: _update, debug, downloadConfig, compareVersion, }: UpdaterOption): Updater;
 
-interface AppOption {
+type AppOption = {
+    /**
+     * name of your application
+    *
+     * you can use the `name` in `package.json`
+    */
+    name: string;
     /**
      * path of electron output dist
      * @default 'dist-electron'
-     */
+    */
     electronDistPath?: string;
     /**
      * relative path of main entry in electron dist
      * @default 'main/index.js'
-     */
+    */
     mainPath?: string;
-}
+};
+type OptionalProperty<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type InitUpdaterOptions = OptionalProperty<UpdaterOption, 'productName'>;
 /**
- * Initialize application
- * @param productName name of your application
- * @param updater updater instance or updater options
- * @param option options for entry, will be used to generate electron main path, default target path: `dist-electron/main/index.js`
- * @returns a function to init your application with a updater
- *
+ * create updater manually
  * @example
- * **manual** generate updater
  * ```ts
- * import { initApp } from 'electron-incremental-updater'
+ * 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_PUB = '' // auto generate
+ *
+ * const { cdnPrefix } = getGithubReleaseCdnGroup()[0]
  * const updater = createUpdater({
  *   SIGNATURE_PUB,
  *   productName: name,
  *   repository,
+ *   updateJsonURL: parseGithubCdnURL(repository, 'fastly.jsdelivr.net/gh', 'version.json'),
+ *   releaseAsarURL: parseGithubCdnURL(repository, cdnPrefix, `download/latest/${name}.asar.gz`),
+ *   debug: true,
  * })
- * initApp(name, updater)
+ * initApp({ name }).setUpdater(updater)
  * ```
- * @example
- * **auto** generate updater and set update URL
+ */
+declare function initApp(appOptions: AppOption): {
+    setUpdater: (updater: Updater) => void;
+};
+/**
+ * create updater when init, no need to set productName
  *
+ * @example
  * ```ts
- * import { getReleaseDnsPrefix, initApp } from 'electron-incremental-update'
+ * import { initApp } from 'electron-incremental-update'
  * import { name, repository } from '../package.json'
  *
- * const SIGNATURE_PUB = '' // auto generate RSA public key when start app
+ * const SIGNATURE_PUB = '' // auto generate
  *
- * const { urlPrefix } = getReleaseCdnPrefix()[0]
- * initApp(name, {
- *   SIGNATURE_PUB,
- *   repository,
- *   updateJsonURL: `https://cdn.jsdelivr.net/gh/${repository.replace('https://github.com', '')}/version.json`,
- *   releaseAsarURL: `${urlPrefix}/download/latest/${name}.asar.gz`,
- * }, {
- *  // options for main entry
- * })
+ * initApp({ name }, { SIGNATURE_PUB, repository })
  * ```
-*/
-declare function initApp(productName: string, updater: Updater | Omit<UpdaterOption, 'productName'> & {
-    productName?: string;
-}, option?: AppOption): any;
+ */
+declare function initApp(appOptions: AppOption, updaterOptions: InitUpdaterOptions): undefined;
 
-export { BaseOption, CheckResultType, UpdateJSON, Updater, UpdaterOption, createUpdater, getAppAsarPath, getAppVersion, getEntryVersion, getGithubReleaseCdnGroup, initApp, parseGithubCdnURL, requireNative };
+export { AppOption, CheckResultType, InitUpdaterOptions, UpdateJSON, Updater, UpdaterOption, createUpdater, getAppAsarPath, getAppVersion, getEntryVersion, getGithubReleaseCdnGroup, initApp, parseGithubCdnURL, requireNative, restartApp };

package/dist/index.mjs

@@ -25,17 +25,18 @@ function downloadJSONDefault(url, updater, headers) {
       res.headers = headers;
       res.on("data", (chunk) => data += chunk);
       res.on("end", () => {
-        updater.emit("downloadEnd", true);
-        const json = JSON.parse(data);
-        if ("signature" in json && "version" in json && "size" in json) {
-          resolve2(json);
-        } else {
-          throw new Error("invalid update json");
+        try {
+          const json = JSON.parse(data);
+          if ("signature" in json && "version" in json && "size" in json) {
+            resolve2(json);
+          } else {
+            throw Error;
+          }
+        } catch (e) {
+          reject(new Error("invalid json"));
         }
       });
     }).on("error", (e) => {
-      e && updater.emit("donwnloadError", e);
-      updater.emit("downloadEnd", false);
       reject(e);
     });
   });
@@ -50,12 +51,9 @@ function downloadBufferDefault(url, updater, headers) {
         data.push(chunk);
       });
       res.on("end", () => {
-        updater.emit("downloadEnd", true);
         resolve2(Buffer.concat(data));
       });
     }).on("error", (e) => {
-      e && updater.emit("donwnloadError", e);
-      updater.emit("downloadEnd", false);
       reject(e);
     });
   });
@@ -127,6 +125,10 @@ function getGithubReleaseCdnGroup() {
     { cdnPrefix: "download.nuaa.cf", maintainer: "LibraryCloud-nuaa" }
   ];
 }
+function restartApp() {
+  app.relaunch();
+  app.quit();
+}
 
 // src/updater/index.ts
 function createUpdater({
@@ -140,9 +142,13 @@ function createUpdater({
   compareVersion
 }) {
   const updater = new EventEmitter();
+  let signature = "";
+  let version = "";
+  const gzipPath = `../${productName}.asar.gz`;
+  const tmpFile = gzipPath.replace(".asar.gz", ".tmp.gz");
   const { downloadBuffer, downloadJSON, extraHeader, userAgent } = downloadConfig || {};
-  function log(...args) {
-    debug && console.log(...args);
+  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";
@@ -151,12 +157,16 @@ function createUpdater({
       UserAgent: ua,
       ...extraHeader
     };
-    log("[updater] headers", headers);
+    log(`download headers: ${JSON.stringify(headers, null, 2)}`);
     const downloadFn = format === "json" ? downloadJSON ?? downloadJSONDefault : downloadBuffer ?? downloadBufferDefault;
-    return await downloadFn(url, updater, headers);
+    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;
     }
     gzipFilePath = gzipFilePath.replace(".asar.gz", ".tmp.gz");
@@ -165,108 +175,136 @@ function createUpdater({
       const input = createReadStream(gzipFilePath);
       const outputFilePath = gzipFilePath.replace(".tmp.gz", ".asar");
       const output = createWriteStream(outputFilePath);
-      log("[updater] outputFilePath", outputFilePath);
+      log(`outputFilePath: ${outputFilePath}`);
       input.pipe(gunzip).pipe(output).on("finish", async () => {
         await rm(gzipFilePath);
-        log("[updater] finish");
+        log(`${gzipFilePath} unzipped`);
         resolve2(outputFilePath);
       }).on("error", async (err) => {
         await rm(gzipFilePath);
-        log("[updater] error", err);
         output.destroy(err);
         reject(err);
       });
     });
   }
-  function verify(buffer, signature) {
-    log("[updater] signature", signature);
-    return createVerify("RSA-SHA256").update(buffer).verify(SIGNATURE_PUB, signature, "base64");
+  function verify(buffer, signature2) {
+    return createVerify("RSA-SHA256").update(buffer).verify(SIGNATURE_PUB, signature2, "base64");
   }
-  function needUpdate(version) {
-    if (!version || !app2.isPackaged) {
+  function needUpdate(version2) {
+    if (!app2.isPackaged) {
+      log("in dev mode, no need to update");
       return false;
     }
     const currentVersion = getEntryVersion();
-    log("[updater] currentVersion", currentVersion);
-    log("[updater] newVersion", version);
+    log(`check update:
+    current version is ${currentVersion},
+    new version is ${version2}`);
     const _compare = compareVersion ?? compareVersionDefault;
-    return _compare(currentVersion, version);
+    return _compare(currentVersion, version2);
   }
-  async function checkUpdate(option) {
-    let {
-      updateJsonURL = _update,
-      releaseAsarURL = _release
-    } = option || {};
-    if (!updateJsonURL || !releaseAsarURL) {
-      log("[updater] no updateJsonURL or releaseAsarURL, use repository");
+  async function checkUpdate(url) {
+    url ??= _update;
+    if (!url) {
+      log("no updateJsonURL, fallback to use repository");
       if (!repository) {
-        throw new Error("updateJsonURL or releaseAsarURL are not set");
+        throw new Error("updateJsonURL or repository are not set");
       }
-      updateJsonURL = `${repository.replace("github.com", "raw.githubusercontent.com")}/version.json`;
-      releaseAsarURL = `${repository}/releases/download/latest/${productName}.asar.gz`;
+      url = `${repository.replace("github.com", "raw.githubusercontent.com")}/master/version.json`;
     }
-    log("[updater] updateJsonURL", updateJsonURL);
-    log("[updater] releaseAsarURL", releaseAsarURL);
-    const gzipPath = `../${productName}.asar.gz`;
-    const tmpFile = gzipPath.replace(".asar.gz", ".tmp.gz");
     if (existsSync(tmpFile)) {
-      log("[updater] remove tmp file", tmpFile);
+      log(`remove tmp file: ${tmpFile}`);
       await rm(tmpFile);
     }
-    const json = await download(updateJsonURL, "json");
-    if (!json) {
-      throw new Error("fetch update json failed");
+    if (existsSync(gzipPath)) {
+      log(`remove .gz file: ${gzipPath}`);
+      await rm(gzipPath);
     }
+    const json = await download(url, "json");
     const {
-      signature,
-      version,
+      signature: _sig,
+      version: _v,
       size
     } = json;
-    log("[updater] UpdateJSON", json);
-    if (!needUpdate(version)) {
-      return "unavailable";
+    log(`update info: ${JSON.stringify(json, null, 2)}`);
+    if (!await needUpdate(_v)) {
+      log(`update unavailable: ${_v}`);
+      return false;
+    } else {
+      log(`update available: ${_v}`);
+      signature = _sig;
+      version = _v;
+      return { size, version };
+    }
+  }
+  async function downloadUpdate(src) {
+    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");
     }
-    updater.emit("downloadStart", size);
-    const buffer = await download(releaseAsarURL, "buffer");
-    log("[updater] start verify");
-    if (!verify(buffer, signature)) {
-      throw new Error("file broken, invalid signature!");
+    log("verify start");
+    if (!verify(src, signature)) {
+      log("verify failed");
+      throw new Error("invalid signature");
     }
-    log("[updater] write file", gzipPath);
-    await writeFile(gzipPath, buffer);
-    log("[updater] extract file", gzipPath);
+    log("verify success");
+    log(`write file: ${gzipPath}`);
+    await writeFile(gzipPath, src);
+    log(`extract file: ${gzipPath}`);
     await extractFile(gzipPath);
-    return "success";
+    log(`update success, version: ${version}`);
+    updater.emit("downloaded");
   }
-  const onCheck = async (option) => {
+  const onCheck = async (url) => {
     try {
-      const result = await checkUpdate(option);
+      const result = await checkUpdate(url);
       updater.emit("checkResult", result);
     } catch (error) {
-      updater.emit("checkResult", "fail", error);
+      log(error);
+      updater.emit("checkResult", error);
     }
   };
   updater.on("check", onCheck);
   updater.checkUpdate = onCheck;
+  const onDownload = async (src) => {
+    try {
+      await downloadUpdate(src);
+    } catch (error) {
+      log(error);
+      updater.emit("donwnloadError", error);
+    }
+  };
+  updater.on("download", onDownload);
+  updater.downloadUpdate = onDownload;
   return updater;
 }
 
 // src/index.ts
-function initApp(productName, updater, option) {
+function initApp(appOptions, updaterOptions) {
   const {
+    name: productName,
     electronDistPath = "dist-electron",
     mainPath = "main/index.js"
-  } = option ?? {};
+  } = appOptions ?? {};
   const mainDir = app3.isPackaged ? `../${productName}.asar` : electronDistPath;
   const entry = resolve(__dirname, mainDir, mainPath);
-  let _updater;
-  if ("SIGNATURE_PUB" in updater) {
-    const _option = updater.productName ? updater : { ...updater, productName };
-    _updater = createUpdater(_option);
+  if (updaterOptions) {
+    __require(entry)(
+      createUpdater({ ...updaterOptions, productName })
+    );
   } else {
-    _updater = updater;
+    return {
+      setUpdater(updater) {
+        __require(entry)(updater);
+      }
+    };
   }
-  return __require(entry)(_updater);
 }
 export {
   createUpdater,
@@ -276,5 +314,6 @@ export {
   getGithubReleaseCdnGroup,
   initApp,
   parseGithubCdnURL,
-  requireNative
+  requireNative,
+  restartApp
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electron-incremental-update",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "electron incremental update tools, powered by vite",
   "scripts": {
     "build": "tsup",
@@ -63,4 +63,4 @@
   "dependencies": {
     "ci-info": "^3.8.0"
   }
-}
+}