@lvce-editor/shared-process 0.14.15 → 0.15.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.14.15",
+  "version": "0.15.1",
   "description": "Utility package for @lvce-editor/server",
   "main": "index.js",
   "type": "module",
@@ -17,9 +17,9 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.21.4",
-    "@lvce-editor/extension-host": "0.14.15",
-    "@lvce-editor/extension-host-helper-process": "0.14.15",
-    "@lvce-editor/pty-host": "0.14.15",
+    "@lvce-editor/extension-host": "0.15.1",
+    "@lvce-editor/extension-host-helper-process": "0.15.1",
+    "@lvce-editor/pty-host": "0.15.1",
     "debug": "^4.3.4",
     "execa": "^7.1.1",
     "exit-hook": "^3.2.0",
@@ -28,7 +28,7 @@
     "lines-and-columns": "^2.0.3",
     "open": "^9.1.0",
     "p-queue": "^7.3.4",
-    "parse-json": "^6.0.2",
+    "parse-json": "^7.0.0",
     "symlink-dir": "^5.1.1",
     "tail": "^2.2.6",
     "tar-fs": "^2.1.1",

package/src/parts/ChildProcessError/ChildProcessError.js

@@ -1,45 +1,9 @@
-import * as SplitLines from '../SplitLines/SplitLines.js'
-
-const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/
-const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/
-
-const RE_MASSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/
-const RE_MASSAGE_CODE_BLOCK_END = /^\s* at/
-
-const isUnhelpfulNativeModuleError = (stderr) => {
-  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr)
-}
-
-const isMessageCodeBlockStartIndex = (line) => {
-  return RE_MASSAGE_CODE_BLOCK_START.test(line)
-}
-
-const isMessageCodeBlockEndIndex = (line) => {
-  return RE_MASSAGE_CODE_BLOCK_END.test(line)
-}
-
-const getMessageCodeBlock = (stderr) => {
-  const lines = SplitLines.splitLines(stderr)
-  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex)
-  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex)
-  const relevantLines = lines.slice(startIndex, endIndex)
-  const relevantMessage = relevantLines.join(' ').slice('Error: '.length)
-  return relevantMessage
-}
-
-const getNativeModuleErrorMessage = (stderr) => {
-  const message = getMessageCodeBlock(stderr)
-  return `incompatible native node module: ${message}`
-}
+import * as GetHelpfulChildProcessError from '../GetHelpfulChildProcessError/GetHelpfulChildProcessError.js'
 
 export class ChildProcessError extends Error {
   constructor(stderr) {
-    if (isUnhelpfulNativeModuleError(stderr)) {
-      const message = getNativeModuleErrorMessage(stderr)
-      super(message)
-    } else {
-      super('child process error')
-    }
+    const message = GetHelpfulChildProcessError.getHelpfulChildProcessError('', stderr)
+    super(message)
     this.name = 'ChildProcessError'
   }
 }

package/src/parts/DownloadAndExtract/DownloadAndExtract.js

@@ -14,9 +14,7 @@ export const downloadAndExtractTarGz = async ({ url, outDir, strip }) => {
       })
     )
   } catch (error) {
-    // console.log({ error })
     if (error && error instanceof RequestError) {
-      console.log('is req error')
       throw new VError(`Failed to download ${url}: ${error.message}`)
     }
     throw error

package/src/parts/ExtensionHostIpc/ExtensionHostIpc.js

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

package/src/parts/GetErrorResponse/GetErrorResponse.js

@@ -0,0 +1,55 @@
+import { CommandNotFoundError } from '../CommandNotFoundError/CommandNotFoundError.js'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as JsonRpcErrorCode from '../JsonRpcErrorCode/JsonRpcErrorCode.js'
+import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+import * as PrettyError from '../PrettyError/PrettyError.js'
+import * as PrintPrettyError from '../PrintPrettyError/PrintPrettyError.js'
+
+const shouldLogError = (error) => {
+  if (error && error.code === ErrorCodes.ENOENT) {
+    return false
+  }
+  return true
+}
+
+export const getErrorResponse = (message, error) => {
+  if (error && error instanceof CommandNotFoundError) {
+    return {
+      jsonrpc: JsonRpcVersion.Two,
+      id: message.id,
+      error: {
+        code: JsonRpcErrorCode.MethodNotFound,
+        message: error.message,
+        data: error.stack,
+      },
+    }
+  }
+  if (!shouldLogError(error)) {
+    return {
+      jsonrpc: JsonRpcVersion.Two,
+      id: message.id,
+      error: {
+        code: JsonRpcErrorCode.Custom,
+        message: `${error}`,
+        data: {
+          code: error.code,
+        },
+      },
+    }
+  }
+  const prettyError = PrettyError.prepare(error)
+  PrintPrettyError.printPrettyError(prettyError, `[shared-process] `)
+  return {
+    jsonrpc: JsonRpcVersion.Two,
+    id: message.id,
+    error: {
+      code: JsonRpcErrorCode.Custom,
+      message: prettyError.message,
+      data: {
+        stack: prettyError.stack,
+        codeFrame: prettyError.codeFrame,
+        type: prettyError.type,
+      },
+    },
+  }
+}

package/src/parts/GetFirstNodeChildProcessEvent/GetFirstNodeChildProcessEvent.js

@@ -4,12 +4,13 @@ export const getFirstNodeChildProcessEvent = async (childProcess) => {
   const { type, event, stdout, stderr } = await new Promise((resolve, reject) => {
     let stderr = ''
     let stdout = ''
-    const cleanup = () => {
+    const cleanup = (value) => {
       childProcess.stderr.off('data', handleStdErrData)
       childProcess.stdout.off('data', handleStdoutData)
       childProcess.off('message', handleMessage)
       childProcess.off('exit', handleExit)
       childProcess.off('error', handleError)
+      resolve(value)
     }
     const handleStdErrData = (data) => {
       stderr += data
@@ -18,16 +19,13 @@ export const getFirstNodeChildProcessEvent = async (childProcess) => {
       stdout += data
     }
     const handleMessage = (event) => {
-      cleanup()
-      resolve({ type: FirstNodeWorkerEventType.Message, event, stdout, stderr })
+      cleanup({ type: FirstNodeWorkerEventType.Message, event, stdout, stderr })
     }
     const handleExit = (event) => {
-      cleanup()
-      resolve({ type: FirstNodeWorkerEventType.Exit, event, stdout, stderr })
+      cleanup({ type: FirstNodeWorkerEventType.Exit, event, stdout, stderr })
     }
     const handleError = (event) => {
-      cleanup()
-      resolve({ type: FirstNodeWorkerEventType.Error, event, stdout, stderr })
+      cleanup({ type: FirstNodeWorkerEventType.Error, event, stdout, stderr })
     }
     childProcess.stderr.on('data', handleStdErrData)
     childProcess.stdout.on('data', handleStdoutData)

package/src/parts/GetFirstNodeWorkerEvent/GetFirstNodeWorkerEvent.js

@@ -2,17 +2,16 @@ import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNode
 
 export const getFirstNodeWorkerEvent = async (worker) => {
   const { type, event } = await new Promise((resolve, reject) => {
-    const cleanup = () => {
+    const cleanup = (value) => {
       worker.off('exit', handleExit)
       worker.off('error', handleError)
+      resolve(value)
     }
     const handleExit = (event) => {
-      cleanup()
-      resolve({ type: FirstNodeWorkerEventType.Exit, event })
+      cleanup({ type: FirstNodeWorkerEventType.Exit, event })
     }
     const handleError = (event) => {
-      cleanup()
-      resolve({ type: FirstNodeWorkerEventType.Error, event })
+      cleanup({ type: FirstNodeWorkerEventType.Error, event })
     }
     worker.on('exit', handleExit)
     worker.on('error', handleError)

package/src/parts/GetHelpfulChildProcessError/GetHelpfulChildProcessError.js

@@ -0,0 +1,54 @@
+import * as SplitLines from '../SplitLines/SplitLines.js'
+
+const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/
+const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/
+
+const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/
+const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/
+
+const isUnhelpfulNativeModuleError = (stderr) => {
+  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr)
+}
+
+const isMessageCodeBlockStartIndex = (line) => {
+  return RE_MESSAGE_CODE_BLOCK_START.test(line)
+}
+
+const isMessageCodeBlockEndIndex = (line) => {
+  return RE_MESSAGE_CODE_BLOCK_END.test(line)
+}
+
+const getMessageCodeBlock = (stderr) => {
+  const lines = SplitLines.splitLines(stderr)
+  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex)
+  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex)
+  const relevantLines = lines.slice(startIndex, endIndex)
+  const relevantMessage = relevantLines.join(' ').slice('Error: '.length)
+  return relevantMessage
+}
+
+const getNativeModuleErrorMessage = (stderr) => {
+  const message = getMessageCodeBlock(stderr)
+  return `incompatible native node module: ${message}`
+}
+
+const isModulesSyntaxError = (stderr) => {
+  if (!stderr) {
+    return false
+  }
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module')
+}
+
+const getModuleSyntaxError = (stderr) => {
+  return `ES Modules are not supported in electron`
+}
+
+export const getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(stderr)
+  }
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError(stderr)
+  }
+  return 'child process error'
+}

package/src/parts/GetResponse/GetResponse.js

@@ -1,68 +1,15 @@
 import * as Command from '../Command/Command.js'
-import { CommandNotFoundError } from '../CommandNotFoundError/CommandNotFoundError.js'
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-import * as JsonRpcErrorCode from '../JsonRpcErrorCode/JsonRpcErrorCode.js'
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
-import * as PrettyError from '../PrettyError/PrettyError.js'
-import * as PrintPrettyError from '../PrintPrettyError/PrintPrettyError.js'
+import * as GetErrorResponse from '../GetErrorResponse/GetErrorResponse.js'
+import * as GetSuccessResponse from '../GetSuccessResponse/GetSuccessResponse.js'
 import * as RequiresSocket from '../RequiresSocket/RequiresSocket.js'
 
-const shouldLogError = (error) => {
-  if (error && error.code === ErrorCodes.ENOENT) {
-    return false
-  }
-  return true
-}
-
 export const getResponse = async (message, handle) => {
   try {
     const result = RequiresSocket.requiresSocket(message.method)
       ? await Command.execute(message.method, handle, ...message.params)
       : await Command.execute(message.method, ...message.params)
-    return {
-      jsonrpc: JsonRpcVersion.Two,
-      id: message.id,
-      result: result ?? null,
-    }
+    return GetSuccessResponse.getSuccessResponse(message, result)
   } catch (error) {
-    if (error && error instanceof CommandNotFoundError) {
-      return {
-        jsonrpc: JsonRpcVersion.Two,
-        id: message.id,
-        error: {
-          code: JsonRpcErrorCode.MethodNotFound,
-          message: error.message,
-          data: error.stack,
-        },
-      }
-    }
-    if (!shouldLogError(error)) {
-      return {
-        jsonrpc: JsonRpcVersion.Two,
-        id: message.id,
-        error: {
-          code: JsonRpcErrorCode.Custom,
-          message: `${error}`,
-          data: {
-            code: error.code,
-          },
-        },
-      }
-    }
-    const prettyError = PrettyError.prepare(error)
-    PrintPrettyError.printPrettyError(prettyError, `[shared-process] `)
-    return {
-      jsonrpc: JsonRpcVersion.Two,
-      id: message.id,
-      error: {
-        code: JsonRpcErrorCode.Custom,
-        message: prettyError.message,
-        data: {
-          stack: prettyError.stack,
-          codeFrame: prettyError.codeFrame,
-          type: prettyError.type,
-        },
-      },
-    }
+    return GetErrorResponse.getErrorResponse(message, error)
   }
 }

package/src/parts/GetSuccessResponse/GetSuccessResponse.js

@@ -0,0 +1,9 @@
+import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+
+export const getSuccessResponse = (message, result) => {
+  return {
+    jsonrpc: JsonRpcVersion.Two,
+    id: message.id,
+    result: result ?? null,
+  }
+}

package/src/parts/ParentIpc/ParentIpc.js

@@ -7,6 +7,7 @@ import * as ExtensionHostHelperProcessIpc from '../ExtensionHostHelperProcessIpc
 import * as ExtensionHostIpc from '../ExtensionHostIpc/ExtensionHostIpc.js'
 import * as ExtensionHostRpc from '../ExtensionHostRpc/ExtensionHostRpc.js'
 import * as GetResponse from '../GetResponse/GetResponse.js'
+import * as Logger from '../Logger/Logger.js'
 import * as ProtocolType from '../ProtocolType/ProtocolType.js'
 import { VError } from '../VError/VError.js'
 // TODO add tests for this
@@ -63,6 +64,15 @@ const handleWebSocketExtensionHostHelperProcess = async (message, handle) => {
   ipc._process.send(message, handle)
 }
 
+const handleWebSocketUnknown = (message, handle, protocol) => {
+  Logger.warn(`[shared-process] unsupported sec-websocket-procotol ${protocol}`)
+  try {
+    handle.destroy()
+  } catch {
+    // ignore
+  }
+}
+
 const handleWebSocket = (message, handle) => {
   const headers = message.headers
   if (!headers) {
@@ -80,7 +90,7 @@ const handleWebSocket = (message, handle) => {
     case ProtocolType.ExtensionHostHelperProcess:
       return handleWebSocketExtensionHostHelperProcess(message, handle)
     default:
-      console.warn(`unsupported sec-websocket-procotol ${protocol}`)
+      return handleWebSocketUnknown(message, handle, protocol)
   }
 }