@lvce-editor/shared-process 0.15.17 → 0.15.19

package/src/parts/JsonRpc/JsonRpc.js

@@ -10,30 +10,26 @@ export const send = (transport, method, ...params) => {
 }
 
 export const invoke = (ipc, method, ...params) => {
-  return new Promise((resolve, reject) => {
-    // TODO use one map instead of two
-    const callbackId = Callback.register(resolve, reject)
-    ipc.send({
-      jsonrpc: JsonRpcVersion.Two,
-      method,
-      params,
-      id: callbackId,
-    })
+  const { id, promise } = Callback.registerPromise()
+  ipc.send({
+    jsonrpc: JsonRpcVersion.Two,
+    method,
+    params,
+    id,
   })
+  return promise
 }
 
 export const invokeAndTransfer = (ipc, handle, method, ...params) => {
-  return new Promise((resolve, reject) => {
-    // TODO use one map instead of two
-    const callbackId = Callback.register(resolve, reject)
-    ipc.sendAndTransfer(
-      {
-        jsonrpc: JsonRpcVersion.Two,
-        method,
-        params,
-        id: callbackId,
-      },
-      handle
-    )
-  })
+  const { id, promise } = Callback.registerPromise()
+  ipc.sendAndTransfer(
+    {
+      jsonrpc: JsonRpcVersion.Two,
+      method,
+      params,
+      id,
+    },
+    handle
+  )
+  return promise
 }

package/src/parts/Module/Module.js

@@ -2,6 +2,8 @@ import * as ModuleId from '../ModuleId/ModuleId.js'
 
 export const load = (moduleId) => {
   switch (moduleId) {
+    case ModuleId.AttachDebugger:
+      return import('../AttachDebugger/AttachDebugger.ipc.js')
     case ModuleId.AutoUpdater:
       return import('../AutoUpdater/AutoUpdater.ipc.js')
     case ModuleId.AutoUpdaterAppImage:
@@ -40,6 +42,8 @@ export const load = (moduleId) => {
       return import('../Platform/Platform.ipc.js')
     case ModuleId.Preferences:
       return import('../Preferences/Preferences.ipc.js')
+    case ModuleId.Process:
+      return import('../Process/Process.ipc.js')
     case ModuleId.RecentlyOpened:
       return import('../RecentlyOpened/RecentlyOpened.ipc.js')
     case ModuleId.SearchFile:
@@ -58,6 +62,12 @@ export const load = (moduleId) => {
       return import('../RebuildNodePty/RebuildNodePty.ipc.js')
     case ModuleId.HandleWebSocket:
       return import('../HandleWebSocket/HandleWebSocket.ipc.js')
+    case ModuleId.HandleElectronMessagePort:
+      return import('../HandleElectronMessagePort/HandleElectronMessagePort.ipc.js')
+    case ModuleId.HandleNodeMessagePort:
+      return import('../HandleNodeMessagePort/HandleNodeMessagePort.ipc.js')
+    case ModuleId.GetTerminalSpawnOptions:
+      return import('../GetTerminalSpawnOptions/GetTerminalSpawnOptions.ipc.js')
     default:
       throw new Error(`module ${moduleId} not found`)
   }

package/src/parts/ModuleId/ModuleId.js

@@ -26,3 +26,8 @@ export const AutoUpdaterWindowsNsis = 25
 export const RebuildNodePty = 26
 export const ElectronInitialize = 27
 export const HandleWebSocket = 28
+export const Process = 29
+export const AttachDebugger = 30
+export const HandleElectronMessagePort = 31
+export const HandleNodeMessagePort = 32
+export const GetTerminalSpawnOptions = 33

package/src/parts/ModuleMap/ModuleMap.js

@@ -3,6 +3,8 @@ import * as ModuleId from '../ModuleId/ModuleId.js'
 
 export const getModuleId = (commandId) => {
   switch (commandId) {
+    case 'AttachDebugger.attachDebugger':
+      return ModuleId.AttachDebugger
     case 'AutoUpdater.getAutoUpdateType':
     case 'AutoUpdater.getLatestVersion':
       return ModuleId.AutoUpdater
@@ -112,6 +114,10 @@ export const getModuleId = (commandId) => {
       return ModuleId.GitLsFiles
     case 'HandleWebSocket.handleWebSocket':
       return ModuleId.HandleWebSocket
+    case 'HandleElectronMessagePort.handleElectronMessagePort':
+      return ModuleId.HandleElectronMessagePort
+    case 'HandleNodeMessagePort.handleNodeMessagePort':
+      return ModuleId.HandleNodeMessagePort
     case 'InstallExtension.installExtension':
       return ModuleId.InstallExtension
     case 'IsAutoUpdateSupported.isAutoUpdateSupported':
@@ -161,6 +167,14 @@ export const getModuleId = (commandId) => {
       return ModuleId.Workspace
     case 'RebuildNodePty.rebuildNodePty':
       return ModuleId.RebuildNodePty
+    case 'Process.getPid':
+      return ModuleId.Process
+    case 'HandleNodeMessagePort.handleNodeMessagePort':
+      return ModuleId.HandleNodeMessagePort
+    case 'HandleElectronMessagePort.handleElectronMessagePort':
+      return ModuleId.HandleElectronMessagePort
+    case 'GetTerminalSpawnOptions.getTerminalSpawnOptions':
+      return ModuleId.GetTerminalSpawnOptions
     default:
       throw new CommandNotFoundError(commandId)
   }

package/src/parts/PrettyError/PrettyError.js

@@ -1,21 +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
-}
+import * as Logger from '../Logger/Logger.js'
 
 const RE_MODULE_NOT_FOUND_STACK = /Cannot find package '([^']+)' imported from (.+)$/
 
@@ -61,55 +54,52 @@ 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)
-  }
-  const { message } = error
-  if (error && error.cause) {
-    const cause = error.cause()
-    if (cause) {
-      error = cause
+  try {
+    if (error && error.code === ErrorCodes.ERR_MODULE_NOT_FOUND) {
+      return prepareModuleNotFoundError(error)
     }
-  }
-  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+)$/)
+    const { message } = error
+    if (error && error.cause) {
+      const cause = error.cause()
+      if (cause) {
+        error = cause
+      }
     }
-    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),
-        },
+    const lines = CleanStack.cleanStack(error.stack)
+    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.getActualPath(path)
+        const rawLines = readFileSync(actualPath, EncodingType.Utf8)
+        const location = {
+          start: {
+            line: Number.parseInt(line),
+            column: Number.parseInt(column),
+          },
+        }
+        codeFrame = codeFrameColumns(rawLines, location)
       }
-      codeFrame = codeFrameColumns(rawLines, location)
     }
-  }
-  const relevantStack = JoinLines.joinLines(lines)
-  return {
-    message,
-    stack: relevantStack,
-    codeFrame,
-    type: error.constructor.name,
-    code: error.code,
+    const relevantStack = JoinLines.joinLines(lines)
+    return {
+      message,
+      stack: relevantStack,
+      codeFrame,
+      type: error.constructor.name,
+      code: error.code,
+    }
+  } catch (otherError) {
+    Logger.warn(`ErrorHandling Error: ${otherError}`)
+    return error
   }
 }
 

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

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

package/src/parts/Signal/Signal.js

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

package/src/parts/SplitLines/SplitLines.js

@@ -1,3 +1,5 @@
+import * as Character from '../Character/Character.js'
+
 export const splitLines = (lines) => {
-  return lines.split('\n')
+  return lines.split(Character.NewLine)
 }

package/src/parts/Terminal/Terminal.js

@@ -1,37 +1,47 @@
 import * as Assert from '../Assert/Assert.js'
 import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
 import * as PtyHost from '../PtyHost/PtyHost.js'
+import * as TerminalState from '../TerminalState/TerminalState.js'
 import { VError } from '../VError/VError.js'
 
-export const state = {
-  socketMap: Object.create(null),
+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,
+  }
 }
 
-export const create = async (socket, id, cwd) => {
+export const create = async (socket, id, cwd, command, args) => {
   try {
     Assert.object(socket)
     Assert.number(id)
     Assert.string(cwd)
-    // TODO dispose entry
-    state.socketMap[id] = socket
+    // TODO race condition because of await
     const ptyHost = await PtyHost.getOrCreate()
-
-    const handleMessage = (message) => {
-      socket.send(message)
-    }
-    const handleClose = () => {
-      // socket.off('close', handleClose)
-      ptyHost.off('message', handleMessage)
-      ptyHost.dispose()
-    }
-    ptyHost.on('message', handleMessage)
-    socket.on('close', handleClose)
-
+    const terminal = createTerminal(ptyHost, socket)
+    TerminalState.add(id, terminal)
     // TODO use invoke
     ptyHost.send({
       jsonrpc: JsonRpcVersion.Two,
       method: 'Terminal.create',
-      params: [id, cwd],
+      params: [id, cwd, command, args],
     })
   } catch (error) {
     throw new VError(error, `Failed to create terminal`)
@@ -59,6 +69,9 @@ export const resize = (state, columns, rows) => {
 }
 
 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({

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]
+}

package/src/parts/WebSocketServer/WebSocketServer.js

@@ -1,5 +1,6 @@
 import { Buffer } from 'node:buffer'
 import * as _ws from 'ws'
+import * as IsSocket from '../IsSocket/IsSocket.js'
 
 // workaround for jest or node bug
 const WebSocketServer = _ws.WebSocketServer
@@ -14,11 +15,15 @@ const webSocketServer = new WebSocketServer({
   // perMessageDeflate: true
 })
 
-export const handleUpgrade = (request, socket) => {
-  return new Promise((resolve, reject) => {
+export const handleUpgrade = async (request, socket) => {
+  if (!IsSocket.isSocket(socket)) {
+    throw new TypeError(`socket must be of type Socket`)
+  }
+  const webSocket = await new Promise((resolve, reject) => {
     const upgradeCallback = (ws) => {
       resolve(ws)
     }
     webSocketServer.handleUpgrade(request, socket, Buffer.alloc(0), upgradeCallback)
   })
+  return webSocket
 }

package/src/sharedProcessMain.cjs

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

package/src/sharedProcessMain.js

@@ -3,6 +3,7 @@ import * as ErrorHandling from './parts/ErrorHandling/ErrorHandling.js'
 import * as Module from './parts/Module/Module.js'
 import * as ParentIpc from './parts/ParentIpc/ParentIpc.js'
 import * as Process from './parts/Process/Process.js'
+import * as Signal from './parts/Signal/Signal.js'
 // TODO handle structure: one shared process multiple extension hosts
 
 // TODO use named functions here
@@ -34,7 +35,7 @@ const main = async () => {
   console.log('[shared process] started')
   // process.on('beforeExit', handleBeforeExit)
   process.on('disconnect', handleDisconnect)
-  process.on('SIGTERM', handleSigTerm)
+  process.on(Signal.SIGTERM, handleSigTerm)
 
   process.on('uncaughtExceptionMonitor', ErrorHandling.handleUncaughtExceptionMonitor)
   await ParentIpc.listen()

package/src/parts/Socket/Socket.js

@@ -1,77 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as GetResponse from '../GetResponse/GetResponse.js'
-import { VError } from '../VError/VError.js'
-
-export const state = {
-  /**
-   * @type {any}
-   */
-  socket: undefined,
-}
-
-export const send = (message) => {
-  if (!state.socket) {
-    console.warn('socket not yet available')
-    return
-  }
-  state.socket.send(message)
-}
-
-const handleMessage = async (event) => {
-  const object = JSON.parse(event.data)
-  if (object.id) {
-    if (!object.params) {
-      console.warn('[shared-process] invalid message 1', typeof object, object.params, object)
-      return
-    }
-    const response = await GetResponse.getResponse(object, state.socket)
-    send(response)
-  } else {
-    if (!object.params) {
-      console.warn('invalid message', typeof object, object.params, object)
-      return
-    }
-    Command.execute(object.method, state.socket, ...object.params)
-  }
-}
-
-const handleError = (error) => {
-  // console.error(error)
-  throw new VError(error, 'Shared Process Socket Error')
-
-  // console.error('[Shared Process: Socket Error]', event)
-}
-
-// TODO
-const createAbstractSocket = (socket) => {
-  return {
-    _socket: socket,
-    send(message) {
-      socket.send(JSON.stringify(message))
-    },
-    on(event, listener) {
-      switch (event) {
-        case 'message':
-          socket.on('message', listener)
-          break
-        case 'close':
-          socket.on('close', listener)
-          break
-        default:
-          console.warn('socket event not implemented', event, listener)
-          break
-      }
-    },
-  }
-}
-
-export const set = (socket) => {
-  socket.on('close', () => {
-    console.log('[shared-process] socket closed')
-  })
-  socket.onmessage = handleMessage
-  // socket.onerror = handleError
-  socket.on('error', handleError)
-  const abstractSocket = createAbstractSocket(socket)
-  state.socket = abstractSocket
-}