@lvce-editor/process-explorer 2.0.0 → 2.2.0

package/dist/index.js

@@ -7,7 +7,6 @@ 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);
@@ -42,7 +41,6 @@ const number = value => {
     throw new AssertionError('expected value to be of type number');
   }
 };
-
 const state$1$1 = {
   callbacks: Object.create(null)
 };
@@ -55,18 +53,15 @@ const get = id => {
 const remove = id => {
   delete state$1$1.callbacks[id];
 };
-
 const state$2 = {
   id: 0
 };
 const create$3 = () => {
   return ++state$2.id;
 };
-
 const warn = (...args) => {
   console.warn(...args);
 };
-
 const withResolvers$1 = () => {
   /**
    * @type {any}
@@ -80,7 +75,6 @@ const withResolvers$1 = () => {
     promise
   };
 };
-
 const registerPromise = () => {
   const id = create$3();
   const {
@@ -104,7 +98,6 @@ const resolve = (id, args) => {
   fn(args);
   remove(id);
 };
-
 const create$2 = (method, params) => {
   const {
     id,
@@ -121,21 +114,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 +151,6 @@ const getErrorConstructor = (message, type) => {
   }
   return Error;
 };
-
 const constructError = (message, type, name) => {
   const ErrorConstructor = getErrorConstructor(message, type);
   if (ErrorConstructor === DOMException && name) {
@@ -177,11 +165,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 +175,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 +235,6 @@ const restoreJsonRpcError = error => {
   }
   return new Error(`JsonRpc Error: ${error}`);
 };
-
 const unwrapJsonRpcResult = responseMessage => {
   if ('error' in responseMessage) {
     const restoredError = restoreJsonRpcError(responseMessage.error);
@@ -264,7 +245,6 @@ const unwrapJsonRpcResult = responseMessage => {
   }
   throw new JsonRpcError('unexpected response message');
 };
-
 const create$1 = (message, error) => {
   return {
     jsonrpc: Two,
@@ -272,9 +252,7 @@ const create$1 = (message, error) => {
     error
   };
 };
-
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
-
 const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
@@ -300,7 +278,6 @@ const getErrorResponse = (message, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1(message, errorProperty);
 };
-
 const create = (message, result) => {
   return {
     jsonrpc: Two,
@@ -308,12 +285,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 +297,6 @@ const getResponse = async (message, ipc, execute, preparePrettyError, logError,
     return getErrorResponse(message, error, preparePrettyError, logError);
   }
 };
-
 const defaultPreparePrettyError = error => {
   return error;
 };
@@ -391,48 +365,42 @@ const invoke$1 = async (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 +414,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 +461,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 +485,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 +494,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,
 };
 
@@ -561,74 +530,72 @@ const getName = (pid, cmd, rootPid, pidMap) => {
   number$1(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 +615,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 +658,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 +691,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 +715,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);
     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);
   object(pidMap);
   if (stdout === EmptyString) {
-    return []
+    return [];
   }
   const lines = splitLines(stdout);
   const result = [];
@@ -869,22 +818,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 +850,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.0.0",
+  "version": "2.2.0",
   "description": "Process Explorer",
   "main": "dist/index.js",
   "bin": "bin/processExplorer.js",
@@ -18,8 +18,8 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@lvce-editor/assert": "^1.2.0",
-    "@lvce-editor/ipc": "^10.0.2",
+    "@lvce-editor/assert": "^1.3.0",
+    "@lvce-editor/ipc": "^10.0.4",
     "@lvce-editor/json-rpc": "^3.0.0",
     "@lvce-editor/verror": "^1.4.0"
   },