electron-updater-for-render 1.0.0

package/dist/main/index.js

@@ -0,0 +1,337 @@
+// src/main/index.ts
+import path from "path";
+import fs from "original-fs";
+import crypto from "crypto";
+import { app, dialog } from "electron";
+import { pipeline } from "stream/promises";
+import { Readable, Transform } from "stream";
+var RenderUpdater = class {
+  versionsDir;
+  currentVersionFile;
+  baseUrl;
+  activeVersion;
+  publicKey;
+  isDownloading = false;
+  autoDownload;
+  autoPrompt;
+  maxVersionsToKeep;
+  onUpdateAvailable;
+  onDownloadProgress;
+  onDownloadComplete;
+  onError;
+  onBeforeRestart;
+  constructor(options) {
+    this.versionsDir = options.versionsDir;
+    this.currentVersionFile = path.join(this.versionsDir, "current.json");
+    this.baseUrl = options.updateUrl;
+    this.publicKey = options.publicKey;
+    this.autoDownload = options.autoDownload ?? false;
+    this.autoPrompt = options.autoPrompt ?? true;
+    this.maxVersionsToKeep = options.maxVersionsToKeep ?? 2;
+    this.onUpdateAvailable = options.onUpdateAvailable;
+    this.onDownloadProgress = options.onDownloadProgress;
+    this.onDownloadComplete = options.onDownloadComplete;
+    this.onError = options.onError;
+    this.onBeforeRestart = options.onBeforeRestart;
+    if (!fs.existsSync(this.versionsDir)) {
+      fs.mkdirSync(this.versionsDir, { recursive: true });
+    }
+    this.activeVersion = this.readCurrentVersionFromFile();
+    this.cleanOldVersions();
+  }
+  cleanOldVersions() {
+    try {
+      if (!fs.existsSync(this.versionsDir)) return;
+      const items = fs.readdirSync(this.versionsDir);
+      const versionDirs = [];
+      for (const item of items) {
+        if (item === "current.json") continue;
+        const fullPath = path.join(this.versionsDir, item);
+        if (fs.statSync(fullPath).isDirectory()) {
+          versionDirs.push(item);
+        }
+      }
+      versionDirs.sort((a, b) => this.compareVersions(b, a));
+      const activeIdx = versionDirs.indexOf(this.activeVersion);
+      const safeVersions = /* @__PURE__ */ new Set();
+      if (activeIdx !== -1) safeVersions.add(this.activeVersion);
+      let kept = 0;
+      for (const v of versionDirs) {
+        if (kept >= this.maxVersionsToKeep) break;
+        if (!safeVersions.has(v)) {
+          safeVersions.add(v);
+          kept++;
+        }
+      }
+      for (const v of versionDirs) {
+        if (!safeVersions.has(v)) {
+          console.info(`[RenderUpdater] Cleaning up old version: ${v}`);
+          fs.rmSync(path.join(this.versionsDir, v), { recursive: true, force: true });
+        }
+      }
+    } catch (e) {
+      console.error("[RenderUpdater] Failed to clean old versions:", e);
+    }
+  }
+  readCurrentVersionFromFile() {
+    if (fs.existsSync(this.currentVersionFile)) {
+      try {
+        const current = JSON.parse(fs.readFileSync(this.currentVersionFile, "utf-8"));
+        return current.version;
+      } catch {
+        return "0.0.0";
+      }
+    }
+    return "0.0.0";
+  }
+  hasAnyVersion() {
+    return fs.existsSync(this.currentVersionFile);
+  }
+  /**
+   * Returns the file:// URL to the latest renderer.asar index.html,
+   * or empty string if no update is available.
+   */
+  getLoadUrl() {
+    try {
+      if (fs.existsSync(this.currentVersionFile)) {
+        const current = JSON.parse(fs.readFileSync(this.currentVersionFile, "utf-8"));
+        const version = current.version;
+        const asarPath = path.join(this.versionsDir, version, "renderer.asar");
+        if (fs.existsSync(asarPath)) {
+          return `file://${asarPath}/index.html`;
+        }
+      }
+    } catch (e) {
+      console.error("[RenderUpdater] Failed to get load URL:", e);
+    }
+    return "";
+  }
+  async check() {
+    try {
+      const response = await fetch(`${this.baseUrl}/latest.json?t=${Date.now()}`);
+      if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+      const remoteInfo = await response.json();
+      const currentVersion = this.activeVersion;
+      if (this.compareVersions(remoteInfo.version, currentVersion) > 0) {
+        return { updateAvailable: true, version: remoteInfo.version, info: remoteInfo };
+      }
+      return { updateAvailable: false };
+    } catch (e) {
+      console.error("[RenderUpdater] Update check failed:", e);
+      throw e;
+    }
+  }
+  /**
+   * Downloads the update with resume support.
+   */
+  async download(onProgress) {
+    if (this.isDownloading) throw new Error("[RenderUpdater] Download is already in progress.");
+    this.isDownloading = true;
+    try {
+      const response = await fetch(`${this.baseUrl}/latest.json?t=${Date.now()}`);
+      if (!response.ok) throw new Error("[RenderUpdater] Cannot fetch latest.json for download");
+      const info = await response.json();
+      const versionDir = path.join(this.versionsDir, info.version);
+      const asarPath = path.join(versionDir, "renderer.asar");
+      if (fs.existsSync(asarPath) && this.verifyFile(asarPath, info)) {
+        onProgress?.(100);
+        this.useVersion(info.version);
+        return;
+      }
+      if (!fs.existsSync(versionDir)) {
+        fs.mkdirSync(versionDir, { recursive: true });
+      }
+      let downloadedBytes = 0;
+      if (fs.existsSync(asarPath)) {
+        downloadedBytes = fs.statSync(asarPath).size;
+      }
+      const fetchOptions = {};
+      if (downloadedBytes > 0) {
+        fetchOptions.headers = {
+          Range: `bytes=${downloadedBytes}-`
+        };
+      }
+      const downloadUrl = info.path ? `${this.baseUrl.replace(/\/$/, "")}/${info.path}` : info.url;
+      if (!downloadUrl) throw new Error("[RenderUpdater] Cannot determine download URL: info.path and info.url are both missing.");
+      const downloadResponse = await fetch(downloadUrl, fetchOptions);
+      if (downloadResponse.status !== 206 && downloadResponse.status !== 200) {
+        throw new Error(`Failed to download update: ${downloadResponse.statusText}`);
+      }
+      if (downloadResponse.status === 200) {
+        downloadedBytes = 0;
+      }
+      const contentLength = downloadResponse.headers.get("content-length");
+      const incomingTotal = contentLength ? parseInt(contentLength, 10) : 0;
+      const total = downloadedBytes + incomingTotal;
+      if (!downloadResponse.body) throw new Error("Response body is empty");
+      const fileStream = fs.createWriteStream(asarPath, { flags: downloadResponse.status === 206 ? "a" : "w" });
+      const progressTransform = new Transform({
+        transform(chunk, _encoding, callback) {
+          downloadedBytes += chunk.length;
+          if (total > 0) {
+            onProgress?.(downloadedBytes / total * 100);
+          }
+          callback(null, chunk);
+        }
+      });
+      await pipeline(
+        Readable.fromWeb(downloadResponse.body),
+        progressTransform,
+        fileStream
+      );
+      if (!this.verifyFile(asarPath, info)) {
+        fs.rmSync(versionDir, { recursive: true, force: true });
+        throw new Error("[RenderUpdater] Verification failed after download (SHA256 or RSA Mismatch)");
+      }
+      this.useVersion(info.version);
+      this.cleanOldVersions();
+    } finally {
+      this.isDownloading = false;
+    }
+  }
+  verifyFile(filePath, info) {
+    const fileBuffer = fs.readFileSync(filePath);
+    const hashSum = crypto.createHash("sha256");
+    hashSum.update(fileBuffer);
+    const sha256 = hashSum.digest("hex");
+    if (sha256 !== info.sha256) {
+      console.error(`[RenderUpdater] SHA256 mismatch! Expected ${info.sha256}, got ${sha256}`);
+      return false;
+    }
+    if (this.publicKey && info.signature) {
+      try {
+        const verify = crypto.createVerify("RSA-SHA256");
+        verify.update(fileBuffer);
+        verify.end();
+        const isValid = verify.verify(this.publicKey, info.signature, "base64");
+        if (!isValid) {
+          console.error("[RenderUpdater] RSA Signature verification failed.");
+          return false;
+        }
+      } catch (err) {
+        console.error("[RenderUpdater] RSA verification error:", err);
+        return false;
+      }
+    }
+    return true;
+  }
+  useVersion(version) {
+    fs.writeFileSync(
+      this.currentVersionFile,
+      JSON.stringify({ version, date: (/* @__PURE__ */ new Date()).toISOString() })
+    );
+    this.activeVersion = version;
+  }
+  compareVersions(v1, v2) {
+    const parts1 = v1.split(".").map(Number);
+    const parts2 = v2.split(".").map(Number);
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+      const n1 = parts1[i] || 0;
+      const n2 = parts2[i] || 0;
+      if (n1 > n2) return 1;
+      if (n1 < n2) return -1;
+    }
+    return 0;
+  }
+  /**
+   * One-stop method to check for updates, show dialogs (if autoPrompt=true),
+   * download, and restart application.
+   */
+  async checkForUpdatesAndNotify() {
+    try {
+      const checkResult = await this.check();
+      if (!checkResult.updateAvailable || !checkResult.info) {
+        return;
+      }
+      const info = checkResult.info;
+      const doDownload = async () => {
+        try {
+          await this.download(this.onDownloadProgress);
+          const doInstall = async () => {
+            if (this.onBeforeRestart) {
+              await this.onBeforeRestart();
+            }
+            app.relaunch();
+            app.quit();
+          };
+          if (this.onDownloadComplete) {
+            this.onDownloadComplete(info, () => {
+              doInstall().catch(console.error);
+            });
+          } else {
+            if (info.forceUpdate) {
+              if (info.forceUpdate === "prompt") {
+                dialog.showMessageBoxSync({
+                  type: "warning",
+                  title: "\u6700\u9AD8\u7EA7\u522B\u5F3A\u5236\u63A5\u7BA1",
+                  message: "\u7D27\u6025\u707E\u96BE\u4FEE\u590D\u7EC4\u4EF6\u5DF2\u7ECF\u4E0B\u8F7D\u5C31\u7EEA\u3002\u5373\u5C06\u5F3A\u884C\u963B\u65AD\u5E76\u91CD\u542F\u5E94\u7528\u8FDB\u884C\u6302\u8F7D\u3002",
+                  buttons: ["\u5F3A\u5236\u63A5\u7BA1"]
+                });
+              }
+              doInstall().catch(console.error);
+            } else if (this.autoPrompt) {
+              dialog.showMessageBoxSync({
+                type: "info",
+                title: "\u4E0B\u8F7D\u5B8C\u6210",
+                message: "\u6700\u65B0\u7248\u672C\u5DF2\u4E0B\u8F7D\u5B8C\u6BD5\u3002\u70B9\u51FB\u786E\u5B9A\u91CD\u542F\u5E94\u7528\u4EE5\u5E94\u7528\u66F4\u65B0\u3002",
+                buttons: ["\u786E\u5B9A"]
+              });
+              doInstall().catch(console.error);
+            } else {
+            }
+          }
+        } catch (e) {
+          if (this.onError) {
+            this.onError(e);
+          } else {
+            console.error("[RenderUpdater] Download error:", e);
+          }
+        }
+      };
+      if (this.onUpdateAvailable) {
+        this.onUpdateAvailable(info, doDownload);
+      } else {
+        if (info.forceUpdate) {
+          if (info.forceUpdate === "prompt") {
+            dialog.showMessageBoxSync({
+              type: "warning",
+              title: "\u{1F6A8} \u53D1\u73B0\u751F\u6B7B\u6538\u5173\u7684\u6838\u5FC3\u66F4\u65B0",
+              message: `\u63A2\u6D4B\u5230\u7CFB\u7EDF\u81F4\u547D Bug \u7684\u4FEE\u590D\u7248\u672C (v${info.version})\u3002
+\u5E94\u7528\u73AF\u5883\u5373\u523B\u88AB\u9501\u5B9A\uFF0C\u5F00\u59CB\u5F3A\u5236\u6267\u884C\u5168\u91CF\u4E0B\u8F7D\uFF0C\u4EFB\u4F55\u4EBA\u90FD\u65E0\u6CD5\u4E2D\u6B62\uFF01
+
+\u66F4\u65B0\u65E5\u5FD7\uFF1A
+${info.releaseNotes || "\u707E\u5907\u9884\u6848\u5F3A\u5236\u6FC0\u6D3B\uFF0C\u65E0\u53EF\u5949\u544A\u3002"}`,
+              buttons: ["\u4E56\u4E56\u5347\u7EA7"]
+            });
+          }
+          await doDownload();
+        } else if (this.autoDownload) {
+          await doDownload();
+        } else if (this.autoPrompt) {
+          const { response } = await dialog.showMessageBox({
+            type: "info",
+            title: "\u53D1\u73B0\u65B0\u7248\u672C",
+            message: `\u53D1\u73B0\u53EF\u7528\u66F4\u65B0 (v${info.version})\u3002\u662F\u5426\u7ACB\u5373\u4E0B\u8F7D\u66F4\u65B0\uFF1F
+
+\u66F4\u65B0\u65E5\u5FD7\uFF1A
+${info.releaseNotes || "\u65E0\u8BE6\u7EC6\u8BB0\u5F55\u3002"}`,
+            buttons: ["\u7ACB\u5373\u66F4\u65B0", "\u7A0D\u540E\u518D\u8BF4"],
+            cancelId: 1
+          });
+          if (response === 0) {
+            await doDownload();
+          }
+        }
+      }
+    } catch (e) {
+      if (this.onError) {
+        this.onError(e);
+      } else {
+        console.error("[RenderUpdater] Error in checkForUpdatesAndNotify:", e);
+      }
+    }
+  }
+};
+export {
+  RenderUpdater
+};

package/dist/types.d.ts

@@ -0,0 +1,105 @@
+export interface UpdateInfo {
+    version: string;
+    url?: string;
+    path?: string;
+    sha256: string;
+    signature?: string;
+    date: string;
+    releaseNotes?: string;
+    /**
+     * Defines if this update is mandatory.
+     * 'prompt' - shows blocking dialogs to force the user to update.
+     * 'silent' - downloads and restarts invisibly on the background.
+     */
+    forceUpdate?: 'prompt' | 'silent';
+}
+export interface UpdaterOptions {
+    /**
+     * The base URL to check for updates (e.g. http://localhost:8000/updates)
+     */
+    updateUrl: string;
+    /**
+     * The local directory where versions will be stored
+     * (e.g. app.getPath('userData') + '/versions')
+     */
+    versionsDir: string;
+    /**
+     * Public key string (PEM format) to verify the RSA signature
+     */
+    publicKey?: string;
+    /**
+     * Whether to automatically download the update when one is found (if false, it prompts the user first if autoPrompt is true)
+     */
+    autoDownload?: boolean;
+    /**
+     * Whether to display built-in dialog prompts (in Chinese) for "Update Available" and "Update Downloaded"
+     * Defaults to true.
+     */
+    autoPrompt?: boolean;
+    /**
+     * Maximum number of recent historical versions to keep locally for fallback.
+     * Older versions will be automatically deleted to save disk space. Defaults to 2.
+     */
+    maxVersionsToKeep?: number;
+    /**
+     * Called when a new update is found.
+     * Provides the UpdateInfo and a callback function `doDownload` which triggers the actual download.
+     */
+    onUpdateAvailable?: (info: UpdateInfo, doDownload: () => Promise<void>) => void;
+    /**
+     * Called with current download progress [0, 100].
+     */
+    onDownloadProgress?: (percent: number) => void;
+    /**
+     * Called when the ASAR update has been successfully downloaded and verified.
+     * Provides `doInstall` callback that calls app.relaunch() and app.quit().
+     */
+    onDownloadComplete?: (info: UpdateInfo, doInstall: () => void) => void;
+    /**
+     * Called if any error occurs during check or download.
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Called right before app.relaunch() and app.quit() is triggered.
+     * Useful for telling the Vue renderer to save state and cleanup.
+     */
+    onBeforeRestart?: () => void | Promise<void>;
+}
+export interface BuilderOptions {
+    /**
+     * The directory to pack into the ASAR (e.g. './dist')
+     */
+    outDir: string;
+    /**
+     * The output directory for the update package (e.g. './dist_updates')
+     */
+    updatesDir?: string;
+    /**
+     * Name of the ASAR file, defaults to 'renderer.asar'
+     */
+    asarName?: string;
+    /**
+     * Explicit version string to use (e.g. '1.2.3').
+     * Takes priority over packageJsonPath. If neither is provided, reads from process.cwd()/package.json.
+     */
+    version?: string;
+    /**
+     * Path to the package.json to read the version from.
+     * Optional. If omitted and version is not set, defaults to process.cwd()/package.json.
+     */
+    packageJsonPath?: string;
+    /**
+     * Path to the private key (PEM format) to sign the ASAR
+     */
+    privateKeyPath?: string;
+    /**
+     * Path to the release notes markdown file
+     */
+    releaseNotesPath?: string;
+    /**
+     * Mark this specific build as a mandatory check-in (forced update)
+     * 'prompt': Warn user before forcefully applying.
+     * 'silent': Stealthily apply it in the background.
+     */
+    forceUpdate?: 'prompt' | 'silent';
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "electron-updater-for-render",
+  "version": "1.0.0",
+  "description": "A lightweight incremental updater for Electron renderer processes",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/main/index.d.ts",
+      "import": "./dist/main/index.js",
+      "require": "./dist/main/index.cjs"
+    },
+    "./builder": {
+      "types": "./dist/builder/index.d.ts",
+      "import": "./dist/builder/index.js",
+      "require": "./dist/builder/index.cjs"
+    },
+    "./vite": {
+      "types": "./dist/builder/vite-plugin.d.ts",
+      "import": "./dist/builder/vite-plugin.js",
+      "require": "./dist/builder/vite-plugin.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsup && tsc --emitDeclarationOnly",
+    "dev": "tsup --watch"
+  },
+  "dependencies": {
+    "original-fs": "^1.2.0"
+  },
+  "peerDependencies": {
+    "asar": "^3.2.0",
+    "electron": ">=20.0.0",
+    "vite": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "asar": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "asar": "^3.2.0",
+    "tsup": "^8.0.2",
+    "typescript": "^5.0.0",
+    "vite": "^5.0.0"
+  },
+  "keywords": [
+    "electron",
+    "updater",
+    "incremental",
+    "render",
+    "vue",
+    "vite"
+  ],
+  "author": "",
+  "license": "MIT"
+}