@lvce-editor/shared-process 0.15.15 → 0.15.17

package/src/parts/ParentIpc/ParentIpc.js

@@ -1,15 +1,7 @@
-import { MessagePort, parentPort } from 'node:worker_threads'
-import * as Callback from '../Callback/Callback.js'
-import * as Command from '../Command/Command.js'
-import * as Debug from '../Debug/Debug.js'
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-import * as ExtensionHostHelperProcessIpc from '../ExtensionHostHelperProcessIpc/ExtensionHostHelperProcessIpc.js'
-import * as ExtensionHostIpc from '../ExtensionHostIpc/ExtensionHostIpc.js'
-import * as ExtensionHostRpc from '../ExtensionHostRpc/ExtensionHostRpc.js'
-import * as GetResponse from '../GetResponse/GetResponse.js'
-import * as Logger from '../Logger/Logger.js'
-import * as ProtocolType from '../ProtocolType/ProtocolType.js'
-import { VError } from '../VError/VError.js'
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
 // TODO add tests for this
 
 // TODO handle structure: one shared process multiple extension hosts
@@ -20,181 +12,11 @@ export const state = {
   electronPortMap: new Map(),
 }
 
-// TODO apparent there are multiple ways for listening to ipc
-// 1. parentPort
-// 2. process.send
-// instead of if/else use interface and abstraction: ParentPortIpc.listen(), ProcessIpc.listen(), ParentPortIpc.send(message), ProcessIpc.send(message)
-
-export const electronSend = (message) => {
-  if (parentPort) {
-    // @ts-ignore
-    // process.send(message)
-    parentPort.postMessage(message)
-  } else if (process.send) {
-    process.send(message)
-  }
-}
-
-const handleWebSocketSharedProcess = (message, handle) => {
-  // TODO when it is an extension host websocket, spawn extension host
-  handle.on('error', (error) => {
-    if (error && error.code === ErrorCodes.ECONNRESET) {
-      return
-    }
-    console.info('[info shared process: handle error]', error)
-  })
-  Command.execute(/* WebSocketServer.handleUpgrade */ 'WebSocketServer.handleUpgrade', /* message */ message, /* handle */ handle)
-}
-
-// TODO lazyload modules for spawning extension host, they are only needed later
-const handleWebSocketExtensionHost = async (message, handle) => {
-  // console.log('[shared-process] received extension host websocket', message)
-  const ipc = await ExtensionHostIpc.create()
-  console.info('[sharedprocess] creating extension ipc')
-  const rpc = await ExtensionHostRpc.create(ipc, handle)
-  console.info('[sharedprocess] created extension host rpc')
-  ipc._process.send(message, handle)
-  // rpc.send(message)
-  // console.log('spawned extension host')
-  // console.log(rpc)
-}
-
-const handleWebSocketExtensionHostHelperProcess = async (message, handle) => {
-  const ipc = await ExtensionHostHelperProcessIpc.create()
-  ipc._process.send(message, handle)
-}
-
-const handleWebSocketUnknown = (message, handle, protocol) => {
-  Logger.warn(`[shared-process] unsupported sec-websocket-procotol ${protocol}`)
-  try {
-    handle.destroy()
-  } catch {
-    // ignore
-  }
-}
-
-const handleWebSocket = (message, handle) => {
-  const headers = message.headers
-  if (!headers) {
-    throw new VError('missing websocket headers')
-  }
-  const protocol = headers['sec-websocket-protocol']
-  if (!protocol) {
-    throw new VError('missing sec websocket protocol header')
-  }
-  switch (protocol) {
-    case ProtocolType.SharedProcess:
-      return handleWebSocketSharedProcess(message, handle)
-    case ProtocolType.ExtensionHost:
-      return handleWebSocketExtensionHost(message, handle)
-    case ProtocolType.ExtensionHostHelperProcess:
-      return handleWebSocketExtensionHostHelperProcess(message, handle)
-    default:
-      return handleWebSocketUnknown(message, handle, protocol)
-  }
-}
-
-const handleJsonRpcResult = (message) => {
-  Callback.resolve(message.id, message.result)
-}
-
-const handleJsonRpcMessage = async (message, handle) => {
-  if (message.id) {
-    const response = await GetResponse.getResponse(message, handle)
-    electronSend(response)
-  } else {
-    // TODO handle error
-    Command.execute(message.method, null, ...message.params)
-  }
-}
-
-const handleMessageFromParentProcess = async (message, handle) => {
-  if (handle) {
-    return handleWebSocket(message, handle)
-  }
-  if (message.result) {
-    return handleJsonRpcResult(message)
-  }
-  if (message.method) {
-    return handleJsonRpcMessage(message, handle)
-  }
-  console.warn('unknown message', message)
-}
-
-/**
- *
- * @param {{initialize:{port: MessagePort, folder:string}}} initializeMessage
- */
-const electronInitialize = (initializeMessage) => {
-  const port = initializeMessage.initialize.port
-  // TODO handle error
-  const fakeSocket = {
-    send: port.postMessage.bind(port),
-    on(event, listener) {
-      switch (event) {
-        case 'close':
-          port.on('close', listener)
-          break
-        case 'message':
-          port.on('message', listener)
-          break
-        default:
-          console.warn('socket event not implemented', event, listener)
-          break
-      }
-    },
-  }
-  const handleOtherMessagesFromMessagePort = async (message) => {
-    // console.log('got port message', message)
-    if (message.result) {
-      Callback.resolve(message.id, message.result)
-    } else if (message.method) {
-      if (message.id) {
-        const response = await GetResponse.getResponse(message, fakeSocket)
-        port.postMessage(response)
-      } else {
-        console.warn(`[shared process] sending messages without id is deprecated: ${message.method}`)
-        Command.execute(message.method, fakeSocket, ...message.params)
-      }
-    } else {
-      console.warn('unknown message', message)
-    }
-  }
-  port.on('message', handleOtherMessagesFromMessagePort)
-}
-
-const handleMessageFromParentProcessElectron = async (message) => {
-  if (message.initialize) {
-    electronInitialize(message)
-    return
-  }
-  if ('result' in message) {
-    Callback.resolve(message.id, message.result)
-    return
-  }
-
-  console.log('unknown message from electron', message)
-  console.log({ message })
-}
-
 // TODO maybe rename to hydrate
-export const listen = () => {
-  // TODO tree-shake out if-else
-  // console.log({ ...process.env })
-  if (process.env.ELECTRON_RUN_AS_NODE && parentPort) {
-    // electron process listens to main process ipc
-    Debug.debug('is electron')
-    // @ts-ignore
-    parentPort.on('message', handleMessageFromParentProcessElectron)
-    electronSend('ready')
-  } else {
-    Debug.debug('is not electron')
-    // otherwise listen to web process ipc
-    // and when a socket is transferred,
-    // listen to socket messages also
-    process.on('message', handleMessageFromParentProcess)
-    if (process.send) {
-      process.send('ready')
-    }
-  }
+export const listen = async () => {
+  const method = IpcChildType.Auto()
+  const ipc = await IpcChild.listen({
+    method,
+  })
+  HandleIpc.handleIpc(ipc)
 }

package/src/parts/PrettyError/PrettyError.js

@@ -109,6 +109,7 @@ export const prepare = (error) => {
     stack: relevantStack,
     codeFrame,
     type: error.constructor.name,
+    code: error.code,
   }
 }
 

package/src/parts/ProtocolType/ProtocolType.js

@@ -1,3 +1,4 @@
-export const SharedProcess = 'lvce.shared-process'
 export const ExtensionHost = 'lvce.extension-host'
 export const ExtensionHostHelperProcess = 'lvce.extension-host-helper-process'
+export const SharedProcess = 'lvce.shared-process'
+export const TerminalProcess = 'lvce.terminal-process'

package/src/parts/PtyHost/PtyHost.js

@@ -0,0 +1,81 @@
+import exitHook from 'exit-hook'
+import * as Debug from '../Debug/Debug.js'
+import * as IpcParent from '../IpcParent/IpcParent.js'
+import * as IpcParentType from '../IpcParentType/IpcParentType.js'
+import * as PtyHostPath from '../PtyHostPath/PtyHostPath.js'
+
+export const state = {
+  /**
+   * @type {any}
+   */
+  ptyHost: undefined,
+  /**
+   * @type {any}
+   */
+  ptyHostPromise: undefined,
+  /**
+   * @type {any[]}
+   */
+  pendingMessages: [],
+  send(message) {
+    state.pendingMessages.push(message)
+  },
+}
+
+const cleanUpAll = () => {
+  if (state.ptyHost) {
+    state.ptyHost.dispose()
+    state.ptyHost = undefined
+  }
+}
+
+const handleProcessExit = () => {
+  Debug.debug('shared process exit, clean terminals')
+  cleanUpAll()
+}
+
+const createPtyHost = async () => {
+  exitHook(handleProcessExit)
+  const ptyHostPath = await PtyHostPath.getPtyHostPath()
+  const ptyHost = await IpcParent.create({
+    method: IpcParentType.NodeForkedProcess,
+    path: ptyHostPath,
+    argv: [],
+    stdio: 'inherit',
+    name: 'Terminal Process',
+  })
+  const handleClose = () => {
+    ptyHost.off('close', handleClose)
+    state.ptyHost = undefined
+    state.ptyHostPromise = undefined
+  }
+  ptyHost.on('close', handleClose)
+  state.ptyHost = ptyHost
+  return ptyHost
+}
+
+export const getOrCreate = () => {
+  Debug.debug('creating pty host')
+  if (!state.ptyHostPromise) {
+    state.ptyHostPromise = createPtyHost()
+  }
+  return state.ptyHostPromise
+}
+
+export const getCurrentInstance = () => {
+  return state.ptyHost
+}
+
+export const disposeAll = () => {
+  if (state.ptyHost) {
+    state.ptyHost.removeAllListeners()
+    if (state.ptyHost) {
+      state.ptyHost.dispose()
+      state.ptyHost = undefined
+    }
+    state.ptyHostState = /* None */ 0
+    state.send = (message) => {
+      state.pendingMessages.push(message)
+    }
+  }
+}

package/src/parts/RebuildNodePty/RebuildNodePty.ipc.js

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

package/src/parts/RebuildNodePty/RebuildNodePty.js

@@ -0,0 +1,48 @@
+import { spawn } from 'node:child_process'
+import * as IsElectron from '../IsElectron/IsElectron.js'
+import * as Path from '../Path/Path.js'
+import * as Root from '../Root/Root.js'
+import { VError } from '../VError/VError.js'
+
+const getElectronRebuildPath = () => {
+  return Path.join(Root.root, 'packages', 'main-process', 'node_modules', '.bin', 'electron-rebuild')
+}
+
+const getPtyHostPath = () => {
+  return Path.join(Root.root, 'packages', 'pty-host')
+}
+
+/**
+ * @param {string} cwd
+ */
+const rebuildNodePtyElectron = async (cwd) => {
+  const electronRebuildPath = getElectronRebuildPath()
+  const childProcess = spawn(electronRebuildPath, [], {
+    cwd,
+    stdio: 'inherit',
+  })
+  // TODO wait for child process to be finished
+}
+
+/**
+ * @param {string} cwd
+ */
+const rebuildNodePtyNode = async (cwd) => {
+  const childProcess = spawn('npm', ['rebuild'], {
+    cwd,
+    stdio: 'inherit',
+  })
+}
+
+export const rebuildNodePty = async () => {
+  try {
+    const ptyHostPath = getPtyHostPath()
+    if (IsElectron.isElectron()) {
+      await rebuildNodePtyElectron(ptyHostPath)
+    } else {
+      await rebuildNodePtyNode(ptyHostPath)
+    }
+  } catch (error) {
+    throw new VError(error, `Failed to rebuild node-pty`)
+  }
+}

package/src/parts/RequiresSocket/RequiresSocket.js

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

package/src/parts/Terminal/Terminal.js

@@ -1,138 +1,53 @@
-import exitHook from 'exit-hook'
 import * as Assert from '../Assert/Assert.js'
-import * as Debug from '../Debug/Debug.js'
-import * as IpcParent from '../IpcParent/IpcParent.js'
-import * as IpcParentType from '../IpcParentType/IpcParentType.js'
 import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
-import * as PtyHostPath from '../PtyHostPath/PtyHostPath.js'
+import * as PtyHost from '../PtyHost/PtyHost.js'
+import { VError } from '../VError/VError.js'
 
 export const state = {
-  /**
-   * @type {any}
-   */
-  ptyHost: undefined,
-  ptyHostState: /* None */ 0,
-  /**
-   * @type {any[]}
-   */
-  pendingMessages: [],
-  send(message) {
-    state.pendingMessages.push(message)
-  },
+  socketMap: Object.create(null),
 }
 
-// const getSpawnOptions = () => {
-//   if (Platform.isWindows) {
-//     return {
-//       command: 'powershell.exe',
-//       args: [],
-//     }
-//   }
-//   return {
-//     command: 'bash',
-//     args: ['-i'],
-//   }
-// }
-
-const cleanUpAll = () => {
-  if (state.ptyHost) {
-    state.ptyHost.kill()
-  }
-}
-
-const handleProcessExit = () => {
-  Debug.debug('shared process exit, clean terminals')
-  cleanUpAll()
-}
-
-const createPtyHost = async () => {
-  exitHook(handleProcessExit)
-  const ptyHostPath = await PtyHostPath.getPtyHostPath()
-  const ptyHost = await IpcParent.create({
-    method: IpcParentType.NodeForkedProcess,
-    path: ptyHostPath,
-    argv: ['--ipc-type=node-forked-process'],
-    stdio: 'inherit',
-    name: 'Terminal Process',
-  })
-  return ptyHost
-}
-
-// const send = (method, ...params) => {
-
-//   state.ptyHost.send({
-//     jsonrpc: '2.0',
-//     method,
-//     params,
-//   })
-// }
-
 export const create = async (socket, id, cwd) => {
-  Assert.object(socket)
-  Assert.number(id)
-  Assert.string(cwd)
-
-  Debug.debug('creating pty host')
-  switch (state.ptyHostState) {
-    case /* None */ 0: {
-      state.ptyHostState = /* Creating */ 1
-      const ptyHost = await createPtyHost()
+  try {
+    Assert.object(socket)
+    Assert.number(id)
+    Assert.string(cwd)
+    // TODO dispose entry
+    state.socketMap[id] = socket
+    const ptyHost = await PtyHost.getOrCreate()
 
-      Debug.debug('pty host ready')
-      state.ptyHostState = /* Ready */ 2
-      const handleMessage = (message) => {
-        const data = message.params[1]
-        socket.send({
-          jsonrpc: JsonRpcVersion.Two,
-          method: 'Viewlet.send',
-          params: ['Terminal', 'handleData', data],
-        })
-      }
-      ptyHost.on('message', handleMessage)
-      state.send = (message) => {
-        ptyHost.send(message)
-      }
-      while (state.pendingMessages.length > 0) {
-        state.send(state.pendingMessages.shift())
-      }
-      state.ptyHost = ptyHost
-      break
-    }
-    case /* Creating */ 1: {
-      break
+    const handleMessage = (message) => {
+      socket.send(message)
     }
-    case /* Ready */ 2: {
-      break
-    }
-    default:
-      break
-  }
-  state.send({
-    jsonrpc: JsonRpcVersion.Two,
-    method: 'Terminal.create',
-    params: [id, cwd],
-  })
-  const handleClose = () => {
-    if (state.ptyHost) {
-      state.ptyHost.dispose()
-      state.ptyHost = undefined
-      state.ptyHostState = /* None */ 0
-      state.send = (message) => {
-        state.pendingMessages.push(message)
-      }
+    const handleClose = () => {
+      // socket.off('close', handleClose)
+      ptyHost.off('message', handleMessage)
+      ptyHost.dispose()
     }
+    ptyHost.on('message', handleMessage)
+    socket.on('close', handleClose)
+
+    // TODO use invoke
+    ptyHost.send({
+      jsonrpc: JsonRpcVersion.Two,
+      method: 'Terminal.create',
+      params: [id, cwd],
+    })
+  } catch (error) {
+    throw new VError(error, `Failed to create terminal`)
   }
-  socket.on('close', handleClose)
 }
 
 export const write = (id, data) => {
   Assert.number(id)
   Assert.string(data)
-  if (!state.ptyHost) {
+  const ptyHost = PtyHost.getCurrentInstance()
+  if (!ptyHost) {
     console.log('[shared-process] pty host not ready')
     return
   }
-  state.send({
+  // TODO should use invoke
+  ptyHost.send({
     jsonrpc: JsonRpcVersion.Two,
     method: 'Terminal.write',
     params: [id, data],
@@ -143,8 +58,10 @@ export const resize = (state, columns, rows) => {
   // state.pty.resize(columns, rows)
 }
 
-export const dispose = (id) => {
-  state.send({
+export const dispose = async (id) => {
+  const ptyHost = await PtyHost.getOrCreate()
+  // TODO use invoke
+  ptyHost.send({
     jsonrpc: JsonRpcVersion.Two,
     method: 'Terminal.dispose',
     params: [id],
@@ -152,13 +69,5 @@ export const dispose = (id) => {
 }
 
 export const disposeAll = () => {
-  if (state.ptyHost) {
-    state.ptyHost.removeAllListeners()
-    state.ptyHost.kill()
-    state.ptyHost = undefined
-    state.ptyHostState = /* None */ 0
-    state.send = (message) => {
-      state.pendingMessages.push(message)
-    }
-  }
+  PtyHost.disposeAll()
 }

package/src/parts/WebSocketServer/WebSocketServer.js

@@ -1,6 +1,5 @@
 import { Buffer } from 'node:buffer'
 import * as _ws from 'ws'
-import * as Socket from '../Socket/Socket.js'
 
 // workaround for jest or node bug
 const WebSocketServer = _ws.WebSocketServer
@@ -8,13 +7,6 @@ const WebSocketServer = _ws.WebSocketServer
   : // @ts-ignore
     _ws.default.WebSocketServer
 
-const encode = (commandId, callbackId) => (commandId << 16) | callbackId
-const decodeCommand = (encodedCommand) => encodedCommand >> 16
-const decodeCallback = (encodedCommand) => encodedCommand & 0x0000FFFF
-
-// console.log('ws', _ws)
-// console.log('server', ws.WebSocketServer)
-
 const webSocketServer = new WebSocketServer({
   noServer: true,
 
@@ -22,22 +14,11 @@ const webSocketServer = new WebSocketServer({
   // perMessageDeflate: true
 })
 
-// TODO should not import command directly -> Websocket server should be independent of business logic
-
-const handleSocket = (socket) => {
-  Socket.set(socket)
-}
-
-webSocketServer.on('connection', handleSocket)
-
 export const handleUpgrade = (request, socket) => {
-  const upgradeCallback = (ws) => {
-    webSocketServer.emit('connection', ws, request)
-  }
-  webSocketServer.handleUpgrade(
-    request,
-    socket,
-    Buffer.alloc(0),
-    upgradeCallback
-  )
+  return new Promise((resolve, reject) => {
+    const upgradeCallback = (ws) => {
+      resolve(ws)
+    }
+    webSocketServer.handleUpgrade(request, socket, Buffer.alloc(0), upgradeCallback)
+  })
 }

package/src/sharedProcessMain.js

@@ -37,7 +37,7 @@ const main = async () => {
   process.on('SIGTERM', handleSigTerm)
 
   process.on('uncaughtExceptionMonitor', ErrorHandling.handleUncaughtExceptionMonitor)
-  ParentIpc.listen()
+  await ParentIpc.listen()
 
   // ExtensionHost.start() // TODO start on demand, e.g. not when extensions should be disabled
 }

package/extensions/builtin.language-basics-json5/README.md

@@ -1,16 +0,0 @@
-# Language Basics JSON5
-
-Provides syntax highlighting in JSON5 files.
-
-## Contributing
-
-```sh
-git clone git@github.com:lvce-editor/language-basics-json5.git &&
-cd language-basics-json5 &&
-npm ci &&
-npm test
-```
-
-## Gitpod
-
-[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/lvce-editor/language-basics-json5)

package/extensions/builtin.language-basics-json5/extension.json

@@ -1,12 +0,0 @@
-{
-  "id": "builtin.language-basics-json5",
-  "name": "Language Basics JSON5",
-  "description": "Provides syntax highlighting and bracket matching in JSON5 files.",
-  "languages": [
-    {
-      "id": "json5",
-      "extensions": [".json5"],
-      "tokenize": "src/tokenizeJson5.js"
-    }
-  ]
-}