@lvce-editor/shared-process 0.15.17 → 0.15.18

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

@@ -10,30 +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({
-      jsonrpc: JsonRpcVersion.Two,
-      method,
-      params,
-      id: callbackId,
-    })
+  const { id, promise } = Callback.registerPromise()
+  ipc.send({
+    jsonrpc: JsonRpcVersion.Two,
+    method,
+    params,
+    id,
   })
+  return promise
 }
 
 export const invokeAndTransfer = (ipc, handle, method, ...params) => {
-  return new Promise((resolve, reject) => {
-    // TODO use one map instead of two
-    const callbackId = Callback.register(resolve, reject)
-    ipc.sendAndTransfer(
-      {
-        jsonrpc: JsonRpcVersion.Two,
-        method,
-        params,
-        id: callbackId,
-      },
-      handle
-    )
-  })
+  const { id, promise } = Callback.registerPromise()
+  ipc.sendAndTransfer(
+    {
+      jsonrpc: JsonRpcVersion.Two,
+      method,
+      params,
+      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:
@@ -40,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:
@@ -58,6 +62,10 @@ export const load = (moduleId) => {
       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

@@ -26,3 +26,7 @@ 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
@@ -112,6 +114,10 @@ export const getModuleId = (commandId) => {
       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':
@@ -161,6 +167,12 @@ export const getModuleId = (commandId) => {
       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)
   }

package/src/parts/PrettyError/PrettyError.js

@@ -1,22 +1,14 @@
 import { codeFrameColumns } from '@babel/code-frame'
 import { LinesAndColumns } from 'lines-and-columns'
 import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { AssertionError } from '../AssertionError/AssertionError.js'
 import * as CleanStack from '../CleanStack/CleanStack.js'
 import * as EncodingType from '../EncodingType/EncodingType.js'
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as GetActualPath from '../GetActualPath/GetActualPath.js'
 import * as JoinLines from '../JoinLines/JoinLines.js'
 import * as Json from '../Json/Json.js'
 import * as SplitLines from '../SplitLines/SplitLines.js'
 
-const getActualPath = (fileUri) => {
-  if (fileUri.startsWith('file://')) {
-    return fileURLToPath(fileUri)
-  }
-  return fileUri
-}
-
 const RE_MODULE_NOT_FOUND_STACK = /Cannot find package '([^']+)' imported from (.+)$/
 
 const prepareModuleNotFoundError = (error) => {
@@ -61,13 +53,6 @@ const prepareModuleNotFoundError = (error) => {
   }
 }
 
-const getStackLinesToCut = (error) => {
-  if (error instanceof AssertionError) {
-    return 1
-  }
-  return 0
-}
-
 export const prepare = (error) => {
   if (error && error.code === ErrorCodes.ERR_MODULE_NOT_FOUND) {
     return prepareModuleNotFoundError(error)
@@ -79,8 +64,7 @@ export const prepare = (error) => {
       error = cause
     }
   }
-  const linesToCut = getStackLinesToCut(error)
-  const lines = CleanStack.cleanStack(error.stack).slice(linesToCut)
+  const lines = CleanStack.cleanStack(error.stack)
   const file = lines[0]
   let codeFrame = ''
   if (error.codeFrame) {
@@ -92,7 +76,7 @@ export const prepare = (error) => {
     }
     if (match) {
       const [_, path, line, column] = match
-      const actualPath = getActualPath(path)
+      const actualPath = GetActualPath.getActualPath(path)
       const rawLines = readFileSync(actualPath, EncodingType.Utf8)
       const location = {
         start: {

package/src/parts/Process/Process.ipc.js

@@ -5,4 +5,5 @@ export const name = 'Process'
 export const Commands = {
   crash: Process.crash,
   crashAsync: Process.crashAsync,
+  getPid: Process.getPid,
 }

package/src/parts/Process/Process.js

@@ -28,4 +28,12 @@ export const isConnected = () => {
   return process.connected
 }
 
+export const kill = (pid, signal) => {
+  process.kill(pid, signal)
+}
+
+export const getPid = () => {
+  return process.pid
+}
+
 export const { platform } = process

package/src/parts/ProcessDisplayName/ProcessDisplayName.js

@@ -0,0 +1 @@
+export const processDisplayName = 'shared process'

package/src/parts/RequiresSocket/RequiresSocket.js

@@ -7,7 +7,6 @@ const METHODS_THAT_REQUIRE_SOCKET = new Set([
   'ExtensionHost.send',
   'ExtensionHost.watchColorTheme',
   'Terminal.create',
-  'HandleWebSocket.handleWebSocket',
 ])
 
 export const requiresSocket = (method) => {

package/src/parts/Signal/Signal.js

@@ -0,0 +1,2 @@
+export const SIGUSR1 = 'SIGUSR1'
+export const SIGTERM = 'SIGTERM'

package/src/parts/Terminal/Terminal.js

@@ -1,10 +1,31 @@
 import * as Assert from '../Assert/Assert.js'
 import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
 import * as PtyHost from '../PtyHost/PtyHost.js'
+import * as TerminalState from '../TerminalState/TerminalState.js'
 import { VError } from '../VError/VError.js'
 
-export const state = {
-  socketMap: Object.create(null),
+const createTerminal = (ptyHost, socket) => {
+  const handleMessage = (message) => {
+    socket.send(message)
+  }
+  const handleClose = () => {
+    // socket.off('close', handleClose)
+    ptyHost.off('message', handleMessage)
+    ptyHost.dispose()
+  }
+  const dispose = () => {
+    ptyHost.off('message', handleMessage)
+    socket.off('close', handleClose)
+  }
+  ptyHost.on('message', handleMessage)
+  socket.on('close', handleClose)
+  return {
+    ptyHost,
+    socket,
+    handleMessage,
+    handleClose,
+    dispose,
+  }
 }
 
 export const create = async (socket, id, cwd) => {
@@ -12,21 +33,10 @@ export const create = async (socket, id, cwd) => {
     Assert.object(socket)
     Assert.number(id)
     Assert.string(cwd)
-    // TODO dispose entry
-    state.socketMap[id] = socket
+    // TODO race condition because of await
     const ptyHost = await PtyHost.getOrCreate()
-
-    const handleMessage = (message) => {
-      socket.send(message)
-    }
-    const handleClose = () => {
-      // socket.off('close', handleClose)
-      ptyHost.off('message', handleMessage)
-      ptyHost.dispose()
-    }
-    ptyHost.on('message', handleMessage)
-    socket.on('close', handleClose)
-
+    const terminal = createTerminal(ptyHost, socket)
+    TerminalState.add(id, terminal)
     // TODO use invoke
     ptyHost.send({
       jsonrpc: JsonRpcVersion.Two,
@@ -59,6 +69,9 @@ export const resize = (state, columns, rows) => {
 }
 
 export const dispose = async (id) => {
+  const terminal = TerminalState.get(id)
+  terminal.dispose()
+  TerminalState.remove(id)
   const ptyHost = await PtyHost.getOrCreate()
   // TODO use invoke
   ptyHost.send({

package/src/parts/TerminalState/TerminalState.js

@@ -0,0 +1,15 @@
+export const state = {
+  terminals: Object.create(null),
+}
+
+export const add = (id, terminal) => {
+  state.terminals[id] = terminal
+}
+
+export const get = (id) => {
+  return state.terminals[id]
+}
+
+export const remove = (id) => {
+  delete state.terminals[id]
+}

package/src/parts/WebSocketServer/WebSocketServer.js

@@ -1,5 +1,6 @@
 import { Buffer } from 'node:buffer'
 import * as _ws from 'ws'
+import * as IsSocket from '../IsSocket/IsSocket.js'
 
 // workaround for jest or node bug
 const WebSocketServer = _ws.WebSocketServer
@@ -14,11 +15,15 @@ const webSocketServer = new WebSocketServer({
   // perMessageDeflate: true
 })
 
-export const handleUpgrade = (request, socket) => {
-  return new Promise((resolve, reject) => {
+export const handleUpgrade = async (request, socket) => {
+  if (!IsSocket.isSocket(socket)) {
+    throw new TypeError(`socket must be of type Socket`)
+  }
+  const webSocket = await new Promise((resolve, reject) => {
     const upgradeCallback = (ws) => {
       resolve(ws)
     }
     webSocketServer.handleUpgrade(request, socket, Buffer.alloc(0), upgradeCallback)
   })
+  return webSocket
 }

package/src/sharedProcessMain.cjs

@@ -0,0 +1 @@
+import('./sharedProcessMain.js')

package/src/sharedProcessMain.js

@@ -3,6 +3,7 @@ import * as ErrorHandling from './parts/ErrorHandling/ErrorHandling.js'
 import * as Module from './parts/Module/Module.js'
 import * as ParentIpc from './parts/ParentIpc/ParentIpc.js'
 import * as Process from './parts/Process/Process.js'
+import * as Signal from './parts/Signal/Signal.js'
 // TODO handle structure: one shared process multiple extension hosts
 
 // TODO use named functions here
@@ -34,7 +35,7 @@ const main = async () => {
   console.log('[shared process] started')
   // process.on('beforeExit', handleBeforeExit)
   process.on('disconnect', handleDisconnect)
-  process.on('SIGTERM', handleSigTerm)
+  process.on(Signal.SIGTERM, handleSigTerm)
 
   process.on('uncaughtExceptionMonitor', ErrorHandling.handleUncaughtExceptionMonitor)
   await ParentIpc.listen()

package/src/parts/Socket/Socket.js

@@ -1,77 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as GetResponse from '../GetResponse/GetResponse.js'
-import { VError } from '../VError/VError.js'
-
-export const state = {
-  /**
-   * @type {any}
-   */
-  socket: undefined,
-}
-
-export const send = (message) => {
-  if (!state.socket) {
-    console.warn('socket not yet available')
-    return
-  }
-  state.socket.send(message)
-}
-
-const handleMessage = async (event) => {
-  const object = JSON.parse(event.data)
-  if (object.id) {
-    if (!object.params) {
-      console.warn('[shared-process] invalid message 1', typeof object, object.params, object)
-      return
-    }
-    const response = await GetResponse.getResponse(object, state.socket)
-    send(response)
-  } else {
-    if (!object.params) {
-      console.warn('invalid message', typeof object, object.params, object)
-      return
-    }
-    Command.execute(object.method, state.socket, ...object.params)
-  }
-}
-
-const handleError = (error) => {
-  // console.error(error)
-  throw new VError(error, 'Shared Process Socket Error')
-
-  // console.error('[Shared Process: Socket Error]', event)
-}
-
-// TODO
-const createAbstractSocket = (socket) => {
-  return {
-    _socket: socket,
-    send(message) {
-      socket.send(JSON.stringify(message))
-    },
-    on(event, listener) {
-      switch (event) {
-        case 'message':
-          socket.on('message', listener)
-          break
-        case 'close':
-          socket.on('close', listener)
-          break
-        default:
-          console.warn('socket event not implemented', event, listener)
-          break
-      }
-    },
-  }
-}
-
-export const set = (socket) => {
-  socket.on('close', () => {
-    console.log('[shared-process] socket closed')
-  })
-  socket.onmessage = handleMessage
-  // socket.onerror = handleError
-  socket.on('error', handleError)
-  const abstractSocket = createAbstractSocket(socket)
-  state.socket = abstractSocket
-}