@lvce-editor/shared-process 0.0.27 → 0.0.28

package/src/parts/{ExtensionHost/ExtensionHostIconTheme.js → ExtensionManagement/ExtensionManagementIconTheme.js}

@@ -1,6 +1,6 @@
 import * as Error from '../Error/Error.js'
-import * as ExtensionManagement from '../ExtensionManagement/ExtensionManagement.js'
 import * as ReadJson from '../JsonFile/JsonFile.js'
+import * as ExtensionManagement from './ExtensionManagement.js'
 
 export const getIconTheme = async (iconThemeId) => {
   const extensions = await ExtensionManagement.getExtensions()

package/src/parts/{ExtensionHost/ExtensionHostLanguages.js → ExtensionManagement/ExtensionManagementLanguages.js}

@@ -2,9 +2,9 @@ import { join } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import VError from 'verror'
 import * as Error from '../Error/Error.js'
-import * as ExtensionManagement from '../ExtensionManagement/ExtensionManagement.js'
 import * as ReadJson from '../JsonFile/JsonFile.js'
 import * as Path from '../Path/Path.js'
+import * as ExtensionManagement from './ExtensionManagement.js'
 
 const getExtensionLanguages = (extension) => {
   if (!extension.languages) {

package/src/parts/FileSystem/FileSystem.js

@@ -6,6 +6,7 @@ import * as Error from '../Error/Error.js'
 import * as Path from '../Path/Path.js'
 import * as Trash from '../Trash/Trash.js'
 import * as Platform from '../Platform/Platform.js'
+import VError from 'verror'
 
 export const state = {
   watcherMap: Object.create(null),
@@ -15,6 +16,17 @@ export const copy = async (source, target) => {
   try {
     await fs.cp(source, target, { recursive: true })
   } catch (error) {
+    if (
+      error &&
+      error.message &&
+      error.message.startsWith(
+        'Invalid src or dest: cp returned EINVAL (src and dest cannot be the same)'
+      )
+    ) {
+      throw new VError(
+        `Failed to copy "${source}" to "${target}": src and dest cannot be the same`
+      )
+    }
     throw new Error.OperationalError({
       cause: error,
       code: 'E_FILE_SYSTEM_ERROR',
@@ -26,7 +38,7 @@ export const copy = async (source, target) => {
 
 export const readFile = async (path) => {
   try {
-    const content = await fs.readFile(path, 'utf-8')
+    const content = await fs.readFile(path, 'utf8')
     return content
   } catch (error) {
     throw new Error.OperationalError({

package/src/parts/JsonRpc/JsonRpc.js

@@ -8,11 +8,11 @@ export const send = (transport, method, ...params) => {
   })
 }
 
-export const invoke = (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)
-    transport.send({
+    ipc.send({
       jsonrpc: '2.0',
       method,
       params,

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

@@ -10,7 +10,7 @@ const open = (socket, id, path) => {
   console.log({path})
   Assert.object(socket)
   // Assert.string(id)
-  Assert.string(path )
+  Assert.string(path)
   if (!socket) {
     console.warn('socket not available')
     return

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.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/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/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/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,6 +1,6 @@
 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)
@@ -24,7 +24,7 @@ const create = (socket, id, cwd) => {
   Terminal.create(socket, id, cwd)
 }
 
-const write = ( id, input) => {
+const write = (id, input) => {
   console.log({ id, input})
   Terminal.write(id, input)
 }

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/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/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,9 +25,9 @@ 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)

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

package/src/parts/ExtensionHost/ExtensionHostHover.js

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

package/src/parts/ExtensionHost/ExtensionHostImplementation.js

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

package/src/parts/ExtensionHost/ExtensionHostManagement.js

@@ -1,26 +0,0 @@
-import * as Debug from '../Debug/Debug.js'
-
-export const didInstallExtension = (extensionHost, extension) => {
-  return extensionHost.invoke('didInstallExtension', extension)
-}
-
-export const didUninstallExtension = (extensionHost, extension) => {
-  return extensionHost.invoke('didUninstallExtension', extension)
-}
-
-export const disableExtension = (extensionHost, extension) => {
-  return extensionHost.invoke('disableExtension', extension)
-}
-
-// TODO have enableExtensionsCommand to avoid sending too many messages via ipc -> only send one ipc message to enable multiple extensions
-export const enableExtension = async (extensionHost, extension) => {
-  Debug.debug(`ExtensionHost#enableExtension ${extension.id}`)
-  await extensionHost.invoke('enableExtension', extension)
-}
-
-export const activateAll = async (extensions) => {
-  // console.log({ extensions })
-  const results = await Promise.allSettled(extensions.map(enableExtension))
-  // console.log({ results })
-  return results
-}

package/src/parts/ExtensionHost/ExtensionHostOutput.js

@@ -1,3 +0,0 @@
-export const getOutputChannels = (extensionHost) => {
-  return extensionHost.invoke('OutputChannel.getOutputChannels')
-}

package/src/parts/ExtensionHost/ExtensionHostQuickPick.js

@@ -1,6 +0,0 @@
-export const handleQuickPickResult = (extensionHost, index) => {
-  return extensionHost.invoke(
-    'ExtensionHostQuickPick.handleQuickPickResult',
-    index
-  )
-}

package/src/parts/ExtensionHost/ExtensionHostReference.js

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

package/src/parts/ExtensionHost/ExtensionHostRename.js

@@ -1,27 +0,0 @@
-export const executePrepareRename = async (
-  extensionHost,
-  documentId,
-  offset
-) => {
-  const result = await extensionHost.invoke(
-    'Rename.executePrepareRename',
-    documentId,
-    offset
-  )
-  return result
-}
-
-export const executeRename = async (
-  extensionHost,
-  documentId,
-  offset,
-  newName
-) => {
-  const result = await extensionHost.invoke(
-    'Rename.executeRename',
-    documentId,
-    offset,
-    newName
-  )
-  return result
-}

package/src/parts/ExtensionHost/ExtensionHostSemanticTokens.js

@@ -1,10 +0,0 @@
-export const executeSemanticTokenProvider = async (
-  extensionHost,
-  documentId
-) => {
-  const semanticTokens = await extensionHost.invoke(
-    'SemanticTokens.execute',
-    documentId
-  )
-  return semanticTokens
-}

package/src/parts/ExtensionHost/ExtensionHostSourceControl.js

@@ -1,15 +0,0 @@
-export const sourceControlAcceptInput = (extensionHost, text) => {
-  return extensionHost.invoke('SourceControl.acceptInput', text)
-}
-
-export const getSourceControlChangedFiles = async (extensionHost) => {
-  const changedFiles = await extensionHost.invoke(
-    'getSourceControlChangedFiles'
-  )
-  return changedFiles
-}
-
-export const getSourceControlBadgeCount = async (extensionHost) => {
-  const count = await extensionHost.invoke('getSourceControlBadgeCount')
-  return count
-}

package/src/parts/ExtensionHost/ExtensionHostStats.js

@@ -1,3 +0,0 @@
-export const getMemoryUsage = (extensionHost) => {
-  return extensionHost.invoke('getMemoryUsage')
-}