@lvce-editor/pty-host 0.15.16 → 0.15.18

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

@@ -0,0 +1,60 @@
+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) {
+    return {
+      command: 'powershell.exe',
+      args: [],
+    }
+  }
+  return {
+    command: 'bash',
+    args: ['-i'],
+  }
+}
+
+export const create = ({ env = {}, cwd } = {}) => {
+  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) => {
+  Assert.object(pty)
+  pty.onData(fn)
+}
+
+export const write = (pty, 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) => {
+  Assert.object(pty)
+  Assert.number(columns)
+  Assert.number(rows)
+  pty.resize(columns, rows)
+}
+
+export const dispose = (pty) => {
+  pty.kill()
+}

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,48 +1 @@
-import { spawn } from 'node-pty'
-import * as Platform from '../Platform/Platform.js'
-import * as Assert from '../Assert/Assert.js'
-
-const getSpawnOptions = () => {
-  if (Platform.isWindows) {
-    return {
-      command: 'powershell.exe',
-      args: [],
-    }
-  }
-  return {
-    command: 'bash',
-    args: ['-i'],
-  }
-}
-
-export const create = ({ env = {}, cwd } = {}) => {
-  const spawnOptions = getSpawnOptions()
-  const pty = spawn(spawnOptions.command, spawnOptions.args, {
-    encoding: null,
-    cwd,
-    // cols: 10,
-    // rows: 10,
-  })
-  return pty
-}
-
-export const onData = (pty, fn) => {
-  Assert.object(pty)
-  pty.onData(fn)
-}
-
-export const write = (pty, data) => {
-  Assert.object(pty)
-  pty.write(data)
-}
-
-export const resize = (pty, columns, rows) => {
-  Assert.object(pty)
-  Assert.number(columns)
-  Assert.number(rows)
-  pty.resize(columns, rows)
-}
-
-export const dispose = (pty) => {
-  pty.kill()
-}
+export * from '../NodePty/NodePty.js'

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,18 @@ 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]
+  const { ptyMap } = state
+  const pty = 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()