@lvce-editor/shared-process 0.15.15 → 0.15.17

package/config/builtinCommands.json

@@ -226,6 +226,10 @@
     "id": "Developer.toggleDeveloperTools",
     "label": "Developer: Toggle Developer Tools"
   },
+  {
+    "id": "RebuildNodePty.rebuildNodePty",
+    "label": "Developer: Rebuild Node Pty"
+  },
   {
     "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.15",
+  "version": "0.15.17",
   "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.15",
-    "@lvce-editor/extension-host-helper-process": "0.15.15",
-    "@lvce-editor/pty-host": "0.15.15",
+    "@lvce-editor/extension-host": "0.15.17",
+    "@lvce-editor/extension-host-helper-process": "0.15.17",
+    "@lvce-editor/pty-host": "0.15.17",
     "debug": "^4.3.4",
     "execa": "^7.1.1",
     "exit-hook": "^3.2.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/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,40 @@
+import * as Callback from '../Callback/Callback.js'
+import * as Command from '../Command/Command.js'
+import * as GetResponse from '../GetResponse/GetResponse.js'
+
+export const electronInitialize = (port, folder) => {
+  // TODO handle error
+  const fakeSocket = {
+    send: port.postMessage.bind(port),
+    on(event, listener) {
+      switch (event) {
+        case 'close':
+          port.on('close', listener)
+          break
+        case 'message':
+          port.on('message', listener)
+          break
+        default:
+          console.warn('socket event not implemented', event, listener)
+          break
+      }
+    },
+  }
+  const handleOtherMessagesFromMessagePort = async (message) => {
+    // console.log('got port message', message)
+    if (message.result) {
+      Callback.resolve(message.id, message.result)
+    } else if (message.method) {
+      if (message.id) {
+        const response = await GetResponse.getResponse(message, fakeSocket)
+        port.postMessage(response)
+      } else {
+        console.warn(`[shared process] sending messages without id is deprecated: ${message.method}`)
+        Command.execute(message.method, fakeSocket, ...message.params)
+      }
+    } else {
+      console.warn('unknown message', message)
+    }
+  }
+  port.on('message', handleOtherMessagesFromMessagePort)
+}

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/ExportStatic/ExportStatic.js

@@ -127,6 +127,11 @@ const applyOverrides = async ({ root, commitHash, pathPrefix }) => {
       return \`\${assetDir}/themes/\${colorThemeId}.json\`
     }`
   )
+  await replace(
+    Path.join(root, 'dist', commitHash, 'packages', 'extension-host-worker', 'dist', 'extensionHostWorkerMain.js'),
+    `/${commitHash}`,
+    `${pathPrefix}/${commitHash}`
+  )
   await replace(
     Path.join(root, 'dist', commitHash, 'packages', 'renderer-worker', 'dist', 'rendererWorkerMain.js'),
     `getIconThemeUrl = (iconThemeId) => {

package/src/parts/FirstWebSocketEventType/FirstWebSocketEventType.js

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

package/src/parts/GetErrorResponse/GetErrorResponse.js

@@ -49,6 +49,7 @@ export const getErrorResponse = (message, error) => {
         stack: prettyError.stack,
         codeFrame: prettyError.codeFrame,
         type: prettyError.type,
+        code: prettyError.code,
       },
     },
   }

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/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, handle) => {
+    if (message.method) {
+      const response = await GetResponse.getResponse(message, handle)
+      ipc.send(response)
+    } else {
+      // TODO handle error
+      Command.execute(message.method, ...message.params)
+    }
+  }
+
+  const handleMessageFromParentProcess = async (message, handle) => {
+    if (message.result) {
+      return handleJsonRpcResult(message)
+    }
+    if (message.method) {
+      return handleJsonRpcMessage(message, handle)
+    }
+    console.warn('unknown message', message)
+  }
+  ipc.on('message', handleMessageFromParentProcess)
+}

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

package/src/parts/HandleWebSocketForExtensionHost/HandleWebSocketForExtensionHost.js

@@ -0,0 +1,15 @@
+import * as ExtensionHostIpc from '../ExtensionHostIpc/ExtensionHostIpc.js'
+import * as ExtensionHostRpc from '../ExtensionHostRpc/ExtensionHostRpc.js'
+
+// TODO lazyload modules for spawning extension host, they are only needed later
+export const handleWebSocket = async (message, handle) => {
+  // console.log('[shared-process] received extension host websocket', message)
+  const ipc = await 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)
+}

package/src/parts/HandleWebSocketForExtensionHostHelperProcess/HandleWebSocketForExtensionHostHelperProcess.js

@@ -0,0 +1,6 @@
+import * as ExtensionHostHelperProcessIpc from '../ExtensionHostHelperProcessIpc/ExtensionHostHelperProcessIpc.js'
+
+export const handleWebSocket = async (message, handle) => {
+  const ipc = await ExtensionHostHelperProcessIpc.create()
+  ipc._process.send(message, handle)
+}

package/src/parts/HandleWebSocketForSharedProcess/HandleWebSocketForSharedProcess.js

@@ -0,0 +1,16 @@
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as Socket from '../Socket/Socket.js'
+import * as WebSocketServer from '../WebSocketServer/WebSocketServer.js'
+
+const handleSocketError = (error) => {
+  if (error && error.code === ErrorCodes.ECONNRESET) {
+    return
+  }
+  console.info('[info shared process: handle error]', error)
+}
+
+export const handleWebSocket = async (message, handle) => {
+  handle.on('error', handleSocketError)
+  const webSocket = await WebSocketServer.handleUpgrade(message, handle)
+  Socket.set(webSocket)
+}

package/src/parts/HandleWebSocketForTerminalProcess/HandleWebSocketForTerminalProcess.js

@@ -0,0 +1,22 @@
+import * as PtyHost from '../PtyHost/PtyHost.js'
+
+export const handleWebSocket = async (message, handle) => {
+  const instance = await PtyHost.getOrCreate()
+  instance.sendAndTransfer(
+    {
+      jsonrpc: '2.0',
+      method: 'HandleWebSocket.handleWebSocket',
+      params: [message],
+    },
+    handle
+  )
+  // console.log({ instance })
+  // const ipc = await PtyHost.getOrCreate()
+  // 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)
+}

package/src/parts/HandleWebSocketForUnknown/HandleWebSocketForUnknown.js

@@ -0,0 +1,10 @@
+import * as Logger from '../Logger/Logger.js'
+
+export const handleWebSocket = (message, handle, protocol) => {
+  Logger.warn(`[shared-process] unsupported sec-websocket-procotol ${protocol}`)
+  try {
+    handle.destroy()
+  } catch {
+    // ignore
+  }
+}

package/src/parts/HandleWebSocketModule/HandleWebSocketModule.js

@@ -0,0 +1,20 @@
+import * as ProtocolType from '../ProtocolType/ProtocolType.js'
+import { VError } from '../VError/VError.js'
+
+export const load = (protocol) => {
+  if (!protocol) {
+    throw new VError('missing sec websocket protocol header')
+  }
+  switch (protocol) {
+    case ProtocolType.SharedProcess:
+      return import('../HandleWebSocketForSharedProcess/HandleWebSocketForSharedProcess.js')
+    case ProtocolType.ExtensionHost:
+      return import('../HandleWebSocketForExtensionHost/HandleWebSocketForExtensionHost.js')
+    case ProtocolType.ExtensionHostHelperProcess:
+      return import('../HandleWebSocketForExtensionHostHelperProcess/HandleWebSocketForExtensionHostHelperProcess.js')
+    case ProtocolType.TerminalProcess:
+      return import('../HandleWebSocketForTerminalProcess/HandleWebSocketForTerminalProcess.js')
+    default:
+      return import('../HandleWebSocketForUnknown/HandleWebSocketForUnknown.js')
+  }
+}

package/src/parts/IpcChild/IpcChild.js

@@ -2,5 +2,7 @@ import * as IpcChildModule from '../IpcChildModule/IpcChildModule.js'
 
 export const listen = async ({ method }) => {
   const module = await IpcChildModule.getModule(method)
-  return module.listen()
+  const rawIpc = await module.listen()
+  const ipc = module.wrap(rawIpc)
+  return ipc
 }

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -6,6 +6,8 @@ export const getModule = (method) => {
       return import('../IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js')
     case IpcChildType.NodeWorker:
       return import('../IpcChildWithNodeWorker/IpcChildWithNodeWorker.js')
+    case IpcChildType.ElectronUtilityProcess:
+      return import('../IpcChildWithElectronUtilityProcess/IpcChildWithElectronUtilityProcess.js')
     default:
       throw new Error('unexpected ipc type')
   }

package/src/parts/IpcChildType/IpcChildType.js

@@ -1,5 +1,6 @@
 export const NodeWorker = 1
 export const NodeForkedProcess = 2
+export const ElectronUtilityProcess = 3
 
 export const Auto = () => {
   const { argv } = process
@@ -9,5 +10,8 @@ export const Auto = () => {
   if (argv.includes('--ipc-type=node-forked-process')) {
     return NodeForkedProcess
   }
+  if (argv.includes('--ipc-type=electron-utility-process')) {
+    return ElectronUtilityProcess
+  }
   throw new Error(`[shared-process] unknown ipc type`)
 }

package/src/parts/IpcChildWithElectronUtilityProcess/IpcChildWithElectronUtilityProcess.js

@@ -0,0 +1,27 @@
+export const listen = () => {
+  // @ts-ignore
+  const parentPort = process.parentPort
+  if (!parentPort) {
+    throw new Error('parent port must be defined')
+  }
+  parentPort.postMessage('ready')
+  return parentPort
+}
+
+export const wrap = (parentPort) => {
+  return {
+    parentPort,
+    on(event, listener) {
+      this.parentPort.on(event, listener)
+    },
+    off(event, listener) {
+      this.parentPort.off(event, listener)
+    },
+    send(message) {
+      this.parentPort.postMessage(message)
+    },
+    dispose() {
+      this.parentPort.close()
+    },
+  }
+}

package/src/parts/IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js

@@ -1,4 +1,8 @@
 export const listen = async () => {
+  if (!process.send) {
+    throw new Error('process.send must be defined')
+  }
+  process.send('ready')
   return process
 }
 

package/src/parts/IpcParentWithNodeForkedProcess/IpcParentWithNodeForkedProcess.js

@@ -8,7 +8,8 @@ import { VError } from '../VError/VError.js'
 export const create = async ({ path, argv = [], env, execArgv = [], stdio = 'inherit', name = 'child process' }) => {
   try {
     Assert.string(path)
-    const childProcess = fork(path, argv, {
+    const actualArgv = ['--ipc-type=node-forked-process', ...argv]
+    const childProcess = fork(path, actualArgv, {
       env,
       execArgv,
       stdio: 'pipe',
@@ -36,11 +37,14 @@ export const wrap = (childProcess) => {
     on(event, listener) {
       this.childProcess.on(event, listener)
     },
+    off(event, listener) {
+      this.childProcess.off(event, listener)
+    },
     send(message) {
       this.childProcess.send(message)
     },
-    sendAndTransfer(message, transfer) {
-      throw new Error('transfer is not supported')
+    sendAndTransfer(message, handle) {
+      this.childProcess.send(message, handle)
     },
     dispose() {
       this.childProcess.kill()

package/src/parts/IsElectron/IsElectron.js

@@ -0,0 +1,3 @@
+export const isElectron = () => {
+  return Boolean(process.env.ELECTRON_RUN_AS_NODE)
+}

package/src/parts/JsonRpc/JsonRpc.js

@@ -21,3 +21,19 @@ export const invoke = (ipc, method, ...params) => {
     })
   })
 }
+
+export const invokeAndTransfer = (ipc, handle, method, ...params) => {
+  return new Promise((resolve, reject) => {
+    // TODO use one map instead of two
+    const callbackId = Callback.register(resolve, reject)
+    ipc.sendAndTransfer(
+      {
+        jsonrpc: JsonRpcVersion.Two,
+        method,
+        params,
+        id: callbackId,
+      },
+      handle
+    )
+  })
+}

package/src/parts/Module/Module.js

@@ -20,6 +20,8 @@ export const load = (moduleId) => {
       return import('../Download/Download.ipc.js')
     case ModuleId.ExtensionHost:
       return import('../ExtensionHost/ExtensionHost.ipc.js')
+    case ModuleId.ElectronInitialize:
+      return import('../ElectronInitialize/ElectronInitialize.ipc.js')
     case ModuleId.ExtensionManagement:
       return import('../ExtensionManagement/ExtensionManagement.ipc.js')
     case ModuleId.FileSystem:
@@ -52,6 +54,10 @@ export const load = (moduleId) => {
       return import('../WebSocketServer/WebSocketServer.ipc.js')
     case ModuleId.Workspace:
       return import('../Workspace/Workspace.ipc.js')
+    case ModuleId.RebuildNodePty:
+      return import('../RebuildNodePty/RebuildNodePty.ipc.js')
+    case ModuleId.HandleWebSocket:
+      return import('../HandleWebSocket/HandleWebSocket.ipc.js')
     default:
       throw new Error(`module ${moduleId} not found`)
   }

package/src/parts/ModuleId/ModuleId.js

@@ -23,3 +23,6 @@ export const AutoUpdater = 22
 export const IsAutoUpdateSupported = 23
 export const AutoUpdaterAppImage = 24
 export const AutoUpdaterWindowsNsis = 25
+export const RebuildNodePty = 26
+export const ElectronInitialize = 27
+export const HandleWebSocket = 28

package/src/parts/ModuleMap/ModuleMap.js

@@ -31,6 +31,8 @@ export const getModuleId = (commandId) => {
       return ModuleId.Developer
     case 'Download.download':
       return ModuleId.Download
+    case 'ElectronInitialize.electronInitialize':
+      return ModuleId.ElectronInitialize
     case 'ExtensionHost.dispose':
     case 'ExtensionHost.enableExtension':
     case 'ExtensionHost.executeCommand':
@@ -108,6 +110,8 @@ export const getModuleId = (commandId) => {
     case 'GitLsFiles.gitLsFilesHash':
     case 'GitLsFiles.resolveGit':
       return ModuleId.GitLsFiles
+    case 'HandleWebSocket.handleWebSocket':
+      return ModuleId.HandleWebSocket
     case 'InstallExtension.installExtension':
       return ModuleId.InstallExtension
     case 'IsAutoUpdateSupported.isAutoUpdateSupported':
@@ -155,6 +159,8 @@ export const getModuleId = (commandId) => {
     case 'Workspace.getHomeDir':
     case 'Workspace.resolveRoot':
       return ModuleId.Workspace
+    case 'RebuildNodePty.rebuildNodePty':
+      return ModuleId.RebuildNodePty
     default:
       throw new CommandNotFoundError(commandId)
   }