@lvce-editor/pty-host 0.15.16 → 0.15.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/pty-host",
-  "version": "0.15.16",
+  "version": "0.15.17",
   "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,10 @@
+import * as PtyController from '../PtyController/PtyController.js'
+import * as HandleWebSocket from '../HandleWebSocket/HandleWebSocket.js'
+import * as HandleElectronMessagePort from '../HandleElectronMessagePort/HandleElectronMessagePort.js'
+
+export const commandMap = {
+  'Terminal.create': PtyController.create,
+  'Terminal.write': PtyController.write,
+  'HandleWebSocket.handleWebSocket': HandleWebSocket.handleWebSocket,
+  'HandleElectronMessagePort.handleElectronMessagePort': HandleElectronMessagePort.handleElectronMessagePort,
+}

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/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,12 @@ 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')
     default:
       throw new Error('unexpected ipc type')
   }

package/src/parts/IpcChildType/IpcChildType.js

@@ -1,5 +1,8 @@
 export const NodeWorker = 1
 export const NodeForkedProcess = 2
+export const WebSocket = 3
+export const ElectronUtilityProcess = 4
+export const ElectronMessagePort = 5
 
 export const Auto = () => {
   const { argv } = process
@@ -9,5 +12,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,33 @@
+export const listen = ({ messagePort }) => {
+  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,46 @@
+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 {
+    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

@@ -6,11 +6,27 @@ 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 = (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/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
+}
+
+class MessageEvent extends Event {
+  constructor(data, target) {
+    super('message')
+    this.data = data
+    this.target = target
+  }
+}
+
+export const wrap = (webSocket) => {
+  return {
+    webSocket,
+    /**
+     * @type {any}
+     */
+    wrappedListener: undefined,
+    on(event, listener) {
+      switch (event) {
+        case 'message':
+          const wrappedListener = (message) => {
+            const data = JSON.parse(message.toString())
+            listener(data)
+          }
+          webSocket.on('message', wrappedListener)
+          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/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

@@ -0,0 +1,3 @@
+export const joinLines = (lines) => {
+  return lines.join('\n')
+}

package/src/parts/Json/Json.js

@@ -0,0 +1,17 @@
+// parsing error handling based on https://github.com/sindresorhus/parse-json/blob/main/index.js
+
+import { JsonParsingError } from '../JsonParsingError/JsonParsingError.js'
+
+export const parse = async (string, filePath) => {
+  try {
+    return JSON.parse(string)
+  } catch (error) {
+    const JsonError = await import('../JsonError/JsonError.js')
+    const errorProps = JsonError.getErrorPropsFromError(error, string, filePath)
+    throw new JsonParsingError(errorProps.message, errorProps.codeFrame, errorProps.stack)
+  }
+}
+
+export const stringify = (value) => {
+  return JSON.stringify(value, null, 2) + '\n'
+}

package/src/parts/JsonError/JsonError.js

@@ -0,0 +1,64 @@
+import { codeFrameColumns } from '@babel/code-frame'
+import { LinesAndColumns } from 'lines-and-columns'
+
+// parsing error handling based on https://github.com/sindresorhus/parse-json/blob/main/index.js
+
+const emptyError = {
+  message: '',
+  stack: '',
+  codeFrame: '',
+}
+
+export const getErrorPropsFromError = (error, string, filePath) => {
+  const indexMatch = error.message.match(/in JSON at position (\d+)/)
+  if (indexMatch && indexMatch.length > 0) {
+    const lines = new LinesAndColumns(string)
+    const index = Number(indexMatch[1])
+    const location = lines.locationForIndex(index)
+    if (location) {
+      const line = location.line + 1
+      const column = location.column + 1
+      const codeFrame = codeFrameColumns(string, { start: { line, column } }, { highlightCode: false })
+      return {
+        codeFrame,
+        message: 'Json Parsing Error',
+        stack: `    at ${filePath}:${line}:${column}`,
+      }
+    }
+  }
+  if (string.length === 0) {
+    return {
+      codeFrame: ``,
+      message: 'Json Parsing Error: Cannot parse empty string',
+      stack: `    at ${filePath}`,
+    }
+  }
+
+  if (error.message === 'Unexpected end of JSON input') {
+    const lines = new LinesAndColumns(string)
+    const index = string.length - 1
+    const location = lines.locationForIndex(index)
+    if (location) {
+      const codeFrame = codeFrameColumns(string, { start: { line: location.line + 1, column: location.column + 1 } }, { highlightCode: false })
+      return {
+        codeFrame,
+        message: 'Json Parsing Error',
+        stack: `    at ${filePath}`,
+      }
+    }
+  }
+  return {
+    codeFrame: ``,
+    message: 'Json Parsing Error',
+    stack: `    at ${filePath}`,
+  }
+}
+
+export const getErrorProps = (string, filePath) => {
+  try {
+    JSON.parse(string)
+    return emptyError
+  } catch (error) {
+    return getErrorPropsFromError(error, string, filePath)
+  }
+}

package/src/parts/JsonParsingError/JsonParsingError.js

@@ -0,0 +1,17 @@
+import * as JoinLines from '../JoinLines/JoinLines.js'
+import * as SplitLines from '../SplitLines/SplitLines.js'
+
+export class JsonParsingError extends Error {
+  constructor(message, codeFrame, stack) {
+    super(message)
+    this.name = 'JsonParsingError'
+    if (codeFrame) {
+      this.codeFrame = codeFrame
+    }
+
+    if (stack) {
+      const parentStack = JoinLines.joinLines(SplitLines.splitLines(this.stack).slice(1))
+      this.stack = this.name + ': ' + this.message + '\n' + stack + '\n' + parentStack
+    }
+  }
+}

package/src/parts/JsonRpcErrorCode/JsonRpcErrorCode.js

@@ -0,0 +1,2 @@
+export const MethodNotFound = -32601
+export const Custom = -32001

package/src/parts/JsonRpcVersion/JsonRpcVersion.js

@@ -0,0 +1 @@
+export const Two = '2.0'

package/src/parts/Logger/Logger.js

@@ -0,0 +1,50 @@
+import { Console } from 'node:console'
+import { createWriteStream } from 'node:fs'
+import { tmpdir } from 'node:os'
+
+// TODO mock this module when used in unit tests
+
+const state = {
+  /**
+   * @type {Console|undefined}
+   */
+  console: undefined,
+}
+
+const createConsole = () => {
+  const logFile = `${tmpdir()}/log-terminal-process.txt`
+  const writeStream = createWriteStream(logFile)
+  const logger = new Console(writeStream)
+  return logger
+}
+
+const getOrCreateLogger = () => {
+  if (!state.console) {
+    state.console = createConsole()
+  }
+  return state.console
+}
+
+export const log = (...args) => {
+  const logger = getOrCreateLogger()
+  logger.log(...args)
+  console.log(...args)
+}
+
+export const info = (...args) => {
+  const logger = getOrCreateLogger()
+  logger.info(...args)
+  console.info(...args)
+}
+
+export const warn = (...args) => {
+  const logger = getOrCreateLogger()
+  logger.warn(...args)
+  console.warn(...args)
+}
+
+export const error = (...args) => {
+  const logger = getOrCreateLogger()
+  logger.error(...args)
+  console.error(...args)
+}

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

@@ -0,0 +1,139 @@
+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 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) => {
+  const { message } = error
+  const match = message.match(RE_MODULE_NOT_FOUND_STACK)
+  if (!match) {
+    return {
+      message,
+      stack: error.stack,
+      codeFrame: '',
+    }
+  }
+  const notFoundModule = match[1]
+  const importedFrom = match[2]
+  const rawLines = readFileSync(importedFrom, EncodingType.Utf8)
+  let line = 0
+  let column = 0
+  const splittedLines = SplitLines.splitLines(rawLines)
+  for (let i = 0; i < splittedLines.length; i++) {
+    const splittedLine = splittedLines[i]
+    const index = splittedLine.indexOf(notFoundModule)
+    if (index !== -1) {
+      line = i + 1
+      column = index
+      break
+    }
+  }
+  const location = {
+    start: {
+      line,
+      column,
+    },
+  }
+  const codeFrame = codeFrameColumns(rawLines, location)
+  const stackLines = SplitLines.splitLines(error.stack)
+  const newStackLines = [stackLines[0], `    at ${importedFrom}:${line}:${column}`, ...stackLines.slice(1)]
+  const newStack = JoinLines.joinLines(newStackLines)
+  return {
+    message,
+    stack: newStack,
+    codeFrame,
+  }
+}
+
+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)
+  }
+  const { message } = error
+  if (error && error.cause) {
+    const cause = error.cause()
+    if (cause) {
+      error = cause
+    }
+  }
+  const linesToCut = getStackLinesToCut(error)
+  const lines = CleanStack.cleanStack(error.stack).slice(linesToCut)
+  const file = lines[0]
+  let codeFrame = ''
+  if (error.codeFrame) {
+    codeFrame = error.codeFrame
+  } else if (file) {
+    let match = file.match(/\((.*):(\d+):(\d+)\)$/)
+    if (!match) {
+      match = file.match(/at (.*):(\d+):(\d+)$/)
+    }
+    if (match) {
+      const [_, path, line, column] = match
+      const actualPath = getActualPath(path)
+      const rawLines = readFileSync(actualPath, EncodingType.Utf8)
+      const location = {
+        start: {
+          line: Number.parseInt(line),
+          column: Number.parseInt(column),
+        },
+      }
+      codeFrame = codeFrameColumns(rawLines, location)
+    }
+  }
+  const relevantStack = JoinLines.joinLines(lines)
+  return {
+    message,
+    stack: relevantStack,
+    codeFrame,
+    type: error.constructor.name,
+    code: error.code,
+  }
+}
+
+const fixBackslashes = (string) => {
+  return string.replaceAll('\\\\', '\\')
+}
+
+export const prepareJsonError = (json, property, message) => {
+  const string = fixBackslashes(Json.stringify(json))
+  const stringifiedPropertyName = `"${property}"`
+  const index = string.indexOf(stringifiedPropertyName) // TODO this could be wrong in some cases, find a better way
+  console.log({ string, index })
+  const jsonError = {
+    stack: '',
+  }
+  if (index !== -1) {
+    const lines = new LinesAndColumns(string)
+    const location = lines.locationForIndex(index + stringifiedPropertyName.length + 1)
+    const codeFrame = codeFrameColumns(string, {
+      // @ts-ignore
+      start: { line: location.line + 1, column: location.column + 1 },
+    })
+    jsonError.codeFrame = codeFrame
+  }
+  // jsonError.stack = `${bottomMessage}\n    at ${filePath}`
+  return jsonError
+}

package/src/parts/PrintPrettyError/PrintPrettyError.js

@@ -0,0 +1,5 @@
+import * as Logger from '../Logger/Logger.js'
+
+export const printPrettyError = (prettyError, prefix = '') => {
+  Logger.error(`${prefix}${prettyError.type}: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}\n`)
+}

package/src/parts/Pty/Pty.js

@@ -1,6 +1,7 @@
 import { spawn } from 'node-pty'
 import * as Platform from '../Platform/Platform.js'
 import * as Assert from '../Assert/Assert.js'
+import VError from 'verror'
 
 const getSpawnOptions = () => {
   if (Platform.isWindows) {
@@ -16,14 +17,20 @@ const getSpawnOptions = () => {
 }
 
 export const create = ({ env = {}, cwd } = {}) => {
-  const spawnOptions = getSpawnOptions()
-  const pty = spawn(spawnOptions.command, spawnOptions.args, {
-    encoding: null,
-    cwd,
-    // cols: 10,
-    // rows: 10,
-  })
-  return pty
+  try {
+    Assert.string(cwd)
+    const spawnOptions = getSpawnOptions()
+    const pty = spawn(spawnOptions.command, spawnOptions.args, {
+      encoding: null,
+      cwd,
+      // cols: 10,
+      // rows: 10,
+    })
+    return pty
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, `Failed to create terminal`)
+  }
 }
 
 export const onData = (pty, fn) => {
@@ -32,8 +39,13 @@ export const onData = (pty, fn) => {
 }
 
 export const write = (pty, data) => {
-  Assert.object(pty)
-  pty.write(data)
+  try {
+    Assert.object(pty)
+    pty.write(data)
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, `Failed to write data to terminal`)
+  }
 }
 
 export const resize = (pty, columns, rows) => {

package/src/parts/PtyController/PtyController.js

@@ -1,22 +1,24 @@
 import * as Pty from '../Pty/Pty.js'
 import * as Debug from '../Debug/Debug.js'
+import * as Assert from '../Assert/Assert.js'
 
 export const state = {
   ptyMap: Object.create(null),
 }
 
 // TODO maybe merge pty and pty controller
-export const create = (id, cwd) => {
+export const create = (id, cwd, ipc) => {
+  Assert.number(id)
+  Assert.string(cwd)
+  Assert.object(ipc)
   Debug.debug(`create ${id} ${cwd}`)
   const pty = Pty.create({ cwd })
   const handleData = (data) => {
-    if (process.send) {
-      process.send({
-        jsonrpc: '2.0',
-        method: 'Terminal.handleData',
-        params: [id, data],
-      })
-    }
+    ipc.send({
+      jsonrpc: '2.0',
+      method: 'Viewlet.send',
+      params: [id, 'handleData', data],
+    })
   }
   Pty.onData(pty, handleData)
   state.ptyMap[id] = pty
@@ -24,11 +26,17 @@ export const create = (id, cwd) => {
 
 export const write = (id, data) => {
   const pty = state.ptyMap[id]
+  if (!pty) {
+    throw new Error(`pty ${id} not found`)
+  }
   Pty.write(pty, data)
 }
 
 export const dispose = (id) => {
   const pty = state.ptyMap[id]
+  if (!pty) {
+    throw new Error(`pty ${id} not found`)
+  }
   Pty.dispose(pty)
   delete state.ptyMap[id]
 }

package/src/parts/RequiresSocket/RequiresSocket.js

@@ -0,0 +1,5 @@
+const METHODS_THAT_REQUIRE_SOCKET = new Set(['Terminal.create'])
+
+export const requiresSocket = (method) => {
+  return METHODS_THAT_REQUIRE_SOCKET.has(method)
+}

package/src/parts/SplitLines/SplitLines.js

@@ -0,0 +1,3 @@
+export const splitLines = (lines) => {
+  return lines.split('\n')
+}

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,24 @@
+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,
+
+  // TODO not sure if ws compress is working at all
+  // perMessageDeflate: 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/ptyHostMain.cjs

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

package/src/ptyHostMain.js

@@ -1,26 +1,7 @@
-import * as Debug from './parts/Debug/Debug.js'
-import * as IpcChild from './parts/IpcChild/IpcChild.js'
-import * as IpcChildType from './parts/IpcChildType/IpcChildType.js'
-import * as PtyController from './parts/PtyController/PtyController.js'
-
-const handleMessage = (message) => {
-  switch (message.method) {
-    case 'Terminal.create':
-      Debug.debug('create terminal')
-      PtyController.create(...message.params)
-      break
-    case 'Terminal.write':
-      PtyController.write(...message.params)
-      break
-    default:
-      console.warn('unknown message', message)
-      break
-  }
-}
+import * as Main from './parts/Main/Main.js'
 
 const main = async () => {
-  const ipc = await IpcChild.listen({ method: IpcChildType.Auto() })
-  ipc.on('message', handleMessage)
+  await Main.main()
 }
 
 main()