@lvce-editor/shared-process 0.0.27 → 0.0.30

package/src/parts/OutputChannel/OutputChannel.ipc.js

@@ -3,14 +3,14 @@ import * as Command from '../Command/Command.js'
 import * as OutputChannel from './OutputChannel.js'
 
 export const state = {
-  outputChannels: Object.create(null)
+  outputChannels: Object.create(null),
 }
 
 const open = (socket, id, path) => {
-  console.log({path})
+  console.log({ path })
   Assert.object(socket)
   // Assert.string(id)
-  Assert.string(path )
+  Assert.string(path)
   if (!socket) {
     console.warn('socket not available')
     return
@@ -20,22 +20,19 @@ const open = (socket, id, path) => {
   }
   const onData = (data) => {
     console.log('send data', data)
-    socket.send(
-      {
-        jsonrpc: '2.0',
-        method: 2133,
-        params: ['Output', 'handleData', data],
-      }
-    )
+    socket.send({
+      jsonrpc: '2.0',
+      method: 2133,
+      params: ['Output', 'handleData', data],
+    })
   }
   const onError = (error) => {
     console.info(`[shared process] output channel error: ${error}`)
-    socket.send(
-      {
-        jsonrpc: '2.0',
-        method: 2133,
-        params: ['Output', 'handleError', error],
-      })
+    socket.send({
+      jsonrpc: '2.0',
+      method: 2133,
+      params: ['Output', 'handleError', error],
+    })
   }
   state.outputChannels[id] = OutputChannel.open(path, onData, onError)
 }
@@ -45,7 +42,7 @@ const close = (socket, id) => {
   delete state.outputChannels[id]
 }
 
-export const __initialize__ = () => {
-  Command.register('OutputChannel.open', open)
-  Command.register('OutputChannel.close', close)
+export const Commands = {
+  'OutputChannel.open': open,
+  'OutputChannel.close': close,
 }

package/src/parts/ParentIpc/ParentIpc.js

@@ -1,10 +1,13 @@
 import { MessagePort, parentPort } from 'node:worker_threads'
+import VError from 'verror'
 import * as Callback from '../Callback/Callback.js'
 import * as Command from '../Command/Command.js'
 import * as Debug from '../Debug/Debug.js'
 import * as Error from '../Error/Error.js'
 import { requiresSocket } from '../RequiresSocket/RequiresSocket.js'
-
+import * as Platform from '../Platform/Platform.js'
+import * as ExtensionHostIpc from '../ExtensionHostIpc/ExtensionHostIpc.js'
+import * as ExtensionHostRpc from '../ExtensionHostRpc/ExtensionHostRpc.js'
 // TODO add tests for this
 
 // TODO handle structure: one shared process multiple extension hosts
@@ -30,53 +33,99 @@ export const electronSend = (message) => {
   }
 }
 
-const handleMessageFromParentProcess = async (message, handle) => {
-  if (handle) {
-    handle.on('error', (error) => {
-      if (error && error.code === 'ECONNRESET') {
-        return
-      }
-      console.info('[info shared process: handle error]', error)
-    })
-    Command.execute(
-      /* WebSocketServer.handleUpgrade */ 5621,
-      /* message */ message,
-      /* handle */ handle
-    )
-  } else if (message.result) {
-    Callback.resolve(message.id, message.result)
-  } else if (message.method) {
-    if (message.id) {
-      try {
-        const result = requiresSocket(message.method)
-          ? await Command.invoke(message.method, handle, ...message.params)
-          : await Command.invoke(message.method, ...message.params)
-        electronSend({
-          jsonrpc: '2.0',
-          id: message.id,
-          result: result ?? null,
-        })
-      } catch (error) {
-        console.error('[shared process] command failed to execute')
-        console.error(error)
-        electronSend({
-          jsonrpc: '2.0',
-          code: /* ExpectedError */ -32000,
-          id: message.id,
-          error: 'ExpectedError',
-          // @ts-ignore
-          data: error.toString(),
-        })
-      }
-    } else {
-      // TODO handle error
-      Command.execute(message.method, null, ...message.params)
+const handleWebSocketSharedProcess = (message, handle) => {
+  // TODO when it is an extension host websocket, spawn extension host
+  handle.on('error', (error) => {
+    if (error && error.code === 'ECONNRESET') {
+      return
+    }
+    console.info('[info shared process: handle error]', error)
+  })
+  Command.execute(
+    /* WebSocketServer.handleUpgrade */ 5621,
+    /* 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 = 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 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 'lvce.shared-process':
+      return handleWebSocketSharedProcess(message, handle)
+    case 'lvce.extension-host':
+      return handleWebSocketExtensionHost(message, handle)
+    default:
+      throw new VError(`unsupported sec-websocket-procotol ${protocol}`)
+  }
+}
+
+const handleJsonRpcResult = (message) => {
+  Callback.resolve(message.id, message.result)
+}
+
+const handleJsonRpcMessage = async (message, handle) => {
+  if (message.id) {
+    try {
+      const result = requiresSocket(message.method)
+        ? await Command.invoke(message.method, handle, ...message.params)
+        : await Command.invoke(message.method, ...message.params)
+      electronSend({
+        jsonrpc: '2.0',
+        id: message.id,
+        result: result ?? null,
+      })
+    } catch (error) {
+      console.error('[shared process] command failed to execute')
+      console.error(error)
+      electronSend({
+        jsonrpc: '2.0',
+        code: /* ExpectedError */ -32000,
+        id: message.id,
+        error: 'ExpectedError',
+        // @ts-ignore
+        data: error.toString(),
+      })
     }
   } else {
-    console.warn('unknown message', message)
+    // 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
@@ -160,7 +209,7 @@ const electronInitialize = (initializeMessage) => {
               },
             })
           }
-          return
+
         }
       } else {
         Command.execute(message.method, fakeSocket, ...message.params)

package/src/parts/Platform/Platform.ipc.js

@@ -1,21 +1,19 @@
-import * as Command from '../Command/Command.js'
 import * as Platform from '../Platform/Platform.js'
 
 // prettier-ignore
-export const __initialize__ = () => {
-  Command.register('Platform.getConfigDir', Platform.getConfigDir)
-  Command.register('Platform.getAppDir', Platform.getAppDir)
-  Command.register('Platform.getHomeDir', Platform.getHomeDir)
-  Command.register('Platform.getDataDir', Platform.getDataDir)
-  Command.register('Platform.getExtensionsPath', Platform.getExtensionsPath)
-  Command.register('Platform.getBuiltinExtensionsPath', Platform.getBuiltinExtensionsPath)
-  Command.register('Platform.getDisabledExtensionsPath', Platform.getDisabledExtensionsPath)
-  Command.register('Platform.getCachedExtensionsPath', Platform.getCachedExtensionsPath)
-  Command.register('Platform.getMarketplaceUrl', Platform.getMarketplaceUrl)
-  Command.register('Platform.getLogsDir', Platform.getLogsDir)
-  Command.register('Platform.getUserSettingsPath', Platform.getUserSettingsPath)
-  Command.register('Platform.getRecentlyOpenedPath', Platform.getRecentlyOpenedPath)
-  Command.register('Platform.getCacheDir', Platform.getCacheDir)
-  Command.register('Platform.getCacheDir', Platform.getCacheDir)
-  Command.register('Platform.setEnvironmentVariables', Platform.setEnvironmentVariables)
+export const Commands = {
+  'Platform.getConfigDir': Platform.getConfigDir,
+  'Platform.getAppDir': Platform.getAppDir,
+  'Platform.getHomeDir': Platform.getHomeDir,
+  'Platform.getDataDir': Platform.getDataDir,
+  'Platform.getExtensionsPath': Platform.getExtensionsPath,
+  'Platform.getBuiltinExtensionsPath': Platform.getBuiltinExtensionsPath,
+  'Platform.getDisabledExtensionsPath': Platform.getDisabledExtensionsPath,
+  'Platform.getCachedExtensionsPath': Platform.getCachedExtensionsPath,
+  'Platform.getMarketplaceUrl': Platform.getMarketplaceUrl,
+  'Platform.getLogsDir': Platform.getLogsDir,
+  'Platform.getUserSettingsPath': Platform.getUserSettingsPath,
+  'Platform.getRecentlyOpenedPath': Platform.getRecentlyOpenedPath,
+  'Platform.getCacheDir': Platform.getCacheDir,
+  'Platform.setEnvironmentVariables': Platform.setEnvironmentVariables,
 }

package/src/parts/Platform/Platform.js

@@ -1,6 +1,6 @@
-import { extensionHostPath } from '@lvce-editor/extension-host'
 import { homedir, tmpdir } from 'node:os'
 import { sep } from 'node:path'
+import { extensionHostPath } from '@lvce-editor/extension-host'
 import { xdgCache, xdgConfig, xdgData, xdgState } from 'xdg-basedir'
 import * as Path from '../Path/Path.js'
 import * as Root from '../Root/Root.js'

package/src/parts/Preferences/Preferences.ipc.js

@@ -1,6 +1,5 @@
-import * as Command from '../Command/Command.js'
 import * as Preferences from '../Preferences/Preferences.js'
 
-export const __initialize__ = () => {
-  Command.register("Preferences.getAll", Preferences.getAll)
+export const Commands = {
+  'Preferences.getAll': Preferences.getAll,
 }

package/src/parts/PrettyError/PrettyError.js

@@ -13,8 +13,11 @@ const getActualPath = (fileUri) => {
 
 export const prepare = (error) => {
   const message = error.message
-  if (error.cause) {
-    error = error.cause()
+  if (error && error.cause) {
+    const cause = error.cause()
+    if (cause) {
+      error = cause
+    }
   }
   const cleanedStack = cleanStack(error.stack)
   const lines = cleanedStack.split('\n')

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

@@ -1,7 +1,6 @@
-import * as Command from '../Command/Command.js'
 import * as Process from './Process.js'
 
-export const __initialize__ = () => {
-  Command.register(555, Process.crash)
-  Command.register(556, Process.crashAsync)
+export const Commands = {
+  555: Process.crash,
+  556: Process.crashAsync,
 }

package/src/parts/RequiresSocket/RequiresSocket.js

@@ -1,11 +1,12 @@
 // TODO find a better way to do this
 // most commands don't require sockets
 // but output channel and terminal need to continuously send data through the socket
-const METHODS_THAT_REQUIRE_SOCKET = [
-  'OutputChannel.open', // OutputChannel.open
-  'ExtensionHost.start', // ExtensionHost.start
-]
+const METHODS_THAT_REQUIRE_SOCKET = new Set([
+  'OutputChannel.open',
+  'ExtensionHost.start',
+  'ExtensionHost.send',
+])
 
 export const requiresSocket = (method) => {
-  return METHODS_THAT_REQUIRE_SOCKET.includes(method)
+  return METHODS_THAT_REQUIRE_SOCKET.has(method)
 }

package/src/parts/Search/Search.ipc.js

@@ -1,6 +1,5 @@
-import * as Command from '../Command/Command.js'
 import * as Search from './Search.js'
 
-export const __initialize__ = () => {
-  Command.register('Search.search', Search.search)
+export const Commands = {
+  'Search.search': Search.search,
 }

package/src/parts/SearchFile/SearchFile.ipc.js

@@ -1,6 +1,5 @@
-import * as Command from '../Command/Command.js'
 import * as SearchFile from './SearchFile.js'
 
-export const __initialize__ = () => {
-  Command.register('SearchFile.searchFile', SearchFile.searchFile)
+export const Commands = {
+  'SearchFile.searchFile': SearchFile.searchFile,
 }

package/src/parts/Stats/Stats.js

@@ -3,17 +3,17 @@
 import * as Exec from '../Exec/Exec.js'
 
 const PID_CMD =
-  /^\s*([0-9]+)\s+([0-9]+)\s+([0-9]+\.[0-9]+)\s+([0-9]+\.[0-9]+)\s+(.+)$/
+  /^\s*(\d+)\s+(\d+)\s+(\d+\.\d+)\s+(\d+\.\d+)\s+(.+)$/
 
 const parsePsOutputLine = (line) => {
   const matches = PID_CMD.exec(line.trim())
   if (matches && matches.length === 6) {
     return {
-      pid: parseInt(matches[1]),
-      ppid: parseInt(matches[2]),
+      pid: Number.parseInt(matches[1]),
+      ppid: Number.parseInt(matches[2]),
       cwd: matches[5],
-      load: parseInt(matches[3]),
-      mem: parseInt(matches[4]),
+      load: Number.parseInt(matches[3]),
+      mem: Number.parseInt(matches[4]),
     }
   }
 }

package/src/parts/Terminal/Terminal.ipc.js

@@ -1,11 +1,11 @@
 import * as Command from '../Command/Command.js'
-import * as Terminal from './Terminal.js'
 import * as Assert from '../Assert/Assert.js'
+import * as Terminal from './Terminal.js'
 
 const create = (socket, id, cwd) => {
   Assert.object(socket)
   if (!socket) {
-    console.log({socket, id, cwd})
+    console.log({ socket, id, cwd })
     console.warn('socket not available')
     return
   }
@@ -24,8 +24,8 @@ const create = (socket, id, cwd) => {
   Terminal.create(socket, id, cwd)
 }
 
-const write = ( id, input) => {
-  console.log({ id, input})
+const write = (id, input) => {
+  console.log({ id, input })
   Terminal.write(id, input)
 }
 
@@ -37,9 +37,9 @@ const dispose = (socket, id) => {
   Terminal.dispose(id)
 }
 
-export const __initialize__ = () => {
-  Command.register('Terminal.create', create)
-  Command.register('Terminal.dispose', dispose)
-  Command.register('Terminal.write', write)
-  Command.register('Terminal.resize', resize)
+export const Commands = {
+  'Terminal.create': create,
+  'Terminal.dispose': dispose,
+  'Terminal.write': write,
+  'Terminal.resize': resize,
 }

package/src/parts/Terminal/Terminal.js

@@ -1,10 +1,10 @@
 import { ChildProcess, fork } from 'node:child_process'
 import exitHook from 'exit-hook'
+import { ptyHostPath } from '@lvce-editor/pty-host'
 import * as Debug from '../Debug/Debug.js'
 import * as Path from '../Path/Path.js'
 import * as Root from '../Root/Root.js'
 import * as Assert from '../Assert/Assert.js'
-import { ptyHostPath } from '@lvce-editor/pty-host'
 
 export const state = {
   /**

package/src/parts/TextDocument/TextDocument.ipc.js

@@ -1,6 +1,5 @@
-import * as Command from '../Command/Command.js'
 import * as TextDocument from './TextDocument.js'
 
-export const __initialize__ = () => {
- Command.register(4820, TextDocument.applyEdit)
+export const Commands = {
+  4820: TextDocument.applyEdit,
 }

package/src/parts/Timeout/Timeout.js

@@ -0,0 +1,7 @@
+export const setTimeout = (listener, ms) => {
+  return globalThis.setTimeout(listener, ms)
+}
+
+export const clearTimeout = (timeoutId) => {
+  globalThis.clearTimeout(timeoutId)
+}

package/src/parts/WebSocketServer/WebSocketServer.ipc.js

@@ -1,6 +1,5 @@
-import * as Command from '../Command/Command.js'
 import * as WebSocketServer from './WebSocketServer.js'
 
-export const __initialize__ = () => {
- Command.register(5621, WebSocketServer.handleUpgrade)
+export const Commands = {
+  5621: WebSocketServer.handleUpgrade,
 }

package/src/parts/Workspace/Workspace.ipc.js

@@ -1,7 +1,6 @@
-import * as Command from '../Command/Command.js'
 import * as Workspace from './Workspace.js'
 
-export const __initialize__ = () => {
-  Command.register('Workspace.resolveRoot', Workspace.resolveRoot)
-  Command.register('Workspace.getHomeDir', Workspace.getHomeDir)
+export const Commands = {
+  'Workspace.resolveRoot': Workspace.resolveRoot,
+  'Workspace.getHomeDir': Workspace.getHomeDir,
 }

package/src/sharedProcessMain.js

@@ -5,9 +5,18 @@ import * as PrettyError from './parts/PrettyError/PrettyError.js'
 
 // TODO use named functions here
 
+const firstErrorLine = (error) => {
+  if (error.stack) {
+    return error.stack.slice(0, error.stack.indexOf('\n'))
+  }
+  if (error.message) {
+    return error.message
+  }
+  return `${error}`
+}
+
 const handleUncaughtExceptionMonitor = (error, origin) => {
-  console.info(`[shared process] uncaught exception: ${error.stack}`)
-  console.info('code', error.code)
+  console.info(`[shared process] uncaught exception: ${firstErrorLine(error)}`)
   if (error && error.code === 'EPIPE' && !process.connected) {
     // parent process is disposed, ignore
     return
@@ -16,18 +25,14 @@ const handleUncaughtExceptionMonitor = (error, origin) => {
     // parent process is disposed, ignore
     return
   }
-  console.log(error)
+  // console.log(error)
   const prettyError = PrettyError.prepare(error)
-  console.error(prettyError.message)
+  // console.error(prettyError.message)
   console.error(prettyError.codeFrame)
   console.error(prettyError.stack)
   process.exit(1)
 }
 
-const handleSigInt = () => {
-  console.info('[shared process] sigint')
-}
-
 const handleDisconnect = () => {
   console.info('[shared process] disconnected')
 }
@@ -44,7 +49,6 @@ const main = () => {
   console.log('[shared process] started')
   process.on('beforeExit', handleBeforeExit)
   process.on('disconnect', handleDisconnect)
-  process.on('SIGINT', handleSigInt)
   process.on('SIGTERM', handleSigTerm)
 
   process.on('uncaughtExceptionMonitor', handleUncaughtExceptionMonitor)

package/src/parts/Extension/Extension.js

@@ -1,7 +0,0 @@
-export const install = (id) => {}
-
-export const uninstall = (id) => {}
-
-export const enable = (id) => {}
-
-export const disable = (id) => {}

package/src/parts/ExtensionHost/ExtensionHostBraceCompletion.js

@@ -1,14 +0,0 @@
-export const executeBraceCompletionProvider = async (
-  extensionHost,
-  documentId,
-  offset,
-  openingBrace
-) => {
-  const completions = await extensionHost.invoke(
-    'BraceCompletion.execute',
-    documentId,
-    offset,
-    openingBrace
-  )
-  return completions
-}

package/src/parts/ExtensionHost/ExtensionHostClosingTag.js

@@ -1,14 +0,0 @@
-export const executeClosingTagProvider = async (
-  extensionHost,
-  documentId,
-  offset,
-  openingBrace
-) => {
-  const completions = await extensionHost.invoke(
-    'ClosingTag.execute',
-    documentId,
-    offset,
-    openingBrace
-  )
-  return completions
-}

package/src/parts/ExtensionHost/ExtensionHostCommand.js

@@ -1,19 +0,0 @@
-import * as ExtensionManagement from '../ExtensionManagement/ExtensionManagement.js'
-
-export const executeCommand = async (extensionHost, commandId, ...args) => {
-  return extensionHost.invoke('executeCommand', commandId, ...args)
-}
-
-const getExtensionCommands = (extension) => {
-  return extension.commands || []
-}
-
-export const getCommands = async () => {
-  const extensions = await ExtensionManagement.getExtensions()
-  return extensions.flatMap(getExtensionCommands)
-}
-
-export const getCommandsIpc = async () => {
-  const commands = await getCommands()
-  return commands
-}

package/src/parts/ExtensionHost/ExtensionHostCompletion.js

@@ -1,12 +0,0 @@
-export const executeCompletionProvider = async (
-  extensionHost,
-  documentId,
-  offset
-) => {
-  const completions = await extensionHost.invoke(
-    'executeCompletionProvider',
-    documentId,
-    offset
-  )
-  return completions
-}

package/src/parts/ExtensionHost/ExtensionHostDefinition.js

@@ -1,12 +0,0 @@
-export const executeDefinitionProvider = async (
-  extensionHost,
-  textDocumentId,
-  offset
-) => {
-  const result = await extensionHost.invoke(
-    'Definition.executeDefinitionProvider',
-    textDocumentId,
-    offset
-  )
-  return result
-}

package/src/parts/ExtensionHost/ExtensionHostDiagnostic.js

@@ -1,7 +0,0 @@
-export const executeDiagnosticProvider = async (extensionHost, documentId) => {
-  const diagnostics = await extensionHost.invoke(
-    'Diagnostic.execute',
-    documentId
-  )
-  return diagnostics
-}

package/src/parts/ExtensionHost/ExtensionHostFileSystem.js

@@ -1,23 +0,0 @@
-export const readFile = (extensionHost, protocol, uri) => {
-  return extensionHost.invoke('FileSystem.readFile', protocol, uri)
-}
-
-export const writeFile = (extensionHost, protocol, uri, content) => {
-  return extensionHost.invoke('FileSystem.writeFile', protocol, uri, content)
-}
-
-export const readDirWithFileTypes = (extensionHost, protocol, uri) => {
-  return extensionHost.invoke('FileSystem.readDirWithFileTypes', protocol, uri)
-}
-
-export const remove = (extensionHost, protocol, uri) => {
-  return extensionHost.invoke('FileSystem.remove', protocol, uri)
-}
-
-export const rename = (extensionHost, protocol, oldUri, newUri) => {
-  return extensionHost.invoke('FileSystem.rename', protocol, oldUri, newUri)
-}
-
-export const getPathSeparator = (extensionHost, protocol) => {
-  return extensionHost.invoke('FileSystem.getPathSeparator', protocol)
-}

package/src/parts/ExtensionHost/ExtensionHostFormatting.js

@@ -1,4 +0,0 @@
-export const format = async (extensionHost, path, content) => {
-  const formattedContent = await extensionHost.invoke('format', path, content)
-  return formattedContent
-}