@lvce-editor/shared-process 0.15.27 → 0.15.28

package/mocks/windows-process-tree.js

@@ -0,0 +1 @@
+export {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.15.27",
+  "version": "0.15.28",
   "description": "Utility package for @lvce-editor/server",
   "main": "index.js",
   "type": "module",
@@ -16,10 +16,10 @@
     "node": ">=16"
   },
   "dependencies": {
-    "@babel/code-frame": "^7.21.4",
-    "@lvce-editor/extension-host": "0.15.27",
-    "@lvce-editor/extension-host-helper-process": "0.15.27",
-    "@lvce-editor/pty-host": "0.15.27",
+    "@babel/code-frame": "^7.22.5",
+    "@lvce-editor/extension-host": "0.15.28",
+    "@lvce-editor/extension-host-helper-process": "0.15.28",
+    "@lvce-editor/pty-host": "0.15.28",
     "debug": "^4.3.4",
     "execa": "^7.1.1",
     "exit-hook": "^3.2.0",

package/src/parts/CreatePidMap/CreatePidMap.js

@@ -0,0 +1,6 @@
+import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+
+export const createPidMap = async () => {
+  const pidMap = await ParentIpc.invoke('CreatePidMap.createPidMap')
+  return pidMap
+}

package/src/parts/ErrorCodes/ErrorCodes.js

@@ -18,3 +18,4 @@ export const ERR_IPC_CHANNEL_CLOSED = 'ERR_IPC_CHANNEL_CLOSED'
 export const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND'
 export const EXDEV = 'EXDEV'
 export const ERR_DLOPEN_FAILED = 'ERR_DLOPEN_FAILED'
+export const ESRCH = 'ESRCH'

package/src/parts/ErrorType/ErrorType.js

@@ -0,0 +1,4 @@
+export const DomException = 'DOMException'
+export const ReferenceError = 'ReferenceError'
+export const SyntaxError = 'SyntaxError'
+export const TypeError = 'TypeError'

package/src/parts/GetAccurateMemoryUsage/GetAccurateMemoryUsage.js

@@ -0,0 +1,38 @@
+import { join } from 'node:path'
+import { readFile } from 'node:fs/promises'
+import { VError } from '../VError/VError.js'
+import * as Assert from '../Assert/Assert.js'
+import * as EncodingType from '../EncodingType/EncodingType.js'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+
+export const getAccurateMemoryUsage = async (pid) => {
+  Assert.number(pid)
+  try {
+    const filePath = join('/proc', `${pid}`, 'statm')
+    let content
+    try {
+      content = await readFile(filePath, EncodingType.Utf8)
+    } catch (error) {
+      if (
+        error &&
+        // @ts-ignore
+        (error.code === ErrorCodes.ENOENT ||
+          // @ts-ignore
+          error.code === ErrorCodes.ESRCH)
+      ) {
+        return -1
+      }
+      throw error
+    }
+    const trimmedContent = content.trim()
+    const numberBlocks = trimmedContent.split(' ')
+    const pageSize = 4096
+    const rss = Number.parseInt(numberBlocks[1]) * pageSize
+    const shared = Number.parseInt(numberBlocks[2]) * pageSize
+    const memory = rss - shared
+    return memory
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, 'Failed to get accurate memory usage')
+  }
+}

package/src/parts/GetElectronRebuildPath/GetElectronRebuildPath.js

@@ -0,0 +1,6 @@
+import * as Path from '../Path/Path.js'
+import * as Root from '../Root/Root.js'
+
+export const getElectronRebuildPath = () => {
+  return Path.join(Root.root, 'packages', 'main-process', 'node_modules', '.bin', 'electron-rebuild')
+}

package/src/parts/GetErrorConstructor/GetErrorConstructor.js

@@ -0,0 +1,28 @@
+import * as ErrorType from '../ErrorType/ErrorType.js'
+
+export const getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case ErrorType.DomException:
+        return DOMException
+      case ErrorType.TypeError:
+        return TypeError
+      case ErrorType.SyntaxError:
+        return SyntaxError
+      case ErrorType.ReferenceError:
+        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
+}

package/src/parts/GetPsOutput/GetPsOutput.js

@@ -0,0 +1,20 @@
+import { VError } from '../VError/VError.js'
+import { execFile as _execFile } from 'node:child_process'
+import * as Signal from '../Signal/Signal.js'
+import { promisify } from 'node:util'
+
+const execFile = promisify(_execFile)
+
+export 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 === Signal.SIGINT) {
+      return ''
+    }
+    // @ts-ignore
+    throw new VError(error, `Failed to execute ps`)
+  }
+}

package/src/parts/JsonRpc/JsonRpc.js

@@ -1,5 +1,6 @@
 import * as Callback from '../Callback/Callback.js'
 import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+import * as UnwrapJsonRpcResult from '../UnwrapJsonRpcResult/UnwrapJsonRpcResult.js'
 
 export const send = (transport, method, ...params) => {
   transport.send({
@@ -9,7 +10,7 @@ export const send = (transport, method, ...params) => {
   })
 }
 
-export const invoke = (ipc, method, ...params) => {
+export const invoke = async (ipc, method, ...params) => {
   const { id, promise } = Callback.registerPromise()
   ipc.send({
     jsonrpc: JsonRpcVersion.Two,
@@ -17,10 +18,12 @@ export const invoke = (ipc, method, ...params) => {
     params,
     id,
   })
-  return promise
+  const responseMessage = await promise
+  const result = UnwrapJsonRpcResult.unwrapJsonRpcResult(responseMessage)
+  return result
 }
 
-export const invokeAndTransfer = (ipc, handle, method, ...params) => {
+export const invokeAndTransfer = async (ipc, handle, method, ...params) => {
   const { id, promise } = Callback.registerPromise()
   ipc.sendAndTransfer(
     {
@@ -31,5 +34,7 @@ export const invokeAndTransfer = (ipc, handle, method, ...params) => {
     },
     handle
   )
-  return promise
+  const responseMessage = await promise
+  const result = UnwrapJsonRpcResult.unwrapJsonRpcResult(responseMessage)
+  return result
 }

package/src/parts/ListProcessGetName/ListProcessGetName.js

@@ -0,0 +1,54 @@
+import * as Assert from '../Assert/Assert.js'
+
+export const getName = (pid, cmd, rootPid, pidMap) => {
+  Assert.number(pid)
+  Assert.string(cmd)
+  Assert.number(rootPid)
+  Assert.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('typescript/lib/tsserver.js')) {
+    return 'tsserver.js'
+  }
+  if (cmd.includes('typescript/lib/typingsInstaller.js')) {
+    return 'typingsInstaller.js'
+  }
+  if (cmd.includes('extensionHostHelperProcessMain.js')) {
+    return 'extension-host-helper-process'
+  }
+  if (cmd.includes('/bin/rg')) {
+    return 'ripgrep'
+  }
+  if (cmd.startsWith('bash')) {
+    return 'bash'
+  }
+  if (cmd.startsWith(`/opt/sublime_text/sublime_text `)) {
+    return 'sublime-text'
+  }
+  return `${cmd}`
+}

package/src/parts/ListProcessesWithMemoryUsage/ListProcessesWithMemoryUsage.ipc.js

@@ -0,0 +1,7 @@
+import * as ListProcessesWithMemoryUsage from './ListProcessesWithMemoryUsage.js'
+
+export const name = 'ListProcessesWithMemoryUsage'
+
+export const Commands = {
+  listProcessesWithMemoryUsage: ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage,
+}

package/src/parts/ListProcessesWithMemoryUsage/ListProcessesWithMemoryUsage.js

@@ -0,0 +1,13 @@
+import * as Platform from '../Platform/Platform.js'
+
+const getModule = () => {
+  if (Platform.isWindows) {
+    return import('../ListProcessesWithMemoryUsageWindows/ListProcessesWithMemoryUsageWindows.js')
+  }
+  return import('../ListProcessesWithMemoryUsageUnix/ListProcessesWithMemoryUsageUnix.js')
+}
+
+export const listProcessesWithMemoryUsage = async (rootPid) => {
+  const module = await getModule()
+  return module.listProcessesWithMemoryUsage(rootPid)
+}

package/src/parts/ListProcessesWithMemoryUsageUnix/ListProcessesWithMemoryUsageUnix.js

@@ -0,0 +1,32 @@
+import * as CreatePidMap from '../CreatePidMap/CreatePidMap.js'
+import * as GetAccurateMemoryUsage from '../GetAccurateMemoryUsage/GetAccurateMemoryUsage.js'
+import * as GetPsOutput from '../GetPsOutput/GetPsOutput.js'
+import * as ParsePsOutput from '../ParsePsOutput/ParsePsOutput.js'
+
+const addAccurateMemoryUsage = async (process) => {
+  const accurateMemoryUsage = await GetAccurateMemoryUsage.getAccurateMemoryUsage(process.pid)
+  return {
+    ...process,
+    memory: accurateMemoryUsage,
+  }
+}
+
+const hasPositiveMemoryUsage = (process) => {
+  return process.memory >= 0
+}
+
+export const listProcessesWithMemoryUsage = async (rootPid) => {
+  // console.time('getPsOutput')
+  const stdout = await GetPsOutput.getPsOutput()
+  const pidMap = await CreatePidMap.createPidMap()
+  // console.log({ stdout })
+  // console.timeEnd('getPsOutput')
+  // console.time('parsePsOutput')
+  const parsed = ParsePsOutput.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
+}

package/src/parts/ListProcessesWithMemoryUsageWindows/ListProcessesWithMemoryUsageWindows.js

@@ -0,0 +1,51 @@
+// listProcesses windows implementation based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/node/ps.ts (License MIT)
+
+import { VError } from '../VError/VError.js'
+import * as ListProcessGetName from '../ListProcessGetName/ListProcessGetName.js'
+import * as WindowsProcessTree from '../WindowsProcessTree/WindowsProcessTree.js'
+import * as WindowsProcessTreeDataFlag from '../WindowsProcessTreeDataFlag/WindowsProcessTreeDataFlag.js'
+import * as CreatePidMap from '../CreatePidMap/CreatePidMap.js'
+
+/**
+ * @param {import('@vscode/windows-process-tree').IProcessCpuInfo} item
+ * @param {number} rootPid
+ * @param {object} pidMap
+ */
+const toResultItem = (item, rootPid, pidMap) => {
+  return {
+    name: ListProcessGetName.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
+}
+
+export const listProcessesWithMemoryUsage = async (rootPid) => {
+  try {
+    const processList = await WindowsProcessTree.getProcessList(rootPid, WindowsProcessTreeDataFlag.CommandLine | WindowsProcessTreeDataFlag.Memory)
+    if (!processList) {
+      throw new VError(`Root process ${rootPid} not found`)
+    }
+    const pidMap = await CreatePidMap.createPidMap()
+    const completeProcessList = await WindowsProcessTree.addCpuUsage(processList)
+    const result = toResult(completeProcessList, rootPid, pidMap)
+    return result
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, `Failed to list processes`)
+  }
+}

package/src/parts/LoadWindowsProcessTree/LoadWindowsProcessTree.js

@@ -0,0 +1,16 @@
+import { VError } from '../VError/VError.js'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+
+export const loadWindowProcessTree = async () => {
+  try {
+    // @ts-ignore
+    return await import('@vscode/windows-process-tree')
+  } catch (error) {
+    if (error && error instanceof Error && 'code' in error && error.code === ErrorCodes.ERR_DLOPEN_FAILED) {
+      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`)
+  }
+}

package/src/parts/Module/Module.js

@@ -70,6 +70,8 @@ export const load = (moduleId) => {
       return import('../GetTerminalSpawnOptions/GetTerminalSpawnOptions.ipc.js')
     case ModuleId.HandleCliArgs:
       return import('../HandleCliArgs/HandleCliArgs.ipc.js')
+    case ModuleId.ListProcessesWithMemoryUsage:
+      return import('../ListProcessesWithMemoryUsage/ListProcessesWithMemoryUsage.ipc.js')
     default:
       throw new Error(`module ${moduleId} not found`)
   }

package/src/parts/ModuleId/ModuleId.js

@@ -32,3 +32,4 @@ export const HandleElectronMessagePort = 31
 export const HandleNodeMessagePort = 32
 export const GetTerminalSpawnOptions = 33
 export const HandleCliArgs = 34
+export const ListProcessesWithMemoryUsage = 35

package/src/parts/ModuleMap/ModuleMap.js

@@ -168,6 +168,7 @@ export const getModuleId = (commandId) => {
     case 'RebuildNodePty.rebuildNodePty':
       return ModuleId.RebuildNodePty
     case 'Process.getPid':
+    case 'Process.kill':
       return ModuleId.Process
     case 'HandleNodeMessagePort.handleNodeMessagePort':
       return ModuleId.HandleNodeMessagePort
@@ -177,6 +178,8 @@ export const getModuleId = (commandId) => {
       return ModuleId.GetTerminalSpawnOptions
     case 'HandleCliArgs.handleCliArgs':
       return ModuleId.HandleCliArgs
+    case 'ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage':
+      return ModuleId.ListProcessesWithMemoryUsage
     default:
       throw new CommandNotFoundError(commandId)
   }

package/src/parts/ParentIpc/ParentIpc.js

@@ -1,6 +1,7 @@
 import * as HandleIpc from '../HandleIpc/HandleIpc.js'
 import * as IpcChild from '../IpcChild/IpcChild.js'
 import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
 
 // TODO add tests for this
 
@@ -10,6 +11,7 @@ import * as IpcChildType from '../IpcChildType/IpcChildType.js'
 
 export const state = {
   electronPortMap: new Map(),
+  ipc: undefined,
 }
 
 // TODO maybe rename to hydrate
@@ -19,4 +21,10 @@ export const listen = async () => {
     method,
   })
   HandleIpc.handleIpc(ipc)
+  // @ts-ignore
+  state.ipc = ipc
+}
+
+export const invoke = (method, ...params) => {
+  return JsonRpc.invoke(state.ipc, method, ...params)
 }

package/src/parts/ParsePsOutput/ParsePsOutput.js

@@ -0,0 +1,50 @@
+// parse ps output based on vscode https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/node/ps.ts (License MIT)
+
+import * as Assert from '../Assert/Assert.js'
+import * as ListProcessGetName from '../ListProcessGetName/ListProcessGetName.js'
+import * as SplitLines from '../SplitLines/SplitLines.js'
+
+const PID_CMD = /^\s*(\d+)\s+(\d+)\s+([\d.]+)\s+([\d.]+)\s+(.+)$/s
+
+const parsePsOutputLine = (line) => {
+  Assert.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}`)
+}
+
+export const parsePsOutput = (stdout, rootPid, pidMap) => {
+  Assert.string(stdout)
+  Assert.number(rootPid)
+  Assert.object(pidMap)
+  if (stdout === '') {
+    return []
+  }
+  const lines = SplitLines.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: ListProcessGetName.getName(pid, cmd, rootPid, pidMap),
+    })
+    depthMap[pid] = depth + 1
+  }
+  return result
+}

package/src/parts/Process/Process.ipc.js

@@ -6,4 +6,5 @@ export const Commands = {
   crash: Process.crash,
   crashAsync: Process.crashAsync,
   getPid: Process.getPid,
+  kill: Process.kill,
 }

package/src/parts/RebuildNodePty/RebuildNodePty.js

@@ -1,13 +1,10 @@
 import { spawn } from 'node:child_process'
+import * as GetElectronRebuildPath from '../GetElectronRebuildPath/GetElectronRebuildPath.js'
 import * as IsElectron from '../IsElectron/IsElectron.js'
 import * as Path from '../Path/Path.js'
 import * as Root from '../Root/Root.js'
 import { VError } from '../VError/VError.js'
 
-const getElectronRebuildPath = () => {
-  return Path.join(Root.root, 'packages', 'main-process', 'node_modules', '.bin', 'electron-rebuild')
-}
-
 const getPtyHostPath = () => {
   return Path.join(Root.root, 'packages', 'pty-host')
 }
@@ -16,7 +13,7 @@ const getPtyHostPath = () => {
  * @param {string} cwd
  */
 const rebuildNodePtyElectron = async (cwd) => {
-  const electronRebuildPath = getElectronRebuildPath()
+  const electronRebuildPath = GetElectronRebuildPath.getElectronRebuildPath()
   const childProcess = spawn(electronRebuildPath, [], {
     cwd,
     stdio: 'inherit',
@@ -34,14 +31,18 @@ const rebuildNodePtyNode = async (cwd) => {
   })
 }
 
+const getFn = () => {
+  if (IsElectron.isElectron()) {
+    return rebuildNodePtyElectron
+  }
+  return rebuildNodePtyNode
+}
+
 export const rebuildNodePty = async () => {
   try {
     const ptyHostPath = getPtyHostPath()
-    if (IsElectron.isElectron()) {
-      await rebuildNodePtyElectron(ptyHostPath)
-    } else {
-      await rebuildNodePtyNode(ptyHostPath)
-    }
+    const rebuild = getFn()
+    await rebuild(ptyHostPath)
   } catch (error) {
     throw new VError(error, `Failed to rebuild node-pty`)
   }

package/src/parts/RestoreJsonRpcError/RestoreJsonRpcError.js

@@ -0,0 +1,79 @@
+import * as Character from '../Character/Character.js'
+import * as GetErrorConstructor from '../GetErrorConstructor/GetErrorConstructor.js'
+import * as JoinLines from '../JoinLines/JoinLines.js'
+import { JsonRpcError } from '../JsonRpcError/JsonRpcError.js'
+import * as JsonRpcErrorCode from '../JsonRpcErrorCode/JsonRpcErrorCode.js'
+import * as SplitLines from '../SplitLines/SplitLines.js'
+
+const constructError = (message, type, name) => {
+  const ErrorConstructor = GetErrorConstructor.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 recreateStack = (message, stack) => {
+  if (message && !stack.includes(message)) {
+    return message + Character.NewLine + stack
+  }
+  return stack
+}
+
+const getErrorType = (error) => {
+  if (error && error.type) {
+    return error.type
+  }
+  if (error && error.data && error.data.type) {
+    return error.data.type
+  }
+  return ''
+}
+
+export const restoreJsonRpcError = (error) => {
+  if (error && error instanceof Error) {
+    return error
+  }
+  if (error && error.code && error.code === JsonRpcErrorCode.MethodNotFound) {
+    const restoredError = new JsonRpcError(error.message)
+    restoredError.stack = error.stack || error.data || ''
+    return restoredError
+  }
+  if (error && error.message) {
+    const type = getErrorType(error)
+    const restoredError = constructError(error.message, type, error.name)
+    const currentStack = JoinLines.joinLines(SplitLines.splitLines(new Error().stack).slice(1))
+    if (error.data) {
+      if (error.data.stack && type && error.message) {
+        restoredError.stack = type + ': ' + error.message + Character.NewLine + error.data.stack + Character.NewLine + currentStack
+      } else if (error.data.stack) {
+        restoredError.stack = recreateStack(error.message, error.data.stack) + Character.NewLine + currentStack
+      }
+      if (error.data.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.data.codeFrame
+      }
+      if (error.data.code) {
+        // @ts-ignore
+        restoredError.code = error.data.code
+      }
+    } else if (error.stack) {
+      // @ts-ignore
+      restoredError.stack = recreateStack(error.message, error.stack) + Character.NewLine + currentStack
+    }
+    return restoredError
+  }
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`)
+  }
+  console.log({ error })
+  return new Error(`JsonRpc Error: Unknown Error`)
+}

package/src/parts/UnwrapJsonRpcResult/UnwrapJsonRpcResult.js

@@ -0,0 +1,13 @@
+import { JsonRpcError } from '../JsonRpcError/JsonRpcError.js'
+import * as RestoreJsonRpcError from '../RestoreJsonRpcError/RestoreJsonRpcError.js'
+
+export const unwrapJsonRpcResult = (responseMessage) => {
+  if ('error' in responseMessage) {
+    const restoredError = RestoreJsonRpcError.restoreJsonRpcError(responseMessage.error)
+    throw restoredError
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result
+  }
+  throw new JsonRpcError('unexpected response message')
+}

package/src/parts/WindowsProcessTree/WindowsProcessTree.js

@@ -0,0 +1,26 @@
+import * as LoadWindowsProcessTree from '../LoadWindowsProcessTree/LoadWindowsProcessTree.js'
+
+/**
+ *
+ * @param {number} rootPid
+ * @param {WindowsProcessTree.ProcessDataFlag} flags
+ * @returns {Promise<WindowsProcessTree.IProcessInfo[] | undefined>}
+ */
+export const getProcessList = async (rootPid, flags) => {
+  const WindowsProcessTree = await LoadWindowsProcessTree.loadWindowProcessTree()
+  return new Promise((resolve, reject) => {
+    WindowsProcessTree.getProcessList(rootPid, resolve, flags)
+  })
+}
+
+/**
+ *
+ * @param {WindowsProcessTree.IProcessInfo[]} processList
+ * @returns Promise< WindowsProcessTree.IProcessCpuInfo[]>
+ */
+export const addCpuUsage = async (processList) => {
+  const WindowsProcessTree = await LoadWindowsProcessTree.loadWindowProcessTree()
+  return new Promise((resolve) => {
+    WindowsProcessTree.getProcessCpuUsage(processList, resolve)
+  })
+}

package/src/parts/WindowsProcessTreeDataFlag/WindowsProcessTreeDataFlag.js

@@ -0,0 +1,3 @@
+export const None = 0
+export const Memory = 1
+export const CommandLine = 2