@lvce-editor/process-explorer 2.4.0 → 3.1.0

package/dist/index.js

@@ -1,384 +1,90 @@
-import { IpcChildWithWebSocket, IpcChildWithElectronMessagePort, IpcChildWithElectronUtilityProcess, IpcChildWithNodeWorker, IpcChildWithNodeForkedProcess } from '@lvce-editor/ipc';
+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 { 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 Two = '2.0';
-const callbacks = Object.create(null);
-const set = (id, fn) => {
-  callbacks[id] = fn;
-};
-const get = id => {
-  return callbacks[id];
-};
-const remove = id => {
-  delete callbacks[id];
-};
-let id = 0;
-const create$3 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    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) {
-      case DomException:
-        return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
-      case ReferenceError$1:
-        return ReferenceError;
-      default:
-        return Error;
-    }
-  }
-  if (message.startsWith('TypeError: ')) {
-    return TypeError;
-  }
-  if (message.startsWith('SyntaxError: ')) {
-    return SyntaxError;
-  }
-  if (message.startsWith('ReferenceError: ')) {
-    return ReferenceError;
-  }
-  return Error;
-};
-const constructError = (message, type, name) => {
-  const ErrorConstructor = getErrorConstructor(message, type);
-  if (ErrorConstructor === DOMException && name) {
-    return new ErrorConstructor(message, name);
-  }
-  if (ErrorConstructor === Error) {
-    const error = new Error(message);
-    if (name && name !== 'VError') {
-      error.name = name;
-    }
-    return error;
-  }
-  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')) {
-    parentStack = error.message + NewLine$1 + parentStack;
-  }
-  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;
-  }
-  const currentStack = joinLines(splitLines$1(new Error().stack || '').slice(1));
-  if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine$1 + currentStack;
-    return restoredError;
-  }
-  if (error && error.message) {
-    const restoredError = constructError(error.message, error.type, error.name);
-    if (error.data) {
-      if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine$1 + error.data.stack + NewLine$1 + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
-  }
-  if (typeof error === 'string') {
-    return new Error(`JsonRpc Error: ${error}`);
-  }
-  return new Error(`JsonRpc Error: ${error}`);
-};
-const unwrapJsonRpcResult = responseMessage => {
-  if ('error' in responseMessage) {
-    const restoredError = restoreJsonRpcError(responseMessage.error);
-    throw restoredError;
-  }
-  if ('result' in responseMessage) {
-    return responseMessage.result;
-  }
-  throw new JsonRpcError('unexpected response message');
-};
-const warn = (...args) => {
-  console.warn(...args);
-};
-const resolve = (id, response) => {
-  const fn = get(id);
-  if (!fn) {
-    console.log(response);
-    warn(`callback ${id} may already be disposed`);
-    return;
-  }
-  fn(response);
-  remove(id);
-};
-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 {
-      code: MethodNotFound,
-      message: error.message,
-      data: error.stack
-    };
-  }
-  return {
-    code: Custom,
-    message: prettyError.message,
-    data: {
-      stack: prettyError.stack,
-      codeFrame: prettyError.codeFrame,
-      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,
-    id: message.id,
-    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);
-    return getSuccessResponse(message, result);
-  } catch (error) {
-    return getErrorResponse(message, error, preparePrettyError, logError);
-  }
+const state = {
+  commandMap: {}
 };
-const defaultPreparePrettyError = error => {
-  return error;
+const set = commandMap => {
+  state.commandMap = commandMap;
 };
-const defaultLogError = () => {
-  // ignore
+const get = () => {
+  return state.commandMap;
 };
-const defaultRequiresSocket = () => {
+
+const requiresSocket = () => {
   return false;
 };
-const defaultResolve = resolve;
 
-// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
-const normalizeParams = args => {
-  if (args.length === 1) {
-    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);
-      try {
-        ipc.send(response);
-      } catch (error) {
-        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
-        ipc.send(errorResponse);
-      }
-      return;
-    }
-    resolve(message.id, message);
+const setRpc = (rpc, rpcId) => {
+  if (typeof rpcId !== 'number') {
     return;
   }
-  if ('method' in message) {
-    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+  if (rpcId === RpcId.MainProcess) {
+    MainProcess.set(rpc);
     return;
   }
-  throw new JsonRpcError('unexpected message');
+  set$1(rpcId, rpc);
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2(method, params);
-  {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
+
+const createMessagePortRpc = async (create, messagePort) => {
+  return create({
+    commandMap: get(),
+    messagePort,
+    requiresSocket: requiresSocket
+  });
 };
-const invoke$1 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params);
+const handleMessagePort = async (messagePort, rpcId) => {
+  object(messagePort);
+  const rpc = await createMessagePortRpc(ElectronMessagePortRpcClient.create, messagePort);
+  setRpc(rpc, rpcId);
 };
 
-const state$1 = {
-  commands: Object.create(null)
+const handleElectronMessagePort = async (messagePort, rpcId) => {
+  await handleMessagePort(messagePort, rpcId);
 };
-const registerCommand = (key, fn) => {
-  state$1.commands[key] = fn;
-};
-const registerCommands = commandMap => {
-  for (const [key, value] of Object.entries(commandMap)) {
-    registerCommand(key, value);
-  }
+
+const createSocketRpc = async (create, webSocket) => {
+  return create({
+    commandMap: get(),
+    webSocket
+  });
 };
-const getCommand = key => {
-  return state$1.commands[key];
+const handleSocket = async (webSocket, rpcId) => {
+  object(webSocket);
+  const rpc = await createSocketRpc(WebSocketRpcParent.create, webSocket);
+  setRpc(rpc, rpcId);
 };
 
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new Error(`Command not found ${command}`);
-  }
-  return fn(...args);
-};
+const isWindows = process.platform === 'win32';
 
-const preparePrettyError = error => {
-  return error;
-};
-const logError = error => {
-  console.error(error);
+const getModule$1 = async () => {
+  if (isWindows) {
+    return Promise.resolve().then(function () { return ListProcessesWithMemoryUsageWindows; });
+  }
+  return Promise.resolve().then(function () { return ListProcessesWithMemoryUsageUnix; });
 };
-const requiresSocket = () => {
-  return false;
+const listProcessesWithMemoryUsage$2 = async rootPid => {
+  const module = await getModule$1();
+  return module.listProcessesWithMemoryUsage(rootPid);
 };
-const handleMessage = event => {
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, requiresSocket);
+
+const getMainProcessId = () => {
+  return process.ppid;
 };
 
-const handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
-  } else {
-    // deprecated
-    ipc.on('message', handleMessage);
-  }
+const commandMap = {
+  'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort,
+  'HandleMessagePort.handleMessagePort': handleMessagePort,
+  'HandleSocket.handleSocket': handleSocket,
+  'ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage': listProcessesWithMemoryUsage$2,
+  'ProcessId.getMainProcessId': getMainProcessId
+  // 'ElectronContextMenu.openContextMenu': ElectronWebContentsView.handleContextMenu,
 };
 
 const NodeWorker = 1;
@@ -402,18 +108,18 @@ const Auto = () => {
   throw new Error(`[shared-process] unknown ipc type`);
 };
 
-const getModule$1 = method => {
+const getModule = method => {
   switch (method) {
+    case ElectronMessagePort:
+      return ElectronMessagePortRpcClient.create;
+    case ElectronUtilityProcess:
+      return ElectronUtilityProcessRpcClient.create;
     case NodeForkedProcess:
-      return IpcChildWithNodeForkedProcess;
+      return NodeForkedProcessRpcClient.create;
     case NodeWorker:
-      return IpcChildWithNodeWorker;
-    case ElectronUtilityProcess:
-      return IpcChildWithElectronUtilityProcess;
-    case ElectronMessagePort:
-      return IpcChildWithElectronMessagePort;
+      return NodeWorkerRpcClient.create;
     case WebSocket:
-      return IpcChildWithWebSocket;
+      return NodeWebSocketRpcClient.create;
     default:
       throw new Error('unexpected ipc type');
   }
@@ -423,79 +129,79 @@ const listen$1 = async ({
   method,
   ...params
 }) => {
-  const module = await getModule$1(method);
-  // @ts-ignore
-  const rawIpc = await 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 listen = async () => {
-  const ipc = await listen$1({
+  set(commandMap);
+  await listen$1({
+    commandMap: commandMap,
     method: Auto()
   });
-  handleIpc(ipc);
-};
-
-const MainProcess = -5;
-
-const state = {
-  ipc: undefined
-};
-const invoke = (method, ...params) => {
-  return invoke$1(state.ipc, method, ...params);
-};
-
-const handleElectronMessagePort = async (messagePort, ipcId) => {
-  object(messagePort);
-  // Assert.number(ipcId)
-  const ipc = await listen$1({
-    method: ElectronMessagePort,
-    messagePort
-  });
-  handleIpc(ipc);
-  if (ipcId === MainProcess) {
-    state.ipc = ipc;
-  }
-};
-
-const getMainProcessId = () => {
-  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 ListProcessesWithMemoryUsageUnix; });
-};
-const listProcessesWithMemoryUsage$2 = async rootPid => {
-  const module = await getModule();
-  return module.listProcessesWithMemoryUsage(rootPid);
-};
-
-const commandMap = {
-  'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort,
-  'ProcessId.getMainProcessId': getMainProcessId,
-  'ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage': listProcessesWithMemoryUsage$2
-  // 'ElectronContextMenu.openContextMenu': ElectronWebContentsView.handleContextMenu,
 };
 
 const main = async () => {
-  registerCommands(commandMap);
   await listen();
 };
 
 main();
 
+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 fallbackProcessNamePatterns = [{
+  matches: cmd => cmd.includes('--type=renderer'),
+  name: 'renderer'
+}, {
+  matches: cmd => cmd.includes('--type=utility'),
+  name: 'utility'
+}, {
+  matches: cmd => cmd.includes('tsserver.js'),
+  name: 'tsserver.js'
+}, {
+  matches: cmd => cmd.includes('typingsInstaller.js'),
+  name: 'typingsInstaller.js'
+}, {
+  matches: cmd => cmd.includes('extensionHostHelperProcessMain.js'),
+  name: 'extension-host-helper-process'
+}, {
+  matches: cmd => cmd.includes('/bin/rg') || cmd.includes('rg.exe'),
+  name: 'ripgrep'
+}, {
+  matches: cmd => cmd.startsWith('bash'),
+  name: 'bash'
+}, {
+  matches: cmd => cmd.startsWith('/opt/sublime_text/sublime_text '),
+  name: 'sublime-text'
+}, {
+  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 getName = (pid, cmd, rootPid, pidMap) => {
   number(pid);
   string(cmd);
@@ -504,52 +210,18 @@ const getName = (pid, cmd, rootPid, pidMap) => {
   if (pid === rootPid) {
     return 'main';
   }
-  if (cmd.includes('--type=zygote')) {
-    return 'zygote';
-  }
-  if (cmd.includes('--type=gpu-process')) {
-    return 'gpu-process';
-  }
-  if (cmd.includes('extensionHostMain.js')) {
-    return 'extension-host';
-  }
-  if (cmd.includes('ptyHostMain.js')) {
-    return 'pty-host';
-  }
-  if (cmd.includes('--lvce-window-kind=process-explorer')) {
-    return 'process-explorer';
+  const patternName = getPatternName(cmd);
+  if (patternName) {
+    return patternName;
   }
   if (pid in pidMap) {
-    return pidMap[pid] || `<unknown>`;
-  }
-  if (cmd.includes('--type=renderer')) {
-    return `renderer`;
-  }
-  if (cmd.includes('--type=utility')) {
-    return 'utility';
-  }
-  if (cmd.includes('tsserver.js')) {
-    return 'tsserver.js';
+    return pidMap[pid] || '<unknown>';
   }
-  if (cmd.includes('typingsInstaller.js')) {
-    return 'typingsInstaller.js';
+  const fallbackPatternName = getFallbackPatternName(cmd);
+  if (fallbackPatternName) {
+    return fallbackPatternName;
   }
-  if (cmd.includes('extensionHostHelperProcessMain.js')) {
-    return 'extension-host-helper-process';
-  }
-  if (cmd.includes('/bin/rg') || cmd.includes('rg.exe')) {
-    return 'ripgrep';
-  }
-  if (cmd.startsWith('bash')) {
-    return 'bash';
-  }
-  if (cmd.startsWith(`/opt/sublime_text/sublime_text `)) {
-    return 'sublime-text';
-  }
-  if (cmd.includes('\\conhost.exe')) {
-    return 'conhost.exe';
-  }
-  return `${cmd}`;
+  return cmd;
 };
 
 const ENOENT = 'ENOENT';
@@ -557,7 +229,7 @@ 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;
+  return error instanceof Error && 'code' in error && error.code === ERR_DLOPEN_FAILED;
 };
 
 const loadWindowProcessTree = async () => {
@@ -572,30 +244,14 @@ const loadWindowProcessTree = async () => {
 };
 
 const withResolvers = () => {
-  /**
-   * @type {any}
-   */
-  let _resolve;
-  /**
-   * @type {any}
-   */
-  let _reject;
-  const promise = new Promise((resolve, reject) => {
-    _resolve = resolve;
-    _reject = reject;
-  });
-  return {
-    resolve: _resolve,
-    reject: _reject,
-    promise
-  };
+  return Promise.withResolvers();
 };
 
 const getProcessList = async (rootPid, flags) => {
   const WindowsProcessTree = await loadWindowProcessTree();
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = withResolvers();
   WindowsProcessTree.getProcessList(rootPid, resolve, flags);
   return promise;
@@ -603,20 +259,19 @@ const getProcessList = async (rootPid, flags) => {
 const addCpuUsage = async processList => {
   const WindowsProcessTree = await loadWindowProcessTree();
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = withResolvers();
-  WindowsProcessTree.getProcessCpuUsage(processList, resolve);
+  const mutableProcessList = processList.map(process => ({
+    ...process
+  }));
+  WindowsProcessTree.getProcessCpuUsage(mutableProcessList, resolve);
   return promise;
 };
 
 const Memory = 1;
 const CommandLine = 2;
 
-const createPidMap = async () => {
-  return invoke('CreatePidMap.createPidMap');
-};
-
 // listProcesses windows implementation based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/node/ps.ts (License MIT)
 
 /**
@@ -626,18 +281,15 @@ const createPidMap = async () => {
  */
 const toResultItem = (item, rootPid, pidMap) => {
   return {
+    cmd: item.commandLine,
+    memory: item.memory,
     name: getName(item.pid, item.commandLine, rootPid, pidMap),
     pid: item.pid,
-    ppid: item.ppid,
-    memory: item.memory,
-    cmd: item.commandLine
+    ppid: item.ppid
   };
 };
 const toResult = (completeProcessList, rootPid, pidMap) => {
-  const results = [];
-  for (const item of completeProcessList) {
-    results.push(toResultItem(item, rootPid, pidMap));
-  }
+  const results = Array.from(completeProcessList, item => toResultItem(item, rootPid, pidMap));
   return results;
 };
 const listProcessesWithMemoryUsage$1 = async rootPid => {
@@ -699,7 +351,7 @@ const parseMemory = content => {
 
 const getContent = async pid => {
   try {
-    const filePath = join('/proc', `${pid}`, 'statm');
+    const filePath = join('/proc', String(pid), 'statm');
     const content = await readFile(filePath, Utf8);
     return content;
   } catch (error) {
@@ -762,17 +414,36 @@ const splitLines = lines => {
 
 // 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 isSpace = character => {
+  return character === ' ' || character === '\t';
+};
+const readField = (line, startIndex) => {
+  let start = startIndex;
+  while (start < line.length && isSpace(line[start])) {
+    start++;
+  }
+  let end = start;
+  while (end < line.length && !isSpace(line[end])) {
+    end++;
+  }
+  return {
+    nextIndex: end,
+    value: line.slice(start, end)
+  };
+};
 const parsePsOutputLine = line => {
   string(line);
-  const matches = PID_CMD.exec(line.trim());
-  if (matches && matches.length === 6) {
+  const trimmedLine = line.trim();
+  const pidField = readField(trimmedLine, 0);
+  const ppidField = readField(trimmedLine, pidField.nextIndex);
+  const loadField = readField(trimmedLine, ppidField.nextIndex);
+  const memoryField = readField(trimmedLine, loadField.nextIndex);
+  const cmd = trimmedLine.slice(memoryField.nextIndex).trim();
+  if (pidField.value && ppidField.value && loadField.value && memoryField.value && cmd) {
     return {
-      pid: Number.parseInt(matches[1]),
-      ppid: Number.parseInt(matches[2]),
-      cmd: matches[5]
-      // load: parseInt(matches[3]),
-      // mem: parseInt(matches[4]),
+      cmd,
+      pid: Number.parseInt(pidField.value),
+      ppid: Number.parseInt(ppidField.value)
     };
   }
   throw new Error(`line could not be parsed: ${line}`);
@@ -791,9 +462,9 @@ const parsePsOutput = (stdout, rootPid, pidMap) => {
   const parsedLines = lines.map(parsePsOutputLine);
   for (const parsedLine of parsedLines) {
     const {
+      cmd,
       pid,
-      ppid,
-      cmd
+      ppid
     } = parsedLine;
     const depth = pid === rootPid ? 1 : depthMap[ppid];
     if (!depth) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/process-explorer",
-  "version": "2.4.0",
+  "version": "3.1.0",
   "description": "Process Explorer",
   "main": "dist/index.js",
   "bin": "bin/processExplorer.js",
@@ -18,57 +18,12 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@lvce-editor/assert": "^1.3.0",
-    "@lvce-editor/ipc": "^13.7.0",
-    "@lvce-editor/json-rpc": "^5.4.0",
-    "@lvce-editor/verror": "^1.6.0"
+    "@lvce-editor/assert": "^1.5.1",
+    "@lvce-editor/rpc": "^6.4.0",
+    "@lvce-editor/rpc-registry": "^9.27.0",
+    "@lvce-editor/verror": "^1.7.0"
   },
   "optionalDependencies": {
-    "@vscode/windows-process-tree": "^0.6.0"
-  },
-  "xo": {
-    "rules": {
-      "unicorn/filename-case": "off",
-      "indent": "off",
-      "semi": "off",
-      "no-unused-vars": "off",
-      "unicorn/numeric-separators-style": "off",
-      "no-extra-semi": "off",
-      "arrow-body-style": "off",
-      "padded-blocks": "off",
-      "capitalized-comments": "off",
-      "padding-line-between-statements": "off",
-      "arrow-parens": "off",
-      "no-warning-comments": "off",
-      "array-bracket-spacing": "off",
-      "comma-spacing": "off",
-      "unicorn/no-array-callback-reference": "off",
-      "comma-dangle": "off",
-      "operator-linebreak": "off",
-      "no-case-declarations": "off",
-      "no-undef": "off",
-      "object-curly-spacing": "off",
-      "object-shorthand": "off",
-      "complexity": "off",
-      "no-labels": "off",
-      "no-multi-assign": "off",
-      "max-params": "off",
-      "no-bitwise": "off",
-      "unicorn/prefer-math-trunc": "off",
-      "no-await-in-loop": "off",
-      "unicorn/prefer-add-event-listener": "off",
-      "no-unused-expressions": "off",
-      "node/prefer-global/process": "off",
-      "unicorn/prevent-abbreviations": "off",
-      "unicorn/no-process-exit": "off",
-      "quotes": "off",
-      "n/prefer-global/process": [
-        "error",
-        "always"
-      ]
-    },
-    "ignores": [
-      "distmin"
-    ]
+    "@vscode/windows-process-tree": "^0.7.0"
   }
 }