electron-updater-for-render 1.0.0

package/dist/builder/vite-plugin.js

@@ -0,0 +1,96 @@
+// src/builder/index.ts
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+async function createUpdatePackage(options) {
+  const asar = await import("asar").catch(() => {
+    throw new Error('Please install "asar" as a devDependency to use the builder.');
+  });
+  const {
+    outDir,
+    updatesDir = path.resolve(process.cwd(), "dist_updates"),
+    asarName = "renderer.asar",
+    version: explicitVersion,
+    packageJsonPath,
+    privateKeyPath,
+    releaseNotesPath,
+    forceUpdate
+  } = options;
+  if (!fs.existsSync(outDir)) {
+    throw new Error(`Output directory not found at ${outDir}`);
+  }
+  if (!fs.existsSync(updatesDir)) {
+    fs.mkdirSync(updatesDir, { recursive: true });
+  }
+  let version;
+  if (explicitVersion) {
+    version = explicitVersion;
+  } else {
+    const pkgPath = packageJsonPath ?? path.resolve(process.cwd(), "package.json");
+    if (!fs.existsSync(pkgPath)) {
+      throw new Error(
+        `Cannot resolve version: package.json not found at ${pkgPath}. Please set "version" or "packageJsonPath" in the plugin options.`
+      );
+    }
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    version = pkg.version || "0.0.0";
+  }
+  const versionDir = path.join(updatesDir, version);
+  if (!fs.existsSync(versionDir)) {
+    fs.mkdirSync(versionDir, { recursive: true });
+  }
+  const asarPath = path.join(versionDir, asarName);
+  await asar.createPackage(outDir, asarPath);
+  const fileBuffer = fs.readFileSync(asarPath);
+  const hashSum = crypto.createHash("sha256");
+  hashSum.update(fileBuffer);
+  const sha256 = hashSum.digest("hex");
+  let signature = "";
+  if (privateKeyPath && fs.existsSync(privateKeyPath)) {
+    const privateKey = fs.readFileSync(privateKeyPath, "utf8");
+    const sign = crypto.createSign("RSA-SHA256");
+    sign.update(fileBuffer);
+    sign.end();
+    signature = sign.sign(privateKey, "base64");
+  }
+  let releaseNotesContent = "No release notes provided.";
+  if (releaseNotesPath && fs.existsSync(releaseNotesPath)) {
+    releaseNotesContent = fs.readFileSync(releaseNotesPath, "utf-8");
+  }
+  const updateInfo = {
+    version,
+    path: `${version}/${asarName}`,
+    sha256,
+    ...signature ? { signature } : {},
+    date: (/* @__PURE__ */ new Date()).toISOString(),
+    releaseNotes: releaseNotesContent,
+    ...forceUpdate ? { forceUpdate } : {}
+  };
+  const jsonPath = path.join(updatesDir, "latest.json");
+  fs.writeFileSync(jsonPath, JSON.stringify(updateInfo, null, 2));
+  console.log(`[RenderUpdater Builder] Successfully created package for v${version}`);
+  console.log(`[RenderUpdater Builder] ASAR: ${asarPath}`);
+  console.log(`[RenderUpdater Builder] Info: ${jsonPath}`);
+}
+
+// src/builder/vite-plugin.ts
+function electronRenderUpdater(options) {
+  return {
+    name: "vite-plugin-electron-render-updater",
+    apply: "build",
+    closeBundle: async () => {
+      if (!process.env.ELECTRON_PACK_UPDATE) {
+        return;
+      }
+      console.log("\n[vite-plugin-electron-render-updater] Build finished, packing ASAR...");
+      try {
+        await createUpdatePackage(options);
+      } catch (err) {
+        console.error("[vite-plugin-electron-render-updater] Failed to pack ASAR:", err);
+      }
+    }
+  };
+}
+export {
+  electronRenderUpdater
+};

package/dist/main/index.cjs

@@ -0,0 +1,372 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/main/index.ts
+var main_exports = {};
+__export(main_exports, {
+  RenderUpdater: () => RenderUpdater
+});
+module.exports = __toCommonJS(main_exports);
+var import_path = __toESM(require("path"), 1);
+var import_original_fs = __toESM(require("original-fs"), 1);
+var import_crypto = __toESM(require("crypto"), 1);
+var import_electron = require("electron");
+var import_promises = require("stream/promises");
+var import_stream = require("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 = import_path.default.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 (!import_original_fs.default.existsSync(this.versionsDir)) {
+      import_original_fs.default.mkdirSync(this.versionsDir, { recursive: true });
+    }
+    this.activeVersion = this.readCurrentVersionFromFile();
+    this.cleanOldVersions();
+  }
+  cleanOldVersions() {
+    try {
+      if (!import_original_fs.default.existsSync(this.versionsDir)) return;
+      const items = import_original_fs.default.readdirSync(this.versionsDir);
+      const versionDirs = [];
+      for (const item of items) {
+        if (item === "current.json") continue;
+        const fullPath = import_path.default.join(this.versionsDir, item);
+        if (import_original_fs.default.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}`);
+          import_original_fs.default.rmSync(import_path.default.join(this.versionsDir, v), { recursive: true, force: true });
+        }
+      }
+    } catch (e) {
+      console.error("[RenderUpdater] Failed to clean old versions:", e);
+    }
+  }
+  readCurrentVersionFromFile() {
+    if (import_original_fs.default.existsSync(this.currentVersionFile)) {
+      try {
+        const current = JSON.parse(import_original_fs.default.readFileSync(this.currentVersionFile, "utf-8"));
+        return current.version;
+      } catch {
+        return "0.0.0";
+      }
+    }
+    return "0.0.0";
+  }
+  hasAnyVersion() {
+    return import_original_fs.default.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 (import_original_fs.default.existsSync(this.currentVersionFile)) {
+        const current = JSON.parse(import_original_fs.default.readFileSync(this.currentVersionFile, "utf-8"));
+        const version = current.version;
+        const asarPath = import_path.default.join(this.versionsDir, version, "renderer.asar");
+        if (import_original_fs.default.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 = import_path.default.join(this.versionsDir, info.version);
+      const asarPath = import_path.default.join(versionDir, "renderer.asar");
+      if (import_original_fs.default.existsSync(asarPath) && this.verifyFile(asarPath, info)) {
+        onProgress?.(100);
+        this.useVersion(info.version);
+        return;
+      }
+      if (!import_original_fs.default.existsSync(versionDir)) {
+        import_original_fs.default.mkdirSync(versionDir, { recursive: true });
+      }
+      let downloadedBytes = 0;
+      if (import_original_fs.default.existsSync(asarPath)) {
+        downloadedBytes = import_original_fs.default.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 = import_original_fs.default.createWriteStream(asarPath, { flags: downloadResponse.status === 206 ? "a" : "w" });
+      const progressTransform = new import_stream.Transform({
+        transform(chunk, _encoding, callback) {
+          downloadedBytes += chunk.length;
+          if (total > 0) {
+            onProgress?.(downloadedBytes / total * 100);
+          }
+          callback(null, chunk);
+        }
+      });
+      await (0, import_promises.pipeline)(
+        import_stream.Readable.fromWeb(downloadResponse.body),
+        progressTransform,
+        fileStream
+      );
+      if (!this.verifyFile(asarPath, info)) {
+        import_original_fs.default.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 = import_original_fs.default.readFileSync(filePath);
+    const hashSum = import_crypto.default.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 = import_crypto.default.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) {
+    import_original_fs.default.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();
+            }
+            import_electron.app.relaunch();
+            import_electron.app.quit();
+          };
+          if (this.onDownloadComplete) {
+            this.onDownloadComplete(info, () => {
+              doInstall().catch(console.error);
+            });
+          } else {
+            if (info.forceUpdate) {
+              if (info.forceUpdate === "prompt") {
+                import_electron.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) {
+              import_electron.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") {
+            import_electron.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 import_electron.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);
+      }
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RenderUpdater
+});

package/dist/main/index.d.ts

@@ -0,0 +1,43 @@
+import type { UpdateInfo, UpdaterOptions } from '../types';
+export declare class RenderUpdater {
+    private versionsDir;
+    private currentVersionFile;
+    private baseUrl;
+    private activeVersion;
+    private publicKey?;
+    private isDownloading;
+    private autoDownload;
+    private autoPrompt;
+    private maxVersionsToKeep;
+    onUpdateAvailable?: (info: UpdateInfo, doDownload: () => Promise<void>) => void;
+    onDownloadProgress?: (percent: number) => void;
+    onDownloadComplete?: (info: UpdateInfo, doInstall: () => void) => void;
+    onError?: (error: Error) => void;
+    onBeforeRestart?: () => void | Promise<void>;
+    constructor(options: UpdaterOptions);
+    private cleanOldVersions;
+    private readCurrentVersionFromFile;
+    hasAnyVersion(): boolean;
+    /**
+     * Returns the file:// URL to the latest renderer.asar index.html,
+     * or empty string if no update is available.
+     */
+    getLoadUrl(): string;
+    check(): Promise<{
+        updateAvailable: boolean;
+        version?: string;
+        info?: UpdateInfo;
+    }>;
+    /**
+     * Downloads the update with resume support.
+     */
+    download(onProgress?: (percent: number) => void): Promise<void>;
+    private verifyFile;
+    private useVersion;
+    private compareVersions;
+    /**
+     * One-stop method to check for updates, show dialogs (if autoPrompt=true),
+     * download, and restart application.
+     */
+    checkForUpdatesAndNotify(): Promise<void>;
+}