@plasosdk/plaso-electron-sdk 1.0.6

package/index.js

@@ -0,0 +1,6 @@
+const { ipcMain } = require('electron');
+if (ipcMain) {
+    module.exports = require('./js/main.js');
+} else {
+    module.exports = require('./js/render.js');
+}

package/js/code.js

@@ -0,0 +1,34 @@
+const ERROR_CODE = {
+    /** 非 electron 环境 */
+    NO_ELECTRON_ENVIRONMENT: -1,
+    COMMOM_ERROR: -99,
+};
+
+const LESSON_TYPE = {
+    /** 课堂 */
+    LIVECLASS: 'liveClass',
+    /** 备课 */
+    PREPARE_LESSONS: 'prepareLesson',
+};
+
+/** 课堂窗口与外部窗口通讯的消息 */
+const CLASS_WINDOW_MESG_TYPE = {
+    /** 课堂dom渲染成功后告知外部应用窗口,传参用户信息 */
+    LIVE_WINDOW_READY: 'liveWindowReady',
+    /** 离开课堂 */
+    ON_CLASS_FINISHED: 'onClassFinished',
+};
+
+const LEVEL = {
+    error: 3,
+    warn: 2,
+    info: 1,
+    debug: 0,
+};
+
+module.exports = {
+    LESSON_TYPE,
+    ERROR_CODE,
+    CLASS_WINDOW_MESG_TYPE,
+    LEVEL
+};

package/js/common.js

@@ -0,0 +1,99 @@
+function versionComp(newVersion, oldVersion) {
+    const newVersionList = (newVersion || '0').split('.');
+    const oldVersionList = (oldVersion || '0').split('.');
+    const length = newVersionList.length > oldVersionList.length ? newVersionList.length : oldVersionList.length;
+    for (let i = 0; i < length; i++) {
+        const newVersionValue = newVersionList[i] == undefined ? 0 : parseInt(newVersionList[i]);
+        const oldVersionValue = oldVersionList[i] == undefined ? 0 : parseInt(oldVersionList[i]);
+        const res = newVersionValue - oldVersionValue;
+        if (res !== 0) {
+            return res;
+        }
+    }
+    return 0;
+}
+
+function getElectronRemote() {
+    let _remote;
+    try {
+        _remote = window.require('electron').remote;
+    } catch (e) {
+        try {
+            _remote = window.require('@electron/remote');
+        } catch (err) {
+            console.error(err);
+            throw new Error('illegal call, non electron environment');
+        }
+    }
+    return _remote;
+}
+
+function parseUrlParams(url) {
+    const params = {};
+    const queryString = url.split('?')[1];
+
+    if (!queryString) return params;
+
+    queryString.split('&').forEach((pair) => {
+        const [key, value] = pair.split('=');
+        let decodedValue = decodeURIComponent(value || '');
+        if (decodedValue === 'true' || decodedValue === 'false') {
+            decodedValue = decodedValue === 'true';
+        }
+        params[key] = decodedValue;
+    });
+
+    return params;
+}
+
+function getEnvironment(url) {
+    const host = url ?? location.host
+        .replace('wwwr', 'www')
+        .replace('devai', 'dev')
+        .replace('testai', 'test')
+        .replace('itestai', 'itest')
+        .replace('bai', 'b')
+        .replace('ai-cdn', 'www')
+        .replace('ai.', 'www.')
+        .toLocaleUpperCase();
+    const index = host.indexOf('.');
+    let environment = '';
+    //先根据url判断环境。这里single页面访问会用到
+    if (/^192\.|localhost/.test(host)) {
+        environment = 'local';
+    } else {
+        environment = host.substring(0, index);
+    }
+    return environment;
+}
+
+/**
+ * 获取当前BrowserWindow实例
+ */
+function getCurrentWindow() {
+  const remote = getElectronRemote();
+  if (remote) {
+      return remote.getCurrentWindow();
+  }
+}
+
+/**
+ * 获取窗口所属的屏幕（当应用跨屏幕时，应该属于占用面积超过一半的那块屏幕）
+ */
+function getDisplayMatching() {
+  const remote = getElectronRemote();
+  const currentWindow = getCurrentWindow();
+  if (remote && currentWindow) {
+      const { screen } = remote;
+      const currentWindowBounds = currentWindow.getBounds();
+      return screen.getDisplayMatching(currentWindowBounds);
+  }
+}
+
+module.exports = {
+    versionComp,
+    getElectronRemote,
+    parseUrlParams,
+    getEnvironment,
+    getDisplayMatching
+};

package/js/main.js

@@ -0,0 +1,23 @@
+const isElectron = !!process.versions['electron'];
+if (isElectron) {
+    try {
+        require('@plasosdk/winproxy');
+        require('@plasosdk/screenshot');
+        require('@plasosdk/rtmpplayer');
+
+        const { versionComp } = require('./common.js');
+        const electronVersion = process.versions['electron'];
+        const { app } = require('electron');
+
+        if (electronVersion && versionComp(electronVersion, '14.0.0') >= 0) {
+            const electronStore = require('@electron/remote/main');
+            const isInitialized = electronStore.isInitialized();
+            if (!isInitialized) electronStore.initialize();
+        }
+        // 首次添加此开关是为了解决一些GPU导致的渲染问题的，比如进课堂白屏，历史课堂播放进度条不动。
+        // 支持虚拟声卡需要添加此开关
+        app.commandLine.appendSwitch('--no-sandbox');
+    } catch (e) {
+        console.error(e);
+    }
+}

package/js/render.js

@@ -0,0 +1,210 @@
+const LogFormatter = require('../scripts/logger');
+const logger = new LogFormatter();
+logger.init();
+const getConfig = require('../scripts/getConfig');
+
+const { platform } = getConfig();
+
+const isMac = platform === 'darwin';
+
+const { ERROR_CODE, LESSON_TYPE, CLASS_WINDOW_MESG_TYPE } = require('./code');
+
+const { getElectronRemote, parseUrlParams, getEnvironment, getDisplayMatching } = require('./common');
+
+/**
+ * @typedef {Object} windowOptionType
+ * @property {boolean} [autoMaximized] - 控制窗口是否在初始化时自动最大化
+ * @property {boolean} [debug] - 是否开启课堂窗口debug模式
+ * @property {boolean} [fullScreenable] - 课堂最大化按钮是切换 全屏模式or最大化窗口
+ * @property {boolean} useTransparent - 是否开启透明窗口
+ * @property {string} [windowTopic] - 课堂窗口标题
+ */
+
+/**
+ * @typedef {Object} liveClassWindowType
+ * @property {string} classUrl
+ * @property {windowOptionType} windowOptions
+ * @property {Object} [electronWinOptions] 自定义electron自己的窗口参数
+ * @property {(winId: number)=>void} [onClassWindowReadyCb] 课堂窗口打开渲染成功后的回调
+ * @property {()=>void} [onClassWindowFinishedCb] 课堂窗口关闭后的回调
+ */
+
+/**
+ * @param {liveClassWindowType} liveClassWindowProps
+ * @returns
+ */
+function ceratLiveClassWindow({ classUrl, windowOptions, electronWinOptions, onClassWindowReadyCb, onClassWindowFinishedCb }) {
+  logger.info(`课堂窗口创建信息: classUrl is ${classUrl}, windowOptions is ${JSON.stringify(windowOptions)},electronWinOptions is ${JSON.stringify(electronWinOptions)}`);
+
+    const isElectron = !!process.versions['electron'];
+    if (isElectron) {
+        const appProxy = require('@plasosdk/winproxy');
+        const remote = getElectronRemote();
+        const displayInfo = getDisplayMatching();
+        const { ipcRenderer } = window.require('electron');
+
+        if (remote && displayInfo) {
+            const classInfo = parseUrlParams(classUrl);
+            let _path = classUrl;
+            const autoMaximized = windowOptions?.autoMaximized ?? true;
+            const _classInfo = {
+                customTitleBar: true,
+                maximized: autoMaximized,
+                /**
+                 * 传参数到课堂窗口，让课堂窗口执行全屏逻辑，没有直接使用BrowserWindow初始化参数中的fullscreen，
+                 * 直接使用BrowserWindow的fullscreen参数会有个问题，在windows上当任务栏隐藏状态的时候，进入课堂透明窗口的透明会失效，看到的是全黑的背景。
+                 * 猜测是electron内部全屏API调用太早导致的。
+                 *
+                 * 默认简单全屏进入课堂，保留顶部自定义的标题栏
+                 */
+                autoSimpleFullScreen: true,
+                fullScreenable: windowOptions?.fullScreenable ?? false,
+                ...classInfo,
+            };
+
+            const environment = getEnvironment(classUrl);
+            let rhost;
+            if (environment == 'local') {
+                rhost = 'http://127.0.0.1:4399/';
+            } else if (environment == 'dev' || environment == 'test' || environment == 'itest' || environment == 'ftest') {
+                rhost = `https://${environment}.plaso.cn/static/yxtsdk/`;
+            } else {
+                rhost = `https://wwwr.plaso.cn/static/sdk/styleupime/${classInfo.version}/`;
+            }
+            const dhost = classInfo.dhost;
+            const appinfo = {
+                appType: classInfo.appType ?? 'yxtlivesdk',
+                rhost: rhost,
+                dhost: dhost,
+                markString: environment,
+                env: classInfo.dev ?? environment,
+                clsinfo: JSON.stringify(_classInfo),
+                classType: classInfo.classType ?? LESSON_TYPE.LIVECLASS,
+                loggerPath: logger.loggerPath ?? '',
+                clientType: 'electron',
+                enableAgoraV4: true,
+            };
+            for (const key in appinfo) {
+                if (key && classInfo[key] === undefined) _path += `&${key}=${encodeURIComponent(appinfo[key])}`;
+            }
+            const win = remote.getCurrentWindow();
+            const webContents = remote.getCurrentWebContents();
+            _path += `&openerId=${webContents.id}`;
+
+            const bounds = win.getBounds();
+            const screenWidth = displayInfo.size.width;
+            const screenWorkAreaWidth = displayInfo.workAreaSize.width;
+            const screenHeight = displayInfo.size.height;
+            const screenWorkAreaHeight = displayInfo.workAreaSize.height;
+
+            const changeBoundsDate = (ischangeWidth, baseWidthOrHeight) => {
+                const newWidthOrHeight = baseWidthOrHeight - 10;
+                if (ischangeWidth) {
+                    bounds.height = Math.round((bounds.height * newWidthOrHeight) / bounds.width);
+                    bounds.width = newWidthOrHeight;
+                } else {
+                    bounds.width = Math.round((bounds.width * newWidthOrHeight) / bounds.height);
+                    bounds.height = newWidthOrHeight;
+                }
+            };
+            // 课堂窗口创建时的宽或高和 屏幕宽高或屏幕工作区宽高 一致时，此时透明窗口会失效，需要调整进课堂时的窗口宽高
+            if (bounds.width === screenWidth || bounds.width === screenWorkAreaWidth) {
+                changeBoundsDate(true, Math.min(screenWidth, screenWorkAreaWidth));
+            }
+            if (bounds.height === screenHeight || bounds.height === screenWorkAreaHeight) {
+                changeBoundsDate(false, Math.min(screenHeight, screenWorkAreaHeight));
+            }
+
+            const defaultElecteonWinOptions = {
+                frame: false,
+                /**
+                 * electron 12.0.18之后，resizable设为true才能全屏和最大化，
+                 * 而课堂窗口不允许通过electron自身的缩放行为来改变大小，因此进入课堂后会将resizable设为false
+                 */
+                resizable: true,
+                /** 设置为true，mac上setFullScreen(true)才生效，setSimpleFullScreen(true)不依赖此参数 */
+                fullscreenable: true,
+                ...bounds,
+                webPreferences: {
+                    nodeIntegration: true,
+                    enableRemoteModule: true,
+                    contextIsolation: false,
+                    nodeIntegrationInWorker: true,
+                },
+            };
+            if (isMac) {
+                // 在Mac下要显式设置fullscreen为false，防止客户端全屏时进入课堂，课堂窗口也默认全屏，
+                // 导致部分按钮失效，以及独立窗口打开异常
+                defaultElecteonWinOptions.fullscreen = false;
+            }
+            // 学生无需使用透明窗口（透明窗口问题多），减少影响
+            if (windowOptions?.useTransparent) {
+                defaultElecteonWinOptions.transparent = true;
+                defaultElecteonWinOptions.backgroundColor = '#00ffffff';
+            }
+            if (windowOptions?.windowTopic) defaultElecteonWinOptions.title = windowOptions.windowTopic;
+
+            const _electeonWinOptions = electronWinOptions
+                ? {
+                      ...defaultElecteonWinOptions,
+                      ...electronWinOptions,
+                  }
+                : defaultElecteonWinOptions;
+
+            if (_path) {
+                let currentWinId = null;
+
+                const onClassWindowReady = () => {
+                    logger.info(`课堂窗口ready，id:${currentWinId}`);
+                    if (onClassWindowReadyCb && currentWinId) onClassWindowReadyCb(currentWinId);
+                };
+
+                ipcRenderer.on(CLASS_WINDOW_MESG_TYPE.LIVE_WINDOW_READY, onClassWindowReady);
+                appProxy.createWindow(
+                    {
+                        path: _path,
+                        debug: windowOptions?.debug ?? false,
+                        maximize: autoMaximized,
+                        windowOptions: _electeonWinOptions,
+                    },
+                    async (id) => {
+                        currentWinId = id;
+                        appProxy.addWinEventListener(id, 'closed', () => {
+                            logger.info(`课堂窗口关闭，id:${currentWinId}`);
+
+                            currentWinId = null;
+                            if (onClassWindowFinishedCb) onClassWindowFinishedCb();
+                            ipcRenderer.removeListener(CLASS_WINDOW_MESG_TYPE.LIVE_WINDOW_READY, onClassWindowReady);
+                        });
+                    },
+                );
+            }
+        }
+    } else {
+        logger.error('非Electron环境');
+        return ERROR_CODE.NO_ELECTRON_ENVIRONMENT;
+    }
+}
+
+function getVersion() {
+    try {
+        const packageJson = require('../package.json');
+        return packageJson.version;
+    } catch (error) {
+        logger.error(`getVersion error is: ${JSON.stringify(error)}}`);
+        return ERROR_CODE.COMMOM_ERROR;
+    }
+}
+
+/** 日志文件地址 */
+function initLogConfig(logFilePath) {
+    logger.initLoggerFilePath(logFilePath);
+}
+
+const PlasoElectronSdk = {
+    ceratLiveClassWindow: ceratLiveClassWindow,
+    getVersion: getVersion,
+    initLogConfig: initLogConfig,
+};
+
+module.exports = PlasoElectronSdk;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@plasosdk/plaso-electron-sdk",
+  "version": "1.0.6",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "electron .",
+    "install": "npm run download",
+    "download": "node ./scripts/downloadPrebuild.js"
+  },
+  "keywords": [
+    "electron",
+    "windows",
+    "mac"
+  ],
+  "dependencies": {
+    "adm-zip": "^0.5.16",
+    "fs-extra": "^11.1.1",
+    "minimist": "^1.2.5"
+  },
+  "peerDependencies": {
+    "@electron/remote": ">=2.1.2",
+    "@plasosdk/plasoffmpeg": "^1.1.0",
+    "@plasosdk/rbtusbaddon": "^1.0.1",
+    "@plasosdk/rbtwifiaddon": "^1.0.2",
+    "@plasosdk/rtmpplayer": "^2.0.0",
+    "@plasosdk/screenshot": "^1.3.2",
+    "@plasosdk/winproxy": "^1.1.3"
+  },
+  "author": "",
+  "license": "ISC"
+}

package/readme.md

@@ -0,0 +1,65 @@
+# 支持的环境与electron版本
+
+- macOs支持 x64 、arm64
+- windows支持 ia32 、 x64
+- electron支持 12.0.18~22.3.27
+
+
+
+# 1、接入步骤
+
+## 1.1、下载
+
+
+
+
+
+
+
+# 2、进课堂参数说明
+
+## 2.1、窗口相关参数说明
+
+| 参数           | 类型    | 是否必传 | 默认值 | 说明                                                         |
+| -------------- | ------- | -------- | ------ | ------------------------------------------------------------ |
+| autoMaximized  | Boolean | 否       | true   | 控制窗口是否在初始化时自动最大化                             |
+| debug          | Boolean | 否       | false  | 是否开启课堂窗口debug模式                                    |
+| fullScreenable | Boolean | 否       | false  | true：课堂最大化按钮是切换全屏模式<br />false：课堂最大化按钮是最大化窗口；<br />建议仅学生和游客切换全屏，老师切换最大化 |
+| useTransparent | Boolean | 是       | false  | 是否开启透明窗口，影响新桌面共享的使用；<br />建议仅老师、助教开启； |
+| windowTopic    | string  | 否       | 无     | 课堂窗口标题                                                 |
+
+
+
+## 2.2、课堂相关参数说明
+
+| 参数      | 类型   | 是否必传 | 默认值      | 说明                                      |
+| --------- | ------ | -------- | ----------- | ----------------------------------------- |
+| version   | string | 是       | 无          | 指定课堂对应的web版本，格式为：x.xx.xxx； |
+| classType | string | 否       | ‘liveClass’ | 课堂窗口类型，暂仅支持 liveClass          |
+
+
+
+## 2.3、功能相关参数
+
+具体课堂内相关功能对应的参数见
+
+
+
+
+
+# 3、对外暴露的方法
+
+### 3.1、initLogConfig
+
+
+
+### 3.2、ceratLiveClassWindow
+
+
+
+### 3.3、getVersion
+
+
+
+# 4、错误code
+

package/scripts/downloadPrebuild.js

@@ -0,0 +1,133 @@
+/* eslint-disable camelcase */
+
+const path = require('path');
+const fs = require('fs-extra');
+const https = require('https');
+const { exec } = require('child_process');
+
+const AdmZip = require('adm-zip');
+
+const getConfig = require('./getConfig');
+const LogFormatter = require('./logger');
+const logger = new LogFormatter();
+
+const { platform, packageVersion, arch } = getConfig();
+
+const agora_electron_sdk_v4_x32_in_win32 =
+    'npm install agora-electron-sdk@4.2.6-build.153-rc.1 --agora_electron_sdk_arch=ia32 --agora_electron_sdk_platform=win32 --global-style --no-save --no-package-lock';
+const agora_electron_sdk_v4_x64_in_win32 =
+    'npm install agora-electron-sdk@4.2.6-build.153-rc.1 --agora_electron_sdk_arch=x64 --agora_electron_sdk_platform=win32 --global-style --no-save --no-package-lock';
+const agora_electron_sdk_v4_in_darwin =
+    'npm install agora-electron-sdk@4.2.6-build.153-rc.1 --agora_electron_sdk_arch=x64 --agora_electron_sdk_platform=darwin --global-style --no-save --no-package-lock';
+
+const trtc_electron_sdk_x32_in_win32 =
+    'npm install trtc-electron-sdk@11.8.112-beta.6 --trtc_electron_arch=ia32 --trtc_electron_platform=win32 --global-style --no-save --no-package-lock';
+const trtc_electron_sdk_x64_in_win32 =
+    'npm install trtc-electron-sdk@11.8.112-beta.6 --trtc_electron_arch=x64 --trtc_electron_platform=win32 --global-style --no-save --no-package-lock';
+const trtc_electron_sdk_in_darwin =
+    'npm install trtc-electron-sdk@11.8.112-beta.6 --trtc_electron_arch=x64 --trtc_electron_platform=darwin --global-style --no-save --no-package-lock';
+
+const PLATFORM_TYPE = {
+    DARWIN: 'darwin',
+    WIN32: 'win32',
+};
+
+const ARCH_TYPE = {
+    X64: 'x64',
+    IA32: 'ia32',
+    ARM64: 'arm64',
+};
+
+const oldAgoraV4Path = path.join(__dirname, '../node_modules', 'agora-electron-sdk');
+const newAgoraV4Path = path.join(__dirname, '../../../', 'agora-electron-sdk-v4');
+
+const oldTrtcPath = path.join(__dirname, '../node_modules', 'trtc-electron-sdk');
+const newTrtcPath = path.join(__dirname, '../../../', 'trtc-electron-sdk');
+
+const getFlameshotURL = () => {
+    let flameshotZipName = 'win_flameshot';
+    let flameshotZipUrl = 'https://hz-public-files.oss-cn-hangzhou.aliyuncs.com/static/flameshot/win_flameshot.zip';
+    if (platform === PLATFORM_TYPE.DARWIN) {
+        if (arch.includes('arm')) {
+            flameshotZipName = 'arm64_flameshot.app';
+            flameshotZipUrl = 'https://hz-public-files.oss-cn-hangzhou.aliyuncs.com/static/flameshot/arm64_flameshot.app.zip';
+        } else {
+            flameshotZipName = 'x64_flameshot.app';
+            flameshotZipUrl = 'https://hz-public-files.oss-cn-hangzhou.aliyuncs.com/static/flameshot/x64_flameshot.app.zip';
+        }
+    }
+    return [flameshotZipUrl, flameshotZipName];
+};
+
+const npmInstallRtc = () => {
+    let agora_electron_sdk_v4 = agora_electron_sdk_v4_x32_in_win32;
+    let trtc_electron_sdk = trtc_electron_sdk_x32_in_win32;
+    if (platform === PLATFORM_TYPE.DARWIN) {
+        agora_electron_sdk_v4 = agora_electron_sdk_v4_in_darwin;
+        trtc_electron_sdk = trtc_electron_sdk_in_darwin;
+    } else if (arch === ARCH_TYPE.X64) {
+        agora_electron_sdk_v4 = agora_electron_sdk_v4_x64_in_win32;
+        trtc_electron_sdk = trtc_electron_sdk_x64_in_win32;
+    }
+
+    const installCb = (url, error, stdout, stderr) => {
+        logger.info(`installCb 信息: ${url}, ${error?.message}, ${stdout}, ${stderr}`);
+    };
+    exec(agora_electron_sdk_v4, async (error, stdout, stderr) => {
+        installCb(agora_electron_sdk_v4, error, stdout, stderr);
+        fs.move(oldAgoraV4Path, newAgoraV4Path, { overwrite: true }, (err) => {
+            if (!err) {
+                logger.info('更新agora_electron_sdk_v4成功');
+            }
+        });
+    });
+    exec(trtc_electron_sdk, (error, stdout, stderr) => {
+        installCb(trtc_electron_sdk, error, stdout, stderr);
+        fs.move(oldTrtcPath, newTrtcPath, { overwrite: true }, (err) => {
+            if (!err) {
+                logger.info('移动trtc_electron_sdk成功');
+            }
+        });
+    });
+};
+
+const downloadFile = (fileUrl, downloadFilePath, outputFilePath) => {
+    logger.info(`will downloadFile: ${fileUrl}, downloadFilePath is ${downloadFilePath}, outputFilePath is ${outputFilePath}`);
+    https
+        .get(fileUrl, (response) => {
+            const file = fs.createWriteStream(downloadFilePath);
+            response.pipe(file);
+            file.on('finish', () => {
+                file.close(() => {
+                    logger.info(`文件${fileUrl}写入完成`);
+                    // 解压缩
+                    if (outputFilePath) {
+                        const zip = new AdmZip(downloadFilePath);
+                        zip.extractAllTo(outputFilePath, true);
+                        logger.info(`文件${fileUrl}解压完成`);
+                        fs.unlink(downloadFilePath, () => {});
+                    }
+                });
+            });
+        })
+        .on('error', (err) => {
+            // 删除不完整的文件
+            fs.unlink(downloadFilePath, () => {});
+            logger.error(`文件${fileUrl}下载失败，删除不完整的文件`, err.message);
+        });
+};
+
+const downloadPrebuild = async () => {
+    npmInstallRtc();
+    const [flameshotUrl, flameshotZipName] = getFlameshotURL();
+
+    /** start download */
+    logger.info('Package Version: %s', packageVersion);
+    logger.info('Platform: %s', platform);
+    if (arch) logger.info('Arch: %s', arch);
+    const flameshotFilePath = path.join(__dirname, `../lib/${flameshotZipName}.zip`);
+    const flameshotZipOutputDir = path.join(__dirname, '../lib');
+
+    downloadFile(flameshotUrl, flameshotFilePath, flameshotZipOutputDir);
+};
+downloadPrebuild();

package/scripts/getConfig.js

@@ -0,0 +1,26 @@
+
+const LogFormatter = require('./logger');
+const path = require('path');
+
+const minimist = require('minimist');
+const logger = new LogFormatter();
+
+
+const { INIT_CWD } = minimist(process.argv.slice(2));
+logger.info(`pass INIT_CWD ${INIT_CWD}`);
+logger.info(`__dirname ${__dirname}`);
+
+const getConfig = () => {
+    const { version } = require(path.join(__dirname, '../package.json'));
+    var os = require('os');
+    const platform = process.env.npm_config_plaso_electron_sdk_platform || os.platform();
+    const arch = process.env.npm_config_plaso_electron_sdk_arch || os.arch();
+    logger.info(`platform is ${platform}, arch is ${arch}`);
+
+    return {
+        platform,
+        arch,
+        packageVersion: version,
+    };
+};
+module.exports = getConfig;

package/scripts/logger.js

@@ -0,0 +1,138 @@
+const { LEVEL } = require('../js/code');
+const LEVEL_FORMAT_LENGTH = Math.max(...Object.keys(LEVEL).map((key) => key.length)) + 1;
+
+class LogFormatter {
+    constructor(loggerPath) {
+        this.loggerPath = loggerPath ? loggerPath.replace(/\\/g, '/') : '';
+        this.fs;
+        this.util;
+        this.newLogTime;
+        this.ws = null;
+    }
+
+    init() {
+        try {
+            this.fs = window.require('fs');
+            this.util = window.require('util');
+
+            const process = window.require('process');
+            process.on('uncaughtException', (error) => this.write(LEVEL.error, error ? error.stack : {}));
+        } catch (error) {
+            console.error('log error', error);
+        }
+    }
+
+    initLoggerFilePath(_loggerPath) {
+        this.loggerPath = _loggerPath ? _loggerPath.replace(/\\/g, '/') : '';
+    }
+
+    createWS() {
+        if (this.fs && this.loggerPath && this.newLogTime) {
+            const logFileName = `${this.loggerPath}/plasoElectronSdk_${this.newLogTime}.log`;
+            this.ws = this.fs.createWriteStream(logFileName, { flags: 'a' });
+            this.ws.write(`Start log: ${new Date()}\n\n`);
+        }
+    }
+
+    _writeLog(prefix, logContent) {
+        if (this.ws) {
+            this.ws.write(prefix);
+            this.ws.write(logContent);
+            this.ws.write('\n');
+        }
+    }
+
+    write(level, ...format) {
+        try {
+            if (!this.fs || !this.util) {
+                return;
+            }
+            const today = new Date();
+            const newLogTime = `${today.getFullYear()}-${today.getMonth() + 1}-${today.getDate()}`;
+            if (newLogTime !== this.newLogTime) {
+                this.newLogTime = newLogTime;
+                if (this.ws !== null) {
+                    this.ws.end();
+                    this.ws = null;
+                }
+            }
+            if (this.ws == null) {
+                this.createWS();
+            }
+            const maxContentSize = 10 * 1024;
+            let logContent = this.util.format(...format);
+            const logContentSize = logContent.length;
+            // 单条日志长度超过10K则进行截取
+            if (logContentSize > maxContentSize) {
+                logContent =
+                    logContent.slice(0, maxContentSize) +
+                    ` <<< more (${((logContentSize - maxContentSize) / 1024).toFixed(1)}KB)`;
+            }
+            const logTime = `[${today.toLocaleTimeString('en-US', { hour12: false })}.${today
+                .getMilliseconds()
+                .toString()
+                .padStart(3, '0')}]`;
+            let logLevel = '';
+            switch (level) {
+                case LEVEL.ERROR:
+                    logLevel = 'ERROR';
+                    break;
+                case LEVEL.WARN:
+                    logLevel = 'WARN';
+                    break;
+                case LEVEL.INFO:
+                    logLevel = 'INFO';
+                    break;
+                case LEVEL.DEBUG:
+                    logLevel = 'DEBUG';
+                    break;
+            }
+            const prefix = `${logLevel.padEnd(LEVEL_FORMAT_LENGTH, ' ')} ${logTime}  `;
+
+            this._writeLog(prefix, logContent);
+        } catch (e) {
+            console.error('log write error', e);
+        }
+    }
+
+    /**
+     * @param {any[]} content
+     */
+    info(...content) {
+        this.log('info', ...content);
+    }
+
+    /**
+     * @param {any[]} content
+     */
+    debug(...content) {
+        this.log('debug', ...content);
+    }
+    /**
+     * @param {any[]} content
+     */
+    warn(...content) {
+        this.log('warn', ...content);
+    }
+    /**
+     * @param {any[]} content
+     */
+    error(...content) {
+        this.log('error', ...content);
+    }
+
+    /**
+     * @private
+     * @param {'info' | 'debug' | 'error' | 'warn'} level
+     * @param {any[]} content
+     */
+    log(level, ...content) {
+        if (this.loggerPath) {
+            this.write(LEVEL[level], ...content);
+        } else {
+            console[level](...content);
+        }
+    }
+}
+
+module.exports = LogFormatter;