@lvce-editor/shared-process 0.25.12 → 0.26.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.25.12",
+  "version": "0.26.1",
   "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.12",
-    "@lvce-editor/ipc": "^4.0.1",
+    "@lvce-editor/extension-host-helper-process": "0.26.1",
+    "@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.12",
+    "@lvce-editor/pty-host": "0.26.1",
     "@lvce-editor/verror": "^1.2.0",
     "@lvce-editor/web-socket-server": "^1.1.0",
     "debug": "^4.3.4",

package/src/parts/ConnectIpcToElectron/ConnectIpcToElectron.js

@@ -0,0 +1,8 @@
+import * as GetPortTuple from '../GetPortTuple/GetPortTuple.js';
+import * as JsonRpc from '../JsonRpc/JsonRpc.js';
+import * as ParentIpc from '../ParentIpc/ParentIpc.js';
+export const connectIpcToElectron = async (ipc) => {
+    const { port1, port2 } = await GetPortTuple.getPortTuple();
+    await JsonRpc.invokeAndTransfer(ipc, [port1], 'HandleElectronMessagePort.handleElectronMessagePort', /* isElectron */ true);
+    await ParentIpc.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', [port2]);
+};

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', 'dist', '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,11 @@ 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] `);
-    }
-};
-const handleMessage = (event) => {
-    return JsonRpc.handleJsonRpcMessage(event.target, event.data, Command.execute, Callback.resolve, preparePrettyError, logError, RequiresSocket.requiresSocket);
-};
+import * as HandleMessage from '../HandleMessage/HandleMessage.js';
 export const handleIpc = (ipc) => {
-    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/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 {

package/src/parts/LaunchEmbedsProcess/LaunchEmbedsProcess.js

@@ -0,0 +1,17 @@
+import * as ConnectIpcToElectron from '../ConnectIpcToElectron/ConnectIpcToElectron.js';
+import * as EmbedsProcessPath from '../EmbedsProcessPath/EmbedsProcessPath.js';
+import * as HandleIpc from '../HandleIpc/HandleIpc.js';
+import * as IpcParent from '../IpcParent/IpcParent.js';
+import * as IpcParentType from '../IpcParentType/IpcParentType.js';
+export const launchEmbedsProcess = async () => {
+    const ipc = await IpcParent.create({
+        method: IpcParentType.ElectronUtilityProcess,
+        path: EmbedsProcessPath.embedsProcessPath,
+        argv: [],
+        stdio: 'inherit',
+        name: 'Embeds Process',
+    });
+    HandleIpc.handleIpc(ipc);
+    await ConnectIpcToElectron.connectIpcToElectron(ipc);
+    return ipc;
+};

package/src/parts/LaunchProcessExplorer/LaunchProcessExplorer.js

@@ -0,0 +1,17 @@
+import * as ConnectIpcToElectron from '../ConnectIpcToElectron/ConnectIpcToElectron.js';
+import * as HandleIpc from '../HandleIpc/HandleIpc.js';
+import * as IpcParent from '../IpcParent/IpcParent.js';
+import * as IpcParentType from '../IpcParentType/IpcParentType.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 Explorer',
+    });
+    HandleIpc.handleIpc(ipc);
+    await ConnectIpcToElectron.connectIpcToElectron(ipc);
+    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

@@ -5,8 +5,6 @@ export const load = (moduleId) => {
             return import('../AttachDebugger/AttachDebugger.ipc.js');
         case ModuleId.AutoUpdater:
             return import('../AutoUpdater/AutoUpdater.ipc.js');
-        case ModuleId.ElectronBrowserViewFunctions:
-            return import('../ElectronBrowserViewFunctions/ElectronBrowserViewFunctions.ipc.js');
         case ModuleId.AutoUpdaterAppImage:
             return import('../AutoUpdaterAppImage/AutoUpdaterAppImage.ipc.js');
         case ModuleId.GetWindowId:
@@ -27,8 +25,6 @@ export const load = (moduleId) => {
             return import('../Download/Download.ipc.js');
         case ModuleId.ElectronApplicationMenu:
             return import('../ElectronApplicationMenu/ElectronApplicationMenu.ipc.js');
-        case ModuleId.ElectronBrowserView:
-            return import('../ElectronBrowserView/ElectronBrowserView.ipc.js');
         case ModuleId.ElectronContentTracing:
             return import('../ElectronContentTracing/ElectronContentTracing.ipc.js');
         case ModuleId.ElectronDeveloper:
@@ -47,8 +43,6 @@ export const load = (moduleId) => {
             return import('../ElectronSafeStorage/ElectronSafeStorage.ipc.js');
         case ModuleId.Window:
             return import('../ElectronWindow/ElectronWindow.ipc.js');
-        case ModuleId.ElectronBrowserViewQuickPick:
-            return import('../ElectronBrowserViewQuickPick/ElectronBrowserViewQuickPick.ipc.js');
         case ModuleId.ElectronWindowAbout:
             return import('../ElectronWindowAbout/ElectronWindowAbout.ipc.js');
         case ModuleId.ElectronWindowProcessExplorer:
@@ -79,8 +73,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:
@@ -113,8 +105,6 @@ export const load = (moduleId) => {
             return import('../TextDocument/TextDocument.ipc.js');
         case ModuleId.Search:
             return import('../TextSearch/TextSearch.ipc.js');
-        case ModuleId.ElectronBrowserViewSuggestions:
-            return import('../ElectronBrowserViewSuggestions/ElectronBrowserViewSuggestions.ipc.js');
         case ModuleId.WebSocketServer:
             return import('../WebSocketServer/WebSocketServer.ipc.js');
         case ModuleId.Workspace:
@@ -129,6 +119,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:
@@ -137,14 +129,12 @@ export const load = (moduleId) => {
             return import('../HandleRemoteRequest/HandleRemoteRequest.ipc.js');
         case ModuleId.HandleMessagePortForExtensionHostHelperProcess:
             return import('../HandleMessagePortForExtensionHostHelperProcess/HandleMessagePortForExtensionHostHelperProcess.ipc.js');
-        case ModuleId.ElectronWebContents:
-            return import('../ElectronWebContents/ElectronWebContents.ipc.js');
-        case ModuleId.ElectronWebContentsView:
-            return import('../ElectronWebContentsView/ElectronWebContentsView.ipc.js');
-        case ModuleId.ElectronWebContentsViewFunctions:
-            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

@@ -1,4 +1,3 @@
-export const ElectronBrowserViewSuggestions = 111;
 export const ClipBoard = 1;
 export const Developer = 2;
 export const ExtensionHost = 3;
@@ -22,7 +21,6 @@ export const Download = 19;
 export const ElectronPowerSaveBlocker = 222;
 export const GitLsFiles = 20;
 export const BulkReplacement = 21;
-export const ElectronBrowserViewQuickPick = 999;
 export const InstallExtension = 22;
 export const AutoUpdater = 23;
 export const IsAutoUpdateSupported = 24;
@@ -32,7 +30,6 @@ export const RebuildNodePty = 27;
 export const ElectronInitialize = 28;
 export const HandleWebSocket = 29;
 export const Process = 30;
-export const ElectronBrowserViewFunctions = 200;
 export const AttachDebugger = 31;
 export const HandleElectronMessagePort = 32;
 export const HandleNodeMessagePort = 33;
@@ -53,7 +50,6 @@ export const ElectronSafeStorage = 47;
 export const ElectronDeveloper = 100;
 export const ElectronProcess = 48;
 export const ElectronContextMenu = 49;
-export const ElectronBrowserView = 50;
 export const Window = 51;
 export const PassThroughElectronMessagePort = 52;
 export const Exit = 53;
@@ -69,8 +65,8 @@ export const TemporaryMessagePort = 62;
 export const GetElectronFileResponse = 63;
 export const HandleRemoteRequest = 64;
 export const HandleMessagePortForExtensionHostHelperProcess = 65;
-export const ElectronWebContents = 66;
-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

@@ -41,10 +41,6 @@ export const getModuleId = (commandId) => {
         case 'ElectronApplicationMenu.handleClick':
         case 'ElectronApplicationMenu.setItems':
             return ModuleId.ElectronApplicationMenu;
-        case 'ElectronBrowserView.createBrowserView':
-        case 'ElectronBrowserView.disposeBrowserView':
-        case 'ElectronBrowserView.getAll':
-            return ModuleId.ElectronBrowserView;
         case 'ElectronClipBoard.writeText':
             return ModuleId.ElectronClipBoard;
         case 'ElectronContentTracing.startRecording':
@@ -73,9 +69,6 @@ export const getModuleId = (commandId) => {
             return ModuleId.ElectronWindowProcessExplorer;
         case 'Exit.exit':
             return ModuleId.Exit;
-        case 'ElectronBrowserViewQuickPick.createBrowserViewQuickPick':
-        case 'ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick':
-            return ModuleId.ElectronBrowserViewQuickPick;
         case 'ExtensionHost.dispose':
         case 'ExtensionHost.enableExtension':
         case 'ExtensionHost.executeCommand':
@@ -136,34 +129,6 @@ export const getModuleId = (commandId) => {
         case 'ExtensionManagement.install':
         case 'ExtensionManagement.uninstall':
             return ModuleId.ExtensionManagement;
-        case 'ElectronBrowserViewFunctions.resizeBrowserView':
-        case 'ElectronBrowserViewFunctions.setIframeSrc':
-        case 'ElectronBrowserViewFunctions.focus':
-        case 'ElectronBrowserViewFunctions.openDevtools':
-        case 'ElectronBrowserViewFunctions.reload':
-        case 'ElectronBrowserViewFunctions.forward':
-        case 'ElectronBrowserViewFunctions.backward':
-        case 'ElectronBrowserViewFunctions.cancelNavigation':
-        case 'ElectronBrowserViewFunctions.hide':
-        case 'ElectronBrowserViewFunctions.inspectElement':
-        case 'ElectronBrowserViewFunctions.copyImageAt':
-        case 'ElectronBrowserViewFunctions.setFallthroughKeyBindings':
-        case 'ElectronBrowserViewFunctions.getStats':
-            return ModuleId.ElectronBrowserViewFunctions;
-        case 'ElectronWebContentsViewFunctions.resizeBrowserView':
-        case 'ElectronWebContentsViewFunctions.setIframeSrc':
-        case 'ElectronWebContentsViewFunctions.focus':
-        case 'ElectronWebContentsViewFunctions.openDevtools':
-        case 'ElectronWebContentsViewFunctions.reload':
-        case 'ElectronWebContentsViewFunctions.forward':
-        case 'ElectronWebContentsViewFunctions.backward':
-        case 'ElectronWebContentsViewFunctions.cancelNavigation':
-        case 'ElectronWebContentsViewFunctions.hide':
-        case 'ElectronWebContentsViewFunctions.inspectElement':
-        case 'ElectronWebContentsViewFunctions.copyImageAt':
-        case 'ElectronWebContentsViewFunctions.setFallthroughKeyBindings':
-        case 'ElectronWebContentsViewFunctions.getStats':
-            return ModuleId.ElectronWebContentsViewFunctions;
         case 'FileSystem.chmod':
         case 'FileSystem.copy':
         case 'FileSystem.createFile':
@@ -177,10 +142,6 @@ export const getModuleId = (commandId) => {
         case 'FileSystem.rename':
         case 'FileSystem.writeFile':
             return ModuleId.FileSystem;
-        case 'ElectronBrowserViewSuggestions.createBrowserView':
-        case 'ElectronBrowserViewSuggestions.disposeBrowserView':
-        case 'ElectronBrowserViewSuggestions.setSuggestions':
-            return ModuleId.ElectronBrowserViewSuggestions;
         case 'GetTerminalSpawnOptions.getTerminalSpawnOptions':
             return ModuleId.GetTerminalSpawnOptions;
         case 'GitLsFiles.gitLsFiles':
@@ -309,21 +270,16 @@ export const getModuleId = (commandId) => {
             return ModuleId.HandleRemoteRequest;
         case 'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess':
             return ModuleId.HandleMessagePortForExtensionHostHelperProcess;
-        case 'ElectronWebContents.dispose':
-        case 'ElectronWebContents.handleKeyBinding':
-        case 'ElectronWebContents.handleWindowOpen':
-        case 'ElectronWebContents.handleWillNavigate':
-        case 'ElectronWebContents.handleDidNavigate':
-        case 'ElectronWebContents.handleContextMenu':
-        case 'ElectronWebContents.handlePageTitleUpdated':
-            return ModuleId.ElectronWebContents;
-        case 'ElectronWebContentsView.createWebContentsView':
-        case 'ElectronWebContentsView.disposeWebContentsView':
-            return ModuleId.ElectronWebContentsView;
         case 'HandleRequestTest.handleRequestTest':
             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.12';
-export const commit = '0181bc1';
-export const date = '2024-04-16T20:00:32.000Z';
+export const version = '0.26.1';
+export const commit = 'a044a77';
+export const date = '2024-04-21T08:08:58.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,46 +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 = () => {
-        // @ts-ignore
-        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;
 };