electron-incremental-update 0.3.0 → 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

@@ -63,11 +63,15 @@ function downloadJSONDefault(url, updater, headers) {
       res.headers = headers;
       res.on("data", (chunk) => data += chunk);
       res.on("end", () => {
-        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) => {
@@ -177,6 +181,7 @@ 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 { downloadBuffer, downloadJSON, extraHeader, userAgent } = downloadConfig || {};
@@ -190,12 +195,16 @@ function createUpdater({
       UserAgent: ua,
       ...extraHeader
     };
-    log(`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");
@@ -207,55 +216,61 @@ function createUpdater({
       log(`outputFilePath: ${outputFilePath}`);
       input.pipe(gunzip).pipe(output).on("finish", async () => {
         await (0, import_promises.rm)(gzipFilePath);
-        log("finish");
+        log(`${gzipFilePath} unzipped`);
         resolve2(outputFilePath);
       }).on("error", async (err) => {
         await (0, import_promises.rm)(gzipFilePath);
-        log(`error: ${err}`);
         output.destroy(err);
         reject(err);
       });
     });
   }
   function verify(buffer, signature2) {
-    log(`signature: ${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(`currentVersion: ${currentVersion}`);
-    log(`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(url) {
     url ??= _update;
     if (!url) {
-      log("no updateJsonURL, use repository");
+      log("no updateJsonURL, fallback to use repository");
       if (!repository) {
         throw new Error("updateJsonURL or repository are not set");
       }
-      url = `${repository.replace("github.com", "raw.githubusercontent.com")}/version.json`;
+      url = `${repository.replace("github.com", "raw.githubusercontent.com")}/master/version.json`;
     }
-    log(`updateJsonURL: ${url}`);
     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,
+      version: _v,
       size
     } = json;
-    log(`UpdateJSON: ${JSON.stringify(json, null, 2)}`);
-    if (!needUpdate(version)) {
+    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 };
     }
   }
@@ -263,23 +278,25 @@ function createUpdater({
     if (typeof src !== "object") {
       let _url = src ?? _release;
       if (!_url) {
-        log("no releaseAsarURL, use repository");
+        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`;
       }
-      log(`releaseAsarURL: ${_url}`);
       src = await download(_url, "buffer");
     }
-    log("start verify");
+    log("verify start");
     if (!verify(src, signature)) {
-      throw new Error("file broken, invalid signature!");
+      log("verify failed");
+      throw new Error("invalid signature");
     }
+    log("verify success");
     log(`write file: ${gzipPath}`);
     await (0, import_promises.writeFile)(gzipPath, src);
     log(`extract file: ${gzipPath}`);
     await extractFile(gzipPath);
+    log(`update success, version: ${version}`);
     updater.emit("downloaded");
   }
   const onCheck = async (url) => {
@@ -307,21 +324,25 @@ function createUpdater({
 }
 
 // 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 = {

package/dist/index.d.ts

@@ -2,9 +2,9 @@ import { Buffer } from 'node:buffer';
 
 type CheckResultType = Error | false | Omit<UpdateJSON, 'signature'>;
 type UpdateEvents = {
-    check: null;
+    check: [url?: string];
     checkResult: [data: CheckResultType];
-    download: null;
+    download: [src?: string | Buffer];
     downloading: [current: number];
     downloaded: null;
     donwnloadError: [error: unknown];
@@ -16,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[];
@@ -43,11 +29,11 @@ interface TypedUpdater<T extends Record<string | symbol, MaybeArray<any>>, Event
      * - `false`: unavailable
      * - `{size: number, version: string}`: success
      */
-    checkUpdate(url?: BaseOption['updateJsonURL']): Promise<void>;
-    downloadUpdate(url?: BaseOption['releaseAsarURL'] | Buffer): Promise<void>;
+    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
      *
@@ -65,7 +51,7 @@ interface UpdaterOption extends BaseOption {
      */
     SIGNATURE_PUB: string;
     /**
-     * product name
+     * name of your application
      *
      * you can use the `name` in `package.json`
      */
@@ -79,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
@@ -94,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`
          */
@@ -102,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`
          */
@@ -144,61 +151,63 @@ 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, restartApp };
+export { AppOption, CheckResultType, InitUpdaterOptions, UpdateJSON, Updater, UpdaterOption, createUpdater, getAppAsarPath, getAppVersion, getEntryVersion, getGithubReleaseCdnGroup, initApp, parseGithubCdnURL, requireNative, restartApp };

package/dist/index.mjs

@@ -25,11 +25,15 @@ function downloadJSONDefault(url, updater, headers) {
       res.headers = headers;
       res.on("data", (chunk) => data += chunk);
       res.on("end", () => {
-        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) => {
@@ -139,6 +143,7 @@ function createUpdater({
 }) {
   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 || {};
@@ -152,12 +157,16 @@ function createUpdater({
       UserAgent: ua,
       ...extraHeader
     };
-    log(`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");
@@ -169,55 +178,61 @@ function createUpdater({
       log(`outputFilePath: ${outputFilePath}`);
       input.pipe(gunzip).pipe(output).on("finish", async () => {
         await rm(gzipFilePath);
-        log("finish");
+        log(`${gzipFilePath} unzipped`);
         resolve2(outputFilePath);
       }).on("error", async (err) => {
         await rm(gzipFilePath);
-        log(`error: ${err}`);
         output.destroy(err);
         reject(err);
       });
     });
   }
   function verify(buffer, signature2) {
-    log(`signature: ${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(`currentVersion: ${currentVersion}`);
-    log(`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(url) {
     url ??= _update;
     if (!url) {
-      log("no updateJsonURL, use repository");
+      log("no updateJsonURL, fallback to use repository");
       if (!repository) {
         throw new Error("updateJsonURL or repository are not set");
       }
-      url = `${repository.replace("github.com", "raw.githubusercontent.com")}/version.json`;
+      url = `${repository.replace("github.com", "raw.githubusercontent.com")}/master/version.json`;
     }
-    log(`updateJsonURL: ${url}`);
     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,
+      version: _v,
       size
     } = json;
-    log(`UpdateJSON: ${JSON.stringify(json, null, 2)}`);
-    if (!needUpdate(version)) {
+    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 };
     }
   }
@@ -225,23 +240,25 @@ function createUpdater({
     if (typeof src !== "object") {
       let _url = src ?? _release;
       if (!_url) {
-        log("no releaseAsarURL, use repository");
+        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`;
       }
-      log(`releaseAsarURL: ${_url}`);
       src = await download(_url, "buffer");
     }
-    log("start verify");
+    log("verify start");
     if (!verify(src, signature)) {
-      throw new Error("file broken, invalid signature!");
+      log("verify failed");
+      throw new Error("invalid signature");
     }
+    log("verify success");
     log(`write file: ${gzipPath}`);
     await writeFile(gzipPath, src);
     log(`extract file: ${gzipPath}`);
     await extractFile(gzipPath);
+    log(`update success, version: ${version}`);
     updater.emit("downloaded");
   }
   const onCheck = async (url) => {
@@ -269,21 +286,25 @@ function createUpdater({
 }
 
 // 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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electron-incremental-update",
-  "version": "0.3.0",
+  "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"
   }
-}
+}