@lvce-editor/shared-process 0.15.16 → 0.15.18

package/config/builtinCommands.json

@@ -226,6 +226,14 @@
     "id": "Developer.toggleDeveloperTools",
     "label": "Developer: Toggle Developer Tools"
   },
+  {
+    "id": "RebuildNodePty.rebuildNodePty",
+    "label": "Developer: Rebuild Node Pty"
+  },
+  {
+    "id": "DebugSharedProcess.debugSharedProcess",
+    "label": "Developer: Debug Shared Process"
+  },
   {
     "id": "Window.reload",
     "label": "Window: Reload",

package/config/defaultSettings.json

@@ -38,6 +38,8 @@
 
   "simpleBrowser.suggestions": false,
 
+  "terminal.separateConnection": false,
+
   "window.titleBarStyle": "native",
   "window.zoomLevel": 0,
   "window.controlsOverlay.enabled": true,

package/extensions/builtin.language-basics-python/extension.json

@@ -6,7 +6,7 @@
     {
       "id": "python",
       "extensions": [".py"],
-      "fileNames": ["SCsub"],
+      "fileNames": ["SCsub", "SConstruct"],
       "configuration": "./languageConfiguration.json",
       "tokenize": "src/tokenizePython.js",
       "firstLine": "^#!\\s*/?.*\\bpython[0-9.-]*\\b"

package/extensions/builtin.language-basics-xml/extension.json

@@ -72,7 +72,8 @@
         ".tmtheme",
         ".mm",
         ".tmDragCommand",
-        ".tmCommand"
+        ".tmCommand",
+        ".natvis"
       ],
       "fileNames": [".project", "resources.grd"],
       "tokenize": "src/tokenizeXml.js"

package/extensions/builtin.language-basics-xml/src/tokenizeXml.js

@@ -81,7 +81,7 @@ const RE_SLASH = /^\//
 const RE_STRING_DOUBLE_QUOTE_CONTENT = /^[^"]+/
 const RE_STRING_SINGLE_QUOTE_CONTENT = /^[^']+/
 const RE_TAG_TEXT = /^[^\s>]+/
-const RE_TAGNAME = /^[!\w\-]+/
+const RE_TAGNAME = /^[!\w\-\:]+/
 const RE_TEXT = /^[^<>\n]+/
 const RE_WHITESPACE = /^\s+/
 const RE_WORD = /^[^\s]+/

package/extensions/builtin.theme-atom-one-dark/color-theme.json

@@ -96,6 +96,10 @@
       "name": "CssSelectorId",
       "foreground": "#61AFEF"
     },
+    {
+      "name": "CssAtRule",
+      "foreground": "#C678DD"
+    },
     {
       "name": "CssPropertyName",
       "foreground": "#ABB2BF"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.15.16",
+  "version": "0.15.18",
   "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.15.16",
-    "@lvce-editor/extension-host-helper-process": "0.15.16",
-    "@lvce-editor/pty-host": "0.15.16",
+    "@lvce-editor/extension-host": "0.15.18",
+    "@lvce-editor/extension-host-helper-process": "0.15.18",
+    "@lvce-editor/pty-host": "0.15.18",
     "debug": "^4.3.4",
     "execa": "^7.1.1",
     "exit-hook": "^3.2.0",

package/src/parts/AttachDebugger/AttachDebugger.ipc.js

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

package/src/parts/AttachDebugger/AttachDebugger.js

@@ -0,0 +1,6 @@
+import * as Process from '../Process/Process.js'
+import * as Signal from '../Signal/Signal.js'
+
+export const attachDebugger = (pid) => {
+  Process.kill(pid, Signal.SIGUSR1)
+}

package/src/parts/Callback/Callback.js

@@ -1,48 +1,39 @@
+import * as Id from '../Id/Id.js'
+
 export const state = {
   callbacks: Object.create(null),
   onceListeners: new Set(),
-  id: 2,
-}
-
-export const register = (resolve, reject) => {
-  state.callbacks[++state.id] = {
-    resolve,
-    reject,
-  }
-  return state.id
 }
 
-export const unregister = (id) => {
-  delete state.callbacks[id]
+export const registerPromise = () => {
+  const id = Id.create()
+  const promise = new Promise((resolve, reject) => {
+    state.callbacks[id] = { resolve, reject }
+  })
+  return { id, promise }
 }
 
 // TODO merge resolve and resolveEmpty
 export const resolve = (id, args) => {
-  if (!(id in state.callbacks)) {
+  const { callbacks } = state
+  if (!(id in callbacks)) {
     console.warn(`callback ${id} may already be disposed`)
     return
   }
-  state.callbacks[id].resolve(args)
-}
-
-export const resolveEmpty = (id) => {
-  if (!(id in state.callbacks)) {
-    console.warn(`callback (resolved) ${id} may already be disposed`)
-    return
-  }
-  state.callbacks[id].resolve()
+  callbacks[id].resolve(args)
+  delete callbacks[id]
 }
 
 export const reject = (id, error) => {
-  if (!(id in state.callbacks)) {
+  const { callbacks } = state
+  if (!(id in callbacks)) {
     console.warn(`callback (rejected) ${id} may already be disposed`)
     return
   }
-  state.callbacks[id].reject(error)
+  callbacks[id].reject(error)
+  delete callbacks[id]
 }
 
 export const isAllEmpty = () => {
-  return (
-    Object.keys(state.callbacks).length === 0 && state.onceListeners.size === 0
-  )
+  return Object.keys(state.callbacks).length === 0 && state.onceListeners.size === 0
 }

package/src/parts/ChildProcessError/ChildProcessError.js

@@ -2,8 +2,11 @@ import * as GetHelpfulChildProcessError from '../GetHelpfulChildProcessError/Get
 
 export class ChildProcessError extends Error {
   constructor(stderr) {
-    const message = GetHelpfulChildProcessError.getHelpfulChildProcessError('', stderr)
+    const { message, code } = GetHelpfulChildProcessError.getHelpfulChildProcessError('', stderr)
     super(message)
     this.name = 'ChildProcessError'
+    if (code) {
+      this.code = code
+    }
   }
 }

package/src/parts/CleanStack/CleanStack.js

@@ -7,6 +7,7 @@ const RE_GET_RESPONSE = /^\s*at async getResponse/
 const RE_WEBSOCKET_HANDLE_MESSAGE = /^\s*at async WebSocket.handleMessage/
 const RE_EXECUTE_COMMAND_ASYNC = /^\s*at executeCommandAsync/
 const RE_HANDLE_OTHER_MESSAGES_FROM_MESSAGE_PORT = /^\s*at async MessagePort\.handleOtherMessagesFromMessagePort/
+const RE_ASSERT = /^\s*at .*\/Assert\.js/
 
 const isInternalLine = (line) => {
   return line.includes('node:') || RE_AT_PROMISE_INDEX.test(line) || line.includes('node_modules/ws')
@@ -18,6 +19,9 @@ const isRelevantLine = (line) => {
 
 const isApplicationUsefulLine = (line, index) => {
   if (index === 0) {
+    if (RE_ASSERT.test(line)) {
+      return false
+    }
     return true
   }
   if (RE_GET_RESPONSE.test(line)) {

package/src/parts/CommandNotFoundError/CommandNotFoundError.js

@@ -1,8 +1,9 @@
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as ProcessDisplayName from '../ProcessDisplayName/ProcessDisplayName.js'
 
 export class CommandNotFoundError extends Error {
   constructor(id) {
-    super(`command ${id} not found`)
+    super(`command ${id} not found in ${ProcessDisplayName.processDisplayName}`)
     this.name = 'CommandNotFoundError'
     this.code = ErrorCodes.E_COMMAND_NOT_FOUND
   }

package/src/parts/CreateCpuProfile/CreateCpuProfile.js

@@ -0,0 +1,59 @@
+import { writeFile } from 'fs/promises'
+import got from 'got'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { WebSocket } from 'ws'
+import * as DevtoolsProtocolRpc from '../DevtoolsProtocolRpc/DevtoolsProtocolRpc.js'
+
+const createConnection = (webSocketDebuggerUrl) => {
+  const webSocket = new WebSocket(webSocketDebuggerUrl)
+  // console.log({ webSocket })
+  return {
+    on(event, listener) {
+      if (event === 'message') {
+        const wrappedListener = (string) => {
+          listener(JSON.parse(string))
+        }
+        webSocket.on(event, wrappedListener)
+      } else {
+        webSocket.on(event, listener)
+      }
+    },
+    send(message) {
+      webSocket.send(JSON.stringify(message))
+    },
+  }
+}
+
+export const createCpuProfile = async (pid) => {
+  // AttachDebugger.attachDebugger(pid)
+  const response = await got('http://localhost:9229/json/list').json()
+  const first = response[0]
+  const webSocketDebuggerUrl = first.webSocketDebuggerUrl
+  const ipc = createConnection(webSocketDebuggerUrl)
+
+  await new Promise((r) => {
+    ipc.on('open', r)
+  })
+  const rpc = DevtoolsProtocolRpc.create(ipc)
+  const result = await rpc.invoke('Debugger.enable')
+  const debuggerId = result.result.debuggerId
+  console.log({ debuggerId })
+  const p = await rpc.invoke('Profiler.enable')
+  await rpc.invoke('Profiler.start')
+  await new Promise((r) => {
+    setTimeout(r, 10000)
+  })
+  const profileResult = await rpc.invoke('Profiler.stop')
+  console.log({ profileResult })
+  const profile = profileResult.result.profile
+  const profilePath = join(tmpdir(), 'node-profile.cpuprofile')
+  const profileString = JSON.stringify(profile)
+  await writeFile(profilePath, profileString)
+  console.log('finished')
+  // const value = await rpc.invoke('Runtime.evaluate', {
+  //   expression: '1+1',
+  // })
+  // await rpc.invoke('Debugger.pause')
+  // console.log({ value })
+}

package/src/parts/DestroySocket/DestroySocket.js

@@ -0,0 +1,5 @@
+export const destroySocket = (socket) => {
+  try {
+    socket.destroy()
+  } catch {}
+}

package/src/parts/DevtoolsProtocolRpc/DevtoolsProtocolRpc.js

@@ -0,0 +1,32 @@
+const Id = {
+  id: 1,
+  create() {
+    return this.id++
+  },
+}
+
+export const create = (ipc) => {
+  const callbacks = Object.create(null)
+  const handleMessage = (message) => {
+    if ('result' in message) {
+      const callback = callbacks[message.id]
+      callback(message)
+      delete callbacks[message.id]
+    }
+  }
+  ipc.on('message', handleMessage)
+  return {
+    invoke(method, params = {}) {
+      const id = Id.create()
+      const promise = new Promise((resolve, reject) => {
+        callbacks[id] = resolve
+      })
+      ipc.send({
+        method,
+        id,
+        params,
+      })
+      return promise
+    },
+  }
+}

package/src/parts/ElectronInitialize/ElectronInitialize.ipc.js

@@ -0,0 +1,8 @@
+import * as ElectronInitialize from './ElectronInitialize.js'
+
+export const name = 'ElectronInitialize'
+
+// prettier-ignore
+export const Commands = {
+  electronInitialize: ElectronInitialize.electronInitialize,
+}

package/src/parts/ElectronInitialize/ElectronInitialize.js

@@ -0,0 +1,11 @@
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+export const electronInitialize = async (port, folder) => {
+  const ipc = await IpcChild.listen({
+    method: IpcChildType.NodeMessagePort,
+    messagePort: port,
+  })
+  HandleIpc.handleIpc(ipc)
+}

package/src/parts/ErrorCodes/ErrorCodes.js

@@ -1,7 +1,9 @@
 export const E_COLOR_THEME_NOT_FOUND = 'E_COLOR_THEME_NOT_FOUND'
 export const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND'
 export const E_ICON_THEME_NOT_FOUND = 'E_ICON_THEME_NOT_FOUND'
+export const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE'
 export const E_MANIFEST_NOT_FOUND = 'E_MANIFEST_NOT_FOUND'
+export const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON'
 export const EACCES = 'EACCES'
 export const ECONNRESET = 'ECONNRESET'
 export const EEXIST = 'EEXIST'

package/src/parts/ErrorHandling/ErrorHandling.js

@@ -1,11 +1,9 @@
 import * as ExitCode from '../ExitCode/ExitCode.js'
+import * as GetNewLineIndex from '../GetNewLineIndex/GetNewLineIndex.js'
 import * as IsIgnoredError from '../IsIgnoredError/IsIgnoredError.js'
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
 import * as Logger from '../Logger/Logger.js'
 import * as PrettyError from '../PrettyError/PrettyError.js'
 import * as Process from '../Process/Process.js'
-import * as Socket from '../Socket/Socket.js'
-import * as GetNewLineIndex from '../GetNewLineIndex/GetNewLineIndex.js'
 
 export const state = {
   seenErrors: [],
@@ -30,17 +28,17 @@ export const handleError = (error) => {
   }
   state.seenErrors.push(error.message)
   const prettyError = preparePrettyError(error)
-  Socket.send({
-    jsonrpc: JsonRpcVersion.Two,
-    method: /* Dialog.showErrorDialogWithOptions */ 'Dialog.showMessage',
-    params: [
-      {
-        message: prettyError.message,
-        codeFrame: prettyError.codeFrame,
-        stack: prettyError.stack,
-      },
-    ],
-  })
+  // Socket.send({
+  //   jsonrpc: JsonRpcVersion.Two,
+  //   method: /* Dialog.showErrorDialogWithOptions */ 'Dialog.showMessage',
+  //   params: [
+  //     {
+  //       message: prettyError.message,
+  //       codeFrame: prettyError.codeFrame,
+  //       stack: prettyError.stack,
+  //     },
+  //   ],
+  // })
   printPrettyError(prettyError)
 }
 

package/src/parts/FirstWebSocketEventType/FirstWebSocketEventType.js

@@ -0,0 +1,2 @@
+export const Open = 1
+export const Close = 2

package/src/parts/GetActualPath/GetActualPath.js

@@ -0,0 +1,8 @@
+import { fileURLToPath } from 'node:url'
+
+export const getActualPath = (fileUri) => {
+  if (fileUri.startsWith('file://')) {
+    return fileURLToPath(fileUri)
+  }
+  return fileUri
+}

package/src/parts/GetErrorResponse/GetErrorResponse.js

@@ -12,7 +12,11 @@ const shouldLogError = (error) => {
   return true
 }
 
-export const getErrorResponse = (message, error) => {
+export const getErrorResponse = (message, error, ipc) => {
+  const prettyError = PrettyError.prepare(error)
+  if (shouldLogError(error) && (!ipc || ipc.shouldLogError !== false)) {
+    PrintPrettyError.printPrettyError(prettyError, `[shared-process] `)
+  }
   if (error && error instanceof CommandNotFoundError) {
     return {
       jsonrpc: JsonRpcVersion.Two,
@@ -37,8 +41,6 @@ export const getErrorResponse = (message, error) => {
       },
     }
   }
-  const prettyError = PrettyError.prepare(error)
-  PrintPrettyError.printPrettyError(prettyError, `[shared-process] `)
   return {
     jsonrpc: JsonRpcVersion.Two,
     id: message.id,
@@ -49,6 +51,7 @@ export const getErrorResponse = (message, error) => {
         stack: prettyError.stack,
         codeFrame: prettyError.codeFrame,
         type: prettyError.type,
+        code: prettyError.code,
       },
     },
   }

package/src/parts/GetFirstWebSocketEvent/GetFirstWebSocketEvent.js

@@ -0,0 +1,41 @@
+import * as FirstWebSocketEventType from '../FirstWebSocketEventType/FirstWebSocketEventType.js'
+import { WebSocket } from 'ws'
+
+export const getFirstWebSocketEvent = async (webSocket) => {
+  switch (webSocket.readyState) {
+    case WebSocket.OPEN:
+      return {
+        type: FirstWebSocketEventType.Open,
+        event: undefined,
+      }
+    case WebSocket.CLOSED:
+      return {
+        type: FirstWebSocketEventType.Close,
+        event: undefined,
+      }
+    default:
+      break
+  }
+  const { type, event } = await new Promise((resolve) => {
+    const cleanup = (value) => {
+      webSocket.off('open', handleOpen)
+      webSocket.off('close', handleClose)
+      resolve(value)
+    }
+    const handleOpen = (event) => {
+      cleanup({
+        type: FirstWebSocketEventType.Open,
+        event,
+      })
+    }
+    const handleClose = (event) => {
+      cleanup({
+        type: FirstWebSocketEventType.Close,
+        event,
+      })
+    }
+    webSocket.on('open', handleOpen)
+    webSocket.on('close', handleClose)
+  })
+  return { type, event }
+}

package/src/parts/GetHelpfulChildProcessError/GetHelpfulChildProcessError.js

@@ -1,4 +1,5 @@
 import * as SplitLines from '../SplitLines/SplitLines.js'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.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/
@@ -29,7 +30,10 @@ const getMessageCodeBlock = (stderr) => {
 
 const getNativeModuleErrorMessage = (stderr) => {
   const message = getMessageCodeBlock(stderr)
-  return `incompatible native node module: ${message}`
+  return {
+    message: `Incompatible native node module: ${message}`,
+    code: ErrorCodes.E_INCOMPATIBLE_NATIVE_MODULE,
+  }
 }
 
 const isModulesSyntaxError = (stderr) => {
@@ -40,7 +44,10 @@ const isModulesSyntaxError = (stderr) => {
 }
 
 const getModuleSyntaxError = (stderr) => {
-  return `ES Modules are not supported in electron`
+  return {
+    message: `ES Modules are not supported in electron`,
+    code: ErrorCodes.E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+  }
 }
 
 export const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -50,5 +57,8 @@ export const getHelpfulChildProcessError = (stdout, stderr) => {
   if (isModulesSyntaxError(stderr)) {
     return getModuleSyntaxError(stderr)
   }
-  return 'child process error'
+  return {
+    message: `child process error: ${stderr}`,
+    code: '',
+  }
 }

package/src/parts/GetResponse/GetResponse.js

@@ -3,13 +3,13 @@ import * as GetErrorResponse from '../GetErrorResponse/GetErrorResponse.js'
 import * as GetSuccessResponse from '../GetSuccessResponse/GetSuccessResponse.js'
 import * as RequiresSocket from '../RequiresSocket/RequiresSocket.js'
 
-export const getResponse = async (message, handle) => {
+export const getResponse = async (message, ipc) => {
   try {
     const result = RequiresSocket.requiresSocket(message.method)
-      ? await Command.execute(message.method, handle, ...message.params)
+      ? await Command.execute(message.method, ipc, ...message.params)
       : await Command.execute(message.method, ...message.params)
     return GetSuccessResponse.getSuccessResponse(message, result)
   } catch (error) {
-    return GetErrorResponse.getErrorResponse(message, error)
+    return GetErrorResponse.getErrorResponse(message, error, ipc)
   }
 }

package/src/parts/HandleElectronMessagePort/HandleElectronMessagePort.ipc.js

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

package/src/parts/HandleElectronMessagePort/HandleElectronMessagePort.js

@@ -0,0 +1,14 @@
+import * as Assert from '../Assert/Assert.js'
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+export const handleElectronMessagePort = async (messagePort) => {
+  Assert.object(messagePort)
+  const ipc = await IpcChild.listen({
+    method: IpcChildType.ElectronMessagePort,
+    messagePort,
+  })
+  HandleIpc.handleIpc(ipc)
+  messagePort.start()
+}

package/src/parts/HandleIpc/HandleIpc.js

@@ -0,0 +1,30 @@
+import * as Callback from '../Callback/Callback.js'
+import * as Command from '../Command/Command.js'
+import * as GetResponse from '../GetResponse/GetResponse.js'
+
+const handleJsonRpcResult = (message) => {
+  Callback.resolve(message.id, message.result)
+}
+
+export const handleIpc = (ipc) => {
+  const handleJsonRpcMessage = async (message) => {
+    if (message.method) {
+      const response = await GetResponse.getResponse(message, ipc)
+      ipc.send(response)
+    } else {
+      // TODO handle error
+      Command.execute(message.method, ...message.params)
+    }
+  }
+
+  const handleMessageFromParentProcess = async (message) => {
+    if (message.result) {
+      return handleJsonRpcResult(message)
+    }
+    if (message.method) {
+      return handleJsonRpcMessage(message)
+    }
+    console.warn('unknown message', message)
+  }
+  ipc.on('message', handleMessageFromParentProcess)
+}

package/src/parts/HandleNodeMessagePort/HandleNodeMessagePort.ipc.js

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

package/src/parts/HandleNodeMessagePort/HandleNodeMessagePort.js

@@ -0,0 +1,12 @@
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+export const handleNodeMessagePort = async (messagePort) => {
+  const ipc = await IpcChild.listen({
+    method: IpcChildType.NodeMessagePort,
+    messagePort,
+  })
+  HandleIpc.handleIpc(ipc)
+  messagePort.start()
+}

package/src/parts/HandleWebSocket/HandleWebSocket.ipc.js

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

package/src/parts/HandleWebSocket/HandleWebSocket.js

@@ -0,0 +1,26 @@
+import * as Assert from '../Assert/Assert.js'
+import * as DestroyWebSocket from '../DestroySocket/DestroySocket.js'
+import * as HandleWebSocketModule from '../HandleWebSocketModule/HandleWebSocketModule.js'
+import { VError } from '../VError/VError.js'
+
+export const handleWebSocket = async (message, handle) => {
+  try {
+    Assert.object(message)
+    Assert.object(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')
+    }
+    handle.pause()
+    const module = await HandleWebSocketModule.load(protocol)
+    await module.handleWebSocket(message, handle, protocol)
+    handle.resume()
+  } catch (error) {
+    DestroyWebSocket.destroySocket(handle)
+    throw new VError(error, `Failed to connect to websocket`)
+  }
+}