@lvce-editor/process-explorer 3.1.0 → 3.3.0

package/dist/index.js

@@ -1,18 +1,16 @@
 import { ElectronMessagePortRpcClient, WebSocketRpcParent, NodeWebSocketRpcClient, NodeWorkerRpcClient, NodeForkedProcessRpcClient, ElectronUtilityProcessRpcClient } from '@lvce-editor/rpc';
 import { object, number, string } from '@lvce-editor/assert';
-import { RpcId, MainProcess, set as set$1 } from '@lvce-editor/rpc-registry';
+import { RpcId, MainProcess, set as set$2 } from '@lvce-editor/rpc-registry';
+import { execFile as execFile$2 } from 'node:child_process';
+import { promisify } from 'node:util';
 import { VError } from '@lvce-editor/verror';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { execFile as execFile$1 } from 'node:child_process';
-import { promisify } from 'node:util';
 
 const state = {
   commandMap: {}
 };
-const set = commandMap => {
-  state.commandMap = commandMap;
-};
+
 const get = () => {
   return state.commandMap;
 };
@@ -21,6 +19,14 @@ const requiresSocket = () => {
   return false;
 };
 
+const createMessagePortRpc = async (create, messagePort) => {
+  return create({
+    commandMap: get(),
+    messagePort,
+    requiresSocket: requiresSocket
+  });
+};
+
 const setRpc = (rpc, rpcId) => {
   if (typeof rpcId !== 'number') {
     return;
@@ -29,16 +35,9 @@ const setRpc = (rpc, rpcId) => {
     MainProcess.set(rpc);
     return;
   }
-  set$1(rpcId, rpc);
+  set$2(rpcId, rpc);
 };
 
-const createMessagePortRpc = async (create, messagePort) => {
-  return create({
-    commandMap: get(),
-    messagePort,
-    requiresSocket: requiresSocket
-  });
-};
 const handleMessagePort = async (messagePort, rpcId) => {
   object(messagePort);
   const rpc = await createMessagePortRpc(ElectronMessagePortRpcClient.create, messagePort);
@@ -55,12 +54,31 @@ const createSocketRpc = async (create, webSocket) => {
     webSocket
   });
 };
+
 const handleSocket = async (webSocket, rpcId) => {
   object(webSocket);
   const rpc = await createSocketRpc(WebSocketRpcParent.create, webSocket);
   setRpc(rpc, rpcId);
 };
 
+const createWebSocketRpc = async (create, handle, request) => {
+  return create({
+    commandMap: get(),
+    handle,
+    request,
+    requiresSocket: requiresSocket
+  });
+};
+const handleWebSocket = async (handle, request, rpcId) => {
+  if (!handle || !request) {
+    return;
+  }
+  object(handle);
+  object(request);
+  const rpc = await createWebSocketRpc(NodeWebSocketRpcClient.create, handle, request);
+  setRpc(rpc, rpcId);
+};
+
 const isWindows = process.platform === 'win32';
 
 const getModule$1 = async () => {
@@ -69,24 +87,71 @@ const getModule$1 = async () => {
   }
   return Promise.resolve().then(function () { return ListProcessesWithMemoryUsageUnix; });
 };
-const listProcessesWithMemoryUsage$2 = async rootPid => {
+
+const listProcessesWithMemoryUsage$2 = async (rootPid, includeElectronData = true) => {
   const module = await getModule$1();
-  return module.listProcessesWithMemoryUsage(rootPid);
+  return module.listProcessesWithMemoryUsage(rootPid, includeElectronData);
 };
 
-const getMainProcessId = () => {
-  return process.ppid;
+const execFile$1 = promisify(execFile$2);
+const parseProcessId = stdout => {
+  const parentProcessId = Number(stdout.trim());
+  if (!Number.isFinite(parentProcessId) || parentProcessId <= 0) {
+    return 0;
+  }
+  return parentProcessId;
+};
+const getParentProcessIdUnix = async pid => {
+  const {
+    stdout
+  } = await execFile$1('ps', ['-o', 'ppid=', '-p', String(pid)]);
+  return parseProcessId(stdout);
+};
+const getParentProcessIdWindows = async pid => {
+  const {
+    stdout
+  } = await execFile$1('powershell.exe', ['-NoProfile', '-Command', `(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").ParentProcessId`]);
+  return parseProcessId(stdout);
+};
+const getParentProcessId = async pid => {
+  if (process.platform === 'win32') {
+    return getParentProcessIdWindows(pid);
+  }
+  return getParentProcessIdUnix(pid);
+};
+const getRemoteRootProcessId = async (childProcessId = process.ppid) => {
+  try {
+    const parentProcessId = await getParentProcessId(childProcessId);
+    return parentProcessId || process.ppid;
+  } catch {
+    return process.ppid;
+  }
+};
+const getMainProcessId = (includeElectronData = true, childProcessId = process.ppid) => {
+  if (includeElectronData) {
+    return Promise.resolve(process.ppid);
+  }
+  return getRemoteRootProcessId(childProcessId);
 };
 
 const commandMap = {
   'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort,
   'HandleMessagePort.handleMessagePort': handleMessagePort,
   'HandleSocket.handleSocket': handleSocket,
+  'HandleWebSocket.handleWebSocket': handleWebSocket,
   'ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage': listProcessesWithMemoryUsage$2,
   'ProcessId.getMainProcessId': getMainProcessId
   // 'ElectronContextMenu.openContextMenu': ElectronWebContentsView.handleContextMenu,
 };
 
+const set$1 = commandMap => {
+  state.commandMap = commandMap;
+};
+
+const set = commandMap => {
+  set$1(commandMap);
+};
+
 const NodeWorker = 1;
 const NodeForkedProcess = 2;
 const ElectronUtilityProcess = 3;
@@ -148,26 +213,56 @@ const main = async () => {
 
 main();
 
+const ENOENT = 'ENOENT';
+const ERR_DLOPEN_FAILED = 'ERR_DLOPEN_FAILED';
+const ESRCH = 'ESRCH';
+
+const isDlOpenError = error => {
+  return error instanceof Error && 'code' in error && error.code === ERR_DLOPEN_FAILED;
+};
+
+const loadWindowProcessTree = async () => {
+  try {
+    return await import('@vscode/windows-process-tree');
+  } catch (error) {
+    if (isDlOpenError(error)) {
+      throw new VError(`Failed to load windows process tree: The native module "@vscode/windows-process-tree" is not compatible with this node version and must be compiled against a matching electron version using electron-rebuild`);
+    }
+    throw new VError(error, `Failed to load windows process tree`);
+  }
+};
+
+const withResolvers = () => {
+  return Promise.withResolvers();
+};
+
+const addCpuUsage = async processList => {
+  const WindowsProcessTree = await loadWindowProcessTree();
+  const {
+    promise,
+    resolve
+  } = withResolvers();
+  const mutableProcessList = processList.map(process => ({
+    ...process
+  }));
+  WindowsProcessTree.getProcessCpuUsage(mutableProcessList, resolve);
+  return promise;
+};
+
 const createPidMap = async () => {
   return MainProcess.invoke('CreatePidMap.createPidMap');
 };
 
-const processNamePatterns = [{
-  matches: cmd => cmd.includes('--type=zygote'),
-  name: 'zygote'
-}, {
-  matches: cmd => cmd.includes('--type=gpu-process'),
-  name: 'gpu-process'
-}, {
-  matches: cmd => cmd.includes('extensionHostMain.js'),
-  name: 'extension-host'
-}, {
-  matches: cmd => cmd.includes('ptyHostMain.js'),
-  name: 'pty-host'
-}, {
-  matches: cmd => cmd.includes('--lvce-window-kind=process-explorer'),
-  name: 'process-explorer'
-}];
+const getProcessList = async (rootPid, flags) => {
+  const WindowsProcessTree = await loadWindowProcessTree();
+  const {
+    promise,
+    resolve
+  } = withResolvers();
+  WindowsProcessTree.getProcessList(rootPid, resolve, flags);
+  return promise;
+};
+
 const fallbackProcessNamePatterns = [{
   matches: cmd => cmd.includes('--type=renderer'),
   name: 'renderer'
@@ -196,12 +291,32 @@ const fallbackProcessNamePatterns = [{
   matches: cmd => cmd.includes('\\conhost.exe'),
   name: 'conhost.exe'
 }];
-const getPatternName = cmd => {
-  return processNamePatterns.find(pattern => pattern.matches(cmd))?.name || '';
-};
+
 const getFallbackPatternName = cmd => {
   return fallbackProcessNamePatterns.find(pattern => pattern.matches(cmd))?.name || '';
 };
+
+const processNamePatterns = [{
+  matches: cmd => cmd.includes('--type=zygote'),
+  name: 'zygote'
+}, {
+  matches: cmd => cmd.includes('--type=gpu-process'),
+  name: 'gpu-process'
+}, {
+  matches: cmd => cmd.includes('extensionHostMain.js'),
+  name: 'extension-host'
+}, {
+  matches: cmd => cmd.includes('ptyHostMain.js'),
+  name: 'pty-host'
+}, {
+  matches: cmd => cmd.includes('--lvce-window-kind=process-explorer'),
+  name: 'process-explorer'
+}];
+
+const getPatternName = cmd => {
+  return processNamePatterns.find(pattern => pattern.matches(cmd))?.name || '';
+};
+
 const getName = (pid, cmd, rootPid, pidMap) => {
   number(pid);
   string(cmd);
@@ -224,61 +339,6 @@ const getName = (pid, cmd, rootPid, pidMap) => {
   return cmd;
 };
 
-const ENOENT = 'ENOENT';
-const ERR_DLOPEN_FAILED = 'ERR_DLOPEN_FAILED';
-const ESRCH = 'ESRCH';
-
-const isDlOpenError = error => {
-  return error instanceof Error && 'code' in error && error.code === ERR_DLOPEN_FAILED;
-};
-
-const loadWindowProcessTree = async () => {
-  try {
-    return await import('@vscode/windows-process-tree');
-  } catch (error) {
-    if (isDlOpenError(error)) {
-      throw new VError(`Failed to load windows process tree: The native module "@vscode/windows-process-tree" is not compatible with this node version and must be compiled against a matching electron version using electron-rebuild`);
-    }
-    throw new VError(error, `Failed to load windows process tree`);
-  }
-};
-
-const withResolvers = () => {
-  return Promise.withResolvers();
-};
-
-const getProcessList = async (rootPid, flags) => {
-  const WindowsProcessTree = await loadWindowProcessTree();
-  const {
-    promise,
-    resolve
-  } = withResolvers();
-  WindowsProcessTree.getProcessList(rootPid, resolve, flags);
-  return promise;
-};
-const addCpuUsage = async processList => {
-  const WindowsProcessTree = await loadWindowProcessTree();
-  const {
-    promise,
-    resolve
-  } = withResolvers();
-  const mutableProcessList = processList.map(process => ({
-    ...process
-  }));
-  WindowsProcessTree.getProcessCpuUsage(mutableProcessList, resolve);
-  return promise;
-};
-
-const Memory = 1;
-const CommandLine = 2;
-
-// listProcesses windows implementation based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/node/ps.ts (License MIT)
-
-/**
- * @param {import('@vscode/windows-process-tree').IProcessCpuInfo} item
- * @param {number} rootPid
- * @param {object} pidMap
- */
 const toResultItem = (item, rootPid, pidMap) => {
   return {
     cmd: item.commandLine,
@@ -288,17 +348,24 @@ const toResultItem = (item, rootPid, pidMap) => {
     ppid: item.ppid
   };
 };
+
 const toResult = (completeProcessList, rootPid, pidMap) => {
   const results = Array.from(completeProcessList, item => toResultItem(item, rootPid, pidMap));
   return results;
 };
-const listProcessesWithMemoryUsage$1 = async rootPid => {
+
+const Memory = 1;
+const CommandLine = 2;
+
+// listProcesses windows implementation based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/node/ps.ts (License MIT)
+
+const listProcessesWithMemoryUsage$1 = async (rootPid, includeElectronData = true) => {
   try {
     const processList = await getProcessList(rootPid, CommandLine | Memory);
     if (!processList) {
       throw new VError(`Root process ${rootPid} not found`);
     }
-    const pidMap = await createPidMap();
+    const pidMap = includeElectronData ? await createPidMap() : {};
     const completeProcessList = await addCpuUsage(processList);
     const result = toResult(completeProcessList, rootPid, pidMap);
     return result;
@@ -315,13 +382,14 @@ const ListProcessesWithMemoryUsageWindows = {
 
 const Utf8 = 'utf8';
 
+const isEnoentErrorLinux = error => {
+  return error.code === ENOENT;
+};
+
 const isEnoentErrorWindows = error => {
   return error && error.message && error.message.includes('The system cannot find the path specified.');
 };
 
-const isEnoentErrorLinux = error => {
-  return error.code === ENOENT;
-};
 const isEnoentError = error => {
   if (!error) {
     return false;
@@ -333,6 +401,19 @@ const isEsrchError = error => {
   return error && error.code === ESRCH;
 };
 
+const getContent = async pid => {
+  try {
+    const filePath = join('/proc', String(pid), 'statm');
+    const content = await readFile(filePath, Utf8);
+    return content;
+  } catch (error) {
+    if (isEnoentError(error) || isEsrchError(error)) {
+      return '';
+    }
+    throw error;
+  }
+};
+
 const isMacOs = process.platform === 'darwin';
 
 const EmptyString = '';
@@ -349,18 +430,6 @@ const parseMemory = content => {
   return memory;
 };
 
-const getContent = async pid => {
-  try {
-    const filePath = join('/proc', String(pid), 'statm');
-    const content = await readFile(filePath, Utf8);
-    return content;
-  } catch (error) {
-    if (isEnoentError(error) || isEsrchError(error)) {
-      return '';
-    }
-    throw error;
-  }
-};
 const getAccurateMemoryUsage = async pid => {
   try {
     number(pid);
@@ -388,7 +457,7 @@ const addAccurateMemoryUsage = async process => {
 
 const SIGINT = 'SIGINT';
 
-const execFile = promisify(execFile$1);
+const execFile = promisify(execFile$2);
 const getPsOutput = async () => {
   try {
     const {
@@ -408,15 +477,10 @@ const hasPositiveMemoryUsage = process => {
   return process.memory >= 0;
 };
 
-const splitLines = lines => {
-  return lines.split(NewLine);
-};
-
-// parse ps output based on vscode https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/node/ps.ts (License MIT)
-
 const isSpace = character => {
   return character === ' ' || character === '\t';
 };
+
 const readField = (line, startIndex) => {
   let start = startIndex;
   while (start < line.length && isSpace(line[start])) {
@@ -431,6 +495,7 @@ const readField = (line, startIndex) => {
     value: line.slice(start, end)
   };
 };
+
 const parsePsOutputLine = line => {
   string(line);
   const trimmedLine = line.trim();
@@ -448,6 +513,13 @@ const parsePsOutputLine = line => {
   }
   throw new Error(`line could not be parsed: ${line}`);
 };
+
+const splitLines = lines => {
+  return lines.split(NewLine);
+};
+
+// parse ps output based on vscode https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/node/ps.ts (License MIT)
+
 const parsePsOutput = (stdout, rootPid, pidMap) => {
   string(stdout);
   number(rootPid);
@@ -480,10 +552,10 @@ const parsePsOutput = (stdout, rootPid, pidMap) => {
   return result;
 };
 
-const listProcessesWithMemoryUsage = async rootPid => {
+const listProcessesWithMemoryUsage = async (rootPid, includeElectronData = true) => {
   // console.time('getPsOutput')
   const stdout = await getPsOutput();
-  const pidMap = await createPidMap();
+  const pidMap = includeElectronData ? await createPidMap() : {};
   // console.log({ stdout })
   // console.timeEnd('getPsOutput')
   // console.time('parsePsOutput')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/process-explorer",
-  "version": "3.1.0",
+  "version": "3.3.0",
   "description": "Process Explorer",
   "main": "dist/index.js",
   "bin": "bin/processExplorer.js",
@@ -20,7 +20,7 @@
   "dependencies": {
     "@lvce-editor/assert": "^1.5.1",
     "@lvce-editor/rpc": "^6.4.0",
-    "@lvce-editor/rpc-registry": "^9.27.0",
+    "@lvce-editor/rpc-registry": "^9.28.0",
     "@lvce-editor/verror": "^1.7.0"
   },
   "optionalDependencies": {