@lvce-editor/shared-process 0.106.4 → 0.107.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.106.4",
+  "version": "0.107.0",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -18,7 +18,7 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "1.9.0",
-    "@lvce-editor/extension-host-helper-process": "0.106.4",
+    "@lvce-editor/extension-host-helper-process": "0.107.0",
     "@lvce-editor/ipc": "16.12.0",
     "@lvce-editor/json-rpc": "8.7.0",
     "@lvce-editor/jsonc-parser": "1.5.0",

package/src/parts/BuiltinExtensionsPath/BuiltinExtensionsPath.js

@@ -3,6 +3,6 @@ import { fileURLToPath } from 'url'
 
 export const getBuiltinExtensionsPath = () => {
   const staticServerPath = fileURLToPath(import.meta.resolve('@lvce-editor/static-server'))
-  const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', '71bebb6', 'extensions')
+  const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', '64c8cbf', 'extensions')
   return builtinExtensionsPath
 }

package/src/parts/ExtensionNodeProcessIpc/ExtensionNodeProcessIpc.js

@@ -0,0 +1,15 @@
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcParent from '../IpcParent/IpcParent.js'
+import * as ResolveExtensionNodeProcess from '../ResolveExtensionNodeProcess/ResolveExtensionNodeProcess.js'
+
+export const create = async ({ extensionId, method, rpcId }     ) => {
+  const { name, path } = await ResolveExtensionNodeProcess.resolveExtensionNodeProcess(extensionId, rpcId)
+  const ipc = await IpcParent.create({
+    execArgv: [],
+    method,
+    name,
+    path,
+  })
+  HandleIpc.handleIpc(ipc)
+  return ipc
+}

package/src/parts/HandleMessagePortForExtensionNodeProcess/HandleMessagePortForExtensionNodeProcess.ipc.js

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

package/src/parts/HandleMessagePortForExtensionNodeProcess/HandleMessagePortForExtensionNodeProcess.js

@@ -0,0 +1,35 @@
+import * as Assert from '../Assert/Assert.js'
+import * as ExtensionNodeProcessIpc from '../ExtensionNodeProcessIpc/ExtensionNodeProcessIpc.js'
+import * as IpcParentType from '../IpcParentType/IpcParentType.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
+export const handleMessagePortForExtensionNodeProcess = async (
+  rendererWorkerIpc,
+  port,
+  extensionId,
+  rpcId,
+) => {
+  Assert.object(port)
+  Assert.string(extensionId)
+  Assert.string(rpcId)
+  const ipc = await ExtensionNodeProcessIpc.create({
+    extensionId,
+    method: IpcParentType.ElectronUtilityProcess,
+    rpcId,
+  })
+  const dispose = () => {
+    ipc.dispose()
+  }
+  const removeRendererCloseListener = () => {
+    rendererWorkerIpc.off('close', dispose)
+  }
+  rendererWorkerIpc.on('close', dispose)
+  ipc.on('close', removeRendererCloseListener)
+  try {
+    await JsonRpc.invokeAndTransfer(ipc, 'NodeRpcProcess.handleElectronMessagePort', port)
+  } catch (error) {
+    removeRendererCloseListener()
+    ipc.dispose()
+    throw error
+  }
+}

package/src/parts/HandleWebSocketForExtensionNodeProcess/HandleWebSocketForExtensionNodeProcess.js

@@ -0,0 +1,23 @@
+import * as ExtensionNodeProcessIpc from '../ExtensionNodeProcessIpc/ExtensionNodeProcessIpc.js'
+import * as IpcParentType from '../IpcParentType/IpcParentType.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
+export const handleWebSocket = async (message, handle) => {
+  const url = new URL(message.url, 'http://localhost')
+  const extensionId = url.searchParams.get('extensionId')
+  const rpcId = url.searchParams.get('rpcId')
+  if (!extensionId || !rpcId) {
+    throw new Error('Remote extension node process request is incomplete')
+  }
+  const ipc = await ExtensionNodeProcessIpc.create({
+    extensionId,
+    method: IpcParentType.NodeForkedProcess,
+    rpcId,
+  })
+  try {
+    await JsonRpc.invokeAndTransfer(ipc, 'NodeRpcProcess.handleWebSocket', handle, message)
+  } catch (error) {
+    ipc.dispose()
+    throw error
+  }
+}

package/src/parts/HandleWebSocketModule/HandleWebSocketModule.js

@@ -1,5 +1,6 @@
 import * as HandleWebSocketForClipBoardProcess from '../HandleWebSocketForClipBoardProcess/HandleWebSocketForClipBoardProcess.js'
 import * as HandleWebSocketForExtensionHostHelperProcess from '../HandleWebSocketForExtensionHostHelperProcess/HandleWebSocketForExtensionHostHelperProcess.js'
+import * as HandleWebSocketForExtensionNodeProcess from '../HandleWebSocketForExtensionNodeProcess/HandleWebSocketForExtensionNodeProcess.js'
 import * as HandleWebSocketForFileSystemProcess from '../HandleWebSocketForFileSystemProcess/HandleWebSocketForFileSystemProcess.js'
 import * as HandleWebSocketForProcessExplorer from '../HandleWebSocketForProcessExplorer/HandleWebSocketForProcessExplorer.js'
 import * as HandleWebSocketForSearchProcess from '../HandleWebSocketForSearchProcess/HandleWebSocketForSearchProcess.js'
@@ -18,6 +19,8 @@ export const load = (protocol) => {
       return HandleWebSocketForClipBoardProcess
     case ProtocolType.ExtensionHostHelperProcess:
       return HandleWebSocketForExtensionHostHelperProcess
+    case ProtocolType.ExtensionNodeProcess:
+      return HandleWebSocketForExtensionNodeProcess
     case ProtocolType.FileSystemProcess:
       return HandleWebSocketForFileSystemProcess
     case ProtocolType.ProcessExplorer:

package/src/parts/Module/Module.js

@@ -88,6 +88,8 @@ export const load = (moduleId) => {
       return import('../HandleMessagePortForEmbedsProcess/HandleMessagePortForEmbedsProcess.ipc.js')
     case ModuleId.HandleMessagePortForExtensionHostHelperProcess:
       return import('../HandleMessagePortForExtensionHostHelperProcess/HandleMessagePortForExtensionHostHelperProcess.ipc.js')
+    case ModuleId.HandleMessagePortForExtensionNodeProcess:
+      return import('../HandleMessagePortForExtensionNodeProcess/HandleMessagePortForExtensionNodeProcess.ipc.js')
     case ModuleId.HandleMessagePortForFileSystemProcess:
       return import('../HandleMessagePortForFileSystemProcess/HandleMessagePortForFileSystemProcess.ipc.js')
     case ModuleId.HandleMessagePortForProcessExplorer:

package/src/parts/ModuleId/ModuleId.js

@@ -82,3 +82,4 @@ export const SendMessagePortToMainProcess = 88
 export const SecretStorage = 89
 export const FirefoxCookieImport = 91
 export const IpcTrace = 92
+export const HandleMessagePortForExtensionNodeProcess = 93

package/src/parts/ModuleMap/ModuleMap.js

@@ -184,6 +184,8 @@ export const getModuleId = (commandId) => {
     case 'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess':
     case 'HandleMessagePortForExtensionHostHelperProcess.handlePreloadedMessagePortForExtensionHostHelperProcess':
       return ModuleId.HandleMessagePortForExtensionHostHelperProcess
+    case 'HandleMessagePortForExtensionNodeProcess.handleMessagePortForExtensionNodeProcess':
+      return ModuleId.HandleMessagePortForExtensionNodeProcess
     case 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess':
       return ModuleId.HandleMessagePortForFileSystemProcess
     case 'HandleMessagePortForProcessExplorer.handleMessagePortForProcessExplorer':

package/src/parts/Platform/Platform.js

@@ -61,11 +61,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.106.4'
+export const version = '0.107.0'
 
-export const commit = '71bebb6'
+export const commit = '64c8cbf'
 
-export const date = '2026-08-22T16:15:27.000Z'
+export const date = '2026-08-22T16:38:17.000Z'
 
 export const getVersion = () => {
   return version

package/src/parts/PreloadUrl/PreloadUrl.js

@@ -2,5 +2,5 @@ import { join } from 'node:path'
 import * as Root from '../Root/Root.js'
 
 export const getPreloadUrl = () => {
-  return join(Root.root, 'static', '71bebb6', 'packages', 'preload', 'dist', 'index.js')
+  return join(Root.root, 'static', '64c8cbf', 'packages', 'preload', 'dist', 'index.js')
 }

package/src/parts/ProtocolType/ProtocolType.js

@@ -1,5 +1,6 @@
 export const ExtensionHost = 'extension-host'
 export const ExtensionHostHelperProcess = 'extension-host-helper-process'
+export const ExtensionNodeProcess = 'extension-node-process'
 export const SearchProcess = 'search-process'
 export const ProcessExplorer = 'process-explorer'
 export const FileSystemProcess = 'file-system-process'

package/src/parts/RequiresSocket/RequiresSocket.js

@@ -11,6 +11,7 @@ const METHODS_THAT_REQUIRE_SOCKET = new Set([
   'IncrementalTextSearch.start',
   'ElectronApplicationMenu.setItems',
   'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess',
+  'HandleMessagePortForExtensionNodeProcess.handleMessagePortForExtensionNodeProcess',
   'ElectronBrowserView.createBrowserView',
   'ElectronWebContentsView.createWebContentsView',
   'FileWatcher.dispose',

package/src/parts/ResolveExtensionNodeProcess/ResolveExtensionNodeProcess.js

@@ -0,0 +1,55 @@
+import { readFile, realpath } from 'node:fs/promises'
+import path from 'node:path'
+import * as ExtensionManagement from '../ExtensionManagement/ExtensionManagement.js'
+
+const idRegex = /^[A-Za-z0-9][A-Za-z0-9._-]*$/
+const schemeRegex = /^[A-Za-z][A-Za-z\d+.-]*:/
+
+const isInside = (parent, child) => child === parent || child.startsWith(`${parent}${path.sep}`)
+
+const validateId = (value, name) => {
+  if (!idRegex.test(value)) {
+    throw new Error(`Invalid extension node process ${name}`)
+  }
+}
+
+const getExtension = async (extensionId) => {
+  const extensions = await ExtensionManagement.getExtensions()
+  const extension = extensions.find((candidate) => candidate?.id === extensionId)
+  if (!extension || typeof extension.path !== 'string') {
+    throw new Error(`Extension ${extensionId} is not installed`)
+  }
+  return extension
+}
+
+                                           
+                       
+                       
+ 
+
+export const resolveExtensionNodeProcess = async (extensionId, rpcId) => {
+  validateId(extensionId, 'extension id')
+  validateId(rpcId, 'rpc id')
+  const extension = await getExtension(extensionId)
+  const extensionRoot = await realpath(extension.path)
+  const manifestPath = await realpath(path.join(extensionRoot, 'extension.json'))
+  if (!isInside(extensionRoot, manifestPath)) {
+    throw new Error('Extension manifest escapes the extension root')
+  }
+  const manifest = JSON.parse(await readFile(manifestPath, 'utf8'))
+  const rpc = manifest.rpc?.find((candidate) => candidate?.id === rpcId)
+  if (!rpc || rpc.type !== 'node-process' || typeof rpc.url !== 'string') {
+    throw new Error(`Node process ${rpcId} is not declared by extension ${extensionId}`)
+  }
+  if (!rpc.url || path.isAbsolute(rpc.url) || path.win32.isAbsolute(rpc.url) || schemeRegex.test(rpc.url)) {
+    throw new Error(`Node process ${rpcId} must use a relative url`)
+  }
+  const processPath = await realpath(path.resolve(extensionRoot, rpc.url))
+  if (!isInside(extensionRoot, processPath)) {
+    throw new Error('Extension node process path escapes the extension root')
+  }
+  return {
+    name: `Extension ${extensionId}: ${typeof rpc.name === 'string' && rpc.name ? rpc.name : rpcId}`,
+    path: processPath,
+  }
+}