@lvce-editor/shared-process 0.15.16 → 0.15.18

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

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

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

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

package/src/parts/Process/Process.js

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

package/src/parts/ProcessDisplayName/ProcessDisplayName.js

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

package/src/parts/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/Signal/Signal.js

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

package/src/parts/Terminal/Terminal.js

@@ -1,138 +1,63 @@
-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 * as TerminalState from '../TerminalState/TerminalState.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)
-  },
-}
-
-// const getSpawnOptions = () => {
-//   if (Platform.isWindows) {
-//     return {
-//       command: 'powershell.exe',
-//       args: [],
-//     }
-//   }
-//   return {
-//     command: 'bash',
-//     args: ['-i'],
-//   }
-// }
-
-const cleanUpAll = () => {
-  if (state.ptyHost) {
-    state.ptyHost.kill()
+const createTerminal = (ptyHost, socket) => {
+  const handleMessage = (message) => {
+    socket.send(message)
+  }
+  const handleClose = () => {
+    // socket.off('close', handleClose)
+    ptyHost.off('message', handleMessage)
+    ptyHost.dispose()
+  }
+  const dispose = () => {
+    ptyHost.off('message', handleMessage)
+    socket.off('close', handleClose)
+  }
+  ptyHost.on('message', handleMessage)
+  socket.on('close', handleClose)
+  return {
+    ptyHost,
+    socket,
+    handleMessage,
+    handleClose,
+    dispose,
   }
 }
 
-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()
-
-      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
-    }
-    case /* Ready */ 2: {
-      break
-    }
-    default:
-      break
+  try {
+    Assert.object(socket)
+    Assert.number(id)
+    Assert.string(cwd)
+    // TODO race condition because of await
+    const ptyHost = await PtyHost.getOrCreate()
+    const terminal = createTerminal(ptyHost, socket)
+    TerminalState.add(id, terminal)
+    // TODO use invoke
+    ptyHost.send({
+      jsonrpc: JsonRpcVersion.Two,
+      method: 'Terminal.create',
+      params: [id, cwd],
+    })
+  } catch (error) {
+    throw new VError(error, `Failed to create terminal`)
   }
-  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)
-      }
-    }
-  }
-  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 +68,13 @@ export const resize = (state, columns, rows) => {
   // state.pty.resize(columns, rows)
 }
 
-export const dispose = (id) => {
-  state.send({
+export const dispose = async (id) => {
+  const terminal = TerminalState.get(id)
+  terminal.dispose()
+  TerminalState.remove(id)
+  const ptyHost = await PtyHost.getOrCreate()
+  // TODO use invoke
+  ptyHost.send({
     jsonrpc: JsonRpcVersion.Two,
     method: 'Terminal.dispose',
     params: [id],
@@ -152,13 +82,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/TerminalState/TerminalState.js

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