@lvce-editor/process-explorer 3.22.0 → 3.23.0

package/dist/index.js

@@ -1,5 +1,9 @@
 import { spawn, execFile as execFile$2 } from 'node:child_process';
 import { promisify } from 'node:util';
+import { createWriteStream, readFileSync } from 'node:fs';
+import { readdir, readlink, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2$1 from 'http';
@@ -11,10 +15,8 @@ import require$$7 from 'url';
 import require$$0 from 'zlib';
 import require$$0$1 from 'buffer';
 import require$$2 from 'util';
+import { setTimeout as setTimeout$1 } from 'node:timers/promises';
 import { Buffer as Buffer$1 } from 'node:buffer';
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { readFileSync } from 'node:fs';
 
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
@@ -82,7 +84,7 @@ const Object$1 = 1;
 const Number$1 = 2;
 const Array$1 = 3;
 const String$1 = 4;
-const Boolean = 5;
+const Boolean$1 = 5;
 const Function = 6;
 const Null = 7;
 const Unknown = 8;
@@ -103,7 +105,7 @@ const getType = value => {
       }
       return Object$1;
     case 'boolean':
-      return Boolean;
+      return Boolean$1;
     default:
       return Unknown;
   }
@@ -1497,11 +1499,12 @@ const kill = (pid, signal) => {
 
 const SIGINT = 'SIGINT';
 const SIGTERM = 'SIGTERM';
+const SIGUSR1 = 'SIGUSR1';
 
 const fixtureScript = 'setTimeout(() => process.exit(0), 120_000); setInterval(() => {}, 1000)';
 const fixtureProcesses = new Map();
 const createE2eFixtureProcess = marker => {
-  const childProcess = spawn(process.execPath, ['-e', fixtureScript, marker], {
+  const childProcess = spawn(process.execPath, ['--inspect=9000', '-e', fixtureScript, marker], {
     env: {
       ...process.env,
       ELECTRON_RUN_AS_NODE: '1'
@@ -1725,91 +1728,6 @@ const getMainProcessId = ({
   return getRemoteRootProcessId(childProcessId);
 };
 
-const commandMap = {
-  'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort,
-  'HandleMessagePort.handleMessagePort': handleMessagePort,
-  'HandleSocket.handleSocket': handleSocket,
-  'HandleWebSocket.handleWebSocket': handleWebSocket,
-  'ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage': listProcessesWithMemoryUsage$2,
-  'Process.createE2eFixtureProcess': createE2eFixtureProcess,
-  'Process.disposeE2eFixtureProcess': disposeE2eFixtureProcess,
-  'Process.kill': killProcess,
-  'ProcessId.getMainProcessId': getMainProcessId
-};
-
-const set$1 = commandMap => {
-  state.commandMap = commandMap;
-};
-
-const set = commandMap => {
-  set$1(commandMap);
-};
-
-const NodeWorker = 1;
-const NodeForkedProcess = 2;
-const ElectronUtilityProcess = 3;
-const ElectronMessagePort = 4;
-const WebSocket$1 = 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 = method => {
-  switch (method) {
-    case ElectronMessagePort:
-      return create$6;
-    case ElectronUtilityProcess:
-      return create$5;
-    case NodeForkedProcess:
-      return create$3;
-    case NodeWorker:
-      return create$1;
-    case WebSocket$1:
-      return create$2;
-    default:
-      throw new Error('unexpected ipc type');
-  }
-};
-
-const listen$1 = async ({
-  method,
-  ...params
-}) => {
-  const create = getModule(method);
-  const rpc = await create(params);
-  return rpc;
-};
-
-const registerLaunchParentRpc = rpc => {
-  setRpc(rpc, SharedProcess);
-};
-const listen = async () => {
-  set(commandMap);
-  const rpc = await listen$1({
-    commandMap: commandMap,
-    method: Auto()
-  });
-  registerLaunchParentRpc(rpc);
-};
-
-const main = async () => {
-  await listen();
-};
-
-main();
-
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -2165,7 +2083,7 @@ function requirePermessageDeflate() {
     acceptAsServer(offers) {
       const opts = this._options;
       const accepted = offers.find(params => {
-        if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === 'number' && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === 'number' && !params.client_max_window_bits) {
+        if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === 'number' && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === 'number' && (typeof params.client_max_window_bits === 'number' ? opts.clientMaxWindowBits > params.client_max_window_bits : !params.client_max_window_bits)) {
           return false;
         }
         return true;
@@ -5589,7 +5507,7 @@ function requireSubprotocol() {
 requireSubprotocol();
 
 var websocketExports = requireWebsocket();
-const WebSocket = /*@__PURE__*/getDefaultExportFromCjs(websocketExports);
+const WebSocket$1 = /*@__PURE__*/getDefaultExportFromCjs(websocketExports);
 
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */
 var websocketServer$1;
@@ -6064,10 +5982,354 @@ const websocketServer = /*@__PURE__*/getDefaultExportFromCjs(websocketServerExpo
 
 const wrapper = {
   __proto__: null,
-  WebSocket,
+  WebSocket: WebSocket$1,
   WebSocketServer: websocketServer,
-  default: WebSocket
+  default: WebSocket$1
+};
+
+const defaultInspectorPorts = [9000, 9229];
+const inspectOptionRegex = /--inspect(?:-brk|-wait|-port)?(?:=|\s+)([^\s"']+)/g;
+const digitsRegex = /^\d+$/;
+const getInspectorPortsFromCommand = command => {
+  const ports = new Set(defaultInspectorPorts);
+  for (const match of command.matchAll(inspectOptionRegex)) {
+    const portText = match[1].split(':').at(-1) || '';
+    const port = digitsRegex.test(portText) ? Number(portText) : 0;
+    if (port > 0 && port <= 65_535) {
+      ports.add(port);
+    }
+  }
+  return [...ports];
+};
+
+const commandId$1 = 1;
+const timeoutMs$1 = 2000;
+const getInspectorProcessId = url => {
+  return new Promise(resolve => {
+    const webSocket = new WebSocket$1(url);
+    let settled = false;
+    const finish = pid => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      webSocket.close();
+      resolve(pid);
+    };
+    const timeout = setTimeout(finish, timeoutMs$1, 0);
+    webSocket.on('error', () => finish(0));
+    webSocket.on('close', () => finish(0));
+    webSocket.on('message', data => {
+      try {
+        const message = JSON.parse(data.toString());
+        if (message.id !== commandId$1) {
+          return;
+        }
+        const value = message.result?.result?.value;
+        finish(typeof value === 'number' ? value : 0);
+      } catch {
+        finish(0);
+      }
+    });
+    webSocket.on('open', () => {
+      webSocket.send(JSON.stringify({
+        id: commandId$1,
+        method: 'Runtime.evaluate',
+        params: {
+          expression: 'process.pid',
+          returnByValue: true
+        }
+      }));
+    });
+  });
+};
+
+const socketRegex = /^socket:\[(\d+)\]$/;
+const whitespaceRegex = /\s+/;
+const parseProcNetTcp = (content, socketInodes) => {
+  const ports = [];
+  const lines = content.split('\n').slice(1);
+  for (const line of lines) {
+    const fields = line.trim().split(whitespaceRegex);
+    if (fields.length < 10 || fields[3] !== '0A') {
+      continue;
+    }
+    const inode = fields[9];
+    if (!socketInodes.has(inode)) {
+      continue;
+    }
+    const separatorIndex = fields[1].lastIndexOf(':');
+    const port = Number.parseInt(fields[1].slice(separatorIndex + 1), 16);
+    if (port > 0) {
+      ports.push(port);
+    }
+  }
+  return ports;
+};
+const getSocketInodes = async pid => {
+  const directory = `/proc/${pid}/fd`;
+  const entries = await readdir(directory);
+  const links = await Promise.allSettled(entries.map(entry => readlink(`${directory}/${entry}`)));
+  const inodes = new Set();
+  for (const link of links) {
+    if (link.status !== 'fulfilled') {
+      continue;
+    }
+    const match = link.value.match(socketRegex);
+    if (match) {
+      inodes.add(match[1]);
+    }
+  }
+  return inodes;
+};
+const readNetworkTable = async path => {
+  try {
+    return await readFile(path, 'utf8');
+  } catch {
+    return '';
+  }
 };
+const getLinuxProcessListeningPorts = async pid => {
+  try {
+    const socketInodes = await getSocketInodes(pid);
+    const [tcp, tcp6] = await Promise.all([readNetworkTable(`/proc/${pid}/net/tcp`), readNetworkTable(`/proc/${pid}/net/tcp6`)]);
+    return [...parseProcNetTcp(tcp, socketInodes), ...parseProcNetTcp(tcp6, socketInodes)];
+  } catch {
+    return [];
+  }
+};
+
+const getProcessListeningPorts = async pid => {
+  if (process.platform !== 'linux') {
+    return [];
+  }
+  return getLinuxProcessListeningPorts(pid);
+};
+
+const maxAttempts = 50;
+const retryDelay = 100;
+const getInspectorWebSocketUrlAtPort = async (pid, port) => {
+  try {
+    const response = await fetch(`http://127.0.0.1:${port}/json/list`, {
+      signal: AbortSignal.timeout(500)
+    });
+    if (!response.ok) {
+      return '';
+    }
+    const targets = await response.json();
+    if (!Array.isArray(targets)) {
+      return '';
+    }
+    const pidSuffix = `[${pid}]`;
+    for (const target of targets) {
+      const {
+        title = '',
+        webSocketDebuggerUrl = ''
+      } = target;
+      if (!webSocketDebuggerUrl) {
+        continue;
+      }
+      if (title.endsWith(pidSuffix)) {
+        return webSocketDebuggerUrl;
+      }
+      const inspectorPid = await getInspectorProcessId(webSocketDebuggerUrl);
+      if (inspectorPid === pid) {
+        return webSocketDebuggerUrl;
+      }
+    }
+    return '';
+  } catch {
+    return '';
+  }
+};
+const getInspectorWebSocketUrl = async (pid, command) => {
+  const commandPorts = getInspectorPortsFromCommand(command);
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const listeningPorts = await getProcessListeningPorts(pid);
+    const ports = new Set([...commandPorts, ...listeningPorts]);
+    const urls = await Promise.all(Array.from(ports, port => getInspectorWebSocketUrlAtPort(pid, port)));
+    const url = urls.find(Boolean);
+    if (url) {
+      return url;
+    }
+    await setTimeout$1(retryDelay);
+  }
+  throw new Error(`Could not find the inspector for process ${pid}`);
+};
+
+const commandId = 1;
+const timeoutMs = 5 * 60 * 1000;
+const takeHeapSnapshotWithCdp = (webSocket, output) => {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timeout = setTimeout(() => {
+      fail(new Error('Timed out while taking the heap snapshot'));
+    }, timeoutMs);
+    const dispose = () => {
+      clearTimeout(timeout);
+      webSocket.close();
+    };
+    const fail = error => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      output.destroy();
+      dispose();
+      reject(error);
+    };
+    output.on('error', fail);
+    webSocket.on('error', fail);
+    webSocket.on('close', () => {
+      fail(new Error('Inspector connection closed while taking heap snapshot'));
+    });
+    webSocket.on('message', data => {
+      try {
+        const message = JSON.parse(data.toString());
+        if (message.method === 'HeapProfiler.addHeapSnapshotChunk') {
+          const chunk = message.params?.chunk;
+          if (!output.write(chunk)) {
+            webSocket.pause();
+            output.once('drain', () => webSocket.resume());
+          }
+          return;
+        }
+        if (message.id !== commandId) {
+          return;
+        }
+        if (message.error) {
+          fail(new Error(message.error.message));
+          return;
+        }
+        output.end(() => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          dispose();
+          resolve();
+        });
+      } catch (error) {
+        fail(new Error('Failed to handle inspector message', {
+          cause: error
+        }));
+      }
+    });
+    webSocket.on('open', () => {
+      webSocket.send(JSON.stringify({
+        id: commandId,
+        method: 'HeapProfiler.takeHeapSnapshot',
+        params: {
+          reportProgress: false
+        }
+      }));
+    });
+  });
+};
+
+const takeHeapSnapshot = async (pid, command) => {
+  kill(pid, SIGUSR1);
+  const inspectorUrl = await getInspectorWebSocketUrl(pid, command);
+  const path = join(tmpdir(), `lvce-process-${pid}-${Date.now()}.heapsnapshot`);
+  const webSocket = new WebSocket$1(inspectorUrl);
+  const output = createWriteStream(path);
+  try {
+    await takeHeapSnapshotWithCdp(webSocket, output);
+    return path;
+  } catch (error) {
+    await rm(path, {
+      force: true
+    });
+    throw error;
+  }
+};
+
+const commandMap = {
+  'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort,
+  'HandleMessagePort.handleMessagePort': handleMessagePort,
+  'HandleSocket.handleSocket': handleSocket,
+  'HandleWebSocket.handleWebSocket': handleWebSocket,
+  'ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage': listProcessesWithMemoryUsage$2,
+  'Process.createE2eFixtureProcess': createE2eFixtureProcess,
+  'Process.disposeE2eFixtureProcess': disposeE2eFixtureProcess,
+  'Process.kill': killProcess,
+  'Process.takeHeapSnapshot': takeHeapSnapshot,
+  'ProcessId.getMainProcessId': getMainProcessId
+};
+
+const set$1 = commandMap => {
+  state.commandMap = commandMap;
+};
+
+const set = commandMap => {
+  set$1(commandMap);
+};
+
+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 = method => {
+  switch (method) {
+    case ElectronMessagePort:
+      return create$6;
+    case ElectronUtilityProcess:
+      return create$5;
+    case NodeForkedProcess:
+      return create$3;
+    case NodeWorker:
+      return create$1;
+    case WebSocket:
+      return create$2;
+    default:
+      throw new Error('unexpected ipc type');
+  }
+};
+
+const listen$1 = async ({
+  method,
+  ...params
+}) => {
+  const create = getModule(method);
+  const rpc = await create(params);
+  return rpc;
+};
+
+const registerLaunchParentRpc = rpc => {
+  setRpc(rpc, SharedProcess);
+};
+const listen = async () => {
+  set(commandMap);
+  const rpc = await listen$1({
+    commandMap: commandMap,
+    method: Auto()
+  });
+  registerLaunchParentRpc(rpc);
+};
+
+const main = async () => {
+  await listen();
+};
+
+main();
 
 const createWebSocketServer = async () => {
   const _ws = await Promise.resolve().then(function () { return wrapper; });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/process-explorer",
-  "version": "3.22.0",
+  "version": "3.23.0",
   "description": "Process Explorer",
   "main": "dist/index.js",
   "bin": "bin/processExplorer.js",