@lvce-editor/shared-process 0.0.26 → 0.0.29

package/src/parts/ExtensionHost/ExtensionHost.js

@@ -1,163 +1,84 @@
 import VError from 'verror'
+import * as Assert from '../Assert/Assert.js'
 import * as Callback from '../Callback/Callback.js'
-import * as ChildProcess from '../ChildProcess/ChildProcess.js'
-import * as Error from '../Error/Error.js'
+import * as ExtensionHostIpc from '../ExtensionHostIpc/ExtensionHostIpc.js'
+import * as ExtensionHostRpc from '../ExtensionHostRpc/ExtensionHostRpc.js'
 import * as JsonRpc from '../JsonRpc/JsonRpc.js'
-import * as Platform from '../Platform/Platform.js'
-import * as Socket from '../Socket/Socket.js'
-import * as Assert from '../Assert/Assert.js'
-// TODO maybe rename to extension host management for clarity
 
-// TODO needed? probably not
-const NULL_EXTENSION_HOST = {
-  dispose() {
-    throw new VError('not implemented')
-  },
-  send(message) {
-    throw new VError(
-      'extension host must be started before commands can be invoked'
-    )
-  },
-  async invoke(commandId, ...args) {
-    throw new VError(
-      'extension host must be started before commands can be invoked'
-    )
-  },
-}
+// TODO maybe rename to extension host management for clarity
 
 /**
- * @type{{
- *   extensionHost: {dispose:()=>void, invoke:(commandId, ...args)=>Promise<any>},
- * }}
+ * @type{{extensionHosts:any }}
  */
 export const state = {
-  extensionHost: NULL_EXTENSION_HOST,
+  extensionHosts: Object.create(null),
 }
 
-const onMessage = (message) => {
-  if (message.id) {
-    if ('result' in message) {
-      Callback.resolve(message.id, message.result)
-    } else if ('error' in message) {
-      Callback.reject(
-        message.id,
-        new Error.OperationalError({
-          code: 'E_CALLBACK_REJECTED',
-          message: message.error.message,
-          stack: message.error.data.stack,
-          codeFrame: message.error.data.codeFrame,
-          // @ts-ignore
-          stderr: message.error.data.stderr,
-        })
-      )
-    } else {
-      Socket.send(message)
-    }
-  } else {
-    Socket.send(message)
-  }
+// TODO this function is very ugly and has probably memory leaks
+const createExtensionHost = async (socket) => {
+  Assert.object(socket)
+  const ipc = ExtensionHostIpc.create()
+  const rpc = ExtensionHostRpc.create(ipc, socket)
+  return rpc
 }
 
-// TODO this function is very ugly and has probably memory leaks
 export const start = async (socket) => {
   try {
-    Assert.object(socket)
-    const extensionHostPath = Platform.getExtensionHostPath()
-    const childProcess = ChildProcess.fork(extensionHostPath, {
-      execArgv: [
-        '--experimental-json-modules',
-        '--max-old-space-size=60',
-        '--enable-source-maps',
-      ],
-      env: {
-        ...process.env,
-        LOGS_DIR: Platform.getLogsDir(),
-        CONFIG_DIR: Platform.getConfigDir(),
-      },
-    })
-
-    const handleChildProcessError = (error) => {
-      console.error(`[Extension Host] ${error}`)
-    }
-
-    const handleChildProcessExit = (exitCode) => {
-      console.info(
-        `[SharedProcess] Extension Host exited with code ${exitCode}`
-      )
-      state.extensionHost = NULL_EXTENSION_HOST
-    }
-
-    const handleSocketClose = () => {
-      console.info('[shared process] disposing extension host')
-      childProcess.kill()
-    }
-
-    socket.on('close', handleSocketClose)
-
-    childProcess.on('error', handleChildProcessError)
-
-    childProcess.on('exit', handleChildProcessExit)
-
-    state.extensionHost = {
-      invoke(...args) {
-        return JsonRpc.invoke(childProcess, ...args)
-      },
-      dispose() {
-        childProcess.kill()
-      },
-    }
-
-    await new Promise((resolve, reject) => {
-      const handleFirstError = (error) => {
-        cleanup()
-        reject(error)
-      }
-      const handleFirstExit = (exitCode) => {
-        cleanup()
-        reject(
-          new globalThis.Error(`Extension Host exited with code ${exitCode}`)
-        )
+    const id = 1
+    console.log('start extension host', id)
+    const handleMessage = (message) => {
+      if ('result' in message) {
+        Callback.resolve(message.id, message.result)
+      } else if ('error' in message) {
+        Callback.reject(message.id, message.error)
+      } else {
+        console.error('unsupported message type')
       }
-      const handleFirstMessage = () => {
-        cleanup()
-        childProcess.on('message', onMessage)
-        resolve(undefined)
-      }
-      const handleSocketClose = () => {
-        cleanup()
-        childProcess.off('error', handleChildProcessError)
-        childProcess.off('exit', handleChildProcessExit)
-        resolve(undefined)
-      }
-      const cleanup = () => {
-        childProcess.off('error', handleFirstError)
-        childProcess.off('exit', handleFirstExit)
-        childProcess.off('message', handleFirstMessage)
-      }
-      childProcess.on('error', handleFirstError)
-      childProcess.on('exit', handleFirstExit)
-      childProcess.on('message', handleFirstMessage)
-      socket.on('close', handleSocketClose)
-    })
+    }
+    const extensionHost = await createExtensionHost(socket)
+    extensionHost.on('message', handleMessage)
+    state.extensionHosts[id] = extensionHost
+    return id
   } catch (error) {
     // @ts-ignore
     throw new VError(error, 'Failed to start extension host')
   }
 }
 
-export const stop = () => {
-  state.extensionHost.dispose()
-  state.extensionHost = NULL_EXTENSION_HOST
-}
-
-export const restart = () => {
-  stop()
-  start()
+export const send = async (socket, id, message) => {
+  Assert.number(id)
+  Assert.object(message)
+  console.log(Object.keys(state))
+  const extensionHost = state.extensionHosts[id]
+  if (!extensionHost) {
+    throw new VError(`no extension host with id ${id} found`)
+  }
+  try {
+    const result = await JsonRpc.invoke(
+      extensionHost,
+      message.method,
+      ...message.params
+    )
+    socket.send({
+      jsonrpc: '2.0',
+      id: message.id,
+      result,
+    })
+  } catch (error) {
+    // console.log({ error })
+    socket.send({
+      jsonrpc: '2.0',
+      id: message.id,
+      error,
+    })
+  }
 }
 
-export const wrapExtensionHostCommand = (fn) => {
-  const wrappedExtensionHostCommand = (...args) => {
-    return fn(state.extensionHost, ...args)
+export const dispose = (id) => {
+  const extensionHost = state.extensionHosts[id]
+  if (!extensionHost) {
+    throw new VError(`no extension host with id ${id} found`)
   }
-  return wrappedExtensionHostCommand
+  extensionHost.dispose()
+  delete state.extensionHosts[id]
 }

package/src/parts/ExtensionHostIpc/ExtensionHostIpc.js

@@ -0,0 +1,5 @@
+import * as ExtensionHostIpcWithChildProcess from './ExtensionHostIpcWithChildProcess.js'
+
+export const create = () => {
+  return ExtensionHostIpcWithChildProcess.create()
+}

package/src/parts/ExtensionHostIpc/ExtensionHostIpcWithChildProcess.js

@@ -0,0 +1,57 @@
+import * as ChildProcess from '../ChildProcess/ChildProcess.js'
+import * as Platform from '../Platform/Platform.js'
+
+export const create = () => {
+  const extensionHostPath = Platform.getExtensionHostPath()
+  const childProcess = ChildProcess.fork(extensionHostPath, {
+    execArgv: [
+      '--experimental-json-modules',
+      '--max-old-space-size=60',
+      '--enable-source-maps',
+    ],
+    env: {
+      ...process.env,
+      LOGS_DIR: Platform.getLogsDir(),
+      CONFIG_DIR: Platform.getConfigDir(),
+    },
+  })
+  return {
+    on(event, listener) {
+      switch (event) {
+        case 'message':
+          childProcess.on('message', listener)
+          break
+        case 'error':
+          childProcess.on('error', listener)
+          break
+        case 'exit':
+          childProcess.on('exit', listener)
+          break
+        default:
+          throw new Error(`unsupported event type ${event}`)
+      }
+    },
+    off(event, listener) {
+      switch (event) {
+        case 'message':
+          childProcess.off('message', listener)
+          break
+        case 'error':
+          childProcess.off('error', listener)
+          break
+        case 'exit':
+          childProcess.off('exit', listener)
+          break
+        default:
+          throw new Error(`unsupported event type ${event}`)
+      }
+    },
+    send(message) {
+      childProcess.send(message)
+    },
+    dispose() {
+      childProcess.kill()
+    },
+    _process: childProcess,
+  }
+}

package/src/parts/ExtensionHostIpc/ExtensionHostIpcWithWorker.js

@@ -0,0 +1,38 @@
+import { Worker } from 'node:worker_threads'
+import * as Platform from '../Platform/Platform.js'
+
+export const create = () => {
+  const extensionHostPath = Platform.getExtensionHostPath()
+  const child = new Worker(extensionHostPath, {
+    execArgv: [
+      '--experimental-json-modules',
+      '--max-old-space-size=60',
+      '--enable-source-maps',
+    ],
+    env: {
+      ...process.env,
+      LOGS_DIR: Platform.getLogsDir(),
+      CONFIG_DIR: Platform.getConfigDir(),
+    },
+  })
+  return {
+    on(event, listener) {
+      switch (event) {
+        case 'message':
+          child.on('message', listener)
+          break
+        case 'error':
+          child.on('error', listener)
+          break
+        default:
+          break
+      }
+    },
+    send(message) {
+      child.postMessage(message)
+    },
+    dispose() {
+      child.terminate()
+    },
+  }
+}

package/src/parts/ExtensionHostRpc/ExtensionHostRpc.js

@@ -0,0 +1,82 @@
+import VError from 'verror'
+import * as Assert from '../Assert/Assert.js'
+import * as Timeout from '../Timeout/Timeout.js'
+
+// TODO maybe rename to extension host management for clarity
+
+const CONNECTION_TIMEOUT = 1000
+
+export const create = async (ipc, socket) => {
+  Assert.object(socket)
+
+  const handleChildProcessError = (error) => {
+    console.error(`[Extension Host] ${error}`)
+  }
+
+  const handleChildProcessExit = (exitCode) => {
+    console.info(`[SharedProcess] Extension Host exited with code ${exitCode}`)
+  }
+
+  const handleSocketClose = () => {
+    console.info('[shared process] disposing extension host')
+    ipc.dispose()
+  }
+
+  socket.on('close', handleSocketClose)
+
+  ipc.on('error', handleChildProcessError)
+
+  ipc.on('exit', handleChildProcessExit)
+
+  await new Promise((resolve, reject) => {
+    const handleFirstError = (error) => {
+      cleanup()
+      reject(error)
+    }
+    const handleFirstExit = (exitCode) => {
+      cleanup()
+      reject(new VError(`Extension Host exited with code ${exitCode}`))
+    }
+    const handleFirstMessage = (message) => {
+      cleanup()
+      if (message === 'ready') {
+        resolve(undefined)
+      } else {
+        reject(new VError('Unexpected first message from extension host'))
+      }
+    }
+    const handleSocketClose = () => {
+      cleanup()
+      ipc.off('error', handleChildProcessError)
+      ipc.off('exit', handleChildProcessExit)
+      resolve(undefined)
+    }
+    const cleanup = () => {
+      ipc.off('error', handleFirstError)
+      ipc.off('exit', handleFirstExit)
+      ipc.off('message', handleFirstMessage)
+      clearTimeout(timeout)
+    }
+    const handleTimeout = () => {
+      cleanup()
+      reject(new VError('Extension host did not connect'))
+    }
+    const timeout = Timeout.setTimeout(handleTimeout, CONNECTION_TIMEOUT)
+    ipc.on('error', handleFirstError)
+    ipc.on('exit', handleFirstExit)
+    ipc.on('message', handleFirstMessage)
+    socket.on('close', handleSocketClose)
+  })
+
+  return {
+    on(event, listener) {
+      ipc.on(event, listener)
+    },
+    send(message) {
+      ipc.send(message)
+    },
+    dispose() {
+      ipc.dispose()
+    },
+  }
+}

package/src/parts/ExtensionManagement/ExtensionManagement.ipc.js

@@ -1,11 +1,19 @@
-import * as Command from '../Command/Command.js'
+import * as ExtensionHostIconTheme from '../ExtensionManagement/ExtensionManagementIconTheme.js'
 import * as ExtensionManagement from './ExtensionManagement.js'
+import * as ExtensionHostColorTheme from './ExtensionManagementColorTheme.js'
+import * as ExtensionHostLanguages from './ExtensionManagementLanguages.js'
 
-export const __initialize__ = () => {
-  Command.register('ExtensionManagement.install', ExtensionManagement.install)
-  Command.register('ExtensionManagement.uninstall', ExtensionManagement.uninstall)
-  Command.register('ExtensionManagement.enable', ExtensionManagement.enable)
-  Command.register('ExtensionManagement.disable', ExtensionManagement.disable)
-  Command.register('ExtensionManagement.getAllExtensions', ExtensionManagement.getAllExtensions)
-  Command.register('ExtensionManagement.getExtensions', ExtensionManagement.getExtensions)
+// prettier-ignore
+export const Commands = {
+  'ExtensionManagement.install': ExtensionManagement.install,
+  'ExtensionManagement.uninstall': ExtensionManagement.uninstall,
+  'ExtensionManagement.enable': ExtensionManagement.enable,
+  'ExtensionManagement.disable': ExtensionManagement.disable,
+  'ExtensionManagement.getAllExtensions': ExtensionManagement.getAllExtensions,
+  'ExtensionManagement.getExtensions': ExtensionManagement.getExtensions,
+  'ExtensionHost.getColorThemeJson': ExtensionHostColorTheme.getColorThemeJson,
+  'ExtensionHost.getColorThemeNames': ExtensionHostColorTheme.getColorThemeNames,
+  'ExtensionHost.getLanguages': ExtensionHostLanguages.getLanguages,
+  'ExtensionHost.getLanguageConfiguration': ExtensionHostLanguages.getLanguageConfiguration,
+  'ExtensionHost.getIconThemeJson': ExtensionHostIconTheme.getIconTheme,
 }

package/src/parts/ExtensionManagement/ExtensionManagement.js

@@ -1,5 +1,6 @@
 import { mkdir, readdir, rename, rm } from 'node:fs/promises'
 import { performance } from 'node:perf_hooks'
+import path from 'node:path'
 import isObject from 'is-object'
 import VError from 'verror'
 import * as Debug from '../Debug/Debug.js'
@@ -8,10 +9,12 @@ import * as ReadJson from '../JsonFile/JsonFile.js'
 import * as Path from '../Path/Path.js'
 import * as Platform from '../Platform/Platform.js'
 import * as Queue from '../Queue/Queue.js'
-import path from 'node:path'
 
 const isLanguageBasics = (extension) => {
-  return extension.id.includes('language-basics')
+  if (extension && extension.id) {
+    return extension.id.includes('language-basics')
+  }
+  return false
 }
 
 export const state = {

package/src/parts/{ExtensionHost/ExtensionHostColorTheme.js → ExtensionManagement/ExtensionManagementColorTheme.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'
 
 // TODO test this function
 // TODO very similar with getIconTheme

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.ipc.js

@@ -1,4 +1,3 @@
-import * as Command from '../Command/Command.js'
 import * as FileSystem from './FileSystem.js'
 
 // TODO ugly code here -> should be inside FileSystem.js
@@ -6,7 +5,6 @@ const fileSystemWatch = (socket, id, path) => {
   // const watcher = FileSystem.watch(path, {
   //   onAll(...args) {
   //     socket.send(JSON.stringify([/* callback */ id, /* event */ args]))
-
   //   }
   // }
   // )
@@ -16,17 +14,18 @@ const fileSystemWatch = (socket, id, path) => {
 }
 
 // TODO separate ipc from code like in renderer worker
-export const __initialize__ = () => {
-  Command.register('FileSystem.readFile', FileSystem.readFile)
-  Command.register('FileSystem.writeFile', FileSystem.writeFile)
-  Command.register('FileSystem.readDirWithFileTypes', FileSystem.readDirWithFileTypes)
-  Command.register('FileSystem.remove', FileSystem.remove)
-  Command.register('FileSystem.mkdir', FileSystem.mkdir)
-  // Command.register(106, fileSystemWatch) // TODO
-  Command.register('FileSystem.createFile', FileSystem.createFile)
-  Command.register('FileSystem.createFolder', FileSystem.createFolder)
-  Command.register('FileSystem.rename', FileSystem.rename)
-  Command.register('FileSystem.ensureFile', FileSystem.ensureFile)
-  Command.register('FileSystem.copy', FileSystem.copy)
-  Command.register('FileSystem.getPathSeparator', FileSystem.getPathSeparator)
+export const Commands = {
+  'FileSystem.copy': FileSystem.copy,
+  'FileSystem.createFile': FileSystem.createFile,
+  'FileSystem.createFolder': FileSystem.createFolder,
+  'FileSystem.ensureFile': FileSystem.ensureFile,
+  'FileSystem.getPathSeparator': FileSystem.getPathSeparator,
+  'FileSystem.getRealPath': FileSystem.getRealPath,
+  'FileSystem.mkdir': FileSystem.mkdir,
+  'FileSystem.readDirWithFileTypes': FileSystem.readDirWithFileTypes,
+  'FileSystem.readFile': FileSystem.readFile,
+  'FileSystem.remove': FileSystem.remove,
+  'FileSystem.rename': FileSystem.rename,
+  'FileSystem.stat': FileSystem.stat,
+  'FileSystem.writeFile': FileSystem.writeFile,
 }

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({
@@ -135,6 +147,9 @@ export const exists = async (path) => {
   }
 }
 
+/**
+ * @param {import('fs').Dirent|import('fs').StatsBase} dirent
+ */
 const getType = (dirent) => {
   if (dirent.isFile()) {
     return 'file'
@@ -142,9 +157,24 @@ const getType = (dirent) => {
   if (dirent.isDirectory()) {
     return 'directory'
   }
+  if (dirent.isSymbolicLink()) {
+    return 'symlink'
+  }
+  if (dirent.isSocket()) {
+    return 'socket'
+  }
+  if (dirent.isBlockDevice()) {
+    return 'block-device'
+  }
+  if (dirent.isCharacterDevice()) {
+    return 'character-device'
+  }
   return 'unknown'
 }
 
+/**
+ * @param {import('fs').Dirent} dirent
+ */
 const toPrettyDirent = (dirent) => {
   return {
     name: dirent.name,
@@ -212,6 +242,31 @@ export const getPathSeparator = () => {
   return Platform.getPathSeparator()
 }
 
+export const getRealPath = async (path) => {
+  try {
+    return await fs.realpath(path)
+  } catch (error) {
+    // @ts-ignore
+    if (error && error instanceof globalThis.Error && error.code === 'ENOENT') {
+      let content
+      try {
+        content = await fs.readlink(path)
+      } catch {
+        throw new VError(error, `Failed to resolve real path for ${path}`)
+      }
+      throw new VError(`Broken symbolic link: File not found ${content}`)
+    }
+    throw new VError(error, `Failed to resolve real path for ${path}`)
+  }
+}
+
+export const stat = async (path) => {
+  const stats = await fs.stat(path)
+  const type = getType(stats)
+  return type
+}
+
+// getRealPath('/home/simon/Documents/levivilet/lvce-editor/node_modules/.bin/abc') //?
 // export const unwatch = (id) => {
 //   state.watchers[id].close()
 //   delete state.watchers[id]

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/Native/Native.ipc.js

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