@lvce-editor/process-explorer 3.0.0 → 3.2.0

package/dist/index.js

@@ -1,55 +1,115 @@
+import { ElectronMessagePortRpcClient, WebSocketRpcParent, NodeWebSocketRpcClient, NodeWorkerRpcClient, NodeForkedProcessRpcClient, ElectronUtilityProcessRpcClient } from '@lvce-editor/rpc';
 import { object, number, string } from '@lvce-editor/assert';
-import { handleJsonRpcMessage, resolve, invoke as invoke$1 } from '@lvce-editor/json-rpc';
-import { IpcChildWithWebSocket, IpcChildWithNodeWorker, IpcChildWithNodeForkedProcess, IpcChildWithElectronUtilityProcess, IpcChildWithElectronMessagePort } from '@lvce-editor/ipc';
+import { RpcId, MainProcess, set as set$2 } from '@lvce-editor/rpc-registry';
 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$1 = {
-  commands: Object.create(null)
+const state = {
+  commandMap: {}
 };
-const registerCommand = (key, fn) => {
-  state$1.commands[key] = fn;
+
+const get = () => {
+  return state.commandMap;
 };
-const registerCommands = commandMap => {
-  for (const [key, value] of Object.entries(commandMap)) {
-    registerCommand(key, value);
-  }
+
+const requiresSocket = () => {
+  return false;
 };
-const getCommand = key => {
-  return state$1.commands[key];
+
+const createMessagePortRpc = async (create, messagePort) => {
+  return create({
+    commandMap: get(),
+    messagePort,
+    requiresSocket: requiresSocket
+  });
 };
 
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new Error(`Command not found ${command}`);
+const setRpc = (rpc, rpcId) => {
+  if (typeof rpcId !== 'number') {
+    return;
   }
-  return fn(...args);
+  if (rpcId === RpcId.MainProcess) {
+    MainProcess.set(rpc);
+    return;
+  }
+  set$2(rpcId, rpc);
 };
 
-const preparePrettyError = error => {
-  return error;
+const handleMessagePort = async (messagePort, rpcId) => {
+  object(messagePort);
+  const rpc = await createMessagePortRpc(ElectronMessagePortRpcClient.create, messagePort);
+  setRpc(rpc, rpcId);
 };
-const logError = error => {
-  console.error(error);
+
+const handleElectronMessagePort = async (messagePort, rpcId) => {
+  await handleMessagePort(messagePort, rpcId);
 };
-const requiresSocket = () => {
-  return false;
+
+const createSocketRpc = async (create, webSocket) => {
+  return create({
+    commandMap: get(),
+    webSocket
+  });
+};
+
+const handleSocket = async (webSocket, rpcId) => {
+  object(webSocket);
+  const rpc = await createSocketRpc(WebSocketRpcParent.create, webSocket);
+  setRpc(rpc, rpcId);
 };
-const handleMessage = event => {
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, requiresSocket);
+
+const createWebSocketRpc = async (create, handle, request) => {
+  return create({
+    commandMap: get(),
+    handle,
+    request,
+    requiresSocket: requiresSocket
+  });
+};
+const handleWebSocket = async (handle, request, rpcId) => {
+  object(handle);
+  object(request);
+  const rpc = await createWebSocketRpc(NodeWebSocketRpcClient.create, handle, request);
+  setRpc(rpc, rpcId);
 };
 
-const handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
-  } else {
-    // deprecated
-    ipc.on('message', handleMessage);
+const isWindows = process.platform === 'win32';
+
+const getModule$1 = async () => {
+  if (isWindows) {
+    return Promise.resolve().then(function () { return ListProcessesWithMemoryUsageWindows; });
   }
+  return Promise.resolve().then(function () { return ListProcessesWithMemoryUsageUnix; });
+};
+
+const listProcessesWithMemoryUsage$2 = async rootPid => {
+  const module = await getModule$1();
+  return module.listProcessesWithMemoryUsage(rootPid);
+};
+
+const getMainProcessId = () => {
+  return process.ppid;
+};
+
+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;
@@ -73,18 +133,18 @@ const Auto = () => {
   throw new Error(`[shared-process] unknown ipc type`);
 };
 
-const getModule$1 = method => {
+const getModule = method => {
   switch (method) {
     case ElectronMessagePort:
-      return IpcChildWithElectronMessagePort;
+      return ElectronMessagePortRpcClient.create;
     case ElectronUtilityProcess:
-      return IpcChildWithElectronUtilityProcess;
+      return ElectronUtilityProcessRpcClient.create;
     case NodeForkedProcess:
-      return IpcChildWithNodeForkedProcess;
+      return NodeForkedProcessRpcClient.create;
     case NodeWorker:
-      return IpcChildWithNodeWorker;
+      return NodeWorkerRpcClient.create;
     case WebSocket:
-      return IpcChildWithWebSocket;
+      return NodeWebSocketRpcClient.create;
     default:
       throw new Error('unexpected ipc type');
   }
@@ -94,99 +154,75 @@ const listen$1 = async ({
   method,
   ...params
 }) => {
-  const module = getModule$1(method);
-  // @ts-ignore
-  const rawIpc = module.listen(params);
-  // @ts-ignore
-  if (module.signal) {
-    // @ts-ignore
-    module.signal(rawIpc);
-  }
-  // @ts-ignore
-  const ipc = module.wrap(rawIpc);
-  return ipc;
+  const create = getModule(method);
+  const rpc = await create(params);
+  return rpc;
 };
 
-const MainProcess = -5;
-
-const state = {
-  ipc: undefined
-};
-const invoke = (method, ...params) => {
-  return invoke$1(state.ipc, method, ...params);
+const listen = async () => {
+  set(commandMap);
+  await listen$1({
+    commandMap: commandMap,
+    method: Auto()
+  });
 };
 
-const handleElectronMessagePort = async (messagePort, ipcId) => {
-  object(messagePort);
-  // Assert.number(ipcId)
-  const ipc = await listen$1({
-    messagePort,
-    method: ElectronMessagePort
-  });
-  handleIpc(ipc);
-  if (ipcId === MainProcess) {
-    state.ipc = ipc;
-  }
+const main = async () => {
+  await listen();
 };
 
-const isWindows = process.platform === 'win32';
+main();
 
-const getModule = async () => {
-  if (isWindows) {
-    return Promise.resolve().then(function () { return ListProcessesWithMemoryUsageWindows; });
-  }
-  return Promise.resolve().then(function () { return ListProcessesWithMemoryUsageUnix; });
-};
-const listProcessesWithMemoryUsage$2 = async rootPid => {
-  const module = await getModule();
-  return module.listProcessesWithMemoryUsage(rootPid);
-};
+const ENOENT = 'ENOENT';
+const ERR_DLOPEN_FAILED = 'ERR_DLOPEN_FAILED';
+const ESRCH = 'ESRCH';
 
-const getMainProcessId = () => {
-  return process.ppid;
+const isDlOpenError = error => {
+  return error instanceof Error && 'code' in error && error.code === ERR_DLOPEN_FAILED;
 };
 
-const commandMap = {
-  'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort,
-  'ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage': listProcessesWithMemoryUsage$2,
-  'ProcessId.getMainProcessId': getMainProcessId
-  // 'ElectronContextMenu.openContextMenu': ElectronWebContentsView.handleContextMenu,
+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 listen = async () => {
-  const ipc = await listen$1({
-    method: Auto()
-  });
-  handleIpc(ipc);
+const withResolvers = () => {
+  return Promise.withResolvers();
 };
 
-const main = async () => {
-  registerCommands(commandMap);
-  await listen();
+const addCpuUsage = async processList => {
+  const WindowsProcessTree = await loadWindowProcessTree();
+  const {
+    promise,
+    resolve
+  } = withResolvers();
+  const mutableProcessList = processList.map(process => ({
+    ...process
+  }));
+  WindowsProcessTree.getProcessCpuUsage(mutableProcessList, resolve);
+  return promise;
 };
 
-main();
-
 const createPidMap = async () => {
-  return invoke('CreatePidMap.createPidMap');
+  return MainProcess.invoke('CreatePidMap.createPidMap');
+};
+
+const getProcessList = async (rootPid, flags) => {
+  const WindowsProcessTree = await loadWindowProcessTree();
+  const {
+    promise,
+    resolve
+  } = withResolvers();
+  WindowsProcessTree.getProcessList(rootPid, resolve, flags);
+  return promise;
 };
 
-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 fallbackProcessNamePatterns = [{
   matches: cmd => cmd.includes('--type=renderer'),
   name: 'renderer'
@@ -215,12 +251,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);
@@ -243,61 +299,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,
@@ -307,10 +308,17 @@ 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 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 => {
   try {
     const processList = await getProcessList(rootPid, CommandLine | Memory);
@@ -334,13 +342,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;
@@ -352,6 +361,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 = '';
@@ -368,18 +390,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);
@@ -427,15 +437,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])) {
@@ -450,6 +455,7 @@ const readField = (line, startIndex) => {
     value: line.slice(start, end)
   };
 };
+
 const parsePsOutputLine = line => {
   string(line);
   const trimmedLine = line.trim();
@@ -467,6 +473,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/process-explorer",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "description": "Process Explorer",
   "main": "dist/index.js",
   "bin": "bin/processExplorer.js",
@@ -19,8 +19,8 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "^1.5.1",
-    "@lvce-editor/ipc": "^16.0.0",
-    "@lvce-editor/json-rpc": "^8.0.0",
+    "@lvce-editor/rpc": "^6.4.0",
+    "@lvce-editor/rpc-registry": "^9.28.0",
     "@lvce-editor/verror": "^1.7.0"
   },
   "optionalDependencies": {