fcr-ui-scene 3.8.1 → 3.8.2

package/lib-es/electron/ipc/ipc.js

@@ -0,0 +1,134 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import "core-js/modules/es.error.to-string.js";
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.date.to-json.js";
+import "core-js/modules/es.date.to-string.js";
+import "core-js/modules/es.json.stringify.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.regexp.to-string.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/esnext.json.parse.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import { createConnection } from 'net';
+import EventEmitter from 'events';
+import { getLogger } from '../logger';
+export var IPCClient = /*#__PURE__*/function () {
+  function IPCClient(_ref) {
+    var _this = this;
+    var port = _ref.port;
+    _classCallCheck(this, IPCClient);
+    _defineProperty(this, "_logger", getLogger());
+    _defineProperty(this, "_observable", new EventEmitter());
+    _defineProperty(this, "_buffer", Buffer.alloc(0));
+    _defineProperty(this, "_handleMessage", function (message) {
+      _this._logger.log('IPC SOCKET: Received message:', message);
+      try {
+        var parsedMessage = JSON.parse(message);
+        _this._observable.emit('onMessageReceived', parsedMessage);
+      } catch (error) {
+        _this._logger.error('IPC SOCKET: Error parsing message:', error);
+      }
+    });
+    _defineProperty(this, "_handleError", function (error) {
+      _this._logger.error('IPC SOCKET: Error:', error);
+      _this._observable.emit('onError', error);
+    });
+    this._logger.info('IPC SOCKET: initialize tcp connection', 'port:', port);
+    this._socket = createConnection({
+      port: port,
+      timeout: 5000,
+      host: '127.0.0.1'
+    }, function () {
+      _this._logger.info("IPC SOCKET: connected to server!remote info:".concat(JSON.stringify(_this._socket), ",remote address:").concat(_this._socket.remoteAddress, ",remote port:").concat(_this._socket.remotePort));
+    });
+    this._socket.on('end', function () {
+      _this._logger.info('IPC SOCKET: disconnected from server');
+    });
+    this._socket.on('close', function () {
+      _this._logger.info('IPC SOCKET: disconnected from server');
+      _this._observable.emit('onDisconnected');
+    });
+    this._socket.on('data', function (data) {
+      _this._logger.info("IPC SOCKET: received data,this.socket.remoteAddress:".concat(_this._socket.remoteAddress, ",this.socket").concat(JSON.stringify(_this._socket)));
+      // 将新数据追加到现有缓冲区
+      _this._buffer = Buffer.concat([_this._buffer, data]);
+      // 处理可能的多条消息
+      _this._processBuffer();
+    });
+    this._socket.on('error', function (error) {
+      _this._logger.error('IPC SOCKET: Socket error:', error);
+      _this._handleError(error);
+    });
+  }
+  return _createClass(IPCClient, [{
+    key: "_processBuffer",
+    value: function _processBuffer() {
+      // 循环处理缓冲区中的所有完整消息
+      while (this._buffer.length >= 4) {
+        // 读取消息长度
+        var messageLength = this._buffer.readUInt32BE(0);
+
+        // 检查是否有完整的消息
+        if (this._buffer.length >= messageLength + 4) {
+          // 提取消息内容（跳过4字节长度前缀）
+          var messageContent = this._buffer.slice(4, messageLength + 4);
+          // 更新缓冲区，移除已处理的消息
+          this._buffer = this._buffer.slice(messageLength + 4);
+
+          // 处理消息
+          var message = messageContent.toString();
+          this._handleMessage(message);
+        } else {
+          // 消息不完整，等待更多数据
+          break;
+        }
+      }
+    }
+  }, {
+    key: "sendMessage",
+    value: function sendMessage(message) {
+      var _this2 = this;
+      var messageString = JSON.stringify(message);
+      // 1. 创建包含消息长度的buffer(4字节)
+      var lengthBuffer = Buffer.alloc(4);
+      // 2. 以大端序(网络字节序)写入消息长度
+      var messageBuffer = Buffer.from(messageString);
+      lengthBuffer.writeUInt32BE(messageBuffer.length, 0);
+      // 3. 先发送长度，再发送消息内容
+
+      this._socket.write(Buffer.concat([lengthBuffer, Buffer.from(messageString)]), function (error) {
+        if (error) {
+          _this2._logger.error('IPC SOCKET: Error sending message:', error);
+        } else {
+          _this2._logger.log('IPC SOCKET: Message sent:', messageString);
+        }
+      });
+    }
+  }, {
+    key: "addObserver",
+    value: function addObserver(observer) {
+      var _this3 = this;
+      Object.keys(observer).forEach(function (eventKey) {
+        if (typeof observer[eventKey] === 'function') {
+          _this3._observable.on(eventKey, observer[eventKey]);
+        }
+      });
+    }
+  }, {
+    key: "removeObserver",
+    value: function removeObserver(observer) {
+      var _this4 = this;
+      Object.keys(observer).forEach(function (eventKey) {
+        if (typeof observer[eventKey] === 'function') {
+          _this4._observable.off(eventKey, observer[eventKey]);
+        }
+      });
+    }
+  }]);
+}();

package/lib-es/electron/ipc/type.js

@@ -0,0 +1,22 @@
+export var IPCMessageCMD = /*#__PURE__*/function (IPCMessageCMD) {
+  // send
+  IPCMessageCMD["ElectronMainWindowLoaded"] = "electron-main-window-loaded";
+  IPCMessageCMD["LaunchSuccess"] = "launch-meeting-success";
+  IPCMessageCMD["LaunchFailure"] = "launch-meeting-failure";
+  IPCMessageCMD["ExitedMeeting"] = "exited-meeting";
+  IPCMessageCMD["WidgetClicked"] = "widget-clicked";
+  IPCMessageCMD["TokenWillExpire"] = "user-token-will-expire";
+  IPCMessageCMD["ExitUiSceneFromMainProcess"] = "exit-ui-scene-from-main-process";
+  IPCMessageCMD["Error"] = "error";
+  IPCMessageCMD["CurrentDependencyVersions"] = "current-dependency-versions";
+  // handle
+  IPCMessageCMD["LaunchMeeting"] = "launch-meeting";
+  IPCMessageCMD["InitCreator"] = "init-creator";
+  IPCMessageCMD["OpenSetting"] = "open-setting";
+  IPCMessageCMD["CloseSetting"] = "close-setting";
+  IPCMessageCMD["SetParameters"] = "set-parameters";
+  IPCMessageCMD["RenewUserToken"] = "renew-user-token";
+  IPCMessageCMD["ExitUiScene"] = "exit-ui-scene";
+  IPCMessageCMD["GetDependencyVersions"] = "get-dependency-versions";
+  return IPCMessageCMD;
+}({});

package/lib-es/electron/ipc-protocol.js

@@ -0,0 +1,58 @@
+/**
+ * BrowserWindow IPC 通信协议
+ */
+export var BrowserWindowIPCAction = /*#__PURE__*/function (BrowserWindowIPCAction) {
+  // 窗口操作
+  BrowserWindowIPCAction["MOVE_TOP"] = "browser-window:move-top";
+  BrowserWindowIPCAction["CLOSE"] = "browser-window:close";
+  BrowserWindowIPCAction["SHOW"] = "browser-window:show";
+  BrowserWindowIPCAction["HIDE"] = "browser-window:hide";
+  BrowserWindowIPCAction["FOCUS"] = "browser-window:focus";
+  BrowserWindowIPCAction["MAXIMIZE"] = "browser-window:maximize";
+  BrowserWindowIPCAction["UNMAXIMIZE"] = "browser-window:unmaximize";
+  // 窗口状态查询
+  BrowserWindowIPCAction["IS_VISIBLE"] = "browser-window:is-visible";
+  BrowserWindowIPCAction["IS_MAXIMIZED"] = "browser-window:is-maximized";
+  BrowserWindowIPCAction["IS_FULLSCREEN"] = "browser-window:is-fullscreen";
+  BrowserWindowIPCAction["GET_TITLE"] = "browser-window:get-title";
+  BrowserWindowIPCAction["GET_BOUNDS"] = "browser-window:get-bounds";
+  BrowserWindowIPCAction["GET_POSITION"] = "browser-window:get-position";
+  // 窗口设置
+  BrowserWindowIPCAction["SET_POSITION"] = "browser-window:set-position";
+  BrowserWindowIPCAction["SET_BOUNDS"] = "browser-window:set-bounds";
+  BrowserWindowIPCAction["SET_FULLSCREEN"] = "browser-window:set-fullscreen";
+  BrowserWindowIPCAction["SET_IGNORE_MOUSE_EVENTS"] = "browser-window:set-ignore-mouse-events";
+  BrowserWindowIPCAction["SET_ALWAYS_ON_TOP"] = "browser-window:set-always-on-top";
+  BrowserWindowIPCAction["SET_PREVENT_CLOSE"] = "browser-window:set-prevent-close";
+  // 窗口事件监听
+  BrowserWindowIPCAction["REGISTER_EVENT_LISTENER"] = "browser-window:register-event-listener";
+  BrowserWindowIPCAction["UNREGISTER_EVENT_LISTENER"] = "browser-window:unregister-event-listener";
+  // 窗口事件通知（主进程 -> 渲染进程）
+  BrowserWindowIPCAction["EVENT_SHOW"] = "browser-window:event:show";
+  BrowserWindowIPCAction["EVENT_HIDE"] = "browser-window:event:hide";
+  BrowserWindowIPCAction["EVENT_RESIZED"] = "browser-window:event:resized";
+  BrowserWindowIPCAction["EVENT_MOVED"] = "browser-window:event:moved";
+  BrowserWindowIPCAction["EVENT_CLOSE"] = "browser-window:event:close";
+  BrowserWindowIPCAction["EVENT_CLOSED"] = "browser-window:event:closed";
+  BrowserWindowIPCAction["EVENT_FOCUS"] = "browser-window:event:focus";
+  BrowserWindowIPCAction["EVENT_BLUR"] = "browser-window:event:blur";
+  return BrowserWindowIPCAction;
+}({});
+
+/**
+ * IPC 请求参数类型
+ */
+
+/**
+ * IPC 响应类型
+ * Note: With invoke pattern, success/error is handled by promise resolution/rejection
+ * This interface is kept for backward compatibility in the proxy layer
+ */
+
+/**
+ * 窗口事件通知类型
+ */
+
+/**
+ * 具体操作的参数类型
+ */

package/lib-es/electron/logger.js

@@ -0,0 +1,57 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.array.push.js";
+import { app } from 'electron';
+import winston from 'winston';
+import path from 'path';
+var _winston$format = winston.format,
+  combine = _winston$format.combine,
+  timestamp = _winston$format.timestamp,
+  printf = _winston$format.printf;
+var LoggerManager = /*#__PURE__*/function () {
+  function LoggerManager() {
+    _classCallCheck(this, LoggerManager);
+    this.initialize({
+      logFilePath: path.resolve(app.getPath('logs'), 'logs', 'agora-main.log'),
+      console: true
+    });
+  }
+  return _createClass(LoggerManager, [{
+    key: "initialize",
+    value: function initialize(options) {
+      var logFilePath = options.logFilePath,
+        enableConsole = options.console;
+      var transports = [];
+      if (logFilePath) {
+        transports.push(new winston.transports.File({
+          filename: logFilePath,
+          maxFiles: 5,
+          maxsize: 1048576 //1MB
+        }));
+      }
+      if (enableConsole) {
+        transports.push(new winston.transports.Console());
+      }
+      this._logger = winston.createLogger({
+        level: 'info',
+        format: combine(timestamp(), printf(function (_ref) {
+          var level = _ref.level,
+            message = _ref.message,
+            timestamp = _ref.timestamp;
+          return "".concat(timestamp, " [").concat(level, "]: ").concat(message);
+        })),
+        transports: transports
+      });
+    }
+  }, {
+    key: "getLogger",
+    value: function getLogger() {
+      return this._logger;
+    }
+  }]);
+}();
+var loggerManager = new LoggerManager();
+export var getLogger = function getLogger() {
+  return loggerManager.getLogger();
+};

package/lib-es/electron/main.js

@@ -0,0 +1,116 @@
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/web.timers.js";
+import { listenScreenshot } from './plugins/screenshot';
+import { getLogger } from './logger';
+import { listenMeetingState } from './plugins/meeting-state';
+// import { FcrUIDialogKey } from '../utilities/constant';
+import { browserWindowIPCHandler } from './window-proxy/main-process-handler';
+var logger = getLogger();
+export var hookWindow = function hookWindow(mainWindow) {
+  // 设置主窗口，所有事件通知都通过主窗口发送
+  browserWindowIPCHandler.setMainWindow(mainWindow);
+  browserWindowIPCHandler.registerWindow("".concat(mainWindow.id), mainWindow, 'main');
+  mainWindow.webContents.addListener('did-create-window', function (window, details) {
+    logger.info("browser window is opened, frameName: ".concat(details.frameName, ", windowId: ").concat(window.id));
+
+    // const builtinFrameNames = Object.values(FcrUIDialogKey) as string[];
+
+    // if (!builtinFrameNames.includes(details.frameName) && !details.frameName.startsWith('widget')) {
+    //   logger.info(`frameName [${details.frameName}] is not builtin frame, ignore it`);
+    //   return;
+    // }
+
+    browserWindowIPCHandler.registerWindow("".concat(window.id), window, details.frameName);
+
+    // 监听渲染进程崩溃事件
+    // window.webContents.addListener('render-process-gone', (event, details) => {
+    //   // 安全地获取 window 信息，避免在崩溃状态下访问可能失效的属性
+    //   let windowTitle = 'Unknown';
+    //   let windowId = 'Unknown';
+
+    //   try {
+    //     // 检查 window 是否仍然有效
+    //     if (!window.isDestroyed()) {
+    //       windowTitle = window.getTitle() || 'Unknown';
+    //       windowId = String(window.id);
+    //     }
+    //   } catch (error) {
+    //     logger.warn(`failed to get window info during crash: ${error}`);
+    //   }
+
+    //   // 输出详细的崩溃信息
+    //   logger.error(
+    //     `window crash details - title: ${windowTitle}, id: ${windowId}, exitCode: ${details.exitCode}, reason: ${details.reason}`,
+    //   );
+
+    //   // logger.error('exiting process due to render-process-gone event');
+
+    //   // app.exit(AppExitCode.RENDERER_PROCESS_GONE);
+    // });
+  });
+  mainWindow.webContents.setWindowOpenHandler(function (details) {
+    return {
+      action: 'allow',
+      overrideBrowserWindowOptions: {
+        webPreferences: {
+          backgroundThrottling: false,
+          contextIsolation: true,
+          nodeIntegration: false
+        }
+      }
+    };
+  });
+  mainWindow.webContents.addListener('render-process-gone', function (event, details) {
+    // 安全地获取主窗口信息，避免在崩溃状态下访问可能失效的属性
+    var mainWindowTitle = 'Main Window';
+    var mainWindowId = 'Unknown';
+    try {
+      // 检查主窗口是否仍然有效
+      if (!mainWindow.isDestroyed()) {
+        mainWindowTitle = mainWindow.getTitle() || 'Main Window';
+        mainWindowId = String(mainWindow.id);
+      }
+    } catch (error) {
+      logger.warn("failed to get main window info during crash: ".concat(error));
+    }
+    logger.info("main browser window render-process-gone, window [".concat(mainWindowTitle, ":").concat(mainWindowId, "], details.exitCode: ").concat(details.exitCode, ", details.reason: ").concat(details.reason));
+    setTimeout(function () {
+      logger.info('start reloading main window...');
+      try {
+        // 如果窗口被杀死，则不重新加载,
+        // 在C++中，15s没链接成功会kill掉进程，这个捕捉到kill之后不应该重新加载了，否则会重新创建窗口，导致pid不一致
+        if (!mainWindow.isDestroyed() && details.reason !== 'killed') {
+          mainWindow.reload();
+          mainWindow.show();
+          mainWindow.focus();
+        }
+      } catch (error) {
+        logger.error("failed to reload main window: ".concat(error));
+      }
+    }, 1000);
+  });
+  mainWindow.on('enter-full-screen', function () {
+    mainWindow.webContents.send('custom-event', {
+      action: 'ENTER_FULL_SCREEN'
+    });
+    logger.info('main window enter-full-screen');
+  });
+  mainWindow.on('leave-full-screen', function () {
+    mainWindow.webContents.send('custom-event', {
+      action: 'LEAVE_FULL_SCREEN'
+    });
+    logger.info('main window leave-full-screen');
+  });
+
+  // 每次页面开始加载（无论是刷新还是跳转）
+  mainWindow.webContents.on('did-start-loading', function () {
+    logger.info('main window did-start-loading');
+  });
+
+  // 当刷新完成，页面加载完成时
+  mainWindow.webContents.on('did-finish-load', function () {
+    logger.info('main window did-finish-load');
+  });
+  listenScreenshot(mainWindow);
+  listenMeetingState(mainWindow);
+};

package/lib-es/electron/plugins/devtool-shortcut.js

@@ -0,0 +1,26 @@
+import { globalShortcut } from 'electron';
+import { getLogger } from '../logger';
+var logger = getLogger();
+export var listenDevToolShortcut = function listenDevToolShortcut(window) {
+  globalShortcut.register('CommandOrControl+Shift+X', function () {
+    if (window.isFocused()) {
+      logger.info('CommandOrControl+Shift+X is pressed');
+      window.webContents.openDevTools({
+        mode: 'detach'
+      });
+    }
+  });
+  globalShortcut.register('CommandOrControl+Shift+R', function () {
+    if (window.isFocused()) {
+      logger.info('CommandOrControl+Shift+R is pressed');
+      window.webContents.reloadIgnoringCache();
+    }
+  });
+  logger.info("CommandOrControl+Shift+X is ".concat(globalShortcut.isRegistered('CommandOrControl+Shift+X') ? 'registered' : 'not registered', " "));
+  logger.info("CommandOrControl+Shift+R is ".concat(globalShortcut.isRegistered('CommandOrControl+Shift+R') ? 'registered' : 'not registered', " "));
+  var unregister = function unregister() {
+    globalShortcut.unregister('CommandOrControl+Shift+X');
+    globalShortcut.unregister('CommandOrControl+Shift+R');
+  };
+  window.addListener('closed', unregister);
+};

package/lib-es/electron/plugins/meeting-state.js

@@ -0,0 +1,32 @@
+import "core-js/modules/es.array.concat.js";
+import { ipcMain, powerSaveBlocker } from 'electron';
+import { getLogger } from '../logger';
+var logger = getLogger();
+export var isInMeeting = 0;
+export var listenMeetingState = function listenMeetingState(window) {
+  var saveBlockerId = 0;
+  ipcMain.addListener('set-in-meeting-state', function (_, state) {
+    isInMeeting = state;
+    logger.info('in-meeting state changed', state);
+    if (state === 1) {
+      if (!powerSaveBlocker.isStarted(saveBlockerId)) {
+        saveBlockerId = powerSaveBlocker.start('prevent-display-sleep');
+        logger.info("power save blocker is started, blocker id: ".concat(saveBlockerId));
+      }
+    } else {
+      if (powerSaveBlocker.isStarted(saveBlockerId)) {
+        var isStopped = powerSaveBlocker.stop(saveBlockerId);
+        logger.info("power save blocker is stopped, blocker id: ".concat(saveBlockerId, ", isStopped: ").concat(isStopped));
+      }
+    }
+  });
+  window.addListener('close', function (event) {
+    if (isInMeeting === 1) {
+      event.preventDefault();
+      window.webContents.send('custom-event', {
+        action: 'CALL_CLOSE_MAIN_WINDOW',
+        payload: window.id
+      });
+    }
+  });
+};

package/lib-es/electron/plugins/screenshot.js

@@ -0,0 +1,46 @@
+import "core-js/modules/web.timers.js";
+import { ipcMain } from 'electron';
+import Screenshots from 'electron-screenshots';
+export var listenScreenshot = function listenScreenshot(window) {
+  var shortcutCapture = new Screenshots();
+  var isCapturing = false,
+    module = '',
+    alwaysHide = false;
+  var timer = null;
+  var stopScreen = function stopScreen() {
+    !alwaysHide && window.setOpacity(1);
+    isCapturing = false;
+    timer && clearTimeout(timer);
+  };
+  shortcutCapture.on('ok', function () {
+    stopScreen();
+  });
+  shortcutCapture.on('finish', function () {
+    stopScreen();
+  });
+  shortcutCapture.on('cancel', function () {
+    stopScreen();
+  });
+  shortcutCapture.on('save', function () {
+    stopScreen();
+  });
+  var showScreenShot = function showScreenShot() {
+    if (shortcutCapture) {
+      shortcutCapture.startCapture();
+    }
+  };
+  ipcMain.addListener('short-cut-capture', function (_, event, payload) {
+    if (!isCapturing) {
+      isCapturing = true;
+      var hideWindow = false;
+      hideWindow = payload.hideWindow;
+      module = payload.module;
+      alwaysHide = !!(payload !== null && payload !== void 0 && payload.alwaysHide);
+      hideWindow && window.setOpacity(0);
+      if (!shortcutCapture) {
+        shortcutCapture = new Screenshots();
+      }
+      timer = setTimeout(showScreenShot, 500);
+    }
+  });
+};

package/lib-es/electron/preload.js

@@ -0,0 +1,42 @@
+import { openDirectory, openLinkInDefaultBrowser, sendEvent, setFragmentOptions, showItemInFolder, addEventListener, removeEventListener, open, close, captureScreen, getBaseUrl, openRendererWindow, quitApp, getNetworkType, setFragmentBaseUrl, getMediaSourceIdList, restartApp, checkMediaPermission, openSystemPreferences, getUserSettingData, setUserSettingData, getCursorScreenPoint, getDisplayMatching, getAllDisplays, getPrimaryDisplay, getDisplayNearestPoint, fileToBlob, downloadAndExtractResourceFileFromZip, downloadResourceFile, loadBuiltinResources, getSystemCpuInfo, getSystemMemorySize, getCurrentBrowserWindow, createBrowserWindowProxy, getBrowserWindowById } from './injections';
+var runtime = {
+  open: open,
+  close: close,
+  openRendererWindow: openRendererWindow,
+  sendEvent: sendEvent,
+  addEventListener: addEventListener,
+  removeEventListener: removeEventListener,
+  captureScreen: captureScreen,
+  setFragmentOptions: setFragmentOptions,
+  openLinkInDefaultBrowser: openLinkInDefaultBrowser,
+  openDirectory: openDirectory,
+  showItemInFolder: showItemInFolder,
+  quitApp: quitApp,
+  getBaseUrl: getBaseUrl,
+  getNetworkType: getNetworkType,
+  setFragmentBaseUrl: setFragmentBaseUrl,
+  getMediaSourceIdList: getMediaSourceIdList,
+  restartApp: restartApp,
+  checkMediaPermission: checkMediaPermission,
+  openSystemPreferences: openSystemPreferences,
+  getUserSettingData: getUserSettingData,
+  setUserSettingData: setUserSettingData,
+  getCursorScreenPoint: getCursorScreenPoint,
+  getDisplayMatching: getDisplayMatching,
+  getAllDisplays: getAllDisplays,
+  getPrimaryDisplay: getPrimaryDisplay,
+  getDisplayNearestPoint: getDisplayNearestPoint,
+  fileToBlob: fileToBlob,
+  downloadAndExtractResourceFileFromZip: downloadAndExtractResourceFileFromZip,
+  downloadResourceFile: downloadResourceFile,
+  loadBuiltinResources: loadBuiltinResources,
+  getSystemCpuInfo: getSystemCpuInfo,
+  getSystemMemorySize: getSystemMemorySize,
+  getCurrentBrowserWindow: getCurrentBrowserWindow,
+  createBrowserWindowProxy: createBrowserWindowProxy,
+  getBrowserWindowById: getBrowserWindowById
+};
+
+// @ts-ignore
+window.runtime = runtime;
+import './sdk-helper';

package/lib-es/electron/process-manager/constants.js

@@ -0,0 +1 @@
+export var DEFAULT_TIMEOUT = 300;