@lvce-editor/shared-process 0.15.17 → 0.15.19

package/src/parts/GetErrorResponse/GetErrorResponse.js

@@ -12,7 +12,11 @@ const shouldLogError = (error) => {
   return true
 }
 
-export const getErrorResponse = (message, error) => {
+export const getErrorResponse = (message, error, ipc) => {
+  const prettyError = PrettyError.prepare(error)
+  if (shouldLogError(error) && (!ipc || ipc.shouldLogError !== false)) {
+    PrintPrettyError.printPrettyError(prettyError, `[shared-process] `)
+  }
   if (error && error instanceof CommandNotFoundError) {
     return {
       jsonrpc: JsonRpcVersion.Two,
@@ -37,8 +41,6 @@ export const getErrorResponse = (message, error) => {
       },
     }
   }
-  const prettyError = PrettyError.prepare(error)
-  PrintPrettyError.printPrettyError(prettyError, `[shared-process] `)
   return {
     jsonrpc: JsonRpcVersion.Two,
     id: message.id,

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

@@ -1,3 +1,5 @@
+import * as Character from '../Character/Character.js'
+
 /**
  *
  * @param {string} string
@@ -5,5 +7,5 @@
  * @returns
  */
 export const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf('\n', startIndex)
+  return string.indexOf(Character.NewLine, startIndex)
 }

package/src/parts/GetResponse/GetResponse.js

@@ -3,13 +3,13 @@ import * as GetErrorResponse from '../GetErrorResponse/GetErrorResponse.js'
 import * as GetSuccessResponse from '../GetSuccessResponse/GetSuccessResponse.js'
 import * as RequiresSocket from '../RequiresSocket/RequiresSocket.js'
 
-export const getResponse = async (message, handle) => {
+export const getResponse = async (message, ipc) => {
   try {
     const result = RequiresSocket.requiresSocket(message.method)
-      ? await Command.execute(message.method, handle, ...message.params)
+      ? await Command.execute(message.method, ipc, ...message.params)
       : await Command.execute(message.method, ...message.params)
     return GetSuccessResponse.getSuccessResponse(message, result)
   } catch (error) {
-    return GetErrorResponse.getErrorResponse(message, error)
+    return GetErrorResponse.getErrorResponse(message, error, ipc)
   }
 }

package/src/parts/GetTerminalSpawnOptions/GetTerminalSpawnOptions.ipc.js

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

package/src/parts/GetTerminalSpawnOptions/GetTerminalSpawnOptions.js

@@ -0,0 +1,14 @@
+import * as Platform from '../Platform/Platform.js'
+
+export const getTerminalSpawnOptions = () => {
+  if (Platform.isWindows) {
+    return {
+      command: 'powershell.exe',
+      args: [],
+    }
+  }
+  return {
+    command: 'bash',
+    args: ['-i'],
+  }
+}

package/src/parts/HandleElectronMessagePort/HandleElectronMessagePort.ipc.js

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

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

@@ -7,9 +7,9 @@ const handleJsonRpcResult = (message) => {
 }
 
 export const handleIpc = (ipc) => {
-  const handleJsonRpcMessage = async (message, handle) => {
+  const handleJsonRpcMessage = async (message) => {
     if (message.method) {
-      const response = await GetResponse.getResponse(message, handle)
+      const response = await GetResponse.getResponse(message, ipc)
       ipc.send(response)
     } else {
       // TODO handle error
@@ -17,12 +17,12 @@ export const handleIpc = (ipc) => {
     }
   }
 
-  const handleMessageFromParentProcess = async (message, handle) => {
+  const handleMessageFromParentProcess = async (message) => {
     if (message.result) {
       return handleJsonRpcResult(message)
     }
     if (message.method) {
-      return handleJsonRpcMessage(message, handle)
+      return handleJsonRpcMessage(message)
     }
     console.warn('unknown message', message)
   }

package/src/parts/HandleNodeMessagePort/HandleNodeMessagePort.ipc.js

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

package/src/parts/HandleNodeMessagePort/HandleNodeMessagePort.js

@@ -0,0 +1,12 @@
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+export const handleNodeMessagePort = async (messagePort) => {
+  const ipc = await IpcChild.listen({
+    method: IpcChildType.NodeMessagePort,
+    messagePort,
+  })
+  HandleIpc.handleIpc(ipc)
+  messagePort.start()
+}

package/src/parts/HandleWebSocket/HandleWebSocket.js

@@ -1,25 +1,26 @@
 import * as Assert from '../Assert/Assert.js'
+import * as DestroyWebSocket from '../DestroySocket/DestroySocket.js'
 import * as HandleWebSocketModule from '../HandleWebSocketModule/HandleWebSocketModule.js'
 import { VError } from '../VError/VError.js'
 
-export const handleWebSocket = async (handle, message) => {
-  Assert.object(message)
-  Assert.object(handle)
-  const headers = message.headers
-  if (!headers) {
-    throw new VError('missing websocket headers')
-  }
-  const protocol = headers['sec-websocket-protocol']
-  if (!protocol) {
-    throw new VError('missing sec websocket protocol header')
-  }
+export const handleWebSocket = async (message, handle) => {
   try {
+    Assert.object(message)
+    Assert.object(handle)
+    const headers = message.headers
+    if (!headers) {
+      throw new VError('missing websocket headers')
+    }
+    const protocol = headers['sec-websocket-protocol']
+    if (!protocol) {
+      throw new VError('missing sec websocket protocol header')
+    }
+    handle.pause()
     const module = await HandleWebSocketModule.load(protocol)
     await module.handleWebSocket(message, handle, protocol)
+    handle.resume()
   } catch (error) {
-    try {
-      handle.destroy()
-    } catch {}
+    DestroyWebSocket.destroySocket(handle)
     throw new VError(error, `Failed to connect to websocket`)
   }
 }

package/src/parts/HandleWebSocketForSharedProcess/HandleWebSocketForSharedProcess.js

@@ -1,16 +1,23 @@
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-import * as Socket from '../Socket/Socket.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
   }
-  console.info('[info shared process: handle error]', error)
+  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)
-  Socket.set(webSocket)
+  const ipc = await IpcChild.listen({
+    method: IpcChildType.WebSocket,
+    webSocket,
+  })
+  HandleIpc.handleIpc(ipc)
 }

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,8 +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)
-  const rawIpc = await module.listen()
+  // @ts-ignore
+  const rawIpc = await module.listen(params)
   const ipc = module.wrap(rawIpc)
   return ipc
 }

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -8,6 +8,12 @@ export const getModule = (method) => {
       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,6 +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

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

@@ -1,3 +1,5 @@
+import * as IsElectron from '../IsElectron/IsElectron.js'
+
 export const listen = () => {
   // @ts-ignore
   const parentPort = process.parentPort
@@ -8,11 +10,33 @@ export const listen = () => {
   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) {
-      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/IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js

@@ -6,11 +6,31 @@ export const listen = async () => {
   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/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/JoinLines/JoinLines.js

@@ -1,3 +1,5 @@
+import * as Character from '../Character/Character.js'
+
 export const joinLines = (lines) => {
-  return lines.join('\n')
+  return lines.join(Character.NewLine)
 }

package/src/parts/Json/Json.js

@@ -1,6 +1,7 @@
 // parsing error handling based on https://github.com/sindresorhus/parse-json/blob/main/index.js
 
 import { JsonParsingError } from '../JsonParsingError/JsonParsingError.js'
+import * as Character from '../Character/Character.js'
 
 export const parse = async (string, filePath) => {
   try {
@@ -13,5 +14,5 @@ export const parse = async (string, filePath) => {
 }
 
 export const stringify = (value) => {
-  return JSON.stringify(value, null, 2) + '\n'
+  return JSON.stringify(value, null, 2) + Character.NewLine
 }

package/src/parts/JsonError/JsonError.js

@@ -9,8 +9,10 @@ const emptyError = {
   codeFrame: '',
 }
 
+const RE_POSITION = /in JSON at position (\d+)/
+
 export const getErrorPropsFromError = (error, string, filePath) => {
-  const indexMatch = error.message.match(/in JSON at position (\d+)/)
+  const indexMatch = error.message.match(RE_POSITION)
   if (indexMatch && indexMatch.length > 0) {
     const lines = new LinesAndColumns(string)
     const index = Number(indexMatch[1])