electron-asar-updater-pro-new 2.5.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 xianyunleo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "electron-asar-updater-pro-new",
+  "version": "2.5.4",
+  "description": "Handles Electron app.asar updates. Electron asar 热更新",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xianyunleo/electron-asar-updater-pro.git"
+  },
+  "keywords": [
+    "electron",
+    "asar",
+    "update",
+    "updater"
+  ],
+  "author": "mojixiang1102@gmail.com",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/xianyunleo/electron-asar-updater-pro/issues"
+  },
+  "homepage": "https://github.com/xianyunleo/electron-asar-updater-pro#readme",
+  "dependencies": {
+    "adm-zip": "^0.5.10",
+    "electron-fetch": "^1.9.1",
+    "electron-log": "^4.0.0",
+    "semver-diff": "^3.0.0"
+  },
+  "devDependencies": {
+    "electron": ">=13.0.0"
+  }
+}

package/readme.md

@@ -0,0 +1,129 @@
+# electron-asar-updater-pro
+
+专业现代化的 electron asar文件更新。支持Windows、Mac 、Linux
+
+优点：Windows 无需额外的 exe，支持C盘Program Files目录下的更新。
+
+建议：因为开发模式下，路径不准确，仅测试代码跑通。完整流程，请将项目编译打包运行测试。
+
+#### 安装
+```
+npm i electron-asar-updater-pro
+```
+
+#### 安装要求
+
+```
+Electron >= 13
+Node >= 14
+```
+
+#### 示例
+
+```js
+//Main Process
+const Updater = require('electron-asar-updater-pro');
+const options = {
+    api: {url: 'http://www.test.com/api'},
+    debug: true
+}
+const updater = new Updater(options);
+
+ipcMain.handle('updater-check', async (event, data) => {
+    return await updater.check();
+});
+
+ipcMain.handle('updater-update', async (event, data) => {
+    updater.on('downloadProgress', progress => {
+        event.sender.send('updater-download-progress', progress)
+    });
+    await updater.update();
+});
+
+//Renderer Process
+async function check() {
+    try {
+        const result = await ipcRenderer.invoke('updater-check');
+        if(result){
+            await update();
+        }
+    } catch (error) {
+        console.log('检查更新失败');
+        console.log(error);
+    }
+};
+
+async function update() {
+    try {
+        ipcRenderer.on('updater-download-progress', (event, message) => {
+            console.log(message)
+        })
+        await ipcRenderer.invoke('updater-update');
+    } catch (error) {
+        console.log('更新失败');
+        console.log(error);
+    }
+};
+
+```
+
+#### 服务端api json 
+```
+远程asar文件名可以随意，sha256是指asar文件或者zip文件的hash
+
+{
+    "version": "1.1.0",
+    "asar": "http://www.test.com/update.asar",
+    "sha256": "xxx"
+}
+
+如果asar是zip文件，那么结构如下
+── update.zip
+└── update.asar
+
+```
+
+#### 构造方法
+
+```js
+options = {
+    api: {
+        url: '', //
+        body: {},   //string或object，服务端可根据这个参数，返回不同的response json
+        method: 'POST|GET', //default POST
+        headers: {}
+    },
+    autoRestart: true,
+    debug: false,
+};
+const updater = new Updater(options);
+```
+
+#### 方法
+
+```js
+await check(); //检查是否有更新，本地版本号和远程版本号比较
+await update(); //更新并重启软件，必须先执行check方法
+stopDownload(); //停止下载，仅限node v15及以上版本。
+```
+
+#### 事件
+```js
+updater.on('downloadProgress', progress => {
+    //下载进度
+});
+
+updater.on('status', status => {
+    //Updater.EnumStatus，更新的状态，用作参考。 
+});
+```
+#### 静态属性
+```js
+Updater.EnumStatus; //更新的状态
+```
+
+#### 其它：
+
+如果你使用了`electron-vite` 作为脚手架，那么你可能需要配置`build.rollupOptions.external: ["original-fs"],`，请参考 https://cn.electron-vite.org/config/#%E5%86%85%E7%BD%AE%E9%85%8D%E7%BD%AE
+
+如果你使用了`vue-cli-plugin-electron-builder` 作为脚手架，那么你可能需要配置`externals: ["electron-asar-updater-pro"],`，请参考 https://nklayman.github.io/vue-cli-plugin-electron-builder/guide/guide.html#native-modules

package/src/index.js

@@ -0,0 +1,396 @@
+const {app,net} = require('electron');
+const fs = require("original-fs");
+const fsPromises = fs.promises;
+const path = require("path");
+const child_process = require("child_process");
+const {EventEmitter} = require("events");
+const electronLog = require("electron-log");
+const semverDiff = require("semver-diff");
+const Fetch  = require('electron-fetch')
+const AdmZip = require("adm-zip");
+
+const exists = async (p) => {
+    return fsPromises.access(p).then(() => true).catch(() => false)
+}
+
+const Updater = class Updater extends EventEmitter {
+    _options = {
+        api: {
+            url: null,
+            body: '',
+            method: 'POST',
+            headers:{}
+        },
+        autoRestart: true,
+        debug: false,
+    };
+    _updateFileName = 'update.asar';
+    _downloadUrl = '';
+    _sha256 = '';
+    _downloadDir = '';
+    _downloadFilePath = '';
+    _status = 0;
+    _dlAbortController;
+    _isOldNode = false;
+    static EnumStatus = {
+        Ready: 0,
+        CheckError: 101,
+        Downloading: 102,
+        Downloaded: 103,
+        DownloadError: 104,
+        Extracting: 105,
+        Extracted: 106,
+        ExtractError: 107,
+        Moving: 108,
+        MoveError: 109,
+        HashNoMatch: 110,
+        Finish: 100,
+        Cancel: 200,
+    }
+
+    /**
+     * @param {Object} options
+     * @param {Object} options.api
+     * @param {string} options.api.url
+     * @param {string|Object} [options.api.body]
+     * @param {string} [options.api.method]
+     * @param {Object} [options.api.headers]
+     * @param {boolean} [options.autoRestart]
+     * @param {boolean} [options.debug]
+     */
+    constructor(options) {
+        super();
+        this._isOldNode = !!this._getNodeMajorVersion() < 15;
+        options.autoRestart = options.autoRestart ?? true
+        this._options = options;
+        this._downloadDir = app.getPath('userData');
+        if (!this._isOldNode) {
+            this._dlAbortController = new AbortController();
+        }
+    }
+
+    /**
+     *
+     * @returns {Promise<boolean>}
+     */
+    async check() {
+        const url = this._options.api.url;
+        if (!url) return false;
+
+        this._log(`AppDir: ${this.getAppDir()}`);
+        const appVersion = this.getAppVersion();
+        this._log(`Check:appVersion:${appVersion}`);
+        let respData;
+        const fetchOpts = {method: this._options.api.method ?? 'POST'};
+        try {
+            if (this._options.api.body) {
+                if (typeof this._options.api.body !== 'string') {
+                    this._options.api.body = JSON.stringify(this._options.api.body);
+                }
+                fetchOpts.body = this._options.api.body;
+            }
+            if (this._options.api.headers) {
+                fetchOpts.headers = this._options.api.headers;
+            }
+            respData = await (await Fetch.default(url, fetchOpts)).json();
+        } catch (error) {
+            this._changeStatus(Updater.EnumStatus.Cancel, `Cannot connect to api url,${error.message}`);
+            throw new Error(`Cannot connect to api url,${error.message}`);
+        }
+
+        if (!respData.version || !respData.asar) {
+            this._changeStatus(Updater.EnumStatus.Cancel, 'Api url response not valid');
+            throw new Error('Api url response not valid');
+        }
+
+        if (!semverDiff(appVersion, respData.version)) {
+            this._changeStatus(Updater.EnumStatus.Cancel, 'No updates available');
+            return false;
+        }
+        this._downloadUrl = respData.asar;
+        this._sha256 =  respData.sha256;
+        return true;
+    }
+
+    async update() {
+        try {
+            this._changeStatus(Updater.EnumStatus.Downloading);
+            await this._download();
+        } catch (error) {
+            if (error.name === 'AbortError') {
+                this._changeStatus(Updater.EnumStatus.Cancel, 'Download cancelled');
+                return;
+            } else {
+                this._changeStatus(Updater.EnumStatus.DownloadError, `Download Error,${error}`);
+                throw new Error(`Download Error,${error}`);
+            }
+        }
+
+        if (this._sha256) {
+            const fileBuffer = await fsPromises.readFile(this._downloadFilePath);
+            if (this.sha256(fileBuffer) !== this._sha256) {
+                this._changeStatus(Updater.EnumStatus.HashNoMatch, `File hash mismatch`);
+                throw new Error('File hash mismatch');
+            }
+        }
+
+        if (this._downloadFilePath.endsWith('.zip')) {
+            try {
+                this._changeStatus(Updater.EnumStatus.Extracting, 'Extracting');
+                await this._zipExtract();
+                this._changeStatus(Updater.EnumStatus.Extracted);
+            } catch (error) {
+                this._changeStatus(Updater.EnumStatus.ExtractError, 'Extract Error');
+                throw new Error('Extract Error');
+            }
+        }
+
+        try {
+            this._changeStatus(Updater.EnumStatus.Moving, 'Moving');
+            await this._move();
+        } catch (error) {
+            this._changeStatus(Updater.EnumStatus.MoveError, error.message);
+            throw new Error(`Move Error,${error.message}`);
+        }
+        this._changeStatus(Updater.EnumStatus.Finish);
+
+        if (this._options.autoRestart) {
+            app.relaunch();
+            app.quit();
+        }
+
+    }
+
+    async _download() {
+        let receivedBytes = 0;
+        const request = net.request({url:this._downloadUrl});
+        const responsePromise =   this._getResponse(request);
+        request.end();
+        const response = await responsePromise;
+        const headers = response.headers;
+        const contentType = headers['content-type'];
+        const totalBytes = headers['content-length'] ? parseInt(headers['content-length']) : 0;
+        if (!await exists(this._downloadDir)) {
+            await fsPromises.mkdir(this._downloadDir, {recursive: true});
+        }
+
+        const isZipFromUrl = this._downloadUrl.toLowerCase().includes('.zip');
+        const isZipFromHeader = contentType && contentType.includes('zip');
+        let filePath = path.join(this._downloadDir, this._updateFileName);
+        if (isZipFromUrl || isZipFromHeader) {
+            let zipName = `${this._updateFileName}.zip`;
+            try {
+                const urlPathName = new URL(this._downloadUrl).pathname;
+                const basename = path.basename(urlPathName);
+                if (basename) {
+                    zipName = basename;
+                }
+            } catch {
+            }
+            filePath = path.join(this._downloadDir, zipName);
+        }
+        this._downloadFilePath = filePath;
+        if (await exists(filePath)) {
+            await this.deleteFile(filePath);
+        }
+        const writeStream = fs.createWriteStream(filePath);
+
+        response.on('data', (buffer) => {
+            receivedBytes += buffer.length;
+            const progress = {
+                percent: totalBytes === 0 ? 0 : receivedBytes / totalBytes,
+                transferred: receivedBytes,
+                total: totalBytes,
+            }
+            this.emit('downloadProgress', progress)
+        })
+
+
+        if (this._isOldNode) {
+            const util = require('util');
+            const stream = require('stream');
+            const pipeline = util.promisify(stream.pipeline);
+            await pipeline(response, writeStream);
+        } else {
+            const {pipeline} = require('node:stream/promises');
+            await pipeline(response, writeStream, {signal: this._dlAbortController.signal});
+        }
+
+        this._changeStatus(Updater.EnumStatus.Downloaded);
+    }
+
+    async deleteFile($p) {
+        try {
+            await fsPromises.unlink($p);
+            if (await exists($p)) {
+                await fsPromises.rm($p, {force: true, recursive: true});
+            }
+        } catch {
+        }
+    }
+
+    async _zipExtract() {
+        let zip = new AdmZip(this._downloadFilePath);
+        zip.extractAllTo(this._downloadDir, true);
+    }
+
+    stopDownload() {
+        if (this._isOldNode) {
+            throw new Error('This method only supports node v15 and later');
+        } else {
+            this._dlAbortController.abort();
+        }
+    }
+
+    async _move() {
+        const resourcesDir =  this.getResourcesDir();
+        const updateAsarPath = path.join(this._downloadDir,this._updateFileName);
+        const appAsarPath = path.join(resourcesDir, 'app.asar');
+
+        if (!this.isDev()) {
+            try {
+                const bakAsarPath = path.join(this._downloadDir, 'app.bak.asar');
+                await this.deleteFile(bakAsarPath); //如果已有bak文件是只读，那么必须要先删除才能copy overwrite
+                await fsPromises.copyFile(appAsarPath, bakAsarPath);
+            } catch (e) {
+                this._log(`Backup app.bak.asar error.${e.message}`);
+            }
+        }
+
+        const canWriteResources = await this._checkWritePermission(appAsarPath);
+        this._log(`CanWriteResources ${canWriteResources}`);
+        if (canWriteResources) {
+            this._log(`Copy ${updateAsarPath} to ${appAsarPath}`);
+            await fsPromises.chmod(appAsarPath, 0o666)
+            await fsPromises.copyFile(updateAsarPath, appAsarPath);
+        } else {
+            if (process.platform !== 'win32') {
+                throw new Error('app.asar access denied');
+            }
+
+            const shell = 'powershell';
+            const options = {shell: shell, stdio: 'ignore'};
+            const command = `Start-Process`;
+            const updateAsarPathArg = this._getArg(updateAsarPath, true);
+            const appAsarPathArg = this._getArg(appAsarPath, true);
+            const args = [
+                '-WindowStyle', 'hidden',
+                '-FilePath', 'cmd',
+                '-ArgumentList', `"/c attrib -r ${appAsarPathArg} & copy /y ${updateAsarPathArg} ${appAsarPathArg}"`,
+                '-Verb', 'RunAs'
+            ];
+
+            this._log(`Update start shell process. Command:${command}, Args:${args.join(' ')}`);
+            try {
+                const childProcess = child_process.spawn(command, args, options);
+                await new Promise((resolve, reject) => {
+                    childProcess.on('exit', (code) => {
+                        if (code == 1) {
+                            reject(new Error('The operation has been canceled by the user'));
+                        } else {
+                            resolve();
+                        }
+                    });
+                    childProcess.on('error', (error) => {
+                        reject(error);
+                    });
+                });
+            } catch (error) {
+                throw new Error('Start shell process Error: ' + error);
+            }
+        }
+    }
+
+    async _getResponse(request) {
+        return new Promise((resolve, reject) => {
+            request.on('response', response => {
+                resolve(response);
+            });
+            request.on('error', error => {
+                reject(error);
+            });
+        });
+    }
+
+    _changeStatus(status, logText = '') {
+        this._status = status;
+        this.emit('status', status);
+        if (logText) {
+            this._log(logText);
+        }
+    }
+
+    _log(text) {
+        if (this._options.debug) {
+            console.log('Updater: ', text)
+        }
+        electronLog.info('[ electron-asar-updater-pro ]', text)
+    }
+
+    _getNodeMajorVersion(version) {
+        return parseInt(process.versions.node.split('.')[0]);
+    }
+
+    getStatus() {
+        return this._status;
+    }
+
+    getAppVersion() {
+        return app.getVersion();
+    }
+
+    getAppDir() {
+        if (this.isDev()) {
+            return app.getAppPath();
+        } else {
+            return path.dirname(this.getExePath());
+        }
+    }
+
+    getResourcesDir() {
+        if (this.isDev()) {
+            return app.getAppPath();
+        } else {
+            return path.dirname(app.getAppPath());
+        }
+    }
+
+    getExePath() {
+        //可执行文件路径，Mac返回路径为 AppName.app/Contents/MacOS/AppName。dev返回node_modules\electron\dist\updater.exe
+        return app.getPath('exe');
+    }
+
+    isDev() {
+        return !app.isPackaged;
+    }
+
+    _getArg(str, isPowershell = false) {
+        if (isPowershell) {
+            return `\`"${str}\`"`;
+        }
+        return `"${str}"`;
+    }
+
+    async _checkWritePermission(path) {
+        try {
+            if (process.platform === 'win32') {
+                const fileHandle  = await fsPromises.open(path, "w");
+                await fileHandle?.close();
+            } else {
+                await fsPromises.access(path, fs.constants.W_OK);
+            }
+            return true;
+        } catch (err) {
+            return false;
+        }
+    }
+
+    sha256(data) {
+        const crypto = require('crypto');
+        const hash = crypto.createHash('sha256');
+        hash.update(data);
+        return hash.digest('hex');
+    }
+}
+
+module.exports = Updater;