@lvce-editor/process-explorer 2.1.0 → 2.3.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { IpcChildWithWebSocket, IpcChildWithElectronMessagePort, IpcChildWithElectronUtilityProcess, IpcChildWithNodeWorker, IpcChildWithNodeForkedProcess } from '@lvce-editor/ipc';
-import { object, number as number$1, string } from '@lvce-editor/assert';
+import { object, number, string } from '@lvce-editor/assert';
 import { VError } from '@lvce-editor/verror';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -7,104 +7,47 @@ import { execFile as execFile$1 } from 'node:child_process';
 import { promisify } from 'node:util';
 
 const Two = '2.0';
-
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const getType = value => {
-  switch (typeof value) {
-    case 'number':
-      return 'number';
-    case 'function':
-      return 'function';
-    case 'string':
-      return 'string';
-    case 'object':
-      if (value === null) {
-        return 'null';
-      }
-      if (Array.isArray(value)) {
-        return 'array';
-      }
-      return 'object';
-    case 'boolean':
-      return 'boolean';
-    default:
-      return 'unknown';
-  }
-};
-const number = value => {
-  const type = getType(value);
-  if (type !== 'number') {
-    throw new AssertionError('expected value to be of type number');
-  }
-};
-
-const state$1$1 = {
+const state$2 = {
   callbacks: Object.create(null)
 };
 const set = (id, fn) => {
-  state$1$1.callbacks[id] = fn;
+  state$2.callbacks[id] = fn;
 };
 const get = id => {
-  return state$1$1.callbacks[id];
+  return state$2.callbacks[id];
 };
 const remove = id => {
-  delete state$1$1.callbacks[id];
-};
-
-const state$2 = {
-  id: 0
+  delete state$2.callbacks[id];
 };
+let id = 0;
 const create$3 = () => {
-  return ++state$2.id;
+  return ++id;
 };
-
 const warn = (...args) => {
   console.warn(...args);
 };
-
-const withResolvers$1 = () => {
-  /**
-   * @type {any}
-   */
-  let _resolve;
-  const promise = new Promise(resolve => {
-    _resolve = resolve;
-  });
-  return {
-    resolve: _resolve,
-    promise
-  };
-};
-
 const registerPromise = () => {
   const id = create$3();
   const {
     resolve,
     promise
-  } = withResolvers$1();
+  } = Promise.withResolvers();
   set(id, resolve);
   return {
     id,
     promise
   };
 };
-const resolve = (id, args) => {
-  number(id);
+const resolve = (id, response) => {
   const fn = get(id);
   if (!fn) {
-    console.log(args);
+    console.log(response);
     warn(`callback ${id} may already be disposed`);
     return;
   }
-  fn(args);
+  fn(response);
   remove(id);
 };
-
 const create$2 = (method, params) => {
   const {
     id,
@@ -121,21 +64,17 @@ const create$2 = (method, params) => {
     promise
   };
 };
-
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
     this.name = 'JsonRpcError';
   }
 }
-
 const NewLine$1 = '\n';
-
 const DomException = 'DOMException';
 const ReferenceError$1 = 'ReferenceError';
 const SyntaxError$1 = 'SyntaxError';
 const TypeError$1 = 'TypeError';
-
 const getErrorConstructor = (message, type) => {
   if (type) {
     switch (type) {
@@ -162,7 +101,6 @@ const getErrorConstructor = (message, type) => {
   }
   return Error;
 };
-
 const constructError = (message, type, name) => {
   const ErrorConstructor = getErrorConstructor(message, type);
   if (ErrorConstructor === DOMException && name) {
@@ -177,11 +115,9 @@ const constructError = (message, type, name) => {
   }
   return new ErrorConstructor(message);
 };
-
 const getNewLineIndex = (string, startIndex = undefined) => {
   return string.indexOf(NewLine$1, startIndex);
 };
-
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
   if (parentStack.startsWith('    at')) {
@@ -189,18 +125,14 @@ const getParentStack = error => {
   }
   return parentStack;
 };
-
 const joinLines = lines => {
   return lines.join(NewLine$1);
 };
-
 const MethodNotFound = -32601;
 const Custom = -32001;
-
 const splitLines$1 = lines => {
   return lines.split(NewLine$1);
 };
-
 const restoreJsonRpcError = error => {
   if (error && error instanceof Error) {
     return error;
@@ -253,7 +185,6 @@ const restoreJsonRpcError = error => {
   }
   return new Error(`JsonRpc Error: ${error}`);
 };
-
 const unwrapJsonRpcResult = responseMessage => {
   if ('error' in responseMessage) {
     const restoredError = restoreJsonRpcError(responseMessage.error);
@@ -264,17 +195,16 @@ const unwrapJsonRpcResult = responseMessage => {
   }
   throw new JsonRpcError('unexpected response message');
 };
-
-const create$1 = (message, error) => {
-  return {
-    jsonrpc: Two,
-    id: message.id,
-    error
-  };
-};
-
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
-
+const getErrorType = prettyError => {
+  if (prettyError && prettyError.type) {
+    return prettyError.type;
+  }
+  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
+    return prettyError.constructor.name;
+  }
+  return undefined;
+};
 const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
@@ -289,18 +219,25 @@ const getErrorProperty = (error, prettyError) => {
     data: {
       stack: prettyError.stack,
       codeFrame: prettyError.codeFrame,
-      type: prettyError.type,
-      code: prettyError.code
+      type: getErrorType(prettyError),
+      code: prettyError.code,
+      name: prettyError.name
     }
   };
 };
+const create$1 = (message, error) => {
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    error
+  };
+};
 const getErrorResponse = (message, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1(message, errorProperty);
 };
-
 const create = (message, result) => {
   return {
     jsonrpc: Two,
@@ -308,12 +245,10 @@ const create = (message, result) => {
     result: result ?? null
   };
 };
-
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
   return create(message, resultProperty);
 };
-
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
   try {
     const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
@@ -322,7 +257,6 @@ const getResponse = async (message, ipc, execute, preparePrettyError, logError,
     return getErrorResponse(message, error, preparePrettyError, logError);
   }
 };
-
 const defaultPreparePrettyError = error => {
   return error;
 };
@@ -333,32 +267,42 @@ const defaultRequiresSocket = () => {
   return false;
 };
 const defaultResolve = resolve;
-const handleJsonRpcMessage = async (...args) => {
-  let message;
-  let ipc;
-  let execute;
-  let preparePrettyError;
-  let logError;
-  let resolve;
-  let requiresSocket;
+
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
   if (args.length === 1) {
-    const arg = args[0];
-    message = arg.message;
-    ipc = arg.ipc;
-    execute = arg.execute;
-    preparePrettyError = arg.preparePrettyError || defaultPreparePrettyError;
-    logError = arg.logError || defaultLogError;
-    requiresSocket = arg.requiresSocket || defaultRequiresSocket;
-    resolve = arg.resolve || defaultResolve;
-  } else {
-    ipc = args[0];
-    message = args[1];
-    execute = args[2];
-    resolve = args[3];
-    preparePrettyError = args[4];
-    logError = args[5];
-    requiresSocket = args[6];
+    const options = args[0];
+    return {
+      ipc: options.ipc,
+      message: options.message,
+      execute: options.execute,
+      resolve: options.resolve || defaultResolve,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      logError: options.logError || defaultLogError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket
+    };
   }
+  return {
+    ipc: args[0],
+    message: args[1],
+    execute: args[2],
+    resolve: args[3],
+    preparePrettyError: args[4],
+    logError: args[5],
+    requiresSocket: args[6]
+  };
+};
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    message,
+    ipc,
+    execute,
+    resolve,
+    preparePrettyError,
+    logError,
+    requiresSocket
+  } = options;
   if ('id' in message) {
     if ('method' in message) {
       const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
@@ -379,60 +323,58 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invoke$1 = async (ipc, method, ...params) => {
+const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const {
     message,
     promise
   } = create$2(method, params);
-  ipc.send(message);
+  {
+    ipc.send(message);
+  }
   const responseMessage = await promise;
-  const result = unwrapJsonRpcResult(responseMessage);
-  return result;
+  return unwrapJsonRpcResult(responseMessage);
+};
+const invoke$1 = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params);
 };
 
 const state$1 = {
-  commands: Object.create(null),
+  commands: Object.create(null)
 };
-
 const registerCommand = (key, fn) => {
   state$1.commands[key] = fn;
 };
-
-const registerCommands = (commandMap) => {
+const registerCommands = commandMap => {
   for (const [key, value] of Object.entries(commandMap)) {
     registerCommand(key, value);
   }
 };
-
-const getCommand = (key) => {
-  return state$1.commands[key]
+const getCommand = key => {
+  return state$1.commands[key];
 };
 
 const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
-    throw new Error(`Command not found ${command}`)
+    throw new Error(`Command not found ${command}`);
   }
-  return fn(...args)
+  return fn(...args);
 };
 
-const preparePrettyError = (error) => {
-  return error
+const preparePrettyError = error => {
+  return error;
 };
-
-const logError = (error) => {
+const logError = error => {
   console.error(error);
 };
-
 const requiresSocket = () => {
-  return false
+  return false;
 };
-
-const handleMessage = (event) => {
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, requiresSocket)
+const handleMessage = event => {
+  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, requiresSocket);
 };
 
-const handleIpc = (ipc) => {
+const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
     ipc.addEventListener('message', handleMessage);
   } else {
@@ -446,39 +388,43 @@ const NodeForkedProcess = 2;
 const ElectronUtilityProcess = 3;
 const ElectronMessagePort = 4;
 const WebSocket = 6;
-
 const Auto = () => {
-  const { argv } = process;
+  const {
+    argv
+  } = process;
   if (argv.includes('--ipc-type=node-worker')) {
-    return NodeWorker
+    return NodeWorker;
   }
   if (argv.includes('--ipc-type=node-forked-process')) {
-    return NodeForkedProcess
+    return NodeForkedProcess;
   }
   if (argv.includes('--ipc-type=electron-utility-process')) {
-    return ElectronUtilityProcess
+    return ElectronUtilityProcess;
   }
-  throw new Error(`[shared-process] unknown ipc type`)
+  throw new Error(`[shared-process] unknown ipc type`);
 };
 
-const getModule$1 = (method) => {
+const getModule$1 = method => {
   switch (method) {
     case NodeForkedProcess:
-      return IpcChildWithNodeForkedProcess
+      return IpcChildWithNodeForkedProcess;
     case NodeWorker:
-      return IpcChildWithNodeWorker
+      return IpcChildWithNodeWorker;
     case ElectronUtilityProcess:
-      return IpcChildWithElectronUtilityProcess
+      return IpcChildWithElectronUtilityProcess;
     case ElectronMessagePort:
-      return IpcChildWithElectronMessagePort
+      return IpcChildWithElectronMessagePort;
     case WebSocket:
-      return IpcChildWithWebSocket
+      return IpcChildWithWebSocket;
     default:
-      throw new Error('unexpected ipc type')
+      throw new Error('unexpected ipc type');
   }
 };
 
-const listen$1 = async ({ method, ...params }) => {
+const listen$1 = async ({
+  method,
+  ...params
+}) => {
   const module = await getModule$1(method);
   // @ts-ignore
   const rawIpc = await module.listen(params);
@@ -489,25 +435,23 @@ const listen$1 = async ({ method, ...params }) => {
   }
   // @ts-ignore
   const ipc = module.wrap(rawIpc);
-  return ipc
+  return ipc;
 };
 
 const listen = async () => {
-  const ipc = await listen$1({ method: Auto() });
+  const ipc = await listen$1({
+    method: Auto()
+  });
   handleIpc(ipc);
 };
 
 const MainProcess = -5;
 
 const state = {
-  /**
-   * @type {any}
-   */
-  ipc: undefined,
+  ipc: undefined
 };
-
 const invoke = (method, ...params) => {
-  return invoke$1(state.ipc, method, ...params)
+  return invoke$1(state.ipc, method, ...params);
 };
 
 const handleElectronMessagePort = async (messagePort, ipcId) => {
@@ -515,7 +459,7 @@ const handleElectronMessagePort = async (messagePort, ipcId) => {
   // Assert.number(ipcId)
   const ipc = await listen$1({
     method: ElectronMessagePort,
-    messagePort,
+    messagePort
   });
   handleIpc(ipc);
   if (ipcId === MainProcess) {
@@ -524,27 +468,26 @@ const handleElectronMessagePort = async (messagePort, ipcId) => {
 };
 
 const getMainProcessId = () => {
-  return process.ppid
+  return process.ppid;
 };
 
 const isWindows = process.platform === 'win32';
 
 const getModule = () => {
   if (isWindows) {
-    return Promise.resolve().then(function () { return ListProcessesWithMemoryUsageWindows; })
+    return Promise.resolve().then(function () { return ListProcessesWithMemoryUsageWindows; });
   }
-  return Promise.resolve().then(function () { return ListProcessesWithMemoryUsageUnix; })
+  return Promise.resolve().then(function () { return ListProcessesWithMemoryUsageUnix; });
 };
-
-const listProcessesWithMemoryUsage$2 = async (rootPid) => {
+const listProcessesWithMemoryUsage$2 = async rootPid => {
   const module = await getModule();
-  return module.listProcessesWithMemoryUsage(rootPid)
+  return module.listProcessesWithMemoryUsage(rootPid);
 };
 
 const commandMap = {
   'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort,
   'ProcessId.getMainProcessId': getMainProcessId,
-  'ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage': listProcessesWithMemoryUsage$2,
+  'ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage': listProcessesWithMemoryUsage$2
   // 'ElectronContextMenu.openContextMenu': ElectronWebContentsView.handleContextMenu,
 };
 
@@ -556,79 +499,77 @@ const main = async () => {
 main();
 
 const getName = (pid, cmd, rootPid, pidMap) => {
-  number$1(pid);
+  number(pid);
   string(cmd);
-  number$1(rootPid);
+  number(rootPid);
   object(pidMap);
   if (pid === rootPid) {
-    return 'main'
+    return 'main';
   }
   if (cmd.includes('--type=zygote')) {
-    return 'zygote'
+    return 'zygote';
   }
   if (cmd.includes('--type=gpu-process')) {
-    return 'gpu-process'
+    return 'gpu-process';
   }
   if (cmd.includes('extensionHostMain.js')) {
-    return 'extension-host'
+    return 'extension-host';
   }
   if (cmd.includes('ptyHostMain.js')) {
-    return 'pty-host'
+    return 'pty-host';
   }
   if (cmd.includes('--lvce-window-kind=process-explorer')) {
-    return 'process-explorer'
+    return 'process-explorer';
   }
   if (pid in pidMap) {
-    return pidMap[pid] || `<unknown>`
+    return pidMap[pid] || `<unknown>`;
   }
   if (cmd.includes('--type=renderer')) {
-    return `renderer`
+    return `renderer`;
   }
   if (cmd.includes('--type=utility')) {
-    return 'utility'
+    return 'utility';
   }
   if (cmd.includes('tsserver.js')) {
-    return 'tsserver.js'
+    return 'tsserver.js';
   }
   if (cmd.includes('typingsInstaller.js')) {
-    return 'typingsInstaller.js'
+    return 'typingsInstaller.js';
   }
   if (cmd.includes('extensionHostHelperProcessMain.js')) {
-    return 'extension-host-helper-process'
+    return 'extension-host-helper-process';
   }
   if (cmd.includes('/bin/rg') || cmd.includes('rg.exe')) {
-    return 'ripgrep'
+    return 'ripgrep';
   }
   if (cmd.startsWith('bash')) {
-    return 'bash'
+    return 'bash';
   }
   if (cmd.startsWith(`/opt/sublime_text/sublime_text `)) {
-    return 'sublime-text'
+    return 'sublime-text';
   }
   if (cmd.includes('\\conhost.exe')) {
-    return 'conhost.exe'
+    return 'conhost.exe';
   }
-  return `${cmd}`
+  return `${cmd}`;
 };
 
 const ENOENT = 'ENOENT';
 const ERR_DLOPEN_FAILED = 'ERR_DLOPEN_FAILED';
 const ESRCH = 'ESRCH';
 
-const isDlOpenError = (error) => {
-  return error && error instanceof Error && 'code' in error && error.code === ERR_DLOPEN_FAILED
+const isDlOpenError = error => {
+  return error && error instanceof Error && 'code' in error && error.code === ERR_DLOPEN_FAILED;
 };
 
 const loadWindowProcessTree = async () => {
   try {
-    return await import('@vscode/windows-process-tree')
+    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(`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`)
+    throw new VError(error, `Failed to load windows process tree`);
   }
 };
 
@@ -648,45 +589,38 @@ const withResolvers = () => {
   return {
     resolve: _resolve,
     reject: _reject,
-    promise,
-  }
+    promise
+  };
 };
 
-/**
- *
- * @param {number} rootPid
- * @param {number} flags
- * @returns {Promise<any[] | undefined>}
- */
 const getProcessList = async (rootPid, flags) => {
   const WindowsProcessTree = await loadWindowProcessTree();
-  const { resolve, promise } = withResolvers();
+  const {
+    resolve,
+    promise
+  } = withResolvers();
   WindowsProcessTree.getProcessList(rootPid, resolve, flags);
-  return promise
+  return promise;
 };
-
-/**
- *
- * @param {any[]} processList
- * @returns Promise< WindowsProcessTree.IProcessCpuInfo[]>
- */
-const addCpuUsage = async (processList) => {
+const addCpuUsage = async processList => {
   const WindowsProcessTree = await loadWindowProcessTree();
-  const { resolve, promise } = withResolvers();
+  const {
+    resolve,
+    promise
+  } = withResolvers();
   WindowsProcessTree.getProcessCpuUsage(processList, resolve);
-  return promise
+  return promise;
 };
 
 const Memory = 1;
 const CommandLine = 2;
 
 const createPidMap = async () => {
-  return invoke('CreatePidMap.createPidMap')
+  return invoke('CreatePidMap.createPidMap');
 };
 
 // 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
@@ -698,36 +632,29 @@ const toResultItem = (item, rootPid, pidMap) => {
     pid: item.pid,
     ppid: item.ppid,
     memory: item.memory,
-    cmd: item.commandLine,
-  }
+    cmd: item.commandLine
+  };
 };
-
-/**
- *
- * @param {import('@vscode/windows-process-tree').IProcessCpuInfo[]} completeProcessList
- * @param {number} rootPid
- */
 const toResult = (completeProcessList, rootPid, pidMap) => {
   const results = [];
   for (const item of completeProcessList) {
     results.push(toResultItem(item, rootPid, pidMap));
   }
-  return results
+  return results;
 };
-
-const listProcessesWithMemoryUsage$1 = async (rootPid) => {
+const listProcessesWithMemoryUsage$1 = async rootPid => {
   try {
     const processList = await getProcessList(rootPid, CommandLine | Memory);
     if (!processList) {
-      throw new VError(`Root process ${rootPid} not found`)
+      throw new VError(`Root process ${rootPid} not found`);
     }
     const pidMap = await createPidMap();
     const completeProcessList = await addCpuUsage(processList);
     const result = toResult(completeProcessList, rootPid, pidMap);
-    return result
+    return result;
   } catch (error) {
     // @ts-ignore
-    throw new VError(error, `Failed to list processes`)
+    throw new VError(error, `Failed to list processes`);
   }
 };
 
@@ -738,23 +665,22 @@ const ListProcessesWithMemoryUsageWindows = {
 
 const Utf8 = 'utf8';
 
-const isEnoentErrorWindows = (error) => {
-  return error && error.message && error.message.includes('The system cannot find the path specified.')
+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 isEnoentErrorLinux = error => {
+  return error.code === ENOENT;
 };
-
-const isEnoentError = (error) => {
+const isEnoentError = error => {
   if (!error) {
-    return false
+    return false;
   }
-  return isEnoentErrorLinux(error) || isEnoentErrorWindows(error)
+  return isEnoentErrorLinux(error) || isEnoentErrorWindows(error);
 };
 
-const isEsrchError = (error) => {
-  return error && error.code === ESRCH
+const isEsrchError = error => {
+  return error && error.code === ESRCH;
 };
 
 const isMacOs = process.platform === 'darwin';
@@ -763,105 +689,102 @@ const EmptyString = '';
 const NewLine = '\n';
 const Space = ' ';
 
-const parseMemory = (content) => {
+const parseMemory = content => {
   const trimmedContent = content.trim();
   const numberBlocks = trimmedContent.split(Space);
   const pageSize = 4096;
   const rss = Number.parseInt(numberBlocks[1]) * pageSize;
   const shared = Number.parseInt(numberBlocks[2]) * pageSize;
   const memory = rss - shared;
-  return memory
+  return memory;
 };
 
-const getContent = async (pid) => {
+const getContent = async pid => {
   try {
     const filePath = join('/proc', `${pid}`, 'statm');
     const content = await readFile(filePath, Utf8);
-    return content
+    return content;
   } catch (error) {
     if (isEnoentError(error) || isEsrchError(error)) {
-      return ''
+      return '';
     }
-    throw error
+    throw error;
   }
 };
-
-const getAccurateMemoryUsage = async (pid) => {
+const getAccurateMemoryUsage = async pid => {
   try {
-    number$1(pid);
+    number(pid);
     if (isMacOs) {
-      return 0
+      return 0;
     }
     const content = await getContent(pid);
     if (!content) {
-      return -1
+      return -1;
     }
     const memory = parseMemory(content);
-    return memory
+    return memory;
   } catch (error) {
-    throw new VError(error, 'Failed to get accurate memory usage')
+    throw new VError(error, 'Failed to get accurate memory usage');
   }
 };
 
-const addAccurateMemoryUsage = async (process) => {
+const addAccurateMemoryUsage = async process => {
   const accurateMemoryUsage = await getAccurateMemoryUsage(process.pid);
   return {
     ...process,
-    memory: accurateMemoryUsage,
-  }
+    memory: accurateMemoryUsage
+  };
 };
 
 const SIGINT = 'SIGINT';
 
 const execFile = promisify(execFile$1);
-
 const getPsOutput = async () => {
   try {
-    const { stdout } = await execFile('ps', ['-ax', '-o', 'pid=,ppid=,pcpu=,pmem=,command=']);
-    return stdout.trim()
+    const {
+      stdout
+    } = await execFile('ps', ['-ax', '-o', 'pid=,ppid=,pcpu=,pmem=,command=']);
+    return stdout.trim();
   } catch (error) {
     // @ts-ignore
     if (error && error.signal === SIGINT) {
-      return ''
+      return '';
     }
-    throw new VError(error, `Failed to execute ps`)
+    throw new VError(error, `Failed to execute ps`);
   }
 };
 
-const hasPositiveMemoryUsage = (process) => {
-  return process.memory >= 0
+const hasPositiveMemoryUsage = process => {
+  return process.memory >= 0;
 };
 
-const splitLines = (lines) => {
-  return lines.split(NewLine)
+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 PID_CMD = /^\s*(\d+)\s+(\d+)\s+([\d.]+)\s+([\d.]+)\s+(.+)$/s;
-
-const parsePsOutputLine = (line) => {
+const parsePsOutputLine = line => {
   string(line);
   const matches = PID_CMD.exec(line.trim());
   if (matches && matches.length === 6) {
     return {
       pid: Number.parseInt(matches[1]),
       ppid: Number.parseInt(matches[2]),
-      cmd: matches[5],
+      cmd: matches[5]
       // load: parseInt(matches[3]),
       // mem: parseInt(matches[4]),
-    }
+    };
   }
-  throw new Error(`line could not be parsed: ${line}`)
+  throw new Error(`line could not be parsed: ${line}`);
 };
-
 const parsePsOutput = (stdout, rootPid, pidMap) => {
   string(stdout);
-  number$1(rootPid);
+  number(rootPid);
   object(pidMap);
   if (stdout === EmptyString) {
-    return []
+    return [];
   }
   const lines = splitLines(stdout);
   const result = [];
@@ -869,22 +792,26 @@ const parsePsOutput = (stdout, rootPid, pidMap) => {
   depthMap[rootPid] = 1;
   const parsedLines = lines.map(parsePsOutputLine);
   for (const parsedLine of parsedLines) {
-    const { pid, ppid, cmd } = parsedLine;
+    const {
+      pid,
+      ppid,
+      cmd
+    } = parsedLine;
     const depth = pid === rootPid ? 1 : depthMap[ppid];
     if (!depth) {
-      continue
+      continue;
     }
     result.push({
       ...parsedLine,
       depth,
-      name: getName(pid, cmd, rootPid, pidMap),
+      name: getName(pid, cmd, rootPid, pidMap)
     });
     depthMap[pid] = depth + 1;
   }
-  return result
+  return result;
 };
 
-const listProcessesWithMemoryUsage = async (rootPid) => {
+const listProcessesWithMemoryUsage = async rootPid => {
   // console.time('getPsOutput')
   const stdout = await getPsOutput();
   const pidMap = await createPidMap();
@@ -897,7 +824,7 @@ const listProcessesWithMemoryUsage = async (rootPid) => {
   const parsedWithAccurateMemoryUsage = await Promise.all(parsed.map(addAccurateMemoryUsage));
   // console.timeEnd('addAccurateMemoryUsage')
   const filtered = parsedWithAccurateMemoryUsage.filter(hasPositiveMemoryUsage);
-  return filtered
+  return filtered;
 };
 
 const ListProcessesWithMemoryUsageUnix = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/process-explorer",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Process Explorer",
   "main": "dist/index.js",
   "bin": "bin/processExplorer.js",
@@ -18,10 +18,10 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@lvce-editor/assert": "^1.2.0",
-    "@lvce-editor/ipc": "^10.0.4",
-    "@lvce-editor/json-rpc": "^3.0.0",
-    "@lvce-editor/verror": "^1.4.0"
+    "@lvce-editor/assert": "^1.3.0",
+    "@lvce-editor/ipc": "^11.4.0",
+    "@lvce-editor/json-rpc": "^5.2.0",
+    "@lvce-editor/verror": "^1.6.0"
   },
   "optionalDependencies": {
     "@vscode/windows-process-tree": "^0.6.0"