@lvce-editor/shared-process 0.15.16 → 0.15.18

package/src/parts/HandleWebSocketForExtensionHost/HandleWebSocketForExtensionHost.js

@@ -0,0 +1,15 @@
+import * as ExtensionHostIpc from '../ExtensionHostIpc/ExtensionHostIpc.js'
+import * as ExtensionHostRpc from '../ExtensionHostRpc/ExtensionHostRpc.js'
+
+// TODO lazyload modules for spawning extension host, they are only needed later
+export const handleWebSocket = async (message, handle) => {
+  // console.log('[shared-process] received extension host websocket', message)
+  const ipc = await ExtensionHostIpc.create()
+  console.info('[sharedprocess] creating extension ipc')
+  const rpc = await ExtensionHostRpc.create(ipc, handle)
+  console.info('[sharedprocess] created extension host rpc')
+  ipc._process.send(message, handle)
+  // rpc.send(message)
+  // console.log('spawned extension host')
+  // console.log(rpc)
+}

package/src/parts/HandleWebSocketForExtensionHostHelperProcess/HandleWebSocketForExtensionHostHelperProcess.js

@@ -0,0 +1,6 @@
+import * as ExtensionHostHelperProcessIpc from '../ExtensionHostHelperProcessIpc/ExtensionHostHelperProcessIpc.js'
+
+export const handleWebSocket = async (message, handle) => {
+  const ipc = await ExtensionHostHelperProcessIpc.create()
+  ipc._process.send(message, handle)
+}

package/src/parts/HandleWebSocketForSharedProcess/HandleWebSocketForSharedProcess.js

@@ -0,0 +1,23 @@
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+import * as Logger from '../Logger/Logger.js'
+import * as WebSocketServer from '../WebSocketServer/WebSocketServer.js'
+
+const handleSocketError = (error) => {
+  if (error && error.code === ErrorCodes.ECONNRESET) {
+    return
+  }
+  Logger.info('[info shared process: handle error]', error)
+}
+
+export const handleWebSocket = async (message, handle) => {
+  handle.on('error', handleSocketError)
+  const webSocket = await WebSocketServer.handleUpgrade(message, handle)
+  const ipc = await IpcChild.listen({
+    method: IpcChildType.WebSocket,
+    webSocket,
+  })
+  HandleIpc.handleIpc(ipc)
+}

package/src/parts/HandleWebSocketForTerminalProcess/HandleWebSocketForTerminalProcess.js

@@ -0,0 +1,22 @@
+import * as PtyHost from '../PtyHost/PtyHost.js'
+
+export const handleWebSocket = async (message, handle) => {
+  const instance = await PtyHost.getOrCreate()
+  instance.sendAndTransfer(
+    {
+      jsonrpc: '2.0',
+      method: 'HandleWebSocket.handleWebSocket',
+      params: [message],
+    },
+    handle
+  )
+  // console.log({ instance })
+  // const ipc = await PtyHost.getOrCreate()
+  // console.info('[sharedprocess] creating extension ipc')
+  // const rpc = await ExtensionHostRpc.create(ipc, handle)
+  // console.info('[sharedprocess] created extension host rpc')
+  // ipc._process.send(message, handle)
+  // rpc.send(message)
+  // console.log('spawned extension host')
+  // console.log(rpc)
+}

package/src/parts/HandleWebSocketForUnknown/HandleWebSocketForUnknown.js

@@ -0,0 +1,10 @@
+import * as Logger from '../Logger/Logger.js'
+
+export const handleWebSocket = (message, handle, protocol) => {
+  Logger.warn(`[shared-process] unsupported sec-websocket-procotol ${protocol}`)
+  try {
+    handle.destroy()
+  } catch {
+    // ignore
+  }
+}

package/src/parts/HandleWebSocketModule/HandleWebSocketModule.js

@@ -0,0 +1,20 @@
+import * as ProtocolType from '../ProtocolType/ProtocolType.js'
+import { VError } from '../VError/VError.js'
+
+export const load = (protocol) => {
+  if (!protocol) {
+    throw new VError('missing sec websocket protocol header')
+  }
+  switch (protocol) {
+    case ProtocolType.SharedProcess:
+      return import('../HandleWebSocketForSharedProcess/HandleWebSocketForSharedProcess.js')
+    case ProtocolType.ExtensionHost:
+      return import('../HandleWebSocketForExtensionHost/HandleWebSocketForExtensionHost.js')
+    case ProtocolType.ExtensionHostHelperProcess:
+      return import('../HandleWebSocketForExtensionHostHelperProcess/HandleWebSocketForExtensionHostHelperProcess.js')
+    case ProtocolType.TerminalProcess:
+      return import('../HandleWebSocketForTerminalProcess/HandleWebSocketForTerminalProcess.js')
+    default:
+      return import('../HandleWebSocketForUnknown/HandleWebSocketForUnknown.js')
+  }
+}

package/src/parts/Id/Id.js

@@ -0,0 +1,7 @@
+export const state = {
+  id: 0,
+}
+
+export const create = () => {
+  return ++state.id
+}

package/src/parts/IpcChild/IpcChild.js

@@ -1,6 +1,9 @@
 import * as IpcChildModule from '../IpcChildModule/IpcChildModule.js'
 
-export const listen = async ({ method }) => {
+export const listen = async ({ method, ...params }) => {
   const module = await IpcChildModule.getModule(method)
-  return module.listen()
+  // @ts-ignore
+  const rawIpc = await module.listen(params)
+  const ipc = module.wrap(rawIpc)
+  return ipc
 }

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -6,6 +6,14 @@ export const getModule = (method) => {
       return import('../IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js')
     case IpcChildType.NodeWorker:
       return import('../IpcChildWithNodeWorker/IpcChildWithNodeWorker.js')
+    case IpcChildType.ElectronUtilityProcess:
+      return import('../IpcChildWithElectronUtilityProcess/IpcChildWithElectronUtilityProcess.js')
+    case IpcChildType.ElectronMessagePort:
+      return import('../IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js')
+    case IpcChildType.NodeMessagePort:
+      return import('../IpcChildWithNodeMessagePort/IpcChildWithNodeMessagePort.js')
+    case IpcChildType.WebSocket:
+      return import('../IpcChildWithWebSocket/IpcChildWithWebSocket.js')
     default:
       throw new Error('unexpected ipc type')
   }

package/src/parts/IpcChildType/IpcChildType.js

@@ -1,5 +1,9 @@
 export const NodeWorker = 1
 export const NodeForkedProcess = 2
+export const ElectronUtilityProcess = 3
+export const ElectronMessagePort = 4
+export const NodeMessagePort = 5
+export const WebSocket = 6
 
 export const Auto = () => {
   const { argv } = process
@@ -9,5 +13,8 @@ export const Auto = () => {
   if (argv.includes('--ipc-type=node-forked-process')) {
     return NodeForkedProcess
   }
+  if (argv.includes('--ipc-type=electron-utility-process')) {
+    return ElectronUtilityProcess
+  }
   throw new Error(`[shared-process] unknown ipc type`)
 }

package/src/parts/IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js

@@ -0,0 +1,41 @@
+import { IpcError } from '../IpcError/IpcError.js'
+import * as IsMessagePortMain from '../IsMessagePortMain/IsMessagePortMain.js'
+
+export const listen = ({ messagePort }) => {
+  if (!IsMessagePortMain.isMessagePortMain(messagePort)) {
+    throw new IpcError('port must be of type MessagePortMain')
+  }
+  return messagePort
+}
+
+const getActualData = (event) => {
+  return event.data
+}
+
+export const wrap = (messagePort) => {
+  return {
+    messagePort,
+    on(event, listener) {
+      if (event === 'message') {
+        const wrappedListener = (event) => {
+          const actualData = getActualData(event)
+          listener(actualData)
+        }
+        this.messagePort.on(event, wrappedListener)
+      } else if (event === 'close') {
+        this.messagePort.on('close', listener)
+      } else {
+        throw new Error('unsupported event type')
+      }
+    },
+    off(event, listener) {
+      this.messagePort.off(event, listener)
+    },
+    send(message) {
+      this.messagePort.postMessage(message)
+    },
+    dispose() {
+      this.messagePort.close()
+    },
+  }
+}

package/src/parts/IpcChildWithElectronUtilityProcess/IpcChildWithElectronUtilityProcess.js

@@ -0,0 +1,51 @@
+import * as IsElectron from '../IsElectron/IsElectron.js'
+
+export const listen = () => {
+  // @ts-ignore
+  const parentPort = process.parentPort
+  if (!parentPort) {
+    throw new Error('parent port must be defined')
+  }
+  parentPort.postMessage('ready')
+  return parentPort
+}
+
+const getActualData = (event) => {
+  const { data, ports } = event
+  if (ports.length === 0) {
+    return data
+  }
+  return {
+    ...data,
+    params: [...data.params, ...ports],
+  }
+}
+
+export const wrap = (parentPort) => {
+  return {
+    shouldLogError: !IsElectron.isElectron(),
+    parentPort,
+    on(event, listener) {
+      if (event === 'message') {
+        const wrappedListener = (event) => {
+          const actualData = getActualData(event)
+          listener(actualData)
+        }
+        this.parentPort.on(event, wrappedListener)
+      } else if (event === 'close') {
+        this.parentPort.on('close', listener)
+      } else {
+        throw new Error('unsupported event type')
+      }
+    },
+    off(event, listener) {
+      this.parentPort.off(event, listener)
+    },
+    send(message) {
+      this.parentPort.postMessage(message)
+    },
+    dispose() {
+      this.parentPort.close()
+    },
+  }
+}

package/src/parts/IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js

@@ -1,12 +1,36 @@
 export const listen = async () => {
+  if (!process.send) {
+    throw new Error('process.send must be defined')
+  }
+  process.send('ready')
   return process
 }
 
+const getActualData = (message, handle) => {
+  if (handle) {
+    return {
+      ...message,
+      params: [...message.params, handle],
+    }
+  }
+  return message
+}
+
 export const wrap = (process) => {
   return {
     process,
     on(event, listener) {
-      this.process.on(event, listener)
+      if (event === 'message') {
+        const wrappedListener = (event, handle) => {
+          const actualData = getActualData(event, handle)
+          listener(actualData)
+        }
+        this.process.on(event, wrappedListener)
+      } else if (event === 'close') {
+        this.process.on('close', listener)
+      } else {
+        throw new Error('unsupported event type')
+      }
     },
     off(event, listener) {
       this.process.off(event, listener)

package/src/parts/IpcChildWithNodeMessagePort/IpcChildWithNodeMessagePort.js

@@ -0,0 +1,41 @@
+import { IpcError } from '../IpcError/IpcError.js'
+import * as IsMessagePort from '../IsMessagePort/IsMessagePort.js'
+
+export const listen = ({ messagePort }) => {
+  if (!IsMessagePort.isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort')
+  }
+  return messagePort
+}
+
+const getActualData = (message) => {
+  return message
+}
+
+export const wrap = (messagePort) => {
+  return {
+    messagePort,
+    on(event, listener) {
+      if (event === 'message') {
+        const wrappedListener = (event) => {
+          const actualData = getActualData(event)
+          listener(actualData)
+        }
+        this.messagePort.on(event, wrappedListener)
+      } else if (event === 'close') {
+        this.messagePort.on('close', listener)
+      } else {
+        throw new Error(`unsupported event type ${event}`)
+      }
+    },
+    off(event, listener) {
+      this.messagePort.off(event, listener)
+    },
+    send(message) {
+      this.messagePort.postMessage(message)
+    },
+    dispose() {
+      this.messagePort.close()
+    },
+  }
+}

package/src/parts/IpcChildWithNodeWorker/IpcChildWithNodeWorker.js

@@ -1,4 +1,5 @@
 import { parentPort } from 'node:worker_threads'
+import * as IsElectron from '../IsElectron/IsElectron.js'
 
 export const listen = async () => {
   if (!parentPort) {
@@ -8,11 +9,26 @@ export const listen = async () => {
   return parentPort
 }
 
+const getActualData = (message) => {
+  return message
+}
+
 export const wrap = (parentPort) => {
   return {
+    shouldLogError: !IsElectron.isElectron(),
     parentPort,
     on(event, listener) {
-      this.parentPort.on(event, listener)
+      if (event === 'message') {
+        const wrappedListener = (event) => {
+          const actualData = getActualData(event)
+          listener(actualData)
+        }
+        this.parentPort.on(event, wrappedListener)
+      } else if (event === 'close') {
+        this.parentPort.on('close', listener)
+      } else {
+        throw new Error('unsupported event type')
+      }
     },
     off(event, listener) {
       this.parentPort.off(event, listener)

package/src/parts/IpcChildWithWebSocket/IpcChildWithWebSocket.js

@@ -0,0 +1,51 @@
+import * as GetFirstWebSocketEvent from '../GetFirstWebSocketEvent/GetFirstWebSocketEvent.js'
+import * as IsWebSocketOpen from '../IsWebSocketOpen/IsWebSocketOpen.js'
+
+export const listen = async ({ webSocket }) => {
+  if (!IsWebSocketOpen.isWebSocketOpen(webSocket)) {
+    const { type, event } = await GetFirstWebSocketEvent.getFirstWebSocketEvent(webSocket)
+    console.log({ type, event })
+  }
+  return webSocket
+}
+
+const getActualData = (message) => {
+  const data = JSON.parse(message.toString())
+  return data
+}
+
+export const wrap = (webSocket) => {
+  return {
+    webSocket,
+    /**
+     * @type {any}
+     */
+    wrappedListener: undefined,
+    on(event, listener) {
+      switch (event) {
+        case 'message':
+          const wrappedListener = (message) => {
+            const data = getActualData(message)
+            listener(data)
+          }
+          webSocket.on('message', wrappedListener)
+          break
+        case 'close':
+          webSocket.on('close', listener)
+          break
+        default:
+          throw new Error('unknown event listener type')
+      }
+    },
+    off(event, listener) {
+      this.webSocket.off(event, listener)
+    },
+    send(message) {
+      const stringifiedMessage = JSON.stringify(message)
+      this.webSocket.send(stringifiedMessage)
+    },
+    dispose() {
+      this.webSocket.close()
+    },
+  }
+}

package/src/parts/IpcError/IpcError.js

@@ -0,0 +1,6 @@
+export class IpcError extends Error {
+  constructor(message) {
+    super(message)
+    this.name = 'IpcError'
+  }
+}

package/src/parts/IpcParentWithNodeForkedProcess/IpcParentWithNodeForkedProcess.js

@@ -8,7 +8,8 @@ import { VError } from '../VError/VError.js'
 export const create = async ({ path, argv = [], env, execArgv = [], stdio = 'inherit', name = 'child process' }) => {
   try {
     Assert.string(path)
-    const childProcess = fork(path, argv, {
+    const actualArgv = ['--ipc-type=node-forked-process', ...argv]
+    const childProcess = fork(path, actualArgv, {
       env,
       execArgv,
       stdio: 'pipe',
@@ -36,11 +37,14 @@ export const wrap = (childProcess) => {
     on(event, listener) {
       this.childProcess.on(event, listener)
     },
+    off(event, listener) {
+      this.childProcess.off(event, listener)
+    },
     send(message) {
       this.childProcess.send(message)
     },
-    sendAndTransfer(message, transfer) {
-      throw new Error('transfer is not supported')
+    sendAndTransfer(message, handle) {
+      this.childProcess.send(message, handle)
     },
     dispose() {
       this.childProcess.kill()

package/src/parts/IsElectron/IsElectron.js

@@ -0,0 +1,3 @@
+export const isElectron = () => {
+  return Boolean(process.env.ELECTRON_RUN_AS_NODE)
+}

package/src/parts/IsMessagePort/IsMessagePort.js

@@ -0,0 +1,3 @@
+export const isMessagePort = (value) => {
+  return value && value instanceof MessagePort
+}

package/src/parts/IsMessagePortMain/IsMessagePortMain.js

@@ -0,0 +1,3 @@
+export const isMessagePortMain = (value) => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain'
+}

package/src/parts/IsSocket/IsSocket.js

@@ -0,0 +1,5 @@
+import { Socket } from 'node:net'
+
+export const isSocket = (value) => {
+  return value instanceof Socket
+}

package/src/parts/IsWebSocketOpen/IsWebSocketOpen.js

@@ -0,0 +1,5 @@
+import { WebSocket } from 'ws'
+
+export const isWebSocketOpen = (webSocket) => {
+  return webSocket.readyState === WebSocket.OPEN
+}

package/src/parts/JsonRpc/JsonRpc.js

@@ -10,14 +10,26 @@ export const send = (transport, method, ...params) => {
 }
 
 export const invoke = (ipc, method, ...params) => {
-  return new Promise((resolve, reject) => {
-    // TODO use one map instead of two
-    const callbackId = Callback.register(resolve, reject)
-    ipc.send({
+  const { id, promise } = Callback.registerPromise()
+  ipc.send({
+    jsonrpc: JsonRpcVersion.Two,
+    method,
+    params,
+    id,
+  })
+  return promise
+}
+
+export const invokeAndTransfer = (ipc, handle, method, ...params) => {
+  const { id, promise } = Callback.registerPromise()
+  ipc.sendAndTransfer(
+    {
       jsonrpc: JsonRpcVersion.Two,
       method,
       params,
-      id: callbackId,
-    })
-  })
+      id,
+    },
+    handle
+  )
+  return promise
 }

package/src/parts/Module/Module.js

@@ -2,6 +2,8 @@ import * as ModuleId from '../ModuleId/ModuleId.js'
 
 export const load = (moduleId) => {
   switch (moduleId) {
+    case ModuleId.AttachDebugger:
+      return import('../AttachDebugger/AttachDebugger.ipc.js')
     case ModuleId.AutoUpdater:
       return import('../AutoUpdater/AutoUpdater.ipc.js')
     case ModuleId.AutoUpdaterAppImage:
@@ -20,6 +22,8 @@ export const load = (moduleId) => {
       return import('../Download/Download.ipc.js')
     case ModuleId.ExtensionHost:
       return import('../ExtensionHost/ExtensionHost.ipc.js')
+    case ModuleId.ElectronInitialize:
+      return import('../ElectronInitialize/ElectronInitialize.ipc.js')
     case ModuleId.ExtensionManagement:
       return import('../ExtensionManagement/ExtensionManagement.ipc.js')
     case ModuleId.FileSystem:
@@ -38,6 +42,8 @@ export const load = (moduleId) => {
       return import('../Platform/Platform.ipc.js')
     case ModuleId.Preferences:
       return import('../Preferences/Preferences.ipc.js')
+    case ModuleId.Process:
+      return import('../Process/Process.ipc.js')
     case ModuleId.RecentlyOpened:
       return import('../RecentlyOpened/RecentlyOpened.ipc.js')
     case ModuleId.SearchFile:
@@ -52,6 +58,14 @@ export const load = (moduleId) => {
       return import('../WebSocketServer/WebSocketServer.ipc.js')
     case ModuleId.Workspace:
       return import('../Workspace/Workspace.ipc.js')
+    case ModuleId.RebuildNodePty:
+      return import('../RebuildNodePty/RebuildNodePty.ipc.js')
+    case ModuleId.HandleWebSocket:
+      return import('../HandleWebSocket/HandleWebSocket.ipc.js')
+    case ModuleId.HandleElectronMessagePort:
+      return import('../HandleElectronMessagePort/HandleElectronMessagePort.ipc.js')
+    case ModuleId.HandleNodeMessagePort:
+      return import('../HandleNodeMessagePort/HandleNodeMessagePort.ipc.js')
     default:
       throw new Error(`module ${moduleId} not found`)
   }

package/src/parts/ModuleId/ModuleId.js

@@ -23,3 +23,10 @@ export const AutoUpdater = 22
 export const IsAutoUpdateSupported = 23
 export const AutoUpdaterAppImage = 24
 export const AutoUpdaterWindowsNsis = 25
+export const RebuildNodePty = 26
+export const ElectronInitialize = 27
+export const HandleWebSocket = 28
+export const Process = 29
+export const AttachDebugger = 30
+export const HandleElectronMessagePort = 31
+export const HandleNodeMessagePort = 32

package/src/parts/ModuleMap/ModuleMap.js

@@ -3,6 +3,8 @@ import * as ModuleId from '../ModuleId/ModuleId.js'
 
 export const getModuleId = (commandId) => {
   switch (commandId) {
+    case 'AttachDebugger.attachDebugger':
+      return ModuleId.AttachDebugger
     case 'AutoUpdater.getAutoUpdateType':
     case 'AutoUpdater.getLatestVersion':
       return ModuleId.AutoUpdater
@@ -31,6 +33,8 @@ export const getModuleId = (commandId) => {
       return ModuleId.Developer
     case 'Download.download':
       return ModuleId.Download
+    case 'ElectronInitialize.electronInitialize':
+      return ModuleId.ElectronInitialize
     case 'ExtensionHost.dispose':
     case 'ExtensionHost.enableExtension':
     case 'ExtensionHost.executeCommand':
@@ -108,6 +112,12 @@ export const getModuleId = (commandId) => {
     case 'GitLsFiles.gitLsFilesHash':
     case 'GitLsFiles.resolveGit':
       return ModuleId.GitLsFiles
+    case 'HandleWebSocket.handleWebSocket':
+      return ModuleId.HandleWebSocket
+    case 'HandleElectronMessagePort.handleElectronMessagePort':
+      return ModuleId.HandleElectronMessagePort
+    case 'HandleNodeMessagePort.handleNodeMessagePort':
+      return ModuleId.HandleNodeMessagePort
     case 'InstallExtension.installExtension':
       return ModuleId.InstallExtension
     case 'IsAutoUpdateSupported.isAutoUpdateSupported':
@@ -155,6 +165,14 @@ export const getModuleId = (commandId) => {
     case 'Workspace.getHomeDir':
     case 'Workspace.resolveRoot':
       return ModuleId.Workspace
+    case 'RebuildNodePty.rebuildNodePty':
+      return ModuleId.RebuildNodePty
+    case 'Process.getPid':
+      return ModuleId.Process
+    case 'HandleNodeMessagePort.handleNodeMessagePort':
+      return ModuleId.HandleNodeMessagePort
+    case 'HandleElectronMessagePort.handleElectronMessagePort':
+      return ModuleId.HandleElectronMessagePort
     default:
       throw new CommandNotFoundError(commandId)
   }