@lvce-editor/pty-host 0.15.16 → 0.15.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/pty-host",
-  "version": "0.15.16",
+  "version": "0.15.18",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -16,8 +16,11 @@
     "node": ">=16"
   },
   "dependencies": {
+    "@babel/code-frame": "^7.21.4",
     "debug": "^4.3.4",
-    "verror": "^1.10.1"
+    "lines-and-columns": "^2.0.3",
+    "verror": "^1.10.1",
+    "ws": "^8.13.0"
   },
   "optionalDependencies": {
     "node-pty": "^0.11.0-beta27"

package/src/parts/Assert/Assert.js

@@ -1,3 +1,5 @@
+import { AssertionError } from '../AssertionError/AssertionError.js'
+
 const getType = (value) => {
   switch (typeof value) {
     case 'number':
@@ -24,34 +26,34 @@ const getType = (value) => {
 export const object = (value) => {
   const type = getType(value)
   if (type !== 'object') {
-    throw new Error('expected value to be of type object')
+    throw new AssertionError('expected value to be of type object')
   }
 }
 
 export const number = (value) => {
   const type = getType(value)
   if (type !== 'number') {
-    throw new Error('expected value to be of type number')
+    throw new AssertionError('expected value to be of type number')
   }
 }
 
 export const array = (value) => {
   const type = getType(value)
   if (type !== 'array') {
-    throw new Error('expected value to be of type array')
+    throw new AssertionError('expected value to be of type array')
   }
 }
 
 export const string = (value) => {
   const type = getType(value)
   if (type !== 'string') {
-    throw new Error('expected value to be of type string')
+    throw new AssertionError('expected value to be of type string')
   }
 }
 
 export const boolean = (value) => {
   const type = getType(value)
   if (type !== 'boolean') {
-    throw new Error('expected value to be of type boolean')
+    throw new AssertionError('expected value to be of type boolean')
   }
 }

package/src/parts/AssertionError/AssertionError.js

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

package/src/parts/CleanStack/CleanStack.js

@@ -0,0 +1,93 @@
+import * as SplitLines from '../SplitLines/SplitLines.js'
+
+const RE_AT = /^\s+at/
+const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/
+const RE_OBJECT_AS = /^\s*at (async )?Object\.\w+ \[as ([\w\.]+)\]/
+const RE_GET_RESPONSE = /^\s*at async getResponse/
+const RE_WEBSOCKET_HANDLE_MESSAGE = /^\s*at async WebSocket.handleMessage/
+const RE_EXECUTE_COMMAND_ASYNC = /^\s*at executeCommandAsync/
+const RE_HANDLE_OTHER_MESSAGES_FROM_MESSAGE_PORT = /^\s*at async MessagePort\.handleOtherMessagesFromMessagePort/
+
+const isInternalLine = (line) => {
+  return line.includes('node:') || RE_AT_PROMISE_INDEX.test(line) || line.includes('node_modules/ws')
+}
+
+const isRelevantLine = (line) => {
+  return !isInternalLine(line)
+}
+
+const isApplicationUsefulLine = (line, index) => {
+  if (index === 0) {
+    return true
+  }
+  if (RE_GET_RESPONSE.test(line)) {
+    return false
+  }
+  if (RE_WEBSOCKET_HANDLE_MESSAGE.test(line)) {
+    return false
+  }
+  if (RE_EXECUTE_COMMAND_ASYNC.test(line)) {
+    return false
+  }
+  if (RE_HANDLE_OTHER_MESSAGES_FROM_MESSAGE_PORT.test(line)) {
+    return false
+  }
+  return true
+}
+
+const isNormalStackLine = (line) => {
+  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line)
+}
+
+const cleanLine = (line) => {
+  if (line.startsWith('    at exports.')) {
+    return '    at ' + line.slice('    at exports.'.length)
+  }
+  if (line.startsWith('    at async exports.')) {
+    return '    at async ' + line.slice('    at async exports.'.length)
+  }
+  if (line.startsWith('    at async Module.')) {
+    return '    at async ' + line.slice('    at async Module.'.length)
+  }
+  if (line.startsWith('    at Module.')) {
+    return '    at ' + line.slice('    at Module.'.length)
+  }
+  const objectMatch = line.match(RE_OBJECT_AS)
+  if (objectMatch) {
+    const rest = line.slice(objectMatch[0].length)
+    if (objectMatch[1]) {
+      return '    at ' + objectMatch[1] + objectMatch[2] + rest
+    }
+    return '    at ' + objectMatch[2] + rest
+  }
+  return line
+}
+
+const getDetails = (lines) => {
+  const index = lines.findIndex(isNormalStackLine)
+  return {
+    custom: lines.slice(0, index),
+    actualStack: lines.slice(index).map(cleanLine),
+  }
+}
+
+const RE_PATH_1 = /^\/(.*)(\d+)$/
+
+const mergeCustom = (custom, relevantStack) => {
+  if (custom.length === 0) {
+    return relevantStack
+  }
+  const firstLine = custom[0]
+  if (RE_PATH_1.test(firstLine)) {
+    return [`    at ${firstLine}`, ...relevantStack]
+  }
+  return relevantStack
+}
+
+export const cleanStack = (stack) => {
+  const lines = SplitLines.splitLines(stack)
+  const { custom, actualStack } = getDetails(lines)
+  const relevantStack = actualStack.filter(isRelevantLine).filter(isApplicationUsefulLine)
+  const merged = mergeCustom(custom, relevantStack)
+  return merged
+}

package/src/parts/Command/Command.js

@@ -0,0 +1,9 @@
+import * as CommandState from '../CommandState/CommandState.js'
+
+export const execute = (command, ...args) => {
+  const fn = CommandState.getCommand(command)
+  if (!fn) {
+    throw new Error(`Command not found ${command}`)
+  }
+  return fn(...args)
+}

package/src/parts/CommandMap/CommandMap.js

@@ -0,0 +1,13 @@
+import * as HandleElectronMessagePort from '../HandleElectronMessagePort/HandleElectronMessagePort.js'
+import * as HandleNodeMessagePort from '../HandleNodeMessagePort/HandleNodeMessagePort.js'
+import * as HandleWebSocket from '../HandleWebSocket/HandleWebSocket.js'
+import * as PtyController from '../PtyController/PtyController.js'
+
+export const commandMap = {
+  'HandleElectronMessagePort.handleElectronMessagePort': HandleElectronMessagePort.handleElectronMessagePort,
+  'HandleNodeMessagePort.handleNodeMessagePort': HandleNodeMessagePort.handleNodeMessagePort,
+  'HandleWebSocket.handleWebSocket': HandleWebSocket.handleWebSocket,
+  'Terminal.create': PtyController.create,
+  'Terminal.write': PtyController.write,
+  'Terminal.dispose': PtyController.dispose,
+}

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,17 @@
+export const state = {
+  commands: Object.create(null),
+}
+
+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) => {
+  return state.commands[key]
+}

package/src/parts/EncodingType/EncodingType.js

@@ -0,0 +1 @@
+export const Utf8 = 'utf8'

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

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

package/src/parts/GetErrorResponse/GetErrorResponse.js

@@ -0,0 +1,56 @@
+import { CommandNotFoundError } from '../CommandNotFoundError/CommandNotFoundError.js'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as JsonRpcErrorCode from '../JsonRpcErrorCode/JsonRpcErrorCode.js'
+import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+import * as PrettyError from '../PrettyError/PrettyError.js'
+import * as PrintPrettyError from '../PrintPrettyError/PrintPrettyError.js'
+
+const shouldLogError = (error) => {
+  if (error && error.code === ErrorCodes.ENOENT) {
+    return false
+  }
+  return true
+}
+
+export const getErrorResponse = (message, error) => {
+  if (error && error instanceof CommandNotFoundError) {
+    return {
+      jsonrpc: JsonRpcVersion.Two,
+      id: message.id,
+      error: {
+        code: JsonRpcErrorCode.MethodNotFound,
+        message: error.message,
+        data: error.stack,
+      },
+    }
+  }
+  if (!shouldLogError(error)) {
+    return {
+      jsonrpc: JsonRpcVersion.Two,
+      id: message.id,
+      error: {
+        code: JsonRpcErrorCode.Custom,
+        message: `${error}`,
+        data: {
+          code: error.code,
+        },
+      },
+    }
+  }
+  const prettyError = PrettyError.prepare(error)
+  PrintPrettyError.printPrettyError(prettyError, `[terminal-process] `)
+  return {
+    jsonrpc: JsonRpcVersion.Two,
+    id: message.id,
+    error: {
+      code: JsonRpcErrorCode.Custom,
+      message: prettyError.message,
+      data: {
+        stack: prettyError.stack,
+        codeFrame: prettyError.codeFrame,
+        type: prettyError.type,
+        code: prettyError.code,
+      },
+    },
+  }
+}

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

@@ -0,0 +1,15 @@
+import * as Command from '../Command/Command.js'
+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) => {
+  try {
+    const result = RequiresSocket.requiresSocket(message.method)
+      ? await Command.execute(message.method, ...message.params, handle)
+      : await Command.execute(message.method, ...message.params)
+    return GetSuccessResponse.getSuccessResponse(message, result)
+  } catch (error) {
+    return GetErrorResponse.getErrorResponse(message, error)
+  }
+}

package/src/parts/GetSuccessResponse/GetSuccessResponse.js

@@ -0,0 +1,12 @@
+import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+
+export const getSuccessResponse = (message, result) => {
+  if (!message.id) {
+    return undefined
+  }
+  return {
+    jsonrpc: JsonRpcVersion.Two,
+    id: message.id,
+    result: result ?? null,
+  }
+}

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,13 @@
+import * as Assert from '../Assert/Assert.js'
+import * as GetResponse from '../GetResponse/GetResponse.js'
+
+export const handleIpc = (ipc) => {
+  Assert.object(ipc)
+  const handleMessage = async (message) => {
+    const response = await GetResponse.getResponse(message, ipc)
+    if (response) {
+      ipc.send(response)
+    }
+  }
+  ipc.on('message', handleMessage)
+}

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

@@ -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/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

@@ -6,6 +6,14 @@ export const getModule = (method) => {
       return import('../IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js')
     case IpcChildType.NodeWorker:
       return import('../IpcChildWithNodeWorker/IpcChildWithNodeWorker.js')
+    case IpcChildType.WebSocket:
+      return import('../IpcChildWithWebSocket/IpcChildWithWebSocket.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')
     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 WebSocket = 3
+export const ElectronUtilityProcess = 4
+export const ElectronMessagePort = 5
+export const NodeMessagePort = 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(`[pty-host] unknown ipc type`)
 }

package/src/parts/IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js

@@ -0,0 +1,39 @@
+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 {
+        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,48 @@
+import { IpcError } from '../IpcError/IpcError.js'
+
+export const listen = () => {
+  // @ts-ignore
+  const parentPort = process.parentPort
+  if (!parentPort) {
+    throw new IpcError('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 {
+    parentPort,
+    on(event, listener) {
+      if (event === 'message') {
+        const wrappedListener = (event) => {
+          const actualData = getActualData(event)
+          listener(actualData)
+        }
+        this.parentPort.on(event, wrappedListener)
+      } 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,16 +1,34 @@
+import { IpcError } from '../IpcError/IpcError.js'
+
 export const listen = async () => {
   if (!process.send) {
-    throw new Error('process ipc is not available')
+    throw new IpcError('process ipc is not available')
   }
   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 = (message, handle) => {
+          const actualData = getActualData(message, handle)
+          listener(actualData)
+        }
+        this.process.on(event, wrappedListener)
+      }
     },
     off(event, listener) {
       this.process.off(event, listener)

package/src/parts/IpcChildWithNodeMessagePort/IpcChildWithNodeMessagePort.js

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