@lvce-editor/shared-process 0.95.13 → 0.95.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.95.13",
+  "version": "0.95.14",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -18,12 +18,12 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "1.7.0",
-    "@lvce-editor/extension-host-helper-process": "0.95.13",
+    "@lvce-editor/extension-host-helper-process": "0.95.14",
     "@lvce-editor/ipc": "16.6.0",
     "@lvce-editor/json-rpc": "8.5.0",
     "@lvce-editor/jsonc-parser": "1.5.0",
     "@lvce-editor/pretty-error": "2.0.0",
-    "@lvce-editor/process-explorer": "3.12.1",
+    "@lvce-editor/process-explorer": "3.13.0",
     "@lvce-editor/rpc-registry": "9.43.0",
     "@lvce-editor/verror": "1.7.0",
     "is-object": "^1.0.2",

package/src/parts/AppWindow/AppWindow.js

@@ -1,4 +1,5 @@
-import { isAbsolute, resolve } from 'node:path'
+import { stat } from 'node:fs/promises'
+import { dirname, isAbsolute, resolve } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import * as DefaultUrl from '../DefaultUrl/DefaultUrl.js'
 import * as GetAppWindowOptions from '../GetAppWindowOptions/GetAppWindowOptions.js'
@@ -25,29 +26,40 @@ const getValidatedAppUrl = (url) => {
   return parsedUrl.toString()
 }
 
-const getWorkspaceUri = (parsedArgs, workingDirectory) => {
+const getAbsolutePath = (parsedArgs, workingDirectory) => {
   const path = parsedArgs?._?.at(-1)
   if (!path || typeof path !== 'string') {
     return ''
   }
   if (path.startsWith('file://')) {
-    return pathToFileURL(fileURLToPath(path)).toString()
+    return fileURLToPath(path)
   }
-  const absolutePath = isAbsolute(path) ? path : resolve(workingDirectory, path)
-  return pathToFileURL(absolutePath).toString()
+  return isAbsolute(path) ? path : resolve(workingDirectory, path)
 }
 
-const getAppWindowUrl = (url, parsedArgs, workingDirectory) => {
+const getAppWindowUrl = async (url, parsedArgs, workingDirectory) => {
   const parsedUrl = new URL(getValidatedAppUrl(url))
-  const workspaceUri = getWorkspaceUri(parsedArgs, workingDirectory)
-  if (workspaceUri) {
-    parsedUrl.searchParams.set('workspace', workspaceUri)
+  const absolutePath = getAbsolutePath(parsedArgs, workingDirectory)
+  if (!absolutePath) {
+    return parsedUrl.toString()
   }
+  const uri = pathToFileURL(absolutePath).toString()
+  try {
+    const stats = await stat(absolutePath)
+    if (stats.isFile()) {
+      parsedUrl.searchParams.set('workspace', pathToFileURL(dirname(absolutePath)).toString())
+      parsedUrl.searchParams.set('openUri', uri)
+      return parsedUrl.toString()
+    }
+  } catch {
+    // Preserve the existing folder error for paths that do not exist.
+  }
+  parsedUrl.searchParams.set('workspace', uri)
   return parsedUrl.toString()
 }
 
 export const createAppWindow = async ({ parsedArgs, preferences, preloadUrl, url = DefaultUrl.defaultUrl, workingDirectory }     ) => {
-  const validatedUrl = getAppWindowUrl(url, parsedArgs, workingDirectory)
+  const validatedUrl = await getAppWindowUrl(url, parsedArgs, workingDirectory)
   const { height, width } = await Screen.getBounds()
   const windowOptions = await GetAppWindowOptions.getAppWindowOptions({
     preferences,

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', 'e8dd865', 'extensions')
+  const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', 'b420a78', 'extensions')
   return builtinExtensionsPath
 }

package/src/parts/GetElectronFileResponse/GetElectronFileResponse.js

@@ -17,9 +17,13 @@ import * as Logger from '../Logger/Logger.js'
 // maybe send webview requests directly to preview process
 export const getElectronFileResponse = async (url, request) => {
   try {
+    const fetchDestination = request?.headers?.['sec-fetch-dest']
+    const isRootDocument = url === '/' || url.startsWith('/?')
+    const isSecretDocument = isRootDocument && fetchDestination === 'document'
     const pathName = GetElectronFileResponseRelativePath.getElectronFileResponseRelativePath(url)
     let absolutePath = GetElectronFileResponseAbsolutePath.getElectronFileResponseAbsolutePath(pathName)
     let etag
+    let preparedContent
     let stats
     // TODO when is there no request?
     if (request) {
@@ -31,19 +35,19 @@ export const getElectronFileResponse = async (url, request) => {
         // TODO since dynamic data is injected to the stat size is not accurate
         // which is why this workaround is needed
         // but it's a bit inefficient
-        const content = await GetElectronFileResponseContent.getElectronFileResponseContent(request, absolutePath, url)
-        size = content.byteLength
+        preparedContent = await GetElectronFileResponseContent.getElectronFileResponseContent(request, absolutePath, url)
+        size = preparedContent.byteLength
       }
-      if (request.headers[HttpHeader.IfNotMatch] === etag) {
+      if (!isSecretDocument && request.headers[HttpHeader.IfNotMatch] === etag) {
         const headers = await GetHeaders.getHeaders(absolutePath, pathName, etag, url, size)
         return GetNotModifiedResponse.getNotModifiedResponse(headers)
       }
     }
-    const content = await GetElectronFileResponseContent.getElectronFileResponseContent(request, absolutePath, url)
+    const content = preparedContent || (await GetElectronFileResponseContent.getElectronFileResponseContent(request, absolutePath, url))
     const size = content.byteLength
     const headers = await GetHeaders.getHeaders(absolutePath, pathName, etag, url, size)
 
-    headers[HttpHeader.CacheControl] = 'public, max-age=0, must-revalidate'
+    headers[HttpHeader.CacheControl] = isSecretDocument ? 'no-store' : 'public, max-age=0, must-revalidate'
     return GetContentResponse.getContentResponse(content, headers)
   } catch (error) {
     if (IsEnoentError.isEnoentError(error)) {

package/src/parts/GetElectronFileResponseContent/GetElectronFileResponseContent.js

@@ -3,6 +3,7 @@ import * as AddCustomPathsToIndexHtml from '../AddCustomPathsToIndexHtml/AddCust
 import * as Platform from '../Platform/Platform.js'
 import * as ShouldTranspileTypescript from '../ShouldTranspileTypescript/ShouldTranspileTypescript.js'
 import * as TranspileTypeScript from '../TranspileTypeScript/TranspileTypeScript.js'
+import * as WebSocketIssuerRegistry from '../WebSocketIssuerRegistry/WebSocketIssuerRegistry.js'
 
 const useCache = false // TODO enable this
 
@@ -23,8 +24,11 @@ export const getElectronFileResponseContent = async (request, absolutePath, url)
     content = content.toString().replace('    <link rel="manifest" href="/manifest.json" crossorigin="use-credentials" />\n', '')
     content = await AddCustomPathsToIndexHtml.addCustomPathsToIndexHtml(content)
   }
-  if (url === '/') {
-    content = await AddCustomPathsToIndexHtml.addCustomPathsToIndexHtml(content)
+  if (url === '/' || url.startsWith('/?')) {
+    const fetchDestination = request?.headers?.['sec-fetch-dest']
+    const isDocumentNavigation = fetchDestination === 'document'
+    const additionalConfig = isDocumentNavigation ? { webSocketIssuer: WebSocketIssuerRegistry.create() } : {}
+    content = await AddCustomPathsToIndexHtml.addCustomPathsToIndexHtml(content, additionalConfig)
   }
   if (typeof content === 'string') {
     content = Buffer.from(content)

package/src/parts/GetWebSocketCapabilityResponse/GetWebSocketCapabilityResponse.js

@@ -0,0 +1,43 @@
+import * as HttpHeader from '../HttpHeader/HttpHeader.js'
+import * as HttpStatusCode from '../HttpStatusCode/HttpStatusCode.js'
+import * as WebSocketCapability from '../WebSocketCapability/WebSocketCapability.js'
+import * as WebSocketIssuerRegistry from '../WebSocketIssuerRegistry/WebSocketIssuerRegistry.js'
+
+const jsonHeaders = {
+  [HttpHeader.CacheControl]: 'no-store',
+  [HttpHeader.ContentType]: 'application/json; charset=utf-8',
+}
+
+const getResponse = (status, value) => {
+  return {
+    body: Buffer.from(JSON.stringify(value)),
+    init: {
+      headers: jsonHeaders,
+      status,
+    },
+  }
+}
+
+const getBearerToken = (authorization) => {
+  if (typeof authorization !== 'string' || !authorization.startsWith('Bearer ')) {
+    return ''
+  }
+  return authorization.slice('Bearer '.length)
+}
+
+export const getWebSocketCapabilityResponse = (request) => {
+  if (request.method !== 'GET') {
+    return getResponse(HttpStatusCode.Forbidden, { error: 'method not allowed' })
+  }
+  const issuer = getBearerToken(request.headers?.authorization)
+  if (!WebSocketIssuerRegistry.isValid(issuer)) {
+    return getResponse(HttpStatusCode.Forbidden, { error: 'invalid websocket issuer' })
+  }
+  const prefix = '/websocket-capabilities/'
+  try {
+    const target = decodeURIComponent(request.url.slice(prefix.length).split('?')[0])
+    return getResponse(HttpStatusCode.Ok, WebSocketCapability.create(target))
+  } catch {
+    return getResponse(HttpStatusCode.Forbidden, { error: 'websocket target not allowed' })
+  }
+}

package/src/parts/HandleMessagePortForExtensionHostHelperProcess/HandleMessagePortForExtensionHostHelperProcess.ipc.js

@@ -4,4 +4,6 @@ export const name = 'HandleMessagePortForExtensionHostHelperProcess'
 
 export const Commands = {
   handleMessagePortForExtensionHostHelperProcess: HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess,
+  handlePreloadedMessagePortForExtensionHostHelperProcess:
+    HandleMessagePortForExtensionHostHelperProcess.handlePreloadedMessagePortForExtensionHostHelperProcess,
 }

package/src/parts/HandleMessagePortForExtensionHostHelperProcess/HandleMessagePortForExtensionHostHelperProcess.js

@@ -23,3 +23,22 @@ export const handleMessagePortForExtensionHostHelperProcess = async (rendererWor
   // }
   // rendererWorkerIpc.on('close', cleanup)
 }
+
+export const handlePreloadedMessagePortForExtensionHostHelperProcess = async (
+  port,
+  modulePath,
+) => {
+  Assert.object(port)
+  Assert.string(modulePath)
+  const ipc = await ExtensionHostHelperProcessIpc.create({
+    method: IpcParentType.ElectronUtilityProcess,
+  })
+  HandleIpc.handleIpc(ipc)
+  try {
+    await JsonRpc.invoke(ipc, 'LoadFile.loadFile', modulePath)
+    await JsonRpc.invokeAndTransfer(ipc, 'HandleElectronMessagePort.handleElectronMessagePort', port, IpcId.ExtensionHostWorker)
+  } catch (error) {
+    ipc.dispose()
+    throw error
+  }
+}

package/src/parts/HandleRequest/HandleRequest.js

@@ -1,6 +1,7 @@
 import { join } from 'path'
 import * as Assert from '../Assert/Assert.js'
 import * as GetElectronFileResponse from '../GetElectronFileResponse/GetElectronFileResponse.js'
+import * as GetWebSocketCapabilityResponse from '../GetWebSocketCapabilityResponse/GetWebSocketCapabilityResponse.js'
 import * as HandleRequestTest from '../HandleRequestTest/HandleRequestTest.js'
 import * as HttpServerResponse from '../HttpServerResponse/HttpServerResponse.js'
 import * as StaticPath from '../StaticPath/StaticPath.js'
@@ -17,6 +18,10 @@ export const handleRequest = async (socket, request) => {
     const indexHtmlPath = join(staticPath, 'index.html')
     return HandleRequestTest.handleRequestTest(socket, request, indexHtmlPath)
   }
+  if (request.url.startsWith('/websocket-capabilities/')) {
+    const response = GetWebSocketCapabilityResponse.getWebSocketCapabilityResponse(request)
+    return HttpServerResponse.send(request, socket, response)
+  }
   const fileResponse = await GetElectronFileResponse.getElectronFileResponse(request.url, request)
   HttpServerResponse.send(request, socket, fileResponse)
 }

package/src/parts/HandleWebSocket/HandleWebSocket.js

@@ -5,6 +5,29 @@ import * as HandleWebSocketModule from '../HandleWebSocketModule/HandleWebSocket
 import * as IsAllowedWebSocketOrigin from '../IsAllowedWebSocketOrigin/IsAllowedWebSocketOrigin.js'
 import * as RejectWebSocket from '../RejectWebSocket/RejectWebSocket.js'
 import { VError } from '../VError/VError.js'
+import * as WebSocketCapabilityRegistry from '../WebSocketCapabilityRegistry/WebSocketCapabilityRegistry.js'
+
+const capabilityPath = '/websocket/capability'
+
+const getCapabilityToken = (message) => {
+  const header = message.headers?.['sec-websocket-protocol']
+  if (typeof header !== 'string') {
+    return ''
+  }
+  const protocols = header.split(',').map((protocol) => protocol.trim())
+  if (!protocols.includes(WebSocketCapabilityRegistry.capabilityProtocol)) {
+    return ''
+  }
+  const capabilityProtocol = protocols.find((protocol) => protocol.startsWith(WebSocketCapabilityRegistry.capabilityProtocolPrefix))
+  return capabilityProtocol?.slice(WebSocketCapabilityRegistry.capabilityProtocolPrefix.length) || ''
+}
+
+const sanitizeProtocols = (message) => {
+  message.headers = {
+    ...message.headers,
+    'sec-websocket-protocol': WebSocketCapabilityRegistry.capabilityProtocol,
+  }
+}
 
 export const handleWebSocket = async (handle, message) => {
   try {
@@ -15,10 +38,21 @@ export const handleWebSocket = async (handle, message) => {
       return
     }
     const { url } = message
-    const type = GetTypeFromUrl.getTypeFromUrl(url)
+    if (url.split('?')[0] !== capabilityPath) {
+      RejectWebSocket.rejectWebSocket(handle)
+      return
+    }
+    const token = getCapabilityToken(message)
+    const capability = WebSocketCapabilityRegistry.consume(token)
+    if (!capability) {
+      RejectWebSocket.rejectWebSocket(handle)
+      return
+    }
+    sanitizeProtocols(message)
+    const type = capability.target
     handle.pause()
     const module = HandleWebSocketModule.load(type)
-    module.handleWebSocket(message, handle, type)
+    await module.handleWebSocket(message, handle, type, capability)
   } catch (error) {
     DestroyWebSocket.destroySocket(handle)
     throw new VError(error, `Failed to connect to websocket`)

package/src/parts/HandleWebSocketForExtensionHostHelperProcess/HandleWebSocketForExtensionHostHelperProcess.js

@@ -1,6 +1,22 @@
-import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js'
-import * as IpcId from '../IpcId/IpcId.js'
+                                                                                                        
+import * as ExtensionHostHelperProcessIpc from '../ExtensionHostHelperProcessIpc/ExtensionHostHelperProcessIpc.js'
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcParentType from '../IpcParentType/IpcParentType.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
 
-export const handleWebSocket = (message, handle) => {
-  return HandleIncomingIpc.handleIncomingIpc(IpcId.ExtensionHostHelperProcess, handle, message)
+export const handleWebSocket = async (message, handle, type, capability) => {
+  if (!capability.modulePath) {
+    throw new Error('extension helper capability is missing a module path')
+  }
+  const ipc = await ExtensionHostHelperProcessIpc.create({
+    method: IpcParentType.NodeForkedProcess,
+  })
+  HandleIpc.handleIpc(ipc)
+  try {
+    await JsonRpc.invoke(ipc, 'LoadFile.loadFile', capability.modulePath)
+    await JsonRpc.invokeAndTransfer(ipc, 'HandleWebSocket.handleWebSocket', handle, message)
+  } catch (error) {
+    ipc.dispose()
+    throw error
+  }
 }

package/src/parts/Module/Module.js

@@ -154,6 +154,8 @@ export const load = (moduleId) => {
       return import('../Terminal/Terminal.ipc.js')
     case ModuleId.TextDocument:
       return import('../TextDocument/TextDocument.ipc.js')
+    case ModuleId.WebSocketCapability:
+      return import('../WebSocketCapability/WebSocketCapability.ipc.js')
     case ModuleId.WebViewServer:
       return import('../WebViewServer/WebViewServer.ipc.js')
     case ModuleId.Window:

package/src/parts/ModuleId/ModuleId.js

@@ -82,3 +82,4 @@ export const SendMessagePortToMainProcess = 88
 export const SecretStorage = 89
 export const ChromeCookieImport = 90
 export const FirefoxCookieImport = 91
+export const WebSocketCapability = 92

package/src/parts/ModuleMap/ModuleMap.js

@@ -184,6 +184,7 @@ export const getModuleId = (commandId) => {
     case 'HandleMessagePortForEmbedsProcess.handleMessagePortForEmbedsProcess':
       return ModuleId.HandleMessagePortForEmbedsProcess
     case 'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess':
+    case 'HandleMessagePortForExtensionHostHelperProcess.handlePreloadedMessagePortForExtensionHostHelperProcess':
       return ModuleId.HandleMessagePortForExtensionHostHelperProcess
     case 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess':
       return ModuleId.HandleMessagePortForFileSystemProcess
@@ -300,6 +301,10 @@ export const getModuleId = (commandId) => {
       return ModuleId.Terminal
     case 'Transferrable.transfer':
       return ModuleId.Transferrable
+    case 'WebSocketCapability.create':
+    case 'WebSocketCapability.createExtensionNodeRpc':
+    case 'WebSocketCapability.createLegacyExtensionNodeRpc':
+      return ModuleId.WebSocketCapability
     case 'WebViewServer.create':
     case 'WebViewServer.registerProtocol':
     case 'WebViewServer.setHandler':

package/src/parts/Platform/Platform.js

@@ -61,11 +61,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.95.13'
+export const version = '0.95.14'
 
-export const commit = 'e8dd865'
+export const commit = 'b420a78'
 
-export const date = '2026-08-01T08:43:45.000Z'
+export const date = '2026-08-01T16:57:35.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', 'e8dd865', 'packages', 'preload', 'dist', 'index.js')
+  return join(Root.root, 'static', 'b420a78', 'packages', 'preload', 'dist', 'index.js')
 }

package/src/parts/WebSocketCapability/WebSocketCapability.ipc.js

@@ -0,0 +1,9 @@
+import * as WebSocketCapability from './WebSocketCapability.js'
+
+export const name = 'WebSocketCapability'
+
+export const commandMap = {
+  create: WebSocketCapability.create,
+  createExtensionNodeRpc: WebSocketCapability.createExtensionNodeRpc,
+  createLegacyExtensionNodeRpc: WebSocketCapability.createLegacyExtensionNodeRpc,
+}

package/src/parts/WebSocketCapability/WebSocketCapability.js

@@ -0,0 +1,53 @@
+import * as WebSocketCapabilityRegistry from '../WebSocketCapabilityRegistry/WebSocketCapabilityRegistry.js'
+
+const allowedTargets = new Set([
+  'clipboard-process',
+  'file-system-process',
+  'process-explorer',
+  'search-process',
+  'shared-process',
+  'terminal-process',
+])
+
+                                          
+                                       
+                      
+ 
+
+const createConnectionInfo = (token) => {
+  return {
+    protocols: WebSocketCapabilityRegistry.getProtocols(token),
+    url: '/websocket/capability',
+  }
+}
+
+export const create = (target) => {
+  if (!allowedTargets.has(target)) {
+    throw new Error(`WebSocket target ${target} is not allowed`)
+  }
+  return createConnectionInfo(WebSocketCapabilityRegistry.create(target))
+}
+
+export const createExtensionNodeRpc = (extensionId, rpcId, modulePath) => {
+  if (!extensionId || !rpcId || !modulePath) {
+    throw new TypeError('extension node rpc capability requires extensionId, rpcId and modulePath')
+  }
+  return createConnectionInfo(
+    WebSocketCapabilityRegistry.create('extension-host-helper-process', {
+      extensionId,
+      modulePath,
+      rpcId,
+    }),
+  )
+}
+
+export const createLegacyExtensionNodeRpc = (modulePath) => {
+  if (!modulePath) {
+    throw new TypeError('legacy extension node rpc capability requires a modulePath')
+  }
+  return createConnectionInfo(
+    WebSocketCapabilityRegistry.create('extension-host-helper-process', {
+      modulePath,
+    }),
+  )
+}

package/src/parts/WebSocketCapabilityRegistry/WebSocketCapabilityRegistry.js

@@ -0,0 +1,57 @@
+import { randomBytes } from 'node:crypto'
+
+export const capabilityProtocol = 'lvce-rpc'
+export const capabilityProtocolPrefix = 'lvce-capability.'
+export const capabilityTtl = 60_000
+
+                                      
+                            
+                               
+                              
+                         
+                         
+ 
+
+const capabilities = new Map                             ()
+
+const cleanup = (now) => {
+  for (const [token, capability] of capabilities) {
+    if (capability.expiresAt <= now) {
+      capabilities.delete(token)
+    }
+  }
+}
+
+export const create = (target, options                                                    = {}) => {
+  const now = Date.now()
+  cleanup(now)
+  const token = randomBytes(32).toString('base64url')
+  capabilities.set(token, {
+    ...options,
+    expiresAt: now + capabilityTtl,
+    target,
+  })
+  return token
+}
+
+export const consume = (token) => {
+  const now = Date.now()
+  cleanup(now)
+  const capability = capabilities.get(token)
+  if (!capability) {
+    return undefined
+  }
+  capabilities.delete(token)
+  if (capability.expiresAt <= now) {
+    return undefined
+  }
+  return capability
+}
+
+export const getProtocols = (token) => {
+  return [capabilityProtocol, `${capabilityProtocolPrefix}${token}`]
+}
+
+export const clear = () => {
+  capabilities.clear()
+}

package/src/parts/WebSocketIssuerRegistry/WebSocketIssuerRegistry.js

@@ -0,0 +1,32 @@
+import { randomBytes } from 'node:crypto'
+
+export const issuerTtl = 24 * 60 * 60 * 1000
+
+const issuers = new Map                ()
+
+const cleanup = (now) => {
+  for (const [issuer, expiresAt] of issuers) {
+    if (expiresAt <= now) {
+      issuers.delete(issuer)
+    }
+  }
+}
+
+export const create = () => {
+  const now = Date.now()
+  cleanup(now)
+  const issuer = randomBytes(32).toString('base64url')
+  issuers.set(issuer, now + issuerTtl)
+  return issuer
+}
+
+export const isValid = (issuer) => {
+  const now = Date.now()
+  cleanup(now)
+  const expiresAt = issuers.get(issuer)
+  return typeof expiresAt === 'number' && expiresAt > now
+}
+
+export const clear = () => {
+  issuers.clear()
+}