@lvce-editor/process-explorer 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Lvce Editor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# Lvce Editor Process Explorer
+
+Process Explorer.

package/dist/index.js

@@ -0,0 +1,873 @@
+import { IpcChildWithWebSocket, IpcChildWithElectronMessagePort, IpcChildWithElectronUtilityProcess, IpcChildWithNodeWorker, IpcChildWithNodeForkedProcess } from '@lvce-editor/ipc';
+import { object, number as number$1, string } from '@lvce-editor/assert';
+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';
+
+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 = {
+  callbacks: Object.create(null)
+};
+const set = (id, fn) => {
+  state$1$1.callbacks[id] = fn;
+};
+const get = id => {
+  return state$1$1.callbacks[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}
+   */
+  let _resolve;
+  const promise = new Promise(resolve => {
+    _resolve = resolve;
+  });
+  return {
+    resolve: _resolve,
+    promise
+  };
+};
+
+const registerPromise = () => {
+  const id = create$3();
+  const {
+    resolve,
+    promise
+  } = withResolvers$1();
+  set(id, resolve);
+  return {
+    id,
+    promise
+  };
+};
+const resolve = (id, args) => {
+  number(id);
+  const fn = get(id);
+  if (!fn) {
+    console.log(args);
+    warn(`callback ${id} may already be disposed`);
+    return;
+  }
+  fn(args);
+  remove(id);
+};
+
+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:
+        // @ts-ignore
+        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);
+  // @ts-ignore
+  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 joinLines = lines => {
+  return lines.join(NewLine$1);
+};
+
+const MethodNotFound = -32601;
+const Custom = -32001;
+
+const splitLines$1 = lines => {
+  return lines.split(NewLine$1);
+};
+
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine$1 + parentStack;
+  }
+  return parentStack;
+};
+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) {
+        // TODO accessing stack might be slow
+        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 create$1 = (message, error) => {
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    error
+  };
+};
+
+const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
+
+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: prettyError.type,
+      code: prettyError.code
+    }
+  };
+};
+const getErrorResponse = (message, error, ipc, 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, ipc, preparePrettyError, logError);
+  }
+};
+
+const handleJsonRpcMessage = async (ipc, message, execute, resolve, preparePrettyError, logError, requiresSocket) => {
+  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, ipc, preparePrettyError, logError);
+        ipc.send(errorResponse);
+      }
+      return;
+    }
+    resolve(message.id, message);
+    return;
+  }
+  if ('method' in message) {
+    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+    return;
+  }
+  throw new JsonRpcError('unexpected message');
+};
+const invoke$1 = async (ipc, method, ...params) => {
+  const {
+    message,
+    promise
+  } = create$2(method, params);
+  ipc.send(message);
+  const responseMessage = await promise;
+  const result = unwrapJsonRpcResult(responseMessage);
+  return result;
+};
+
+const state$1 = {
+  commands: Object.create(null),
+};
+
+const registerCommand = (key, fn) => {
+  state$1.commands[key] = fn;
+};
+
+const registerCommands = (commandMap) => {
+  for (const [key, value] of Object.entries(commandMap)) {
+    registerCommand(key, value);
+  }
+};
+
+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}`)
+  }
+  return fn(...args)
+};
+
+const preparePrettyError = (error) => {
+  return error
+};
+
+const logError = (error) => {
+  console.error(error);
+};
+
+const requiresSocket = () => {
+  return false
+};
+
+const handleMessage = (event) => {
+  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, requiresSocket)
+};
+
+const handleIpc = (ipc) => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
+};
+
+const NodeWorker = 1;
+const NodeForkedProcess = 2;
+const ElectronUtilityProcess = 3;
+const ElectronMessagePort = 4;
+const WebSocket = 6;
+
+const Auto = () => {
+  const { argv } = process;
+  if (argv.includes('--ipc-type=node-worker')) {
+    return NodeWorker
+  }
+  if (argv.includes('--ipc-type=node-forked-process')) {
+    return NodeForkedProcess
+  }
+  if (argv.includes('--ipc-type=electron-utility-process')) {
+    return ElectronUtilityProcess
+  }
+  throw new Error(`[shared-process] unknown ipc type`)
+};
+
+const getModule$1 = (method) => {
+  switch (method) {
+    case NodeForkedProcess:
+      return IpcChildWithNodeForkedProcess
+    case NodeWorker:
+      return IpcChildWithNodeWorker
+    case ElectronUtilityProcess:
+      return IpcChildWithElectronUtilityProcess
+    case ElectronMessagePort:
+      return IpcChildWithElectronMessagePort
+    case WebSocket:
+      return IpcChildWithWebSocket
+    default:
+      throw new Error('unexpected ipc type')
+  }
+};
+
+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 listen = async () => {
+  const ipc = await listen$1({ method: Auto() });
+  handleIpc(ipc);
+};
+
+const MainProcess = -5;
+
+const state = {
+  /**
+   * @type {any}
+   */
+  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 getName = (pid, cmd, rootPid, pidMap) => {
+  number$1(pid);
+  string(cmd);
+  number$1(rootPid);
+  object(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'
+  }
+  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'
+  }
+  if (cmd.includes('typingsInstaller.js')) {
+    return 'typingsInstaller.js'
+  }
+  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}`
+};
+
+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 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 = () => {
+  /**
+   * @type {any}
+   */
+  let _resolve;
+  /**
+   * @type {any}
+   */
+  let _reject;
+  const promise = new Promise((resolve, reject) => {
+    _resolve = resolve;
+    _reject = reject;
+  });
+  return {
+    resolve: _resolve,
+    reject: _reject,
+    promise,
+  }
+};
+
+/**
+ *
+ * @param {number} rootPid
+ * @param {number} flags
+ * @returns {Promise<any[] | undefined>}
+ */
+const getProcessList = async (rootPid, flags) => {
+  const WindowsProcessTree = await loadWindowProcessTree();
+  const { resolve, promise } = withResolvers();
+  WindowsProcessTree.getProcessList(rootPid, resolve, flags);
+  return promise
+};
+
+/**
+ *
+ * @param {any[]} processList
+ * @returns Promise< WindowsProcessTree.IProcessCpuInfo[]>
+ */
+const addCpuUsage = async (processList) => {
+  const WindowsProcessTree = await loadWindowProcessTree();
+  const { resolve, promise } = withResolvers();
+  WindowsProcessTree.getProcessCpuUsage(processList, 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)
+
+
+/**
+ * @param {import('@vscode/windows-process-tree').IProcessCpuInfo} item
+ * @param {number} rootPid
+ * @param {object} pidMap
+ */
+const toResultItem = (item, rootPid, pidMap) => {
+  return {
+    name: getName(item.pid, item.commandLine, rootPid, pidMap),
+    pid: item.pid,
+    ppid: item.ppid,
+    memory: item.memory,
+    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
+};
+
+const listProcessesWithMemoryUsage$1 = async (rootPid) => {
+  try {
+    const processList = await getProcessList(rootPid, CommandLine | Memory);
+    if (!processList) {
+      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
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, `Failed to list processes`)
+  }
+};
+
+const ListProcessesWithMemoryUsageWindows = {
+  __proto__: null,
+  listProcessesWithMemoryUsage: listProcessesWithMemoryUsage$1
+};
+
+const Utf8 = 'utf8';
+
+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
+  }
+  return isEnoentErrorLinux(error) || isEnoentErrorWindows(error)
+};
+
+const isEsrchError = (error) => {
+  return error && error.code === ESRCH
+};
+
+const isMacOs = process.platform === 'darwin';
+
+const EmptyString = '';
+const NewLine = '\n';
+const Space = ' ';
+
+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
+};
+
+const getContent = async (pid) => {
+  try {
+    const filePath = join('/proc', `${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$1(pid);
+    if (isMacOs) {
+      return 0
+    }
+    const content = await getContent(pid);
+    if (!content) {
+      return -1
+    }
+    const memory = parseMemory(content);
+    return memory
+  } catch (error) {
+    throw new VError(error, 'Failed to get accurate memory usage')
+  }
+};
+
+const addAccurateMemoryUsage = async (process) => {
+  const accurateMemoryUsage = await getAccurateMemoryUsage(process.pid);
+  return {
+    ...process,
+    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()
+  } catch (error) {
+    // @ts-ignore
+    if (error && error.signal === SIGINT) {
+      return ''
+    }
+    throw new VError(error, `Failed to execute ps`)
+  }
+};
+
+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 PID_CMD = /^\s*(\d+)\s+(\d+)\s+([\d.]+)\s+([\d.]+)\s+(.+)$/s;
+
+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],
+      // load: parseInt(matches[3]),
+      // mem: parseInt(matches[4]),
+    }
+  }
+  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 []
+  }
+  const lines = splitLines(stdout);
+  const result = [];
+  const depthMap = Object.create(null);
+  depthMap[rootPid] = 1;
+  const parsedLines = lines.map(parsePsOutputLine);
+  for (const parsedLine of parsedLines) {
+    const { pid, ppid, cmd } = parsedLine;
+    const depth = pid === rootPid ? 1 : depthMap[ppid];
+    if (!depth) {
+      continue
+    }
+    result.push({
+      ...parsedLine,
+      depth,
+      name: getName(pid, cmd, rootPid, pidMap),
+    });
+    depthMap[pid] = depth + 1;
+  }
+  return result
+};
+
+const listProcessesWithMemoryUsage = async (rootPid) => {
+  // console.time('getPsOutput')
+  const stdout = await getPsOutput();
+  const pidMap = await createPidMap();
+  // console.log({ stdout })
+  // console.timeEnd('getPsOutput')
+  // console.time('parsePsOutput')
+  const parsed = parsePsOutput(stdout, rootPid, pidMap);
+  // console.timeEnd('parsePsOutput')
+  // console.time('addAccurateMemoryUsage')
+  const parsedWithAccurateMemoryUsage = await Promise.all(parsed.map(addAccurateMemoryUsage));
+  // console.timeEnd('addAccurateMemoryUsage')
+  const filtered = parsedWithAccurateMemoryUsage.filter(hasPositiveMemoryUsage);
+  return filtered
+};
+
+const ListProcessesWithMemoryUsageUnix = {
+  __proto__: null,
+  listProcessesWithMemoryUsage
+};

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@lvce-editor/process-explorer",
+  "version": "1.0.0",
+  "description": "Process Explorer",
+  "main": "dist/index.js",
+  "type": "module",
+  "keywords": [
+    "Lvce Editor"
+  ],
+  "author": "Lvce Editor",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lvce-editor/lvce-editor.git",
+    "directory": "packages/process-explorer"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@lvce-editor/assert": "^1.2.0",
+    "@lvce-editor/ipc": "^8.2.1",
+    "@lvce-editor/json-rpc": "^1.3.0",
+    "@lvce-editor/verror": "^1.2.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"
+    ]
+  }
+}