electron-updater-for-render 1.0.0

package/Readme.md

@@ -0,0 +1,356 @@
+# electron-updater-for-render
+
+[中文文档](./README.zh-CN.md)
+
+A highly robust, hybrid (auto-prompt & API-driven) **incremental OTA updater for Electron renderer processes** (Vue / React / plain HTML).
+
+Unlike `electron-updater` which re-downloads the entire app installer, this library updates only the renderer assets (HTML/CSS/JS) using `.asar` files — **no elevated permissions, no installer popups, just a fast and silent hot-patch.**
+
+---
+
+## 🚀 Features
+
+- **Dual-Track Update Mode**: Built-in native OS dialogs *or* a fully custom frontend progress UI via IPC — your choice
+- **Force Update**: Push `forceUpdate: 'prompt'` or `'silent'` from your server for P0 hotfixes that bypass the "Later" button entirely
+- **Graceful Restart Hook**: `onBeforeRestart` async hook lets the renderer save unsaved state before `app.relaunch()`
+- **Concurrency Lock**: Prevents race conditions between auto-check-on-boot and manual-trigger-on-click
+- **Smart Cache Pruning**: `maxVersionsToKeep` automatically removes outdated ASAR bundles while retaining rollback copies
+- **Stream Pipeline Download**: Node.js `stream/promises pipeline` + `Transform` — zero memory leaks, full backpressure support
+- **Zero-config Version Detection**: Auto-reads version from `process.cwd()/package.json` — no extra config required
+- **Separate Build Commands**: Normal `npm run build` is untouched. Only `npm run build:update` triggers ASAR packaging
+
+---
+
+## 📦 Installation
+
+```bash
+npm install electron-updater-for-render
+
+# asar is required for the build step (in your renderer project)
+npm install -D asar cross-env
+```
+
+---
+
+## 🗺️ How It Works
+
+```
+┌─────────────────────────────────────────────────────┐
+│  Renderer Project (e.g. Vue)                        │
+│  npm run build:update                               │
+│  → vite build → pack ASAR → write latest.json      │
+└───────────────┬─────────────────────────────────────┘
+                │  Upload dist_updates/ to server
+                ▼
+┌─────────────────────────────────────────────────────┐
+│  Update Server (Nginx / S3 / CDN)                   │
+│  serves: latest.json + /1.0.2/renderer.asar         │
+└───────────────┬─────────────────────────────────────┘
+                │  HTTP fetch on app startup
+                ▼
+┌─────────────────────────────────────────────────────┐
+│  Electron Main Process                              │
+│  updater.checkForUpdatesAndNotify()                 │
+│  → check version → download ASAR → relaunch        │
+└─────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🛠️ Complete Setup Guide
+
+### Step 1 — Renderer Project: Install & Configure Vite Plugin
+
+```typescript
+// vite.config.ts
+import { defineConfig } from 'vite'
+import { electronRenderUpdater } from 'electron-updater-for-render/vite'
+
+export default defineConfig({
+  plugins: [
+    electronRenderUpdater({
+      outDir: './dist',              // Required: Vite build output directory
+      updatesDir: './dist_updates',  // Optional: where to write update packages (default: './dist_updates')
+      // version: '1.2.3'           // Optional: explicit version (overrides package.json)
+      // packageJsonPath: './package.json'  // Optional: custom package.json path
+      // forceUpdate: 'prompt'      // Optional: 'prompt' | 'silent' — for P0 mandatory rollouts ONLY
+    })
+  ]
+})
+```
+
+**Version resolution priority:**
+1. `version` field (explicit)
+2. `packageJsonPath` → read `version` from that file
+3. Auto-detect: `process.cwd()/package.json` *(default — zero config)*
+
+### Step 2 — Renderer Project: Add Build Script
+
+Add a dedicated `build:update` script to your `package.json`. This is **separate from your normal `build`** — it triggers ASAR packaging only when you explicitly want to release an update.
+
+```json
+{
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "build:update": "cross-env ELECTRON_PACK_UPDATE=1 vite build"
+  }
+}
+```
+
+> `npm run build` — normal frontend build, **no ASAR packing**
+> `npm run build:update` — builds frontend + packs ASAR + writes `latest.json`
+
+### Step 3 — Deploy Update Files
+
+After running `npm run build:update`, the `dist_updates/` directory will contain:
+
+```
+dist_updates/
+├── latest.json          ← version manifest (fetched by the client)
+└── 1.0.2/
+    └── renderer.asar    ← the actual update payload
+```
+
+**Upload everything in `dist_updates/` to your update server** (Nginx, S3, CDN, GitHub Releases, etc.).
+
+Example upload:
+```bash
+# Example: sync to S3 bucket
+aws s3 sync dist_updates/ s3://your-bucket/auto-updates/
+
+# Example: upload to Nginx server
+rsync -avz dist_updates/ user@your-server:/var/www/auto-updates/
+```
+
+The server must serve these files over HTTP(S). The client will fetch:
+- `GET https://your-server.com/latest.json`
+- `GET https://your-server.com/1.0.2/renderer.asar`
+
+---
+
+### Step 4 — Electron Main Process: Configure Runtime
+
+```typescript
+// src/main/index.ts
+import { app, BrowserWindow, ipcMain } from 'electron'
+import { join } from 'path'
+import { RenderUpdater } from 'electron-updater-for-render'
+
+const updater = new RenderUpdater({
+  updateUrl: 'https://your-server.com/auto-updates', // Required: base URL for updates
+  versionsDir: join(app.getPath('userData'), 'versions'), // Required: local version storage
+  maxVersionsToKeep: 2, // Optional: keep 2 old versions for rollback (default: 2)
+
+  // Optional: give the renderer time to save state before restart
+  onBeforeRestart: async () => {
+    const [win] = BrowserWindow.getAllWindows()
+    if (win) {
+      win.webContents.send('updater:before-restart')
+      await new Promise(resolve => setTimeout(resolve, 2000))
+    }
+  }
+})
+
+app.whenReady().then(async () => {
+  const mainWindow = new BrowserWindow({
+    webPreferences: { preload: join(__dirname, '../preload/index.js') }
+    // ...
+  })
+
+  // Load the latest downloaded ASAR, fallback to dev server if no update downloaded yet
+  const loadUrl = updater.getLoadUrl()
+  mainWindow.loadURL(loadUrl || 'http://localhost:5173')
+
+  // Auto-check on startup (respects forceUpdate, shows dialogs if autoPrompt: true)
+  setTimeout(() => updater.checkForUpdatesAndNotify(), 3000)
+})
+
+// Expose manual update controls for custom frontend UI
+ipcMain.handle('updater:check', () => updater.check())
+ipcMain.handle('updater:download', () =>
+  updater.download((percent) => {
+    BrowserWindow.getAllWindows()[0]?.webContents.send('updater:progress', percent)
+  })
+)
+ipcMain.handle('updater:install', () => {
+  app.relaunch()
+  app.quit()
+})
+```
+
+---
+
+### Step 5 — Preload Script
+
+```typescript
+// src/preload/index.ts
+import { contextBridge, ipcRenderer } from 'electron'
+
+contextBridge.exposeInMainWorld('updater', {
+  check: () => ipcRenderer.invoke('updater:check'),
+  download: () => ipcRenderer.invoke('updater:download'),
+  install: () => ipcRenderer.invoke('updater:install'),
+
+  onProgress: (callback: (percent: number) => void) => {
+    const fn = (_: any, p: number) => callback(p)
+    ipcRenderer.on('updater:progress', fn)
+    return () => ipcRenderer.removeListener('updater:progress', fn)
+  },
+
+  onBeforeRestart: (callback: () => void) => {
+    const fn = () => callback()
+    ipcRenderer.on('updater:before-restart', fn)
+    return () => ipcRenderer.removeListener('updater:before-restart', fn)
+  }
+})
+```
+
+---
+
+### Step 6 — Renderer UI (Vue Example)
+
+```vue
+<script setup lang="ts">
+import { ref, onMounted, onUnmounted } from 'vue'
+
+const status = ref('')
+const progress = ref(0)
+const hasUpdate = ref(false)
+
+let removeProgress: (() => void) | null = null
+let removeRestart: (() => void) | null = null
+
+onMounted(() => {
+  // Save state before restart
+  removeRestart = window.updater.onBeforeRestart(() => {
+    status.value = 'Restarting...'
+    localStorage.setItem('draft', JSON.stringify({ /* your state */ }))
+  })
+})
+
+onUnmounted(() => {
+  removeProgress?.()
+  removeRestart?.()
+})
+
+const checkUpdate = async () => {
+  status.value = 'Checking...'
+  const result = await window.updater.check()
+  if (result.updateAvailable) {
+    hasUpdate.value = true
+    status.value = `Update available: v${result.version}`
+  } else {
+    status.value = 'Already up to date'
+  }
+}
+
+const downloadUpdate = async () => {
+  status.value = 'Downloading...'
+  removeProgress = window.updater.onProgress((p) => {
+    progress.value = p
+    status.value = `Downloading... ${p.toFixed(0)}%`
+  })
+  await window.updater.download()
+  removeProgress?.()
+  status.value = 'Download complete'
+}
+
+const installUpdate = () => {
+  window.updater.install()
+}
+</script>
+
+<template>
+  <div>
+    <p>{{ status }}</p>
+    <progress :value="progress" max="100" v-if="progress > 0" />
+    <button @click="checkUpdate">Check for updates</button>
+    <button @click="downloadUpdate" v-if="hasUpdate">Download</button>
+    <button @click="installUpdate">Install & Restart</button>
+  </div>
+</template>
+```
+
+---
+
+## ⚙️ API Reference
+
+### `BuilderOptions` (Vite Plugin)
+
+| Option | Type | Required | Description |
+|---|---|---|---|
+| `outDir` | `string` | ✅ | Vite build output directory |
+| `updatesDir` | `string` | — | Output directory for update packages. Default: `./dist_updates` |
+| `version` | `string` | — | Explicit version string, overrides `packageJsonPath` |
+| `packageJsonPath` | `string` | — | Custom path to `package.json`. Defaults to `process.cwd()/package.json` |
+| `asarName` | `string` | — | ASAR filename. Default: `renderer.asar` |
+| `privateKeyPath` | `string` | — | Path to RSA private key for signing |
+| `releaseNotesPath` | `string` | — | Path to release notes markdown file |
+| `forceUpdate` | `'prompt' \| 'silent'` | — | Mandatory update mode. `'prompt'` = blocking dialog; `'silent'` = fully invisible |
+
+### `UpdaterOptions` (Main Process)
+
+| Option | Type | Required | Description |
+|---|---|---|---|
+| `updateUrl` | `string` | ✅ | Base URL where update files are hosted |
+| `versionsDir` | `string` | ✅ | Local directory to store downloaded ASAR versions |
+| `publicKey` | `string` | — | RSA public key (PEM) for signature verification |
+| `autoDownload` | `boolean` | — | Auto-download without asking. Default: `false` |
+| `autoPrompt` | `boolean` | — | Show built-in native dialogs. Default: `true` |
+| `maxVersionsToKeep` | `number` | — | Number of old versions to retain for rollback. Default: `2` |
+| `onUpdateAvailable` | `function` | — | Custom hook: `(info, doDownload) => void` |
+| `onDownloadProgress` | `function` | — | Progress callback: `(percent: number) => void` |
+| `onDownloadComplete` | `function` | — | Completion hook: `(info, doInstall) => void` |
+| `onError` | `function` | — | Error handler: `(error: Error) => void` |
+| `onBeforeRestart` | `async function` | — | Called before `app.relaunch()`. Await-able for graceful shutdown |
+
+---
+
+## 🛡️ Force Update
+
+For P0 incidents where deferral is not an option:
+
+```typescript
+// vite.config.ts
+electronRenderUpdater({
+  outDir: './dist',
+  forceUpdate: 'prompt'  // or 'silent'
+})
+```
+
+| Mode | Behavior |
+|---|---|
+| `'prompt'` | Native OS warning dialog with only one button ("Confirm"). No "Later" option. Download starts immediately. |
+| `'silent'` | Zero UI. Downloads and restarts entirely in the background. |
+
+> ⚠️ Use only for genuine P0 incidents. This permanently removes the user's ability to defer.
+
+---
+
+## 🔐 RSA Signature Verification (Optional)
+
+```bash
+# Generate key pair
+openssl genrsa -out private.pem 2048
+openssl rsa -in private.pem -pubout -out public.pem
+```
+
+```typescript
+// vite.config.ts
+electronRenderUpdater({ outDir: './dist', privateKeyPath: './private.pem' })
+
+// main/index.ts
+import { readFileSync } from 'fs'
+new RenderUpdater({
+  updateUrl: '...',
+  versionsDir: '...',
+  publicKey: readFileSync('./public.pem', 'utf-8')
+})
+```
+
+---
+
+## License
+
+MIT

package/dist/builder/index.cjs

@@ -0,0 +1,112 @@
+"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/builder/index.ts
+var builder_exports = {};
+__export(builder_exports, {
+  createUpdatePackage: () => createUpdatePackage
+});
+module.exports = __toCommonJS(builder_exports);
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_crypto = __toESM(require("crypto"), 1);
+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 = import_path.default.resolve(process.cwd(), "dist_updates"),
+    asarName = "renderer.asar",
+    version: explicitVersion,
+    packageJsonPath,
+    privateKeyPath,
+    releaseNotesPath,
+    forceUpdate
+  } = options;
+  if (!import_fs.default.existsSync(outDir)) {
+    throw new Error(`Output directory not found at ${outDir}`);
+  }
+  if (!import_fs.default.existsSync(updatesDir)) {
+    import_fs.default.mkdirSync(updatesDir, { recursive: true });
+  }
+  let version;
+  if (explicitVersion) {
+    version = explicitVersion;
+  } else {
+    const pkgPath = packageJsonPath ?? import_path.default.resolve(process.cwd(), "package.json");
+    if (!import_fs.default.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(import_fs.default.readFileSync(pkgPath, "utf-8"));
+    version = pkg.version || "0.0.0";
+  }
+  const versionDir = import_path.default.join(updatesDir, version);
+  if (!import_fs.default.existsSync(versionDir)) {
+    import_fs.default.mkdirSync(versionDir, { recursive: true });
+  }
+  const asarPath = import_path.default.join(versionDir, asarName);
+  await asar.createPackage(outDir, asarPath);
+  const fileBuffer = import_fs.default.readFileSync(asarPath);
+  const hashSum = import_crypto.default.createHash("sha256");
+  hashSum.update(fileBuffer);
+  const sha256 = hashSum.digest("hex");
+  let signature = "";
+  if (privateKeyPath && import_fs.default.existsSync(privateKeyPath)) {
+    const privateKey = import_fs.default.readFileSync(privateKeyPath, "utf8");
+    const sign = import_crypto.default.createSign("RSA-SHA256");
+    sign.update(fileBuffer);
+    sign.end();
+    signature = sign.sign(privateKey, "base64");
+  }
+  let releaseNotesContent = "No release notes provided.";
+  if (releaseNotesPath && import_fs.default.existsSync(releaseNotesPath)) {
+    releaseNotesContent = import_fs.default.readFileSync(releaseNotesPath, "utf-8");
+  }
+  const updateInfo = {
+    version,
+    path: `${version}/${asarName}`,
+    sha256,
+    ...signature ? { signature } : {},
+    date: (/* @__PURE__ */ new Date()).toISOString(),
+    releaseNotes: releaseNotesContent,
+    ...forceUpdate ? { forceUpdate } : {}
+  };
+  const jsonPath = import_path.default.join(updatesDir, "latest.json");
+  import_fs.default.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}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createUpdatePackage
+});

package/dist/builder/index.d.ts

@@ -0,0 +1,2 @@
+import type { BuilderOptions } from '../types';
+export declare function createUpdatePackage(options: BuilderOptions): Promise<void>;

package/dist/builder/index.js

@@ -0,0 +1,77 @@
+// 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}`);
+}
+export {
+  createUpdatePackage
+};

package/dist/builder/vite-plugin.cjs

@@ -0,0 +1,133 @@
+"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/builder/vite-plugin.ts
+var vite_plugin_exports = {};
+__export(vite_plugin_exports, {
+  electronRenderUpdater: () => electronRenderUpdater
+});
+module.exports = __toCommonJS(vite_plugin_exports);
+
+// src/builder/index.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_crypto = __toESM(require("crypto"), 1);
+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 = import_path.default.resolve(process.cwd(), "dist_updates"),
+    asarName = "renderer.asar",
+    version: explicitVersion,
+    packageJsonPath,
+    privateKeyPath,
+    releaseNotesPath,
+    forceUpdate
+  } = options;
+  if (!import_fs.default.existsSync(outDir)) {
+    throw new Error(`Output directory not found at ${outDir}`);
+  }
+  if (!import_fs.default.existsSync(updatesDir)) {
+    import_fs.default.mkdirSync(updatesDir, { recursive: true });
+  }
+  let version;
+  if (explicitVersion) {
+    version = explicitVersion;
+  } else {
+    const pkgPath = packageJsonPath ?? import_path.default.resolve(process.cwd(), "package.json");
+    if (!import_fs.default.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(import_fs.default.readFileSync(pkgPath, "utf-8"));
+    version = pkg.version || "0.0.0";
+  }
+  const versionDir = import_path.default.join(updatesDir, version);
+  if (!import_fs.default.existsSync(versionDir)) {
+    import_fs.default.mkdirSync(versionDir, { recursive: true });
+  }
+  const asarPath = import_path.default.join(versionDir, asarName);
+  await asar.createPackage(outDir, asarPath);
+  const fileBuffer = import_fs.default.readFileSync(asarPath);
+  const hashSum = import_crypto.default.createHash("sha256");
+  hashSum.update(fileBuffer);
+  const sha256 = hashSum.digest("hex");
+  let signature = "";
+  if (privateKeyPath && import_fs.default.existsSync(privateKeyPath)) {
+    const privateKey = import_fs.default.readFileSync(privateKeyPath, "utf8");
+    const sign = import_crypto.default.createSign("RSA-SHA256");
+    sign.update(fileBuffer);
+    sign.end();
+    signature = sign.sign(privateKey, "base64");
+  }
+  let releaseNotesContent = "No release notes provided.";
+  if (releaseNotesPath && import_fs.default.existsSync(releaseNotesPath)) {
+    releaseNotesContent = import_fs.default.readFileSync(releaseNotesPath, "utf-8");
+  }
+  const updateInfo = {
+    version,
+    path: `${version}/${asarName}`,
+    sha256,
+    ...signature ? { signature } : {},
+    date: (/* @__PURE__ */ new Date()).toISOString(),
+    releaseNotes: releaseNotesContent,
+    ...forceUpdate ? { forceUpdate } : {}
+  };
+  const jsonPath = import_path.default.join(updatesDir, "latest.json");
+  import_fs.default.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);
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  electronRenderUpdater
+});

package/dist/builder/vite-plugin.d.ts

@@ -0,0 +1,5 @@
+import type { BuilderOptions } from '../types';
+/**
+ * Vite plugin to automatically pack the renderer asar after build.
+ */
+export declare function electronRenderUpdater(options: BuilderOptions): any;