@lvce-editor/extension-host-helper-process 0.11.2

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022-present, Le Vivilet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/index.js

@@ -0,0 +1,10 @@
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+export const extensionHostHelperProcessPath = join(
+  __dirname,
+  'src',
+  'extensionHostHelperProcessMain.js'
+)

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@lvce-editor/extension-host-helper-process",
+  "version": "0.11.2",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lvce-editor/lvce-editor.git",
+    "directory": "packages/extension-host-helper-process"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "dependencies": {
+    "execa": "^6.1.0",
+    "ws": "^8.11.0"
+  }
+}

package/src/extensionHostHelperProcessMain.js

@@ -0,0 +1,10 @@
+import * as IpcChild from './parts/IpcChild/IpcChild.js'
+import * as IpcChildType from './parts/IpcChildType/IpcChildType.js'
+import * as Rpc from './parts/Rpc/Rpc.js'
+
+const main = async () => {
+  const ipc = await IpcChild.listen({ method: IpcChildType.Auto() })
+  Rpc.listen(ipc)
+}
+
+main()

package/src/parts/Assert/Assert.js

@@ -0,0 +1,64 @@
+class AssertionError extends Error {
+  constructor(message) {
+    super(message)
+    this.name = 'AssertionError'
+  }
+}
+
+const getType = (value) => {
+  switch (typeof value) {
+    case 'number':
+      return 'number'
+    case 'function':
+      return 'function'
+    case 'string':
+      return 'string'
+    case 'object':
+      if (value === null) {
+        return 'null'
+      }
+      if (Array.isArray(value)) {
+        return 'array'
+      }
+      return 'object'
+    case 'boolean':
+      return 'boolean'
+    default:
+      return 'unknown'
+  }
+}
+
+export const object = (value) => {
+  const type = getType(value)
+  if (type !== 'object') {
+    throw new AssertionError('expected value to be of type object')
+  }
+}
+
+export const number = (value) => {
+  const type = getType(value)
+  if (type !== 'number') {
+    throw new AssertionError('expected value to be of type number')
+  }
+}
+
+export const array = (value) => {
+  const type = getType(value)
+  if (type !== 'array') {
+    throw new AssertionError('expected value to be of type array')
+  }
+}
+
+export const string = (value) => {
+  const type = getType(value)
+  if (type !== 'string') {
+    throw new AssertionError('expected value to be of type string')
+  }
+}
+
+export const boolean = (value) => {
+  const type = getType(value)
+  if (type !== 'boolean') {
+    throw new AssertionError('expected value to be of type boolean')
+  }
+}

package/src/parts/Command/Command.js

@@ -0,0 +1,82 @@
+import * as Module from '../Module/Module.js'
+import * as ModuleMap from '../ModuleMap/ModuleMap.js'
+
+const commands = Object.create(null)
+const pendingModules = Object.create(null)
+
+const initializeModule = (module) => {
+  if (module.Commands) {
+    for (const [key, value] of Object.entries(module.Commands)) {
+      if (module.name) {
+        const actualKey = `${module.name}.${key}`
+        register(actualKey, value)
+      } else {
+        register(key, value)
+      }
+    }
+    return
+  }
+  throw new Error(`module ${module.name} is missing commands`)
+}
+
+const getOrLoadModule = (moduleId) => {
+  if (!pendingModules[moduleId]) {
+    const importPromise = Module.load(moduleId)
+    pendingModules[moduleId] = importPromise
+      .then(initializeModule)
+      .catch((error) => {
+        console.error(error)
+      })
+  }
+  return pendingModules[moduleId]
+}
+
+const loadCommand = (command) => getOrLoadModule(ModuleMap.getModuleId(command))
+
+export const register = (commandId, listener) => {
+  commands[commandId] = listener
+}
+
+export const invoke = async (command, ...args) => {
+  if (!(command in commands)) {
+    await loadCommand(command)
+    if (!(command in commands)) {
+      console.warn(
+        `[extension host helper process] Unknown command "${command}"`
+      )
+      throw new Error(`Command ${command} not found`)
+    }
+  }
+  if (typeof commands[command] !== 'function') {
+    throw new TypeError(`Command ${command} is not a function`)
+  }
+  return commands[command](...args)
+}
+
+export const execute = (command, ...args) => {
+  if (command in commands) {
+    return commands[command](...args)
+  } else {
+    return (
+      loadCommand(command)
+        // TODO can skip then block in prod (only to prevent endless loop in dev)
+        .then(() => {
+          if (!(command in commands)) {
+            console.warn(`Unknown command "${command}"`)
+            return
+          }
+          try {
+            execute(command, ...args)
+          } catch (error) {
+            console.error(
+              '[extension host helper process] command failed to execute'
+            )
+            console.error(error)
+          }
+        })
+        .catch((error) => {
+          console.error(error)
+        })
+    )
+  }
+}

package/src/parts/CreateProcessIpc/CreateProcessIpc.js

@@ -0,0 +1,16 @@
+export const createProcessIpc = (process) => {
+  return {
+    send(message) {
+      process.send(message)
+    },
+    on(event, listener) {
+      switch (event) {
+        case 'message':
+          process.on('message', listener)
+          break
+        default:
+          throw new Error('unknown event listener type')
+      }
+    },
+  }
+}

package/src/parts/CreateWebSocketIpc/CreateWebSocketIpc.js

@@ -0,0 +1,23 @@
+import * as Json from '../Json/Json.js'
+
+export const createWebSocketIpc = (webSocket) => {
+  return {
+    send(message) {
+      const stringifiedMessage = Json.stringify(message)
+      webSocket.send(stringifiedMessage)
+    },
+    on(event, listener) {
+      switch (event) {
+        case 'message':
+          const wrappedListener = (message) => {
+            const parsed = Json.parse(message.toString())
+            listener(parsed)
+          }
+          webSocket.on('message', wrappedListener)
+          break
+        default:
+          throw new Error('unknown event listener type')
+      }
+    },
+  }
+}

package/src/parts/Exec/Exec.ipc.js

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

package/src/parts/Exec/Exec.js

@@ -0,0 +1,13 @@
+import { execa } from 'execa'
+import * as Assert from '../Assert/Assert.js'
+
+export const exec = async (file, args, options) => {
+  Assert.string(file)
+  Assert.array(args)
+  const { stdout, stderr, exitCode } = await execa(file, args, options)
+  return {
+    stdout,
+    stderr,
+    exitCode,
+  }
+}

package/src/parts/GetWebSocket/GetWebSocket.js

@@ -0,0 +1,25 @@
+import * as _ws from 'ws'
+
+export const getWebSocket = async (message, handle) => {
+  // workaround for jest or node bug
+  const WebSocketServer = _ws.WebSocketServer
+    ? _ws.WebSocketServer
+    : // @ts-ignore
+      _ws.default.WebSocketServer
+
+  const webSocketServer = new WebSocketServer({
+    noServer: true,
+  })
+  const webSocket = await new Promise((resolve, reject) => {
+    const upgradeCallback = (webSocket) => {
+      resolve(webSocket)
+    }
+    webSocketServer.handleUpgrade(
+      message,
+      handle,
+      Buffer.alloc(0),
+      upgradeCallback
+    )
+  })
+  return webSocket
+}

package/src/parts/IpcChild/IpcChild.js

@@ -0,0 +1,21 @@
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+const getModule = (method) => {
+  switch (method) {
+    case IpcChildType.MessagePort:
+      return import('./IpcChildWithMessagePort.js')
+    case IpcChildType.WebSocket:
+      return import('./IpcChildWithWebSocket.js')
+    case IpcChildType.Parent:
+      return import('./IpcChildWithParent.js')
+    case IpcChildType.ElectronMessagePort:
+      return import('./IpcChildWithElectronMessagePort.js')
+    default:
+      throw new Error('unexpected ipc type')
+  }
+}
+
+export const listen = async ({ method }) => {
+  const module = await getModule(method)
+  return module.listen()
+}

package/src/parts/IpcChild/IpcChildWithElectronMessagePort.js

@@ -0,0 +1,11 @@
+import { once } from 'events'
+
+export const listen = async () => {
+  // const [message, handle] = await once(process, 'message')
+  // console.log({ message, handle })
+  // if (process.send) {
+  //   process.send('ready')
+  // }
+  // return {
+  // }
+}

package/src/parts/IpcChild/IpcChildWithMessagePort.js

@@ -0,0 +1,4 @@
+export const listen = () => {
+  // TODO wait for electron message port to be passed in
+  return {}
+}

package/src/parts/IpcChild/IpcChildWithParent.js

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

package/src/parts/IpcChild/IpcChildWithWebSocket.js

@@ -0,0 +1,10 @@
+import { once } from 'events'
+import * as CreateWebSocketIpc from '../CreateWebSocketIpc/CreateWebSocketIpc.js'
+import * as GetWebSocket from '../GetWebSocket/GetWebSocket.js'
+
+export const listen = async () => {
+  const [message, handle] = await once(process, 'message')
+  const webSocket = await GetWebSocket.getWebSocket(message, handle)
+  const ipc = CreateWebSocketIpc.createWebSocketIpc(webSocket)
+  return ipc
+}

package/src/parts/IpcChildType/IpcChildType.js

@@ -0,0 +1,21 @@
+export const WebSocket = 1
+export const MessagePort = 2
+export const Parent = 3
+export const ElectronMessagePort = 4
+
+export const Auto = () => {
+  const { argv } = process
+  if (argv.includes('--ipc-type=websocket')) {
+    return WebSocket
+  }
+  if (argv.includes('--ipc-type=message-port')) {
+    return MessagePort
+  }
+  if (argv.includes('--ipc-type=parent')) {
+    return Parent
+  }
+  if (argv.includes('--ipc-type=electron-message-port')) {
+    return ElectronMessagePort
+  }
+  throw new Error('[extension-host-helper-process] unknown ipc type')
+}

package/src/parts/Json/Json.js

@@ -0,0 +1,7 @@
+export const stringify = (json) => {
+  return JSON.stringify(json)
+}
+
+export const parse = (data) => {
+  return JSON.parse(data)
+}

package/src/parts/JsonRpc/JsonRpc.js

@@ -0,0 +1,3 @@
+export const Version = '2.0'
+
+export const ErrorMethodNotFound = -32601

package/src/parts/Module/Module.js

@@ -0,0 +1,10 @@
+import * as ModuleId from '../ModuleId/ModuleId.js'
+
+export const load = (moduleId) => {
+  switch (moduleId) {
+    case ModuleId.Exec:
+      return import('../Exec/Exec.ipc.js')
+    default:
+      throw new Error(`module ${moduleId} not found`)
+  }
+}

package/src/parts/ModuleId/ModuleId.js

@@ -0,0 +1 @@
+export const Exec = 1

package/src/parts/ModuleMap/ModuleMap.js

@@ -0,0 +1,10 @@
+import * as ModuleId from '../ModuleId/ModuleId.js'
+
+export const getModuleId = (commandId) => {
+  switch (commandId) {
+    case 'Exec.exec':
+      return ModuleId.Exec
+    default:
+      throw new Error(`command ${commandId} not found`)
+  }
+}

package/src/parts/Rpc/Rpc.js

@@ -0,0 +1,48 @@
+import * as Command from '../Command/Command.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
+const getResponse = async (message) => {
+  try {
+    const result = await Command.invoke(message.method, ...message.params)
+    return {
+      jsonrpc: JsonRpc.Version,
+      id: message.id,
+      result,
+    }
+  } catch (error) {
+    if (
+      error &&
+      error instanceof Error &&
+      error.message &&
+      error.message.startsWith('method not found')
+    ) {
+      return {
+        jsonrpc: JsonRpc.Version,
+        id: message.id,
+        error: {
+          code: JsonRpc.ErrorMethodNotFound,
+          message: error.message,
+          data: error.stack,
+        },
+      }
+    }
+    return {
+      jsonrpc: JsonRpc.Version,
+      id: message.id,
+      error,
+    }
+  }
+}
+export const listen = (ipc) => {
+  const handleMessage = async (message) => {
+    if ('method' in message) {
+      const response = await getResponse(message)
+      console.log({ response })
+      ipc.send(response)
+    }
+  }
+  ipc.on('message', handleMessage)
+  if (process.send) {
+    process.send('ready')
+  }
+}