@lvce-editor/shared-process 0.25.11 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.25.11",
+  "version": "0.26.0",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -18,12 +18,12 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "^1.2.0",
-    "@lvce-editor/extension-host-helper-process": "0.25.11",
-    "@lvce-editor/ipc": "^3.7.1",
+    "@lvce-editor/extension-host-helper-process": "0.26.0",
+    "@lvce-editor/ipc": "^5.1.0",
     "@lvce-editor/json-rpc": "^1.3.0",
     "@lvce-editor/jsonc-parser": "^1.2.0",
     "@lvce-editor/pretty-error": "^1.5.0",
-    "@lvce-editor/pty-host": "0.25.11",
+    "@lvce-editor/pty-host": "0.26.0",
     "@lvce-editor/verror": "^1.2.0",
     "@lvce-editor/web-socket-server": "^1.1.0",
     "debug": "^4.3.4",

package/src/parts/ContentSecurityPolicyDiffWorker/ContentSecurityPolicyDiffWorker.js

@@ -0,0 +1,2 @@
+import * as GetContentSecurityPolicy from '../GetContentSecurityPolicy/GetContentSecurityPolicy.js';
+export const value = GetContentSecurityPolicy.getContentSecurityPolicy([`default-src 'none'`, `script-src 'self'`]);

package/src/parts/ContentSecurityPolicyEmbedsWorker/ContentSecurityPolicyEmbedsWorker.js

@@ -0,0 +1,2 @@
+import * as GetContentSecurityPolicy from '../GetContentSecurityPolicy/GetContentSecurityPolicy.js';
+export const value = GetContentSecurityPolicy.getContentSecurityPolicy([`default-src 'none'`, `script-src 'self'`]);

package/src/parts/EmbedsProcess/EmbedsProcess.js

@@ -0,0 +1,22 @@
+import * as JsonRpc from '../JsonRpc/JsonRpc.js';
+import * as LaunchEmbedsProcess from '../LaunchEmbedsProcess/LaunchEmbedsProcess.js';
+export const state = {
+    /**
+     * @type {any}
+     */
+    ipc: undefined,
+};
+export const getOrCreate = async () => {
+    if (!state.ipc) {
+        state.ipc = LaunchEmbedsProcess.launchEmbedsProcess();
+    }
+    return state.ipc;
+};
+export const invoke = async (method, ...params) => {
+    const ipc = await getOrCreate();
+    return JsonRpc.invoke(ipc, method, ...params);
+};
+export const invokeAndTransfer = async (method, transfer, ...params) => {
+    const ipc = await getOrCreate();
+    return JsonRpc.invokeAndTransfer(ipc, transfer, method, ...params);
+};

package/src/parts/EmbedsProcessPath/EmbedsProcessPath.js

@@ -0,0 +1,3 @@
+import * as Path from '../Path/Path.js';
+import * as Root from '../Root/Root.js';
+export const embedsProcessPath = Path.join(Root.root, 'packages', 'embeds-process', 'src', 'embedsProcessMain.js');

package/src/parts/GetHeaders/GetHeaders.js

@@ -1,5 +1,6 @@
 import { extname } from 'path';
 import * as GetHeadersDefault from '../GetHeadersDefault/GetHeadersDefault.js';
+import * as GetHeadersEmbedsWorker from '../GetHeadersEmbedsWorker/GetHeadersEmbedsWorker.js';
 import * as GetHeadersExtensionHostWorker from '../GetHeadersExtensionHostWorker/GetHeadersExtensionHostWorker.js';
 import * as GetHeadersMainFrame from '../GetHeadersMainFrame/GetHeadersMainFrame.js';
 import * as GetHeadersOtherWorker from '../GetHeadersOtherWorker/GetHeadersOtherWorker.js';
@@ -30,6 +31,9 @@ const getExtraHeaders = (pathName, fileExtension) => {
             if (pathName.endsWith('syntaxHighlightingWorkerMain.js') || pathName.endsWith('syntaxHighlightingWorkerMain.ts')) {
                 return GetHeadersSyntaxHighlightingWorker.getHeadersSyntaxHighlightingWorker();
             }
+            if (pathName.endsWith('embedsWorkerMain.js') || pathName.endsWith('embedsWorkerMain.ts')) {
+                return GetHeadersEmbedsWorker.getHeadersEmbedsWorker();
+            }
             if (pathName.endsWith('WorkerMain.js') || pathName.endsWith('WorkerMain.ts')) {
                 return GetHeadersOtherWorker.getHeadersOtherWorker(pathName);
             }

package/src/parts/GetHeadersEmbedsWorker/GetHeadersEmbedsWorker.js

@@ -0,0 +1,9 @@
+import * as ContentSecurityPolicyEmbedsWorker from '../ContentSecurityPolicyEmbedsWorker/ContentSecurityPolicyEmbedsWorker.js';
+import * as CrossOriginEmbedderPolicy from '../CrossOriginEmbedderPolicy/CrossOriginEmbedderPolicy.js';
+import * as HttpHeader from '../HttpHeader/HttpHeader.js';
+export const getHeadersEmbedsWorker = () => {
+    return {
+        [HttpHeader.CrossOriginEmbedderPolicy]: CrossOriginEmbedderPolicy.value,
+        [HttpHeader.ContentSecurityPolicy]: ContentSecurityPolicyEmbedsWorker.value,
+    };
+};

package/src/parts/GetPortTuple/GetPortTuple.js

@@ -0,0 +1,6 @@
+import * as TemporaryMessagePort from '../TemporaryMessagePort/TemporaryMessagePort.js';
+// workaround for MessageChannelMain not being available in utility process
+export const getPortTuple = async () => {
+    const { port1, port2 } = await TemporaryMessagePort.getPortTuple();
+    return { port1, port2 };
+};

package/src/parts/HandleElectronMessagePort/HandleElectronMessagePort.js

@@ -2,6 +2,8 @@ import * as Assert from '../Assert/Assert.js';
 import * as HandleIpc from '../HandleIpc/HandleIpc.js';
 import * as IpcChild from '../IpcChild/IpcChild.js';
 import * as IpcChildType from '../IpcChildType/IpcChildType.js';
+import * as ParentIpc from '../ParentIpc/ParentIpc.js';
+const mainProcessSpecialId = -5;
 export const handleElectronMessagePort = async (messagePort, ...params) => {
     Assert.object(messagePort);
     const ipc = await IpcChild.listen({
@@ -9,6 +11,12 @@ export const handleElectronMessagePort = async (messagePort, ...params) => {
         messagePort,
     });
     HandleIpc.handleIpc(ipc);
+    if (params[0] === mainProcessSpecialId) {
+        // update ipc with message port ipc that supports transferring objects
+        // @ts-ignore
+        ParentIpc.state.ipc = ipc;
+    }
     // TODO find better way to associate configuration with ipc
+    // @ts-ignore
     ipc.windowId = params[1];
 };

package/src/parts/HandleIpc/HandleIpc.js

@@ -1,22 +1,4 @@
-import * as Callback from '../Callback/Callback.js';
-import * as Command from '../Command/Command.js';
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
-import * as PrettyError from '../PrettyError/PrettyError.js';
-import * as PrintPrettyError from '../PrintPrettyError/PrintPrettyError.js';
-import * as RequiresSocket from '../RequiresSocket/RequiresSocket.js';
-import * as ShouldLogError from '../ShouldLogError/ShouldLogError.js';
-const preparePrettyError = PrettyError.prepare;
-const logError = (error, prettyError) => {
-    if (ShouldLogError.shouldLogError(error)) {
-        PrintPrettyError.printPrettyError(prettyError, `[shared-process] `);
-    }
-};
+import * as HandleMessage from '../HandleMessage/HandleMessage.js';
 export const handleIpc = (ipc) => {
-    const handleMessage = (message) => {
-        return JsonRpc.handleJsonRpcMessage(ipc, message, Command.execute, Callback.resolve, preparePrettyError, logError, RequiresSocket.requiresSocket);
-    };
-    ipc.on('message', handleMessage);
-    if (ipc.start) {
-        ipc.start();
-    }
+    ipc.on('message', HandleMessage.handleMessage);
 };

package/src/parts/HandleMessage/HandleMessage.js

@@ -0,0 +1,16 @@
+import * as Callback from '../Callback/Callback.js';
+import * as Command from '../Command/Command.js';
+import * as JsonRpc from '../JsonRpc/JsonRpc.js';
+import * as PrettyError from '../PrettyError/PrettyError.js';
+import * as PrintPrettyError from '../PrintPrettyError/PrintPrettyError.js';
+import * as RequiresSocket from '../RequiresSocket/RequiresSocket.js';
+import * as ShouldLogError from '../ShouldLogError/ShouldLogError.js';
+const preparePrettyError = PrettyError.prepare;
+const logError = (error, prettyError) => {
+    if (ShouldLogError.shouldLogError(error)) {
+        PrintPrettyError.printPrettyError(prettyError, `[shared-process] `);
+    }
+};
+export const handleMessage = (event) => {
+    return JsonRpc.handleJsonRpcMessage(event.target, event.data, Command.execute, Callback.resolve, preparePrettyError, logError, RequiresSocket.requiresSocket);
+};

package/src/parts/HandleMessagePortForEmbedsProcess/HandleMessagePortForEmbedsProcess.ipc.js

@@ -0,0 +1,5 @@
+import * as HandleMessagePortForEmbedsProcess from './HandleMessagePortForEmbedsProcess.js';
+export const name = 'HandleMessagePortForEmbedsProcess';
+export const Commands = {
+    handleMessagePortForEmbedsProcess: HandleMessagePortForEmbedsProcess.handleMessagePortForEmbedsProcess,
+};

package/src/parts/HandleMessagePortForEmbedsProcess/HandleMessagePortForEmbedsProcess.js

@@ -0,0 +1,8 @@
+import * as Assert from '../Assert/Assert.js';
+import * as EmbedsProcess from '../EmbedsProcess/EmbedsProcess.js';
+import * as JsonRpc from '../JsonRpc/JsonRpc.js';
+export const handleMessagePortForEmbedsProcess = async (port) => {
+    Assert.object(port);
+    const embedsProcess = await EmbedsProcess.getOrCreate();
+    await JsonRpc.invokeAndTransfer(embedsProcess, [port], 'HandleElectronMessagePort.handleElectronMessagePort');
+};

package/src/parts/HandleMessagePortForProcessExplorer/HandleMessagePortForProcessExplorer.ipc.js

@@ -0,0 +1,5 @@
+import * as HandleMessagePortForProcessExplorer from './HandleMessagePortForProcessExplorer.js';
+export const name = 'HandleMessagePortForProcessExplorer';
+export const Commands = {
+    handleMessagePortForProcessExplorer: HandleMessagePortForProcessExplorer.handleMessagePortForProcessExplorer,
+};

package/src/parts/HandleMessagePortForProcessExplorer/HandleMessagePortForProcessExplorer.js

@@ -0,0 +1,8 @@
+import * as Assert from '../Assert/Assert.js';
+import * as JsonRpc from '../JsonRpc/JsonRpc.js';
+import * as ProcessExplorer from '../ProcessExplorer/ProcessExplorer.js';
+export const handleMessagePortForProcessExplorer = async (port) => {
+    Assert.object(port);
+    const ipc = await ProcessExplorer.getOrCreate();
+    await JsonRpc.invokeAndTransfer(ipc, [port], 'HandleElectronMessagePort.handleElectronMessagePort');
+};

package/src/parts/HandleMessagePortForSearchProcess/HandleMessagePortForSearchProcess.ipc.js

@@ -0,0 +1,5 @@
+import * as HandleMessagePortForSearchProcess from './HandleMessagePortForSearchProcess.js';
+export const name = 'HandleMessagePortForSearchProcess';
+export const Commands = {
+    handleMessagePortForSearchProcess: HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess,
+};

package/src/parts/HandleMessagePortForSearchProcess/HandleMessagePortForSearchProcess.js

@@ -0,0 +1,8 @@
+import * as Assert from '../Assert/Assert.js';
+import * as SearchProcess from '../SearchProcess/SearchProcess.js';
+import * as JsonRpc from '../JsonRpc/JsonRpc.js';
+export const handleMessagePortForSearchProcess = async (port) => {
+    Assert.object(port);
+    const ipc = await SearchProcess.getOrCreate();
+    await JsonRpc.invokeAndTransfer(ipc, [port], 'HandleElectronMessagePort.handleElectronMessagePort');
+};

package/src/parts/IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js

@@ -40,6 +40,9 @@ export const wrap = (messagePort) => {
         send(message) {
             this.messagePort.postMessage(message);
         },
+        sendAndTransfer(message, transfer) {
+            this.messagePort.postMessage(message, transfer);
+        },
         dispose() {
             this.messagePort.close();
         },

package/src/parts/IpcChildWithNodeMessagePort/IpcChildWithNodeMessagePort.js

@@ -16,7 +16,11 @@ export const wrap = (messagePort) => {
             if (event === 'message') {
                 const wrappedListener = (event) => {
                     const actualData = getActualData(event);
-                    listener(actualData);
+                    const syntheticEvent = {
+                        data: actualData,
+                        target: this,
+                    };
+                    listener(syntheticEvent);
                 };
                 this.messagePort.on(event, wrappedListener);
             }

package/src/parts/IpcParentWithElectronUtilityProcess/IpcParentWithElectronUtilityProcess.js

@@ -1,3 +1,4 @@
+import * as GetPortTuple from '../GetPortTuple/GetPortTuple.js';
 import * as ParentIpc from '../ParentIpc/ParentIpc.js';
 import * as TemporaryMessagePort from '../TemporaryMessagePort/TemporaryMessagePort.js';
 const ElectronUtilityProcess = 3;
@@ -9,10 +10,14 @@ export const create = async (options) => {
         method: ElectronUtilityProcess,
         noReturn: true,
     });
+    const { port1, port2 } = await GetPortTuple.getPortTuple();
     // TODO use uuid instead of name
-    const port = await TemporaryMessagePort.create(options.name);
-    port.name = options.name;
-    return port;
+    await TemporaryMessagePort.sendTo(options.name, port2);
+    port1.start();
+    return port1;
+};
+export const signal = (port) => {
+    port.start();
 };
 export const wrap = (port) => {
     return {
@@ -30,7 +35,11 @@ export const wrap = (port) => {
                     break;
                 case 'message':
                     const wrapped = (event) => {
-                        listener(event.data);
+                        const syntheticEvent = {
+                            data: event.data,
+                            target: this,
+                        };
+                        listener(syntheticEvent);
                     };
                     this.port.on(event, wrapped);
                     break;

package/src/parts/LaunchEmbedsProcess/LaunchEmbedsProcess.js

@@ -0,0 +1,21 @@
+import * as EmbedsProcessPath from '../EmbedsProcessPath/EmbedsProcessPath.js';
+import * as GetPortTuple from '../GetPortTuple/GetPortTuple.js';
+import * as HandleIpc from '../HandleIpc/HandleIpc.js';
+import * as IpcParent from '../IpcParent/IpcParent.js';
+import * as IpcParentType from '../IpcParentType/IpcParentType.js';
+import * as JsonRpc from '../JsonRpc/JsonRpc.js';
+import * as ParentIpc from '../ParentIpc/ParentIpc.js';
+export const launchEmbedsProcess = async () => {
+    const embedsProcess = await IpcParent.create({
+        method: IpcParentType.ElectronUtilityProcess,
+        path: EmbedsProcessPath.embedsProcessPath,
+        argv: [],
+        stdio: 'inherit',
+        name: 'Embeds Process',
+    });
+    HandleIpc.handleIpc(embedsProcess);
+    const { port1, port2 } = await GetPortTuple.getPortTuple();
+    await JsonRpc.invokeAndTransfer(embedsProcess, [port1], 'HandleElectronMessagePort.handleElectronMessagePort', /* isElectron */ true);
+    await ParentIpc.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', [port2]);
+    return embedsProcess;
+};

package/src/parts/LaunchProcessExplorer/LaunchProcessExplorer.js

@@ -0,0 +1,21 @@
+import * as GetPortTuple from '../GetPortTuple/GetPortTuple.js';
+import * as HandleIpc from '../HandleIpc/HandleIpc.js';
+import * as IpcParent from '../IpcParent/IpcParent.js';
+import * as IpcParentType from '../IpcParentType/IpcParentType.js';
+import * as JsonRpc from '../JsonRpc/JsonRpc.js';
+import * as ParentIpc from '../ParentIpc/ParentIpc.js';
+import * as ProcessExplorerPath from '../ProcessExplorerPath/ProcessExplorerPath.js';
+export const launchProcessExplorer = async () => {
+    const ipc = await IpcParent.create({
+        method: IpcParentType.ElectronUtilityProcess,
+        path: ProcessExplorerPath.processExplorerPath,
+        argv: [],
+        stdio: 'inherit',
+        name: 'Process Process',
+    });
+    HandleIpc.handleIpc(ipc);
+    const { port1, port2 } = await GetPortTuple.getPortTuple();
+    await JsonRpc.invokeAndTransfer(ipc, [port1], 'HandleElectronMessagePort.handleElectronMessagePort');
+    await ParentIpc.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', [port2]);
+    return ipc;
+};

package/src/parts/LaunchPtyHost/LaunchPtyHost.js

@@ -0,0 +1,37 @@
+import exitHook from 'exit-hook';
+import * as Debug from '../Debug/Debug.js';
+import * as HandleIpc from '../HandleIpc/HandleIpc.js';
+import * as IpcParent from '../IpcParent/IpcParent.js';
+import * as PtyHostPath from '../PtyHostPath/PtyHostPath.js';
+import * as PtyHostState from '../PtyHostState/PtyHostState.js';
+const cleanUpAll = () => {
+    if (PtyHostState.state.ipc) {
+        PtyHostState.state.ipc.dispose();
+        PtyHostState.state.ipc = undefined;
+    }
+};
+const handleProcessExit = () => {
+    Debug.debug('shared process exit, clean terminals');
+    cleanUpAll();
+};
+export const launchPtyHost = async (method) => {
+    exitHook(handleProcessExit);
+    const ptyHostPath = await PtyHostPath.getPtyHostPath();
+    const ptyHost = await IpcParent.create({
+        method,
+        path: ptyHostPath,
+        argv: [],
+        stdio: 'inherit',
+        name: 'Terminal Process',
+    });
+    HandleIpc.handleIpc(ptyHost);
+    const handleClose = () => {
+        // @ts-ignore
+        ptyHost.off('close', handleClose);
+        PtyHostState.state.ipc = undefined;
+        PtyHostState.state.ptyHostPromise = undefined;
+    };
+    ptyHost.on('close', handleClose);
+    PtyHostState.state.ipc = ptyHost;
+    return ptyHost;
+};

package/src/parts/LaunchSearchProcess/LaunchSearchProcess.js

@@ -0,0 +1,15 @@
+import * as SearchProcessPath from '../SearchProcessPath/SearchProcessPath.js';
+import * as HandleIpc from '../HandleIpc/HandleIpc.js';
+import * as IpcParent from '../IpcParent/IpcParent.js';
+import * as IpcParentType from '../IpcParentType/IpcParentType.js';
+export const launchSearchProcess = async () => {
+    const embedsProcess = await IpcParent.create({
+        method: IpcParentType.ElectronUtilityProcess,
+        path: SearchProcessPath.searchProcessPath,
+        argv: [],
+        stdio: 'inherit',
+        name: 'Search Process',
+    });
+    HandleIpc.handleIpc(embedsProcess);
+    return embedsProcess;
+};

package/src/parts/Module/Module.js

@@ -79,8 +79,6 @@ export const load = (moduleId) => {
             return import('../InstallExtension/InstallExtension.ipc.js');
         case ModuleId.IsAutoUpdateSupported:
             return import('../IsAutoUpdateSupported/IsAutoUpdateSupported.ipc.js');
-        case ModuleId.ListProcessesWithMemoryUsage:
-            return import('../ListProcessesWithMemoryUsage/ListProcessesWithMemoryUsage.ipc.js');
         case ModuleId.OpenExternal:
             return import('../OpenExternal/OpenExternal.ipc.js');
         case ModuleId.OpenNativeFolder:
@@ -129,6 +127,8 @@ export const load = (moduleId) => {
             return import('../HandleWindowAllClosed/HandleWindowAllClosed.ipc.js');
         case ModuleId.HandleMessagePortForTerminalProcess:
             return import('../HandleMessagePortForTerminalProcess/HandleMessagePortForTerminalProcess.ipc.js');
+        case ModuleId.HandleMessagePortForEmbedsProcess:
+            return import('../HandleMessagePortForEmbedsProcess/HandleMessagePortForEmbedsProcess.ipc.js');
         case ModuleId.TemporaryMessagePort:
             return import('../TemporaryMessagePort/TemporaryMessagePort.ipc.js');
         case ModuleId.GetElectronFileResponse:
@@ -145,6 +145,10 @@ export const load = (moduleId) => {
             return import('../ElectronWebContentsViewFunctions/ElectronWebContentsViewFunctions.ipc.js');
         case ModuleId.ContentSecurityPolicy:
             return import('../ContentSecurityPolicy/ContentSecurityPolicy.ipc.js');
+        case ModuleId.HandleMessagePortForProcessExplorer:
+            return import('../HandleMessagePortForProcessExplorer/HandleMessagePortForProcessExplorer.ipc.js');
+        case ModuleId.HandleMessagePortForSearchProcess:
+            return import('../HandleMessagePortForSearchProcess/HandleMessagePortForSearchProcess.ipc.js');
         default:
             throw new Error(`module ${moduleId} not found`);
     }

package/src/parts/ModuleId/ModuleId.js

@@ -74,3 +74,6 @@ export const ElectronWebContentsView = 67;
 export const ElectronWebContentsViewFunctions = 68;
 export const HandleRequestTest = 69;
 export const ContentSecurityPolicy = 70;
+export const HandleMessagePortForEmbedsProcess = 72;
+export const HandleMessagePortForProcessExplorer = 73;
+export const HandleMessagePortForSearchProcess = 74;

package/src/parts/ModuleMap/ModuleMap.js

@@ -324,6 +324,12 @@ export const getModuleId = (commandId) => {
             return ModuleId.HandleRequestTest;
         case 'ContentSecurityPolicy.set':
             return ModuleId.ContentSecurityPolicy;
+        case 'HandleMessagePortForEmbedsProcess.handleMessagePortForEmbedsProcess':
+            return ModuleId.HandleMessagePortForEmbedsProcess;
+        case 'HandleMessagePortForProcessExplorer.handleMessagePortForProcessExplorer':
+            return ModuleId.HandleMessagePortForProcessExplorer;
+        case 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess':
+            return ModuleId.HandleMessagePortForSearchProcess;
         default:
             throw new CommandNotFoundError(commandId);
     }

package/src/parts/Platform/Platform.js

@@ -41,9 +41,9 @@ export const getAppImageName = () => {
 export const getSetupName = () => {
     return 'Lvce-Setup';
 };
-export const version = '0.25.11';
-export const commit = 'da5cd48';
-export const date = '2024-04-15T19:21:13.000Z';
+export const version = '0.26.0';
+export const commit = '019c142';
+export const date = '2024-04-20T21:44:51.000Z';
 export const getVersion = () => {
     return version;
 };

package/src/parts/ProcessExplorer/ProcessExplorer.js

@@ -0,0 +1,13 @@
+import * as LaunchProcessExplorer from '../LaunchProcessExplorer/LaunchProcessExplorer.js';
+export const state = {
+    /**
+     * @type {any}
+     */
+    ipc: undefined,
+};
+export const getOrCreate = async () => {
+    if (!state.ipc) {
+        state.ipc = LaunchProcessExplorer.launchProcessExplorer();
+    }
+    return state.ipc;
+};

package/src/parts/ProcessExplorerPath/ProcessExplorerPath.js

@@ -0,0 +1,3 @@
+import * as Path from '../Path/Path.js';
+import * as Root from '../Root/Root.js';
+export const processExplorerPath = Path.join(Root.root, 'packages', 'process-explorer', 'src', 'processExplorerMain.js');

package/src/parts/PtyHost/PtyHost.js

@@ -1,45 +1,12 @@
-import exitHook from 'exit-hook';
 import * as Debug from '../Debug/Debug.js';
-import * as HandleIpc from '../HandleIpc/HandleIpc.js';
-import * as IpcParent from '../IpcParent/IpcParent.js';
 import * as IpcParentType from '../IpcParentType/IpcParentType.js';
 import * as JsonRpc from '../JsonRpc/JsonRpc.js';
-import * as PtyHostPath from '../PtyHostPath/PtyHostPath.js';
+import * as LaunchPtyHost from '../LaunchPtyHost/LaunchPtyHost.js';
 import * as PtyHostState from '../PtyHostState/PtyHostState.js';
-const cleanUpAll = () => {
-    if (PtyHostState.state.ipc) {
-        PtyHostState.state.ipc.dispose();
-        PtyHostState.state.ipc = undefined;
-    }
-};
-const handleProcessExit = () => {
-    Debug.debug('shared process exit, clean terminals');
-    cleanUpAll();
-};
-const createPtyHost = async (method) => {
-    exitHook(handleProcessExit);
-    const ptyHostPath = await PtyHostPath.getPtyHostPath();
-    const ptyHost = await IpcParent.create({
-        method,
-        path: ptyHostPath,
-        argv: [],
-        stdio: 'inherit',
-        name: 'Terminal Process',
-    });
-    HandleIpc.handleIpc(ptyHost);
-    const handleClose = () => {
-        ptyHost.off('close', handleClose);
-        PtyHostState.state.ipc = undefined;
-        PtyHostState.state.ptyHostPromise = undefined;
-    };
-    ptyHost.on('close', handleClose);
-    PtyHostState.state.ipc = ptyHost;
-    return ptyHost;
-};
 export const getOrCreate = (method = IpcParentType.NodeForkedProcess) => {
     Debug.debug('creating pty host');
     if (!PtyHostState.state.ptyHostPromise) {
-        PtyHostState.state.ptyHostPromise = createPtyHost(method);
+        PtyHostState.state.ptyHostPromise = LaunchPtyHost.launchPtyHost(method);
     }
     return PtyHostState.state.ptyHostPromise;
 };

package/src/parts/SearchProcess/SearchProcess.js

@@ -0,0 +1,18 @@
+import * as LaunchSearchProcess from '../LaunchSearchProcess/LaunchSearchProcess.js';
+import * as JsonRpc from '../JsonRpc/JsonRpc.js';
+export const state = {
+    /**
+     * @type {any}
+     */
+    ipc: undefined,
+};
+export const getOrCreate = async () => {
+    if (!state.ipc) {
+        state.ipc = LaunchSearchProcess.launchSearchProcess();
+    }
+    return state.ipc;
+};
+export const invoke = async (method, ...params) => {
+    const ipc = await getOrCreate();
+    return JsonRpc.invoke(ipc, method, ...params);
+};

package/src/parts/SearchProcessPath/SearchProcessPath.js

@@ -0,0 +1,3 @@
+import * as Path from '../Path/Path.js';
+import * as Root from '../Root/Root.js';
+export const searchProcessPath = Path.join(Root.root, 'packages', 'search-process', 'src', 'searchProcessMain.js');

package/src/parts/TemporaryMessagePort/TemporaryMessagePort.js

@@ -1,5 +1,6 @@
 import * as ParentIpc from '../ParentIpc/ParentIpc.js';
 import * as Assert from '../Assert/Assert.js';
+import * as Id from '../Id/Id.js';
 export const state = {
     ports: Object.create(null),
 };
@@ -14,6 +15,22 @@ export const create = async (name) => {
     port.start();
     return port;
 };
+export const getPortTuple = async () => {
+    const id1 = `${Id.create()}`;
+    const id2 = `${Id.create()}`;
+    await ParentIpc.invoke('TemporaryMessagePort.createPortTuple', id1, id2);
+    const port1 = state.ports[id1];
+    const port2 = state.ports[id2];
+    return {
+        port1,
+        port2,
+    };
+};
+export const sendTo = async (name, port) => {
+    Assert.string(name);
+    Assert.object(port);
+    await ParentIpc.invokeAndTransfer('TemporaryMessagePort.sendTo', [port], name);
+};
 export const handlePort = (port, name) => {
     Assert.string(name);
     Assert.object(port);

package/src/parts/AddAccurateMemoryUsage/AddAccurateMemoryUsage.js

@@ -1,8 +0,0 @@
-import * as GetAccurateMemoryUsage from '../GetAccurateMemoryUsage/GetAccurateMemoryUsage.js';
-export const addAccurateMemoryUsage = async (process) => {
-    const accurateMemoryUsage = await GetAccurateMemoryUsage.getAccurateMemoryUsage(process.pid);
-    return {
-        ...process,
-        memory: accurateMemoryUsage,
-    };
-};

package/src/parts/CreatePidMap/CreatePidMap.js

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

package/src/parts/GetAccurateMemoryUsage/GetAccurateMemoryUsage.js

@@ -1,39 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import * as Assert from '../Assert/Assert.js';
-import * as EncodingType from '../EncodingType/EncodingType.js';
-import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js';
-import * as IsEsrchError from '../IsEsrchError/IsEsrchError.js';
-import * as ParseMemory from '../ParseMemory/ParseMemory.js';
-import * as Platform from '../Platform/Platform.js';
-import { VError } from '../VError/VError.js';
-const getContent = async (pid) => {
-    try {
-        const filePath = join('/proc', `${pid}`, 'statm');
-        const content = await readFile(filePath, EncodingType.Utf8);
-        return content;
-    }
-    catch (error) {
-        if (IsEnoentError.isEnoentError(error) || IsEsrchError.isEsrchError(error)) {
-            return '';
-        }
-        throw error;
-    }
-};
-export const getAccurateMemoryUsage = async (pid) => {
-    try {
-        Assert.number(pid);
-        if (Platform.isMacOs) {
-            return 0;
-        }
-        const content = await getContent(pid);
-        if (!content) {
-            return -1;
-        }
-        const memory = ParseMemory.parseMemory(content);
-        return memory;
-    }
-    catch (error) {
-        throw new VError(error, 'Failed to get accurate memory usage');
-    }
-};

package/src/parts/GetPsOutput/GetPsOutput.js

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

package/src/parts/ListProcessGetName/ListProcessGetName.js

@@ -1,56 +0,0 @@
-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('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}`;
-};

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

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

package/src/parts/ListProcessesWithMemoryUsage/ListProcessesWithMemoryUsage.js

@@ -1,11 +0,0 @@
-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

@@ -1,20 +0,0 @@
-import * as AddAccurateMemoryUsage from '../AddAccurateMemoryUsage/AddAccurateMemoryUsage.js';
-import * as CreatePidMap from '../CreatePidMap/CreatePidMap.js';
-import * as GetPsOutput from '../GetPsOutput/GetPsOutput.js';
-import * as HasPositiveMemoryUsage from '../HasPositiveMemoryUsage/HasPositiveMemoryUsage.js';
-import * as ParsePsOutput from '../ParsePsOutput/ParsePsOutput.js';
-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.addAccurateMemoryUsage));
-    // console.timeEnd('addAccurateMemoryUsage')
-    const filtered = parsedWithAccurateMemoryUsage.filter(HasPositiveMemoryUsage.hasPositiveMemoryUsage);
-    return filtered;
-};

package/src/parts/ListProcessesWithMemoryUsageWindows/ListProcessesWithMemoryUsageWindows.js

@@ -1,48 +0,0 @@
-// 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

@@ -1,13 +0,0 @@
-import * as IsDlOpenError from '../IsDlOpenError/IsDlOpenError.js';
-import { VError } from '../VError/VError.js';
-export const loadWindowProcessTree = async () => {
-    try {
-        return await import('@vscode/windows-process-tree');
-    }
-    catch (error) {
-        if (IsDlOpenError.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`);
-    }
-};

package/src/parts/ParseMemory/ParseMemory.js

@@ -1,10 +0,0 @@
-import * as Character from '../Character/Character.js';
-export const parseMemory = (content) => {
-    const trimmedContent = content.trim();
-    const numberBlocks = trimmedContent.split(Character.Space);
-    const pageSize = 4096;
-    const rss = Number.parseInt(numberBlocks[1]) * pageSize;
-    const shared = Number.parseInt(numberBlocks[2]) * pageSize;
-    const memory = rss - shared;
-    return memory;
-};

package/src/parts/ParsePsOutput/ParsePsOutput.js

@@ -1,47 +0,0 @@
-// 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 Character from '../Character/Character.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 === Character.EmptyString) {
-        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/WindowsProcessTree/WindowsProcessTree.js

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

package/src/parts/WindowsProcessTreeDataFlag/WindowsProcessTreeDataFlag.js

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