@lvce-editor/shared-process 0.15.17 → 0.15.18

package/config/builtinCommands.json

@@ -230,6 +230,10 @@
     "id": "RebuildNodePty.rebuildNodePty",
     "label": "Developer: Rebuild Node Pty"
   },
+  {
+    "id": "DebugSharedProcess.debugSharedProcess",
+    "label": "Developer: Debug Shared Process"
+  },
   {
     "id": "Window.reload",
     "label": "Window: Reload",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.15.17",
+  "version": "0.15.18",
   "description": "Utility package for @lvce-editor/server",
   "main": "index.js",
   "type": "module",
@@ -17,9 +17,9 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.21.4",
-    "@lvce-editor/extension-host": "0.15.17",
-    "@lvce-editor/extension-host-helper-process": "0.15.17",
-    "@lvce-editor/pty-host": "0.15.17",
+    "@lvce-editor/extension-host": "0.15.18",
+    "@lvce-editor/extension-host-helper-process": "0.15.18",
+    "@lvce-editor/pty-host": "0.15.18",
     "debug": "^4.3.4",
     "execa": "^7.1.1",
     "exit-hook": "^3.2.0",

package/src/parts/AttachDebugger/AttachDebugger.ipc.js

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

package/src/parts/AttachDebugger/AttachDebugger.js

@@ -0,0 +1,6 @@
+import * as Process from '../Process/Process.js'
+import * as Signal from '../Signal/Signal.js'
+
+export const attachDebugger = (pid) => {
+  Process.kill(pid, Signal.SIGUSR1)
+}

package/src/parts/Callback/Callback.js

@@ -1,48 +1,39 @@
+import * as Id from '../Id/Id.js'
+
 export const state = {
   callbacks: Object.create(null),
   onceListeners: new Set(),
-  id: 2,
-}
-
-export const register = (resolve, reject) => {
-  state.callbacks[++state.id] = {
-    resolve,
-    reject,
-  }
-  return state.id
 }
 
-export const unregister = (id) => {
-  delete state.callbacks[id]
+export const registerPromise = () => {
+  const id = Id.create()
+  const promise = new Promise((resolve, reject) => {
+    state.callbacks[id] = { resolve, reject }
+  })
+  return { id, promise }
 }
 
 // TODO merge resolve and resolveEmpty
 export const resolve = (id, args) => {
-  if (!(id in state.callbacks)) {
+  const { callbacks } = state
+  if (!(id in callbacks)) {
     console.warn(`callback ${id} may already be disposed`)
     return
   }
-  state.callbacks[id].resolve(args)
-}
-
-export const resolveEmpty = (id) => {
-  if (!(id in state.callbacks)) {
-    console.warn(`callback (resolved) ${id} may already be disposed`)
-    return
-  }
-  state.callbacks[id].resolve()
+  callbacks[id].resolve(args)
+  delete callbacks[id]
 }
 
 export const reject = (id, error) => {
-  if (!(id in state.callbacks)) {
+  const { callbacks } = state
+  if (!(id in callbacks)) {
     console.warn(`callback (rejected) ${id} may already be disposed`)
     return
   }
-  state.callbacks[id].reject(error)
+  callbacks[id].reject(error)
+  delete callbacks[id]
 }
 
 export const isAllEmpty = () => {
-  return (
-    Object.keys(state.callbacks).length === 0 && state.onceListeners.size === 0
-  )
+  return Object.keys(state.callbacks).length === 0 && state.onceListeners.size === 0
 }

package/src/parts/CleanStack/CleanStack.js

@@ -7,6 +7,7 @@ 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 RE_ASSERT = /^\s*at .*\/Assert\.js/
 
 const isInternalLine = (line) => {
   return line.includes('node:') || RE_AT_PROMISE_INDEX.test(line) || line.includes('node_modules/ws')
@@ -18,6 +19,9 @@ const isRelevantLine = (line) => {
 
 const isApplicationUsefulLine = (line, index) => {
   if (index === 0) {
+    if (RE_ASSERT.test(line)) {
+      return false
+    }
     return true
   }
   if (RE_GET_RESPONSE.test(line)) {

package/src/parts/CommandNotFoundError/CommandNotFoundError.js

@@ -1,8 +1,9 @@
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as ProcessDisplayName from '../ProcessDisplayName/ProcessDisplayName.js'
 
 export class CommandNotFoundError extends Error {
   constructor(id) {
-    super(`command ${id} not found`)
+    super(`command ${id} not found in ${ProcessDisplayName.processDisplayName}`)
     this.name = 'CommandNotFoundError'
     this.code = ErrorCodes.E_COMMAND_NOT_FOUND
   }

package/src/parts/CreateCpuProfile/CreateCpuProfile.js

@@ -0,0 +1,59 @@
+import { writeFile } from 'fs/promises'
+import got from 'got'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { WebSocket } from 'ws'
+import * as DevtoolsProtocolRpc from '../DevtoolsProtocolRpc/DevtoolsProtocolRpc.js'
+
+const createConnection = (webSocketDebuggerUrl) => {
+  const webSocket = new WebSocket(webSocketDebuggerUrl)
+  // console.log({ webSocket })
+  return {
+    on(event, listener) {
+      if (event === 'message') {
+        const wrappedListener = (string) => {
+          listener(JSON.parse(string))
+        }
+        webSocket.on(event, wrappedListener)
+      } else {
+        webSocket.on(event, listener)
+      }
+    },
+    send(message) {
+      webSocket.send(JSON.stringify(message))
+    },
+  }
+}
+
+export const createCpuProfile = async (pid) => {
+  // AttachDebugger.attachDebugger(pid)
+  const response = await got('http://localhost:9229/json/list').json()
+  const first = response[0]
+  const webSocketDebuggerUrl = first.webSocketDebuggerUrl
+  const ipc = createConnection(webSocketDebuggerUrl)
+
+  await new Promise((r) => {
+    ipc.on('open', r)
+  })
+  const rpc = DevtoolsProtocolRpc.create(ipc)
+  const result = await rpc.invoke('Debugger.enable')
+  const debuggerId = result.result.debuggerId
+  console.log({ debuggerId })
+  const p = await rpc.invoke('Profiler.enable')
+  await rpc.invoke('Profiler.start')
+  await new Promise((r) => {
+    setTimeout(r, 10000)
+  })
+  const profileResult = await rpc.invoke('Profiler.stop')
+  console.log({ profileResult })
+  const profile = profileResult.result.profile
+  const profilePath = join(tmpdir(), 'node-profile.cpuprofile')
+  const profileString = JSON.stringify(profile)
+  await writeFile(profilePath, profileString)
+  console.log('finished')
+  // const value = await rpc.invoke('Runtime.evaluate', {
+  //   expression: '1+1',
+  // })
+  // await rpc.invoke('Debugger.pause')
+  // console.log({ value })
+}

package/src/parts/DestroySocket/DestroySocket.js

@@ -0,0 +1,5 @@
+export const destroySocket = (socket) => {
+  try {
+    socket.destroy()
+  } catch {}
+}

package/src/parts/DevtoolsProtocolRpc/DevtoolsProtocolRpc.js

@@ -0,0 +1,32 @@
+const Id = {
+  id: 1,
+  create() {
+    return this.id++
+  },
+}
+
+export const create = (ipc) => {
+  const callbacks = Object.create(null)
+  const handleMessage = (message) => {
+    if ('result' in message) {
+      const callback = callbacks[message.id]
+      callback(message)
+      delete callbacks[message.id]
+    }
+  }
+  ipc.on('message', handleMessage)
+  return {
+    invoke(method, params = {}) {
+      const id = Id.create()
+      const promise = new Promise((resolve, reject) => {
+        callbacks[id] = resolve
+      })
+      ipc.send({
+        method,
+        id,
+        params,
+      })
+      return promise
+    },
+  }
+}

package/src/parts/ElectronInitialize/ElectronInitialize.js

@@ -1,40 +1,11 @@
-import * as Callback from '../Callback/Callback.js'
-import * as Command from '../Command/Command.js'
-import * as GetResponse from '../GetResponse/GetResponse.js'
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
 
-export const electronInitialize = (port, folder) => {
-  // 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)
+export const electronInitialize = async (port, folder) => {
+  const ipc = await IpcChild.listen({
+    method: IpcChildType.NodeMessagePort,
+    messagePort: port,
+  })
+  HandleIpc.handleIpc(ipc)
 }

package/src/parts/ErrorHandling/ErrorHandling.js

@@ -1,11 +1,9 @@
 import * as ExitCode from '../ExitCode/ExitCode.js'
+import * as GetNewLineIndex from '../GetNewLineIndex/GetNewLineIndex.js'
 import * as IsIgnoredError from '../IsIgnoredError/IsIgnoredError.js'
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
 import * as Logger from '../Logger/Logger.js'
 import * as PrettyError from '../PrettyError/PrettyError.js'
 import * as Process from '../Process/Process.js'
-import * as Socket from '../Socket/Socket.js'
-import * as GetNewLineIndex from '../GetNewLineIndex/GetNewLineIndex.js'
 
 export const state = {
   seenErrors: [],
@@ -30,17 +28,17 @@ export const handleError = (error) => {
   }
   state.seenErrors.push(error.message)
   const prettyError = preparePrettyError(error)
-  Socket.send({
-    jsonrpc: JsonRpcVersion.Two,
-    method: /* Dialog.showErrorDialogWithOptions */ 'Dialog.showMessage',
-    params: [
-      {
-        message: prettyError.message,
-        codeFrame: prettyError.codeFrame,
-        stack: prettyError.stack,
-      },
-    ],
-  })
+  // Socket.send({
+  //   jsonrpc: JsonRpcVersion.Two,
+  //   method: /* Dialog.showErrorDialogWithOptions */ 'Dialog.showMessage',
+  //   params: [
+  //     {
+  //       message: prettyError.message,
+  //       codeFrame: prettyError.codeFrame,
+  //       stack: prettyError.stack,
+  //     },
+  //   ],
+  // })
   printPrettyError(prettyError)
 }
 

package/src/parts/GetActualPath/GetActualPath.js

@@ -0,0 +1,8 @@
+import { fileURLToPath } from 'node:url'
+
+export const getActualPath = (fileUri) => {
+  if (fileUri.startsWith('file://')) {
+    return fileURLToPath(fileUri)
+  }
+  return fileUri
+}

package/src/parts/GetErrorResponse/GetErrorResponse.js

@@ -12,7 +12,11 @@ const shouldLogError = (error) => {
   return true
 }
 
-export const getErrorResponse = (message, error) => {
+export const getErrorResponse = (message, error, ipc) => {
+  const prettyError = PrettyError.prepare(error)
+  if (shouldLogError(error) && (!ipc || ipc.shouldLogError !== false)) {
+    PrintPrettyError.printPrettyError(prettyError, `[shared-process] `)
+  }
   if (error && error instanceof CommandNotFoundError) {
     return {
       jsonrpc: JsonRpcVersion.Two,
@@ -37,8 +41,6 @@ export const getErrorResponse = (message, error) => {
       },
     }
   }
-  const prettyError = PrettyError.prepare(error)
-  PrintPrettyError.printPrettyError(prettyError, `[shared-process] `)
   return {
     jsonrpc: JsonRpcVersion.Two,
     id: message.id,

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

@@ -3,13 +3,13 @@ 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) => {
+export const getResponse = async (message, ipc) => {
   try {
     const result = RequiresSocket.requiresSocket(message.method)
-      ? await Command.execute(message.method, handle, ...message.params)
+      ? await Command.execute(message.method, ipc, ...message.params)
       : await Command.execute(message.method, ...message.params)
     return GetSuccessResponse.getSuccessResponse(message, result)
   } catch (error) {
-    return GetErrorResponse.getErrorResponse(message, error)
+    return GetErrorResponse.getErrorResponse(message, error, ipc)
   }
 }

package/src/parts/HandleElectronMessagePort/HandleElectronMessagePort.ipc.js

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

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

@@ -7,9 +7,9 @@ const handleJsonRpcResult = (message) => {
 }
 
 export const handleIpc = (ipc) => {
-  const handleJsonRpcMessage = async (message, handle) => {
+  const handleJsonRpcMessage = async (message) => {
     if (message.method) {
-      const response = await GetResponse.getResponse(message, handle)
+      const response = await GetResponse.getResponse(message, ipc)
       ipc.send(response)
     } else {
       // TODO handle error
@@ -17,12 +17,12 @@ export const handleIpc = (ipc) => {
     }
   }
 
-  const handleMessageFromParentProcess = async (message, handle) => {
+  const handleMessageFromParentProcess = async (message) => {
     if (message.result) {
       return handleJsonRpcResult(message)
     }
     if (message.method) {
-      return handleJsonRpcMessage(message, handle)
+      return handleJsonRpcMessage(message)
     }
     console.warn('unknown message', message)
   }

package/src/parts/HandleNodeMessagePort/HandleNodeMessagePort.ipc.js

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

package/src/parts/HandleNodeMessagePort/HandleNodeMessagePort.js

@@ -0,0 +1,12 @@
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+export const handleNodeMessagePort = async (messagePort) => {
+  const ipc = await IpcChild.listen({
+    method: IpcChildType.NodeMessagePort,
+    messagePort,
+  })
+  HandleIpc.handleIpc(ipc)
+  messagePort.start()
+}

package/src/parts/HandleWebSocket/HandleWebSocket.js

@@ -1,25 +1,26 @@
 import * as Assert from '../Assert/Assert.js'
+import * as DestroyWebSocket from '../DestroySocket/DestroySocket.js'
 import * as HandleWebSocketModule from '../HandleWebSocketModule/HandleWebSocketModule.js'
 import { VError } from '../VError/VError.js'
 
-export const handleWebSocket = async (handle, message) => {
-  Assert.object(message)
-  Assert.object(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')
-  }
+export const handleWebSocket = async (message, handle) => {
   try {
+    Assert.object(message)
+    Assert.object(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')
+    }
+    handle.pause()
     const module = await HandleWebSocketModule.load(protocol)
     await module.handleWebSocket(message, handle, protocol)
+    handle.resume()
   } catch (error) {
-    try {
-      handle.destroy()
-    } catch {}
+    DestroyWebSocket.destroySocket(handle)
     throw new VError(error, `Failed to connect to websocket`)
   }
 }

package/src/parts/HandleWebSocketForSharedProcess/HandleWebSocketForSharedProcess.js

@@ -1,16 +1,23 @@
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-import * as Socket from '../Socket/Socket.js'
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+import * as Logger from '../Logger/Logger.js'
 import * as WebSocketServer from '../WebSocketServer/WebSocketServer.js'
 
 const handleSocketError = (error) => {
   if (error && error.code === ErrorCodes.ECONNRESET) {
     return
   }
-  console.info('[info shared process: handle error]', error)
+  Logger.info('[info shared process: handle error]', error)
 }
 
 export const handleWebSocket = async (message, handle) => {
   handle.on('error', handleSocketError)
   const webSocket = await WebSocketServer.handleUpgrade(message, handle)
-  Socket.set(webSocket)
+  const ipc = await IpcChild.listen({
+    method: IpcChildType.WebSocket,
+    webSocket,
+  })
+  HandleIpc.handleIpc(ipc)
 }

package/src/parts/Id/Id.js

@@ -0,0 +1,7 @@
+export const state = {
+  id: 0,
+}
+
+export const create = () => {
+  return ++state.id
+}

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

@@ -8,6 +8,12 @@ export const getModule = (method) => {
       return import('../IpcChildWithNodeWorker/IpcChildWithNodeWorker.js')
     case IpcChildType.ElectronUtilityProcess:
       return import('../IpcChildWithElectronUtilityProcess/IpcChildWithElectronUtilityProcess.js')
+    case IpcChildType.ElectronMessagePort:
+      return import('../IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js')
+    case IpcChildType.NodeMessagePort:
+      return import('../IpcChildWithNodeMessagePort/IpcChildWithNodeMessagePort.js')
+    case IpcChildType.WebSocket:
+      return import('../IpcChildWithWebSocket/IpcChildWithWebSocket.js')
     default:
       throw new Error('unexpected ipc type')
   }

package/src/parts/IpcChildType/IpcChildType.js

@@ -1,6 +1,9 @@
 export const NodeWorker = 1
 export const NodeForkedProcess = 2
 export const ElectronUtilityProcess = 3
+export const ElectronMessagePort = 4
+export const NodeMessagePort = 5
+export const WebSocket = 6
 
 export const Auto = () => {
   const { argv } = process

package/src/parts/IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js

@@ -0,0 +1,41 @@
+import { IpcError } from '../IpcError/IpcError.js'
+import * as IsMessagePortMain from '../IsMessagePortMain/IsMessagePortMain.js'
+
+export const listen = ({ messagePort }) => {
+  if (!IsMessagePortMain.isMessagePortMain(messagePort)) {
+    throw new IpcError('port must be of type MessagePortMain')
+  }
+  return messagePort
+}
+
+const getActualData = (event) => {
+  return event.data
+}
+
+export const wrap = (messagePort) => {
+  return {
+    messagePort,
+    on(event, listener) {
+      if (event === 'message') {
+        const wrappedListener = (event) => {
+          const actualData = getActualData(event)
+          listener(actualData)
+        }
+        this.messagePort.on(event, wrappedListener)
+      } else if (event === 'close') {
+        this.messagePort.on('close', listener)
+      } 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()
+    },
+  }
+}