@lvce-editor/main-process 6.12.0 → 6.14.0

package/dist/mainProcessMain.js

@@ -5,10 +5,10 @@ import { fileURLToPath } from 'node:url';
 import { inspect } from 'node:util';
 import { spawn } from 'node:child_process';
 import { Console } from 'node:console';
-import { createWriteStream, readFileSync, openAsBlob, existsSync, mkdirSync, openSync, writeSync, closeSync, rmSync } from 'node:fs';
-import { tmpdir, homedir } from 'node:os';
+import { mkdirSync, createWriteStream, readFileSync, openAsBlob, existsSync, writeFileSync, rmSync, openSync, writeSync, closeSync } from 'node:fs';
 import * as NodePath from 'node:path';
 import { dirname, join as join$1 } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
 import { MessageChannel } from 'node:worker_threads';
 
 const scheme = 'lvce-oss';
@@ -778,53 +778,92 @@ const getNewLineIndex$2 = (string, startIndex = undefined) => {
   return string.indexOf('\n', startIndex);
 };
 
+const join = (...paths) => {
+  return NodePath.join(...paths);
+};
+
+const __dirname$1 = dirname(fileURLToPath(import.meta.url));
+const root = process.env.LVCE_ROOT || join(__dirname$1, '../../../../..');
+
+const {
+  env,
+  platform
+} = process;
+const isLinux = platform === 'linux';
+const isProduction = false;
+const homeDirectory = homedir();
+
+const xdgCache = env.XDG_CACHE_HOME || (homeDirectory ? join(homeDirectory, '.cache') : undefined);
+const xdgData = env.XDG_DATA_HOME || (homeDirectory ? join(homeDirectory, '.local', 'share') : undefined);
+join(xdgData || tmpdir(), applicationName);
+const xdgState = env.XDG_STATE_HOME || (homeDirectory ? join(homeDirectory, '.local', 'state') : undefined);
+const logsDir = join(xdgState || tmpdir(), applicationName, 'logs');
+const chromeUserDataPath = xdgCache ? join(xdgCache, applicationName, 'userdata') : '';
+
+const useIpcForResponse = true;
+const getSessionId = () => {
+  return process.env.SESSION_ID || `persist:${scheme}`;
+};
+const getSharedProcessPath = () => {
+  if (process.env.LVCE_SHARED_PROCESS_PATH) {
+    return process.env.LVCE_SHARED_PROCESS_PATH;
+  }
+  return join(root, 'packages', 'shared-process', 'src', 'sharedProcessMain.ts');
+};
+
+const createFileLogger = fileName => {
+  mkdirSync(logsDir, {
+    recursive: true
+  });
+  const logFile = join(logsDir, fileName);
+  const writeStream = createWriteStream(logFile);
+  return new Console(writeStream);
+};
+
 // TODO disable logging via environment variable, don't enable logging during tests
 
-const state$6 = {
+const state$7 = {
   console: undefined
 };
 const createConsole = () => {
-  const logFile = `${tmpdir()}/log-main-process.txt`;
-  const writeStream = createWriteStream(logFile);
-  const logger = new Console(writeStream);
-  return logger;
+  return createFileLogger('log-main-process.txt');
 };
-const getOrCreateLogger = () => {
-  state$6.console ||= createConsole();
-  return state$6.console;
+const getOrCreateLogger$1 = () => {
+  state$7.console ||= createConsole();
+  return state$7.console;
 };
 const info = (...args) => {
-  const logger = getOrCreateLogger();
+  const logger = getOrCreateLogger$1();
   logger.info(...args);
   console.info(...args);
 };
 const error = (...args) => {
-  const logger = getOrCreateLogger();
+  const logger = getOrCreateLogger$1();
   logger.error(...args);
   console.error(...args);
 };
 process.stdout.on('close', () => {
-  const logger = getOrCreateLogger();
+  const logger = getOrCreateLogger$1();
   logger.info('stdout closed');
 });
 process.stdout.on('exit', () => {
-  const logger = getOrCreateLogger();
+  const logger = getOrCreateLogger$1();
   logger.info('stdout exited');
 });
 process.stderr.on('close', () => {
-  const logger = getOrCreateLogger();
+  const logger = getOrCreateLogger$1();
   logger.info('stderr closed');
 });
 process.stderr.on('exit', () => {
-  const logger = getOrCreateLogger();
+  const logger = getOrCreateLogger$1();
   logger.info('stderr exited');
 });
 process.stdout.on('error', error => {
-  const logger = getOrCreateLogger();
+  const logger = getOrCreateLogger$1();
   logger.error(`[main-process] stdout error: ${error.stack}`);
 });
 process.stderr.on('error', error => {
-  const logger = getOrCreateLogger();
+  const logger = getOrCreateLogger$1();
   logger.error(`[main-process] stderr error: ${error.stack}`);
 });
 
@@ -2271,7 +2310,7 @@ const IpcChildWithRendererProcess2$1 = {
   listen: listen$2,
   wrap: wrap$a
 };
-const addListener = (emitter, type, callback) => {
+const addListener$1 = (emitter, type, callback) => {
   if ('addEventListener' in emitter) {
     emitter.addEventListener(type, callback);
   } else {
@@ -2304,7 +2343,7 @@ const getFirstEvent = (eventEmitter, eventMap) => {
         type
       });
     };
-    addListener(eventEmitter, event, listener);
+    addListener$1(eventEmitter, event, listener);
     listenerMap[event] = listener;
   }
   return promise;
@@ -3382,27 +3421,27 @@ const formatUtilityProcessName = name => {
   return camelCase(name);
 };
 
-const state$5 = {
+const state$6 = {
   all: Object.create(null)
 };
 const add$1 = (pid, process, name) => {
   number(pid);
   object(process);
   string(name);
-  state$5.all[pid] = {
+  state$6.all[pid] = {
     name,
     process
   };
 };
 const remove$1 = pid => {
   number(pid);
-  delete state$5.all[pid];
+  delete state$6.all[pid];
 };
 const getAll = () => {
-  return Object.entries(state$5.all);
+  return Object.entries(state$6.all);
 };
 const getByName = name => {
-  for (const value of Object.values(state$5.all)) {
+  for (const value of Object.values(state$6.all)) {
     // @ts-ignore
     if (value.name === name) {
       // @ts-ignore
@@ -3492,37 +3531,6 @@ const DidStartSharedProcess = 'code/didStartSharedProcess';
 const WillCreateCodeWindow = 'code/willCreateCodeWindow';
 const DidCreateCodeWindow = 'code/didCreateCodeWindow';
 
-const join = (...paths) => {
-  return NodePath.join(...paths);
-};
-
-const __dirname$1 = dirname(fileURLToPath(import.meta.url));
-const root = process.env.LVCE_ROOT || join(__dirname$1, '../../../../..');
-
-const {
-  env,
-  platform
-} = process;
-const isLinux = platform === 'linux';
-const isProduction = false;
-const homeDirectory = homedir();
-
-const xdgCache = env.XDG_CACHE_HOME || (homeDirectory ? join(homeDirectory, '.cache') : undefined);
-const xdgData = env.XDG_DATA_HOME || (homeDirectory ? join(homeDirectory, '.local', 'share') : undefined);
-join(xdgData || tmpdir(), applicationName);
-const chromeUserDataPath = xdgCache ? join(xdgCache, applicationName, 'userdata') : '';
-
-const useIpcForResponse = true;
-const getSessionId = () => {
-  return process.env.SESSION_ID || `persist:${scheme}`;
-};
-const getSharedProcessPath = () => {
-  if (process.env.LVCE_SHARED_PROCESS_PATH) {
-    return process.env.LVCE_SHARED_PROCESS_PATH;
-  }
-  return join(root, 'packages', 'shared-process', 'src', 'sharedProcessMain.ts');
-};
-
 const requiresSocket = () => {
   return false;
 };
@@ -3586,7 +3594,7 @@ const launchSharedProcess = async ({
   return sharedProcessRpc;
 };
 
-const state$4 = {
+const state$5 = {
   /**
    * @type {any}
    */
@@ -3597,14 +3605,14 @@ const getOrCreate = async ({
   env = {},
   method
 }) => {
-  if (!state$4.promise) {
+  if (!state$5.promise) {
     // @ts-ignore
-    state$4.promise = launchSharedProcess({
+    state$5.promise = launchSharedProcess({
       env,
       method
     });
   }
-  return state$4.promise;
+  return state$5.promise;
 };
 const send$1 = async (method, ...params) => {
   const rpc = await getOrCreate({
@@ -3768,14 +3776,14 @@ const createTitleBar = items => {
 
 const PHASE_DEFAULT = 0;
 const PHASE_SHUTDOWN = -1;
-const state$3 = {
+const state$4 = {
   phase: PHASE_DEFAULT
 };
 const isShutDown = () => {
-  return state$3.phase === PHASE_SHUTDOWN;
+  return state$4.phase === PHASE_SHUTDOWN;
 };
 const setShutDown = () => {
-  state$3.phase = PHASE_SHUTDOWN;
+  state$4.phase = PHASE_SHUTDOWN;
 };
 
 // TODO move this function to shared process
@@ -4073,21 +4081,21 @@ const openExternal = async url => {
   await shell.openExternal(url);
 };
 
-const state$2 = {
+const state$3 = {
   canceled: Object.create(null),
   fallThroughKeyBindings: [],
   views: Object.create(null)
 };
 const add = (id, browserWindow, view) => {
   // state
-  state$2.views[id] = {
+  state$3.views[id] = {
     browserWindow,
     view
   };
 };
 const hasWebContents = id => {
   number(id);
-  return id in state$2.views;
+  return id in state$3.views;
 };
 /**
  *
@@ -4095,19 +4103,19 @@ const hasWebContents = id => {
  * @returns {{browserWindow: Electron.BrowserWindow, view: Electron.WebContentsView}}
  */
 const get$3 = id => {
-  return state$2.views[id];
+  return state$3.views[id];
 };
 const remove = id => {
-  delete state$2.views[id];
+  delete state$3.views[id];
 };
 const setFallthroughKeyBindings = fallthroughKeyBindings => {
-  state$2.fallThroughKeyBindings = fallthroughKeyBindings;
+  state$3.fallThroughKeyBindings = fallthroughKeyBindings;
 };
 const getFallthroughKeyBindings = () => {
-  return state$2.fallThroughKeyBindings;
+  return state$3.fallThroughKeyBindings;
 };
 const setCanceled = id => {
-  state$2.canceled[id] = true;
+  state$3.canceled[id] = true;
 };
 
 const shouldAllowNavigation = webContentsId => {
@@ -4437,20 +4445,20 @@ const createElectronSession = () => {
   return session;
 };
 
-const state$1 = {
+const state$2 = {
   session: undefined
 };
 const has = () => {
-  return Boolean(state$1.session);
+  return Boolean(state$2.session);
 };
 const get$2 = () => {
-  if (!state$1.session) {
+  if (!state$2.session) {
     throw new Error('session is not defined');
   }
-  return state$1.session;
+  return state$2.session;
 };
 const set$1 = value => {
-  state$1.session = value;
+  state$2.session = value;
 };
 
 const create$2 = rpc => {
@@ -4493,6 +4501,28 @@ class WindowLoadError extends VError {
   }
 }
 
+const state$1 = {
+  console: undefined
+};
+const getOrCreateLogger = () => {
+  state$1.console ||= createFileLogger('log-window.txt');
+  return state$1.console;
+};
+const formatMessage = ({
+  level,
+  lineNumber,
+  message,
+  sourceId
+}) => {
+  const source = sourceId ? ` (${sourceId}:${lineNumber})` : '';
+  return `${new Date().toISOString()} [${level}] [Window] ${message}${source}`;
+};
+const addListener = (webContents, logger = getOrCreateLogger()) => {
+  webContents.on('console-message', event => {
+    logger.log(formatMessage(event));
+  });
+};
+
 // TODO impossible to test these methods
 // and ensure that there is no memory leak
 
@@ -4513,9 +4543,6 @@ const addDevDiagnostics = window => {
   if (!process.env.DEV) {
     return;
   }
-  window.webContents.on('console-message', (_event, level, message, line, sourceId) => {
-    info(`[app window console] level=${level} source=${sourceId}:${line} message=${message}`);
-  });
   window.webContents.on('did-fail-load', (_event, errorCode, errorDescription, validatedUrl, isMainFrame) => {
     error(`[app window did-fail-load] code=${errorCode} mainFrame=${isMainFrame} url=${validatedUrl} error=${errorDescription}`);
   });
@@ -4539,6 +4566,7 @@ const createAppWindow = async (windowOptions, parsedArgs, workingDirectory, titl
     }
   });
   mark(DidCreateCodeWindow);
+  addListener(window.webContents);
   addDevDiagnostics(window);
   const handleReadyToShow = () => {
     // due to electron bug, zoom level needs to be set here,
@@ -4860,6 +4888,106 @@ const openContextMenu = async (menuItems, x, y) => {
   }
 };
 
+const profileDuration = 10_000;
+const getFileName$1 = targetName => {
+  const safeTargetName = targetName.replaceAll(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-/, '').replace(/-$/, '') || 'extension-host';
+  return `${safeTargetName}-${Date.now()}.cpuprofile`;
+};
+const wait = async () => {
+  await new Promise(resolve => {
+    setTimeout(resolve, profileDuration);
+  });
+};
+const takeCpuProfile = async (windowId, workerName) => {
+  const browserWindow = Electron.BrowserWindow.fromId(windowId);
+  if (!browserWindow) {
+    throw new Error(`Browser window not found: ${windowId}`);
+  }
+  const electronDebugger = browserWindow.webContents.debugger;
+  const wasAttached = electronDebugger.isAttached();
+  let filePath = '';
+  let profileStarted = false;
+  let profileStopped = false;
+  let sessionId;
+  let success = false;
+  if (!wasAttached) {
+    electronDebugger.attach();
+  }
+  try {
+    if (workerName) {
+      const {
+        frameTree
+      } = await electronDebugger.sendCommand('Page.getFrameTree');
+      const {
+        targetInfos
+      } = await electronDebugger.sendCommand('Target.getTargets');
+      const target = targetInfos.find(targetInfo => targetInfo.type === 'worker' && targetInfo.title === workerName && targetInfo.parentFrameId === frameTree.frame.id);
+      if (!target) {
+        throw new Error(`Worker not found: ${workerName}`);
+      }
+      const attachResult = await electronDebugger.sendCommand('Target.attachToTarget', {
+        flatten: true,
+        targetId: target.targetId
+      });
+      sessionId = attachResult.sessionId;
+    }
+    await electronDebugger.sendCommand('Profiler.enable', undefined, sessionId);
+    await electronDebugger.sendCommand('Profiler.start', undefined, sessionId);
+    profileStarted = true;
+    await wait();
+    const {
+      profile
+    } = await electronDebugger.sendCommand('Profiler.stop', undefined, sessionId);
+    profileStopped = true;
+    const downloadsPath = Electron.app.getPath('downloads');
+    mkdirSync(downloadsPath, {
+      recursive: true
+    });
+    const targetName = workerName || `Extension Host Window ${windowId}`;
+    filePath = join$1(downloadsPath, getFileName$1(targetName));
+    writeFileSync(filePath, JSON.stringify(profile), {
+      flag: 'wx'
+    });
+    success = true;
+    return filePath;
+  } finally {
+    try {
+      if (profileStarted && !profileStopped && electronDebugger.isAttached()) {
+        await electronDebugger.sendCommand('Profiler.stop', undefined, sessionId);
+      }
+      if (electronDebugger.isAttached()) {
+        await electronDebugger.sendCommand('Profiler.disable', undefined, sessionId);
+      }
+    } finally {
+      try {
+        if (!success && filePath) {
+          rmSync(filePath, {
+            force: true
+          });
+        }
+        if (sessionId && electronDebugger.isAttached()) {
+          await electronDebugger.sendCommand('Target.detachFromTarget', {
+            sessionId
+          });
+        }
+      } finally {
+        if (!wasAttached && electronDebugger.isAttached()) {
+          electronDebugger.detach();
+        }
+      }
+    }
+  }
+};
+const takeWindowCpuProfile = async windowId => {
+  number(windowId);
+  return takeCpuProfile(windowId, '');
+};
+const takeWorkerCpuProfile = async (windowId, workerName) => {
+  number(windowId);
+  string(workerName);
+  return takeCpuProfile(windowId, workerName);
+};
+
 const getFileName = workerName => {
   const safeWorkerName = workerName.replaceAll(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-/, '').replace(/-$/, '') || 'worker';
   return `${safeWorkerName}-${Date.now()}.heapsnapshot`;
@@ -6573,6 +6701,8 @@ const commandMap = {
   'ElectronContextMenu.openContextMenu': openContextMenu,
   'ElectronDeveloper.crashMainProcess': crashMainProcess,
   'ElectronDeveloper.getPerformanceEntries': getPerformanceEntries,
+  'ElectronDeveloper.takeWindowCpuProfile': takeWindowCpuProfile,
+  'ElectronDeveloper.takeWorkerCpuProfile': takeWorkerCpuProfile,
   'ElectronDeveloper.takeWorkerHeapSnapshot': takeWorkerHeapSnapshot,
   'ElectronDialog.showMessageBox': showMessageBox,
   'ElectronDialog.showOpenDialog': showOpenDialog,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/main-process",
-  "version": "6.12.0",
+  "version": "6.14.0",
   "keywords": [
     "lvce-editor",
     "electron"