@lvce-editor/extension-host-helper-process 0.15.21 → 0.15.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/extension-host-helper-process",
-  "version": "0.15.21",
+  "version": "0.15.22",
   "description": "",
   "main": "index.js",
   "type": "module",

package/src/extensionHostHelperProcessMain.js

@@ -1,42 +1,3 @@
-import * as GetErrorResponse from './parts/GetErrorResponse/GetErrorResponse.js'
-import * as GetSuccessResponse from './parts/GetSuccessResponse/GetSuccessResponse.js'
-import * as ImportScript from './parts/ImportScript/ImportScript.js'
-import * as IpcChild from './parts/IpcChild/IpcChild.js'
-import * as IpcChildType from './parts/IpcChildType/IpcChildType.js'
-import * as Rpc from './parts/Rpc/Rpc.js'
-import * as GetResponse from './parts/GetResponse/GetResponse.js'
+import * as Main from './parts/Main/Main.js'
 
-const waitForFirstMessage = async (ipc) => {
-  const { message } = await new Promise((resolve) => {
-    const cleanup = (value) => {
-      ipc.off('message', handleMessage)
-      resolve(value)
-    }
-    const handleMessage = (message) => {
-      cleanup({ message })
-    }
-    ipc.on('message', handleMessage)
-  })
-  return message
-}
-
-const main = async () => {
-  const ipc = await IpcChild.listen({ method: IpcChildType.Auto() })
-  const firstMessage = await waitForFirstMessage(ipc)
-  let module
-  try {
-    module = await ImportScript.importScript(firstMessage.params[0])
-    if (!module || !module.execute) {
-      throw new Error(`missing export const execute function`)
-    }
-    const response = GetSuccessResponse.getSuccessResponse(firstMessage, null)
-    ipc.send(response)
-  } catch (error) {
-    const response = await GetErrorResponse.getErrorResponse(firstMessage, error)
-    ipc.send(response)
-    return
-  }
-  Rpc.listen(ipc, module.execute)
-}
-
-main()
+Main.main()

package/src/parts/Ajax/Ajax.js

@@ -1,5 +1,8 @@
 import got from 'got'
 
+/**
+ * @deprecated use node api directly
+ */
 export const getJson = async (url) => {
   const json = await got(url, {
     retry: {

package/src/parts/Callback/Callback.js

@@ -0,0 +1,42 @@
+import * as Assert from '../Assert/Assert.js'
+import * as Id from '../Id/Id.js'
+
+export const state = {
+  callbacks: Object.create(null),
+}
+
+export const registerPromise = () => {
+  const id = Id.create()
+  const promise = new Promise((resolve, reject) => {
+    state.callbacks[id] = {
+      resolve,
+      reject,
+    }
+  })
+  return { id, promise }
+}
+
+export const unregister = (id) => {
+  delete state.callbacks[id]
+}
+
+export const resolve = (id, args) => {
+  Assert.number(id)
+  if (!(id in state.callbacks)) {
+    console.log(args)
+    console.warn(`callback ${id} may already be disposed`)
+    return
+  }
+  state.callbacks[id].resolve(args)
+  delete state.callbacks[id]
+}
+
+export const reject = (id, error) => {
+  Assert.number(id)
+  if (!(id in state.callbacks)) {
+    console.warn(`callback ${id} may already be disposed`)
+    return
+  }
+  state.callbacks[id].reject(error)
+  delete state.callbacks[id]
+}

package/src/parts/Command/Command.js

@@ -1,82 +1,10 @@
-import * as Module from '../Module/Module.js'
-import * as ModuleMap from '../ModuleMap/ModuleMap.js'
-
-const commands = Object.create(null)
-const pendingModules = Object.create(null)
-
-const initializeModule = (module) => {
-  if (module.Commands) {
-    for (const [key, value] of Object.entries(module.Commands)) {
-      if (module.name) {
-        const actualKey = `${module.name}.${key}`
-        register(actualKey, value)
-      } else {
-        register(key, value)
-      }
-    }
-    return
-  }
-  throw new Error(`module ${module.name} is missing commands`)
-}
-
-const getOrLoadModule = (moduleId) => {
-  if (!pendingModules[moduleId]) {
-    const importPromise = Module.load(moduleId)
-    pendingModules[moduleId] = importPromise
-      .then(initializeModule)
-      .catch((error) => {
-        console.error(error)
-      })
-  }
-  return pendingModules[moduleId]
-}
-
-const loadCommand = (command) => getOrLoadModule(ModuleMap.getModuleId(command))
-
-export const register = (commandId, listener) => {
-  commands[commandId] = listener
-}
-
-export const invoke = async (command, ...args) => {
-  if (!(command in commands)) {
-    await loadCommand(command)
-    if (!(command in commands)) {
-      console.warn(
-        `[extension host helper process] Unknown command "${command}"`
-      )
-      throw new Error(`Command ${command} not found`)
-    }
-  }
-  if (typeof commands[command] !== 'function') {
-    throw new TypeError(`Command ${command} is not a function`)
-  }
-  return commands[command](...args)
-}
+import { CommandNotFoundError } from '../CommandNotFoundError/CommandNotFoundError.js'
+import * as CommandState from '../CommandState/CommandState.js'
 
 export const execute = (command, ...args) => {
-  if (command in commands) {
-    return commands[command](...args)
-  } else {
-    return (
-      loadCommand(command)
-        // TODO can skip then block in prod (only to prevent endless loop in dev)
-        .then(() => {
-          if (!(command in commands)) {
-            console.warn(`Unknown command "${command}"`)
-            return
-          }
-          try {
-            execute(command, ...args)
-          } catch (error) {
-            console.error(
-              '[extension host helper process] command failed to execute'
-            )
-            console.error(error)
-          }
-        })
-        .catch((error) => {
-          console.error(error)
-        })
-    )
+  const fn = CommandState.getCommand(command)
+  if (!fn) {
+    throw new CommandNotFoundError(command)
   }
+  return fn(...args)
 }

package/src/parts/CommandMap/CommandMap.js

@@ -0,0 +1,11 @@
+import * as Ajax from '../Ajax/Ajax.js'
+import * as Exec from '../Exec/Exec.js'
+import * as HandleWebSocket from '../HandleWebSocket/HandleWebSocket.js'
+import * as LoadFile from '../LoadFile/LoadFile.js'
+
+export const commandMap = {
+  'Exec.exec': Exec.exec,
+  'Ajax.getJson': Ajax.getJson,
+  'HandleWebSocket.handleWebSocket': HandleWebSocket.handleWebSocket,
+  'LoadFile.loadFile': LoadFile.loadFile,
+}

package/src/parts/CommandNotFoundError/CommandNotFoundError.js

@@ -0,0 +1,9 @@
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+
+export class CommandNotFoundError extends Error {
+  constructor(id) {
+    super(`command ${id} not found`)
+    this.name = 'CommandNotFoundError'
+    this.code = ErrorCodes.E_COMMAND_NOT_FOUND
+  }
+}

package/src/parts/CommandState/CommandState.js

@@ -0,0 +1,34 @@
+export const state = {
+  commands: Object.create(null),
+  /**
+   * @type {any}
+   */
+  execute: undefined,
+}
+
+export const registerCommand = (key, fn) => {
+  state.commands[key] = fn
+}
+
+export const registerCommands = (commandMap) => {
+  for (const [key, value] of Object.entries(commandMap)) {
+    registerCommand(key, value)
+  }
+}
+
+export const getCommand = (key) => {
+  const { commands, execute } = state
+  if (key in commands) {
+    return commands[key]
+  }
+  if (execute) {
+    return (...args) => {
+      return execute(key, ...args)
+    }
+  }
+  return undefined
+}
+
+export const setExecute = (fn) => {
+  state.execute = fn
+}

package/src/parts/ErrorCodes/ErrorCodes.js

@@ -0,0 +1,18 @@
+export const E_COLOR_THEME_NOT_FOUND = 'E_COLOR_THEME_NOT_FOUND'
+export const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND'
+export const E_ICON_THEME_NOT_FOUND = 'E_ICON_THEME_NOT_FOUND'
+export const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE'
+export const E_MANIFEST_NOT_FOUND = 'E_MANIFEST_NOT_FOUND'
+export const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON'
+export const EACCES = 'EACCES'
+export const ECONNRESET = 'ECONNRESET'
+export const EEXIST = 'EEXIST'
+export const EISDIR = 'EISDIR'
+export const ELOOP = 'ELOOP'
+export const ENOENT = 'ENOENT'
+export const ENOTDIR = 'ENOTDIR'
+export const EPERM = 'EPERM'
+export const EPIPE = 'EPIPE'
+export const ERR_IPC_CHANNEL_CLOSED = 'ERR_IPC_CHANNEL_CLOSED'
+export const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND'
+export const EXDEV = 'EXDEV'

package/src/parts/Exec/Exec.js

@@ -1,6 +1,9 @@
 import { execa } from 'execa'
 import * as Assert from '../Assert/Assert.js'
 
+/**
+ * @deprecated use node api directly
+ */
 export const exec = async (file, args, options) => {
   Assert.string(file)
   Assert.array(args)

package/src/parts/FirstWebSocketEventType/FirstWebSocketEventType.js

@@ -0,0 +1,2 @@
+export const Open = 1
+export const Close = 2

package/src/parts/GetFirstWebSocketEvent/GetFirstWebSocketEvent.js

@@ -0,0 +1,41 @@
+import * as FirstWebSocketEventType from '../FirstWebSocketEventType/FirstWebSocketEventType.js'
+import { WebSocket } from 'ws'
+
+export const getFirstWebSocketEvent = async (webSocket) => {
+  switch (webSocket.readyState) {
+    case WebSocket.OPEN:
+      return {
+        type: FirstWebSocketEventType.Open,
+        event: undefined,
+      }
+    case WebSocket.CLOSED:
+      return {
+        type: FirstWebSocketEventType.Close,
+        event: undefined,
+      }
+    default:
+      break
+  }
+  const { type, event } = await new Promise((resolve) => {
+    const cleanup = (value) => {
+      webSocket.off('open', handleOpen)
+      webSocket.off('close', handleClose)
+      resolve(value)
+    }
+    const handleOpen = (event) => {
+      cleanup({
+        type: FirstWebSocketEventType.Open,
+        event,
+      })
+    }
+    const handleClose = (event) => {
+      cleanup({
+        type: FirstWebSocketEventType.Close,
+        event,
+      })
+    }
+    webSocket.on('open', handleOpen)
+    webSocket.on('close', handleClose)
+  })
+  return { type, event }
+}

package/src/parts/HandleElectronMessagePort/HandleElectronMessagePort.js

@@ -0,0 +1,14 @@
+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'
+
+export const handleElectronMessagePort = async (messagePort) => {
+  Assert.object(messagePort)
+  const ipc = await IpcChild.listen({
+    method: IpcChildType.ElectronMessagePort,
+    messagePort,
+  })
+  HandleIpc.handleIpc(ipc)
+  messagePort.start()
+}

package/src/parts/HandleIpc/HandleIpc.js

@@ -0,0 +1,12 @@
+import * as Assert from '../Assert/Assert.js'
+import * as Command from '../Command/Command.js'
+import * as Callback from '../Callback/Callback.js'
+import * as HandleJsonRpcMessage from '../HandleJsonRpcMessage/HandleJsonRpcMessage.js'
+
+export const handleIpc = (ipc) => {
+  Assert.object(ipc)
+  const handleMessage = async (message) => {
+    return HandleJsonRpcMessage.handleJsonRpcMessage(ipc, message, Command.execute, Callback.resolve)
+  }
+  ipc.on('message', handleMessage)
+}

package/src/parts/HandleJsonRpcMessage/HandleJsonRpcMessage.js

@@ -0,0 +1,10 @@
+import * as GetResponse from '../GetResponse/GetResponse.js'
+
+export const handleJsonRpcMessage = async (ipc, message, execute, resolve) => {
+  if ('result' in message || 'error' in message) {
+    resolve(message.id, message)
+    return
+  }
+  const response = await GetResponse.getResponse(message, execute)
+  ipc.send(response)
+}

package/src/parts/HandleWebSocket/HandleWebSocket.js

@@ -0,0 +1,18 @@
+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 WebSocketServer from '../WebSocketServer/WebSocketServer.js'
+
+export const handleWebSocket = async (request, handle) => {
+  Assert.object(request)
+  Assert.object(handle)
+  const webSocket = await WebSocketServer.handleUpgrade(request, handle)
+  webSocket.pause()
+  const ipc = await IpcChild.listen({
+    method: IpcChildType.WebSocket,
+    webSocket,
+  })
+  HandleIpc.handleIpc(ipc)
+  webSocket.resume()
+}

package/src/parts/Id/Id.js

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

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -8,6 +8,8 @@ export const getModule = (method) => {
       return import('../IpcChildWithWebSocket/IpcChildWithWebSocket.js')
     case IpcChildType.Parent:
       return import('../IpcChildWithParent/IpcChildWithParent.js')
+    case IpcChildType.NodeForkedProcess:
+      return import('../IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js')
     case IpcChildType.ElectronMessagePort:
       return import('../IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js')
     case IpcChildType.ElectronUtilityProcess:

package/src/parts/IpcChildType/IpcChildType.js

@@ -6,6 +6,7 @@ export const Parent = 3
 export const ElectronMessagePort = 4
 export const ElectronUtilityProcess = 5
 export const ElectronUtilityProcessMessagePort = 6
+export const NodeForkedProcess = 7
 
 const getRawIpcType = () => {
   const { argv } = process
@@ -29,6 +30,8 @@ export const Auto = () => {
       return ElectronUtilityProcess
     case 'electron-utility-process-message-port':
       return ElectronUtilityProcessMessagePort
+    case 'node-forked-process':
+      return NodeForkedProcess
     default:
       throw new Error(`[extension-host-helper-process] unknown ipc type ${ipcType}`)
   }

package/src/parts/IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js

@@ -1,15 +1,39 @@
-import { once } from 'events'
+import { IpcError } from '../IpcError/IpcError.js'
+import * as IsMessagePortMain from '../IsMessagePortMain/IsMessagePortMain.js'
 
-export const listen = async () => {
-  // const [message, handle] = await once(process, 'message')
-  // if (process.send) {
-  //   process.send('ready')
-  // }
-  // return {
-  // }
+export const listen = ({ messagePort }) => {
+  if (!IsMessagePortMain.isMessagePortMain(messagePort)) {
+    throw new IpcError('port must be of type MessagePortMain')
+  }
+  return messagePort
 }
 
-export const wrap = () => {
-  // TODO
-  return {}
+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 {
+        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

@@ -1,8 +1,10 @@
+import { IpcError } from '../IpcError/IpcError.js'
+
 export const listen = () => {
   // @ts-ignore
   const parentPort = process.parentPort
   if (!parentPort) {
-    throw new Error('parent port must be defined')
+    throw new IpcError('parent port must be defined')
   }
   parentPort.postMessage('ready')
   return parentPort

package/src/parts/IpcChildWithElectronUtilityProcessMessagePort/IpcChildWithElectronUtilityProcessMessagePort.js

@@ -3,6 +3,7 @@ import * as getFirstUtilityProcessEvent from '../GetFirstUtilityProcessEvent/Get
 import * as IpcChildType from '../IpcChildType/IpcChildType.js'
 import * as IpcChildWithElectronUtilityProcess from '../IpcChildWithElectronUtilityProcess/IpcChildWithElectronUtilityProcess.js'
 
+// TODO remove this and use HandleElectronMessagePort function instead
 export const listen = async () => {
   const parentPort = IpcChildWithElectronUtilityProcess.listen()
   const { type, event } = await getFirstUtilityProcessEvent.getFirstUtilityProcessEvent(parentPort)

package/src/parts/IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js

@@ -0,0 +1,36 @@
+import { IpcError } from '../IpcError/IpcError.js'
+
+export const listen = async () => {
+  if (!process.send) {
+    throw new IpcError('process ipc is not available')
+  }
+  process.send('ready')
+  return process
+}
+
+export const wrap = (process) => {
+  return {
+    process,
+    send(message) {
+      this.process.send(message)
+    },
+    on(event, listener) {
+      switch (event) {
+        case 'message':
+          this.process.on('message', listener)
+          break
+        default:
+          throw new Error('unknown event listener type')
+      }
+    },
+    off(event, listener) {
+      switch (event) {
+        case 'message':
+          this.process.off('message', listener)
+          break
+        default:
+          throw new Error('unknown event listener type')
+      }
+    },
+  }
+}

package/src/parts/IpcChildWithWebSocket/IpcChildWithWebSocket.js

@@ -1,10 +1,20 @@
-import { once } from 'events'
-import * as GetWebSocket from '../GetWebSocket/GetWebSocket.js'
-import * as Json from '../Json/Json.js'
+import * as GetFirstWebSocketEvent from '../GetFirstWebSocketEvent/GetFirstWebSocketEvent.js'
+import { IpcError } from '../IpcError/IpcError.js'
+import * as IsWebSocket from '../IsWebSocket/IsWebSocket.js'
+import * as IsWebSocketOpen from '../IsWebSocketOpen/IsWebSocketOpen.js'
+import * as WebSocketSerialization from '../WebSocketSerialization/WebSocketSerialization.js'
 
-export const listen = async () => {
-  const [message, handle] = await once(process, 'message')
-  const webSocket = await GetWebSocket.getWebSocket(message, handle)
+export const listen = async ({ webSocket }) => {
+  if (!webSocket) {
+    throw new IpcError('webSocket must be defined')
+  }
+  if (!IsWebSocket.isWebSocket(webSocket)) {
+    throw new IpcError(`webSocket must be of type WebSocket`)
+  }
+  if (!IsWebSocketOpen.isWebSocketOpen(webSocket)) {
+    const { type, event } = await GetFirstWebSocketEvent.getFirstWebSocketEvent(webSocket)
+    console.log({ type, event })
+  }
   return webSocket
 }
 
@@ -15,31 +25,28 @@ export const wrap = (webSocket) => {
      * @type {any}
      */
     wrappedListener: undefined,
-    send(message) {
-      const stringifiedMessage = Json.stringify(message)
-      this.webSocket.send(stringifiedMessage)
-    },
     on(event, listener) {
       switch (event) {
         case 'message':
-          this.wrappedListener = (message) => {
-            const parsed = Json.parse(message.toString())
-            listener(parsed)
+          const wrappedListener = (message) => {
+            const data = WebSocketSerialization.deserialize(message)
+            listener(data)
           }
-          this.webSocket.on('message', this.wrappedListener)
+          webSocket.on('message', wrappedListener)
           break
         default:
           throw new Error('unknown event listener type')
       }
     },
     off(event, listener) {
-      switch (event) {
-        case 'message':
-          this.webSocket.off('message', this.wrappedListener)
-          break
-        default:
-          throw new Error('unknown event listener type')
-      }
+      this.webSocket.off(event, listener)
+    },
+    send(message) {
+      const stringifiedMessage = WebSocketSerialization.serialize(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/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/IsWebSocket/IsWebSocket.js

@@ -0,0 +1,5 @@
+import { WebSocket } from 'ws'
+
+export const isWebSocket = (value) => {
+  return value instanceof WebSocket
+}

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/LoadFile/LoadFile.js

@@ -0,0 +1,21 @@
+import { VError } from '../VError/VError.js'
+import * as CommandState from '../CommandState/CommandState.js'
+import * as ImportScript from '../ImportScript/ImportScript.js'
+import * as Assert from '../Assert/Assert.js'
+
+export const loadFile = async (path) => {
+  try {
+    Assert.string(path)
+    const module = await ImportScript.importScript(path)
+    if (module && module.commandMap) {
+      const commandMap = module.commandMap
+      CommandState.registerCommands(commandMap)
+    } else if (module && module.execute) {
+      CommandState.setExecute(module.execute)
+    } else {
+      throw new Error(`missing export const execute function`)
+    }
+  } catch (error) {
+    throw new VError(error, `Failed to load ${path}`)
+  }
+}

package/src/parts/Main/Main.js

@@ -0,0 +1,11 @@
+import * as CommandMap from '../CommandMap/CommandMap.js'
+import * as CommandState from '../CommandState/CommandState.js'
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+export const main = async () => {
+  CommandState.registerCommands(CommandMap.commandMap)
+  const ipc = await IpcChild.listen({ method: IpcChildType.Auto() })
+  HandleIpc.handleIpc(ipc)
+}

package/src/parts/WebSocketSerialization/WebSocketSerialization.js

@@ -0,0 +1,7 @@
+export const serialize = (message) => {
+  return JSON.stringify(message)
+}
+
+export const deserialize = (message) => {
+  return JSON.parse(message.toString())
+}

package/src/parts/WebSocketServer/WebSocketServer.ipc.js

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

package/src/parts/WebSocketServer/WebSocketServer.js

@@ -0,0 +1,21 @@
+import { Buffer } from 'node:buffer'
+import * as _ws from 'ws'
+
+// workaround for jest or node bug
+const WebSocketServer = _ws.WebSocketServer
+  ? _ws.WebSocketServer
+  : // @ts-ignore
+    _ws.default.WebSocketServer
+
+const webSocketServer = new WebSocketServer({
+  noServer: true,
+})
+
+export const handleUpgrade = (request, socket) => {
+  return new Promise((resolve, reject) => {
+    const upgradeCallback = (ws) => {
+      resolve(ws)
+    }
+    webSocketServer.handleUpgrade(request, socket, Buffer.alloc(0), upgradeCallback)
+  })
+}

package/src/extensionHostHelperProcessMain.cjs

@@ -1,5 +0,0 @@
-const main = async () => {
-  await import('./extensionHostHelperProcessMain.js')
-}
-
-main()

package/src/parts/IpcChildWithMessagePort/IpcChildWithMessagePort.js

@@ -1,9 +0,0 @@
-export const listen = () => {
-  // TODO wait for electron message port to be passed in
-  return {}
-}
-
-export const wrap = () => {
-  // TODO
-  return {}
-}

package/src/parts/IpcChildWithParent/IpcChildWithParent.js

@@ -1,21 +0,0 @@
-export const listen = () => {
-  return process
-}
-
-export const wrap = (process) => {
-  return {
-    process,
-    send(message) {
-      this.process.send(message)
-    },
-    on(event, listener) {
-      switch (event) {
-        case 'message':
-          this.process.on('message', listener)
-          break
-        default:
-          throw new Error('unknown event listener type')
-      }
-    },
-  }
-}

package/src/parts/Rpc/Rpc.js

@@ -1,13 +0,0 @@
-import * as GetResponse from '../GetResponse/GetResponse.js'
-
-export const listen = (ipc, execute) => {
-  const handleMessage = async (message) => {
-    if ('method' in message) {
-      const response = await GetResponse.getResponse(message, execute)
-      ipc.send(response)
-    } else {
-      console.log({ message })
-    }
-  }
-  ipc.on('message', handleMessage)
-}