@lvce-editor/shared-process 0.16.17 → 0.16.19

package/extensions/builtin.language-basics-javascript/src/tokenizeJavaScript.js

@@ -143,6 +143,8 @@ const RE_REGEX =
 
 const RE_VARIABLE_NAME_SPECIAL = /\p{L}/u
 const RE_VARIABLE_NAME_SPECIAL_2 = /./u
+const RE_BUILTIN_CLASS =
+  /^(?:Array|Object|Promise|ArrayBuffer|URL|URLSearchParams|WebSocket|FileSystemHandle|Function|StorageEvent|MessageEvent|MessageChannel|Int32Array|Boolean|String|Error|Set|RegExp|Map|WeakMap|RangeError|Date|Headers|Response|Request|Buffer|MessagePort|FileHandle|X509Certificate|Blob|HTMLElement)\b/
 
 export const initialLineState = {
   state: State.TopLevelContent,
@@ -251,6 +253,9 @@ export const tokenizeLine = (line, lineState) => {
         } else if ((next = part.match(RE_FUNCTION_CALL_NAME))) {
           token = TokenType.FunctionName
           state = State.TopLevelContent
+        } else if ((next = part.match(RE_BUILTIN_CLASS))) {
+          token = TokenType.Class
+          state = State.TopLevelContent
         } else if ((next = part.match(RE_VARIABLE_NAME))) {
           token = TokenType.VariableName
           state = State.TopLevelContent

package/extensions/builtin.language-basics-less/src/tokenizeLess.js

@@ -125,6 +125,8 @@ const RE_STRING_SINGLE_QUOTE_CONTENT = /^[^']+/
 const RE_SINGLE_QUOTE = /^'/
 const RE_ANYTHING_BUT_CURLY = /^[^\{\}]+/s
 const RE_LINE_COMMENT = /\/\/.*/
+const RE_NESTED_SELECTOR = /^[\w\.\-\s]+(?=\s*(?:\{|,))/
+const RE_AMPERSAND = /^\&/
 
 /**
  * @param {string} line
@@ -205,9 +207,13 @@ export const tokenizeLine = (line, lineState) => {
         if ((next = part.match(RE_WHITESPACE))) {
           token = TokenType.Whitespace
           state = State.AfterSelector
+        } else if ((next = part.match(RE_AMPERSAND))) {
+          token = TokenType.Punctuation
+          state = State.AfterSelector
         } else if ((next = part.match(RE_CURLY_OPEN))) {
           token = TokenType.CurlyOpen
           state = State.InsideSelector
+          stack.push(State.InsideSelector)
         } else if ((next = part.match(RE_SELECTOR_CLASS))) {
           token = TokenType.CssSelectorClass
           state = State.AfterSelector
@@ -297,6 +303,16 @@ export const tokenizeLine = (line, lineState) => {
         if ((next = part.match(RE_WHITESPACE))) {
           token = TokenType.Whitespace
           state = State.InsideSelector
+        } else if ((next = part.match(RE_AMPERSAND))) {
+          token = TokenType.Punctuation
+          state = State.InsideSelector
+        } else if ((next = part.match(RE_NESTED_SELECTOR))) {
+          if (next[0].startsWith('.')) {
+            token = TokenType.CssSelectorClass
+          } else {
+            token = TokenType.CssSelector
+          }
+          state = State.AfterSelector
         } else if ((next = part.match(RE_PROPERTY_NAME))) {
           token = TokenType.CssPropertyName
           state = State.AfterPropertyName
@@ -318,7 +334,7 @@ export const tokenizeLine = (line, lineState) => {
           state = State.InsideSelector
         } else if ((next = part.match(RE_CURLY_CLOSE))) {
           token = TokenType.CurlyClose
-          state = State.TopLevelContent
+          state = stack.pop() || State.TopLevelContent
         } else {
           throw new Error('no')
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.16.17",
+  "version": "0.16.19",
   "description": "Utility package for @lvce-editor/server",
   "main": "index.js",
   "type": "module",
@@ -17,9 +17,9 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.22.5",
-    "@lvce-editor/extension-host": "0.16.17",
-    "@lvce-editor/extension-host-helper-process": "0.16.17",
-    "@lvce-editor/pty-host": "0.16.17",
+    "@lvce-editor/extension-host": "0.16.19",
+    "@lvce-editor/extension-host-helper-process": "0.16.19",
+    "@lvce-editor/pty-host": "0.16.19",
     "debug": "^4.3.4",
     "execa": "^7.1.1",
     "exit-hook": "^3.2.0",

package/src/parts/ElectronContextMenu/ElectronContextMenu.ipc.js

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

package/src/parts/ElectronContextMenu/ElectronContextMenu.js

@@ -0,0 +1,5 @@
+import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+
+export const openContextMenu = (menuItems, x, y, customData) => {
+  return ParentIpc.invoke('ElectronContextMenu.openContextMenu', menuItems, x, y, customData)
+}

package/src/parts/ElectronProcess/ElectronProcess.ipc.js

@@ -0,0 +1,8 @@
+import * as ElectronProcess from './ElectronProcess.js'
+
+export const name = 'ElectronProcess'
+
+export const Commands = {
+  getChromeVersion: ElectronProcess.getChromeVersion,
+  getElectronVersion: ElectronProcess.getElectronVersion,
+}

package/src/parts/ElectronProcess/ElectronProcess.js

@@ -0,0 +1,9 @@
+import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+
+export const getElectronVersion = () => {
+  return ParentIpc.invoke('Process.getElectronVersion')
+}
+
+export const getChromeVersion = () => {
+  return ParentIpc.invoke('Process.getChromeVersion')
+}

package/src/parts/ElectronSafeStorage/ElectronSafeStorage.ipc.js

@@ -0,0 +1,9 @@
+import * as ElectronSafeStorage from './ElectronSafeStorage.js'
+
+export const name = 'ElectronSafeStorage'
+
+export const Commands = {
+  decryptString: ElectronSafeStorage.decryptString,
+  encryptString: ElectronSafeStorage.encryptString,
+  isEncryptionAvailable: ElectronSafeStorage.isEncryptionAvailable,
+}

package/src/parts/ElectronSafeStorage/ElectronSafeStorage.js

@@ -0,0 +1,13 @@
+import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+
+export const isEncryptionAvailable = () => {
+  return ParentIpc.invoke('ElectronSafeStorage.isEncryptionAvailable')
+}
+
+export const encryptString = (plainText) => {
+  return ParentIpc.invoke('ElectronSafeStorage.encryptString', plainText)
+}
+
+export const decryptString = (encrypted) => {
+  return ParentIpc.invoke('ElectronSafeStorage.decryptString', encrypted)
+}

package/src/parts/ExtensionManifest/ExtensionManifest.js

@@ -3,6 +3,7 @@ import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
 import * as ReadJson from '../JsonFile/JsonFile.js'
 import * as Path from '../Path/Path.js'
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
 import { VError } from '../VError/VError.js'
 
 const RE_EXTENSION_FRAGMENT = /.+(\/|\\)(.+)$/
@@ -32,7 +33,7 @@ export const get = async (path) => {
   } catch (error) {
     const id = inferExtensionId(path)
     const enhancedError = new VError(error, `Failed to load extension manifest for ${id}`)
-    if (error.code === ErrorCodes.ENOENT) {
+    if (IsEnoentError.isEnoentError(error)) {
       try {
         const monoRepoPath = Path.join(path, `packages`, 'extension', 'extension.json')
         const json = await ReadJson.readJson(monoRepoPath)

package/src/parts/ExtensionManifests/ExtensionManifestsFromFolder.js

@@ -1,6 +1,6 @@
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
 import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
 import * as ToAbsolutePaths from '../ToAbsolutePaths/ToAbsolutePaths.js'
 import { VError } from '../VError/VError.js'
 
@@ -14,9 +14,7 @@ export const getExtensionManifests = async (path) => {
     const manifests = await Promise.all(absolutePaths.map(ExtensionManifest.get))
     return manifests
   } catch (error) {
-    // TODO how to make typescript happy?
-    // @ts-ignore
-    if (error.code === ErrorCodes.ENOENT) {
+    if (IsEnoentError.isEnoentError(error)) {
       return []
     }
     throw new VError(error, 'Failed to get extension manifests')

package/src/parts/ExtensionManifests/ExtensionManifestsFromLinkedExtensionsFolder.js

@@ -1,8 +1,8 @@
 import { readlink } from 'fs/promises'
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
 import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
 import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
 import * as ToAbsolutePaths from '../ToAbsolutePaths/ToAbsolutePaths.js'
 import { VError } from '../VError/VError.js'
 
@@ -46,9 +46,7 @@ export const getExtensionManifests = async (path) => {
     const merged = mergeWithSymLinks(manifests, symlinks)
     return merged
   } catch (error) {
-    // TODO how to make typescript happy?
-    // @ts-ignore
-    if (error.code === ErrorCodes.ENOENT) {
+    if (IsEnoentError.isEnoentError(error)) {
       return []
     }
     throw new VError(error, 'Failed to get extension manifests')

package/src/parts/FileSystem/FileSystem.js

@@ -1,10 +1,12 @@
 // TODO lazyload chokidar and trash (but doesn't work currently because of bug with jest)
 import * as fs from 'node:fs/promises'
 import * as os from 'node:os'
+import * as Assert from '../Assert/Assert.js'
 import * as EncodingType from '../EncodingType/EncodingType.js'
-import { FileNotFoundError } from '../FileNotFoundError/FileNotFoundError.js'
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import { FileNotFoundError } from '../FileNotFoundError/FileNotFoundError.js'
 import * as GetDirentType from '../GetDirentType/GetDirentType.js'
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
 import * as Path from '../Path/Path.js'
 import * as Platform from '../Platform/Platform.js'
 import * as Trash from '../Trash/Trash.js'
@@ -36,6 +38,7 @@ export const copy = async (source, target) => {
 export const readFile = async (path, encoding = EncodingType.Utf8) => {
   // console.info('[shared-process] read file', path)
   try {
+    Assert.string(path)
     // const start = performance.now()
     // console.time(`read ${path}`)
     const content = await fs.readFile(path, encoding)
@@ -44,7 +47,7 @@ export const readFile = async (path, encoding = EncodingType.Utf8) => {
     // console.timeEnd(`read ${path}`)
     return content
   } catch (error) {
-    if (error && error.code === ErrorCodes.ENOENT) {
+    if (IsEnoentError.isEnoentError(error)) {
       throw new FileNotFoundError(path)
     }
     throw new VError(error, `Failed to read file "${path}"`)
@@ -59,11 +62,13 @@ export const readFile = async (path, encoding = EncodingType.Utf8) => {
  */
 export const writeFile = async (path, content, encoding = EncodingType.Utf8) => {
   try {
+    Assert.string(path)
+    Assert.string(content)
     // queue would be more correct for concurrent writes but also slower
     // Queue.add(`writeFile/${path}`, () =>
     await fs.writeFile(path, content, encoding)
   } catch (error) {
-    if (error && error.code === ErrorCodes.ENOENT) {
+    if (IsEnoentError.isEnoentError(error)) {
       throw new FileNotFoundError(path)
     }
     throw new VError(error, `Failed to write to file "${path}"`)
@@ -169,7 +174,7 @@ export const readDir = async (path) => {
     const dirents = await fs.readdir(path)
     return dirents
   } catch (error) {
-    if (error && error.code === ErrorCodes.ENOENT) {
+    if (IsEnoentError.isEnoentError(error)) {
       throw new FileNotFoundError(path)
     }
     throw new VError(error, `Failed to read directory "${path}"`)

package/src/parts/GetAccurateMemoryUsage/GetAccurateMemoryUsage.js

@@ -3,34 +3,41 @@ import { join } from 'node:path'
 import * as Assert from '../Assert/Assert.js'
 import * as Character from '../Character/Character.js'
 import * as EncodingType from '../EncodingType/EncodingType.js'
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
+import * as IsEsrchError from '../IsEsrchError/IsEsrchError.js'
 import { VError } from '../VError/VError.js'
 
-export const getAccurateMemoryUsage = async (pid) => {
-  Assert.number(pid)
+const getContent = async (pid) => {
   try {
     const filePath = join('/proc', `${pid}`, 'statm')
-    let content
-    try {
-      content = await readFile(filePath, EncodingType.Utf8)
-    } catch (error) {
-      if (
-        error &&
-        // @ts-ignore
-        (error.code === ErrorCodes.ENOENT ||
-          // @ts-ignore
-          error.code === ErrorCodes.ESRCH)
-      ) {
-        return -1
-      }
-      throw error
+    const content = await readFile(filePath, EncodingType.Utf8)
+    return content
+  } catch (error) {
+    if (IsEnoentError.isEnoentError(error) || IsEsrchError.isEsrchError(error)) {
+      return ''
+    }
+    throw error
+  }
+}
+
+const parseMemory = (content) => {
+  const trimmedContent = content.trim()
+  const numberBlocks = trimmedContent.split(Character.Space)
+  const pageSize = 4096
+  const rss = Number.parseInt(numberBlocks[1]) * pageSize
+  const shared = Number.parseInt(numberBlocks[2]) * pageSize
+  const memory = rss - shared
+  return memory
+}
+
+export const getAccurateMemoryUsage = async (pid) => {
+  try {
+    Assert.number(pid)
+    const content = await getContent(pid)
+    if (!content) {
+      return -1
     }
-    const trimmedContent = content.trim()
-    const numberBlocks = trimmedContent.split(Character.Space)
-    const pageSize = 4096
-    const rss = Number.parseInt(numberBlocks[1]) * pageSize
-    const shared = Number.parseInt(numberBlocks[2]) * pageSize
-    const memory = rss - shared
+    const memory = parseMemory(content)
     return memory
   } catch (error) {
     throw new VError(error, 'Failed to get accurate memory usage')

package/src/parts/GetElectronRebuildPath/GetElectronRebuildPath.js

@@ -1,6 +1,10 @@
+import * as IsWindows from '../IsWindows/IsWindows.js'
 import * as Path from '../Path/Path.js'
 import * as Root from '../Root/Root.js'
 
 export const getElectronRebuildPath = () => {
+  if (IsWindows.isWindows) {
+    return Path.join(Root.root, 'packages', 'main-process', 'node_modules', '.bin', 'electron-rebuild.cmd')
+  }
   return Path.join(Root.root, 'packages', 'main-process', 'node_modules', '.bin', 'electron-rebuild')
 }

package/src/parts/GetFirstEvent/GetFirstEvent.js

@@ -0,0 +1,22 @@
+export const getFirstEvent = async (eventEmitter, eventMap) => {
+  const { type, event } = await new Promise((resolve, reject) => {
+    const listenerMap = Object.create(null)
+    const cleanup = (value) => {
+      for (const event of Object.keys(eventMap)) {
+        eventEmitter.off(event, listenerMap[event])
+      }
+      resolve(value)
+    }
+    for (const [event, type] of Object.entries(eventMap)) {
+      const listener = (event) => {
+        cleanup({
+          type,
+          event,
+        })
+      }
+      eventEmitter.on(event, listener)
+      listenerMap[event] = listener
+    }
+  })
+  return { type, event }
+}

package/src/parts/GetFirstNodeChildProcessEvent/GetFirstNodeChildProcessEvent.js

@@ -5,8 +5,10 @@ export const getFirstNodeChildProcessEvent = async (childProcess) => {
     let stderr = ''
     let stdout = ''
     const cleanup = (value) => {
-      childProcess.stderr.off('data', handleStdErrData)
-      childProcess.stdout.off('data', handleStdoutData)
+      if (childProcess.stdout && childProcess.stderr) {
+        childProcess.stderr.off('data', handleStdErrData)
+        childProcess.stdout.off('data', handleStdoutData)
+      }
       childProcess.off('message', handleMessage)
       childProcess.off('exit', handleExit)
       childProcess.off('error', handleError)
@@ -27,8 +29,10 @@ export const getFirstNodeChildProcessEvent = async (childProcess) => {
     const handleError = (event) => {
       cleanup({ type: FirstNodeWorkerEventType.Error, event, stdout, stderr })
     }
-    childProcess.stderr.on('data', handleStdErrData)
-    childProcess.stdout.on('data', handleStdoutData)
+    if (childProcess.stdout && childProcess.stderr) {
+      childProcess.stderr.on('data', handleStdErrData)
+      childProcess.stdout.on('data', handleStdoutData)
+    }
     childProcess.on('message', handleMessage)
     childProcess.on('exit', handleExit)
     childProcess.on('error', handleError)

package/src/parts/GetFirstNodeWorkerEvent/GetFirstNodeWorkerEvent.js

@@ -1,20 +1,9 @@
 import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+import * as GetFirstEvent from '../GetFirstEvent/GetFirstEvent.js'
 
-export const getFirstNodeWorkerEvent = async (worker) => {
-  const { type, event } = await new Promise((resolve, reject) => {
-    const cleanup = (value) => {
-      worker.off('exit', handleExit)
-      worker.off('error', handleError)
-      resolve(value)
-    }
-    const handleExit = (event) => {
-      cleanup({ type: FirstNodeWorkerEventType.Exit, event })
-    }
-    const handleError = (event) => {
-      cleanup({ type: FirstNodeWorkerEventType.Error, event })
-    }
-    worker.on('exit', handleExit)
-    worker.on('error', handleError)
+export const getFirstNodeWorkerEvent = (worker) => {
+  return GetFirstEvent.getFirstEvent(worker, {
+    exit: FirstNodeWorkerEventType.Exit,
+    error: FirstNodeWorkerEventType.Error,
   })
-  return { type, event }
 }

package/src/parts/GetFirstWebSocketEvent/GetFirstWebSocketEvent.js

@@ -1,14 +1,14 @@
 import * as FirstWebSocketEventType from '../FirstWebSocketEventType/FirstWebSocketEventType.js'
-import { WebSocket } from 'ws'
+import * as WebSocketReadyState from '../WebSocketReadyState/WebSocketReadyState.js'
 
 export const getFirstWebSocketEvent = async (webSocket) => {
   switch (webSocket.readyState) {
-    case WebSocket.OPEN:
+    case WebSocketReadyState.Open:
       return {
         type: FirstWebSocketEventType.Open,
         event: undefined,
       }
-    case WebSocket.CLOSED:
+    case WebSocketReadyState.Closed:
       return {
         type: FirstWebSocketEventType.Close,
         event: undefined,

package/src/parts/GetHttpErrorMessage/GetHttpErrorMessage.js

@@ -0,0 +1,28 @@
+import { HTTPError } from 'got'
+
+/**
+ *
+ * @param {HTTPError} error
+ */
+export const getHttpErrorMessage = (error) => {
+  try {
+    const body = error.response.body
+    if (error.response.url.includes('api.github.com') && typeof body === 'string') {
+      const json = JSON.parse(body)
+      if (json.message) {
+        const message = json.message
+        if (message.includes('rate limit exceeded')) {
+          const reset = error.response.headers['x-ratelimit-reset']
+          const limit = error.response.headers['x-ratelimit-limit']
+          if (reset && typeof reset === 'string' && typeof limit === 'string') {
+            const resetDate = new Date(parseInt(reset) * 1000)
+            const limitAmount = parseInt(limit)
+            return `GitHub rate limit of ${limitAmount} requests per hour execeeded, resets at ${resetDate}`
+          }
+        }
+        return json.message
+      }
+    }
+  } catch {}
+  return `${error.message}`
+}

package/src/parts/GetLatestReleaseVersion/GetLatestReleaseVersion.js

@@ -1,33 +1,7 @@
 import got, { HTTPError } from 'got'
+import * as GetHttpErrorMessage from '../GetHttpErrorMessage/GetHttpErrorMessage.js'
 import { VError } from '../VError/VError.js'
 
-/**
- *
- * @param {HTTPError} error
- */
-const getHttpErrorMessage = (error) => {
-  try {
-    const body = error.response.body
-    if (error.response.url.includes('api.github.com') && typeof body === 'string') {
-      const json = JSON.parse(body)
-      if (json.message) {
-        const message = json.message
-        if (message.includes('rate limit exceeded')) {
-          const reset = error.response.headers['x-ratelimit-reset']
-          const limit = error.response.headers['x-ratelimit-limit']
-          if (reset && typeof reset === 'string' && typeof limit === 'string') {
-            const resetDate = new Date(parseInt(reset) * 1000)
-            const limitAmount = parseInt(limit)
-            return `GitHub rate limit of ${limitAmount} requests per hour execeeded, resets at ${resetDate}`
-          }
-        }
-        return json.message
-      }
-    }
-  } catch {}
-  return `${error.message}`
-}
-
 const parseVersionFromUrl = (url, repository) => {
   if (!url.includes('releases/tag')) {
     if (url.endsWith('/releases')) {
@@ -51,7 +25,7 @@ export const getLatestReleaseVersion = async (repository) => {
     return version
   } catch (error) {
     if (error instanceof HTTPError) {
-      const httpErrorMessage = getHttpErrorMessage(error)
+      const httpErrorMessage = GetHttpErrorMessage.getHttpErrorMessage(error)
       throw new VError(`Failed to get latest release for ${repository}: ${httpErrorMessage}`)
     }
     // @ts-ignore

package/src/parts/GetTerminalProcessPath/GetTerminalProcessPath.js

@@ -0,0 +1,6 @@
+import * as Path from '../Path/Path.js'
+import * as Root from '../Root/Root.js'
+
+export const getTerminalProcessPath = () => {
+  return Path.join(Root.root, 'packages', 'pty-host', 'src', 'ptyHostMain.js')
+}

package/src/parts/IpcParentType/IpcParentType.js

@@ -1,2 +1,3 @@
 export const NodeWorker = 1
 export const NodeForkedProcess = 2
+export const ElectronUtilityProcess = 3

package/src/parts/IpcParentWithElectronUtilityProcess/IpcParentWithElectronUtilityProcess.js

@@ -0,0 +1,12 @@
+import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+
+export const create = async (options) => {
+  // TODO how to launch process without race condition?
+  // when promise resolves, process might have already exited
+  const messagePort = await ParentIpc.invoke('IpcParent.create', { ...options })
+  return messagePort
+}
+
+export const wrap = (messagePort) => {
+  return {}
+}

package/src/parts/IsDlOpenError/IsDlOpenError.js

@@ -0,0 +1,5 @@
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+
+export const isDlOpenError = (error) => {
+  return error && error instanceof Error && 'code' in error && error.code === ErrorCodes.ERR_DLOPEN_FAILED
+}

package/src/parts/IsEsrchError/IsEsrchError.js

@@ -0,0 +1,5 @@
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+
+export const isEsrchError = (error) => {
+  return error && error.code === ErrorCodes.ESRCH
+}

package/src/parts/IsWindows/IsWindows.js

@@ -0,0 +1 @@
+export const isWindows = process.platform === 'win32'

package/src/parts/ListProcessGetName/ListProcessGetName.js

@@ -50,5 +50,8 @@ export const getName = (pid, cmd, rootPid, pidMap) => {
   if (cmd.startsWith(`/opt/sublime_text/sublime_text `)) {
     return 'sublime-text'
   }
+  if(cmd.includes('\\conhost.exe')){
+    return 'conhost.exe'
+  }
   return `${cmd}`
 }

package/src/parts/LoadWindowsProcessTree/LoadWindowsProcessTree.js

@@ -1,12 +1,12 @@
+import * as IsDlOpenError from '../IsDlOpenError/IsDlOpenError.js'
 import { VError } from '../VError/VError.js'
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 
 export const loadWindowProcessTree = async () => {
   try {
     // @ts-ignore
     return await import('@vscode/windows-process-tree')
   } catch (error) {
-    if (error && error instanceof Error && 'code' in error && error.code === ErrorCodes.ERR_DLOPEN_FAILED) {
+    if (IsDlOpenError.isDlOpenError(error)) {
       throw new VError(
         `Failed to load windows process tree: The native module "@vscode/windows-process-tree" is not compatible with this node version and must be compiled against a matching electron version using electron-rebuild`
       )

package/src/parts/Module/Module.js

@@ -20,8 +20,14 @@ export const load = (moduleId) => {
       return import('../Developer/Developer.ipc.js')
     case ModuleId.Download:
       return import('../Download/Download.ipc.js')
+    case ModuleId.ElectronContextMenu:
+      return import('../ElectronContextMenu/ElectronContextMenu.ipc.js')
     case ModuleId.ElectronInitialize:
       return import('../ElectronInitialize/ElectronInitialize.ipc.js')
+    case ModuleId.ElectronProcess:
+      return import('../ElectronProcess/ElectronProcess.ipc.js')
+    case ModuleId.ElectronSafeStorage:
+      return import('../ElectronSafeStorage/ElectronSafeStorage.ipc.js')
     case ModuleId.ExtensionHost:
       return import('../ExtensionHost/ExtensionHost.ipc.js')
     case ModuleId.ExtensionManagement:
@@ -52,6 +58,8 @@ export const load = (moduleId) => {
       return import('../OpenNativeFolder/OpenNativeFolder.ipc.js')
     case ModuleId.OutputChannel:
       return import('../OutputChannel/OutputChannel.ipc.js')
+    case ModuleId.Performance:
+      return import('../Performance/Performance.ipc.js')
     case ModuleId.Platform:
       return import('../Platform/Platform.ipc.js')
     case ModuleId.Preferences:
@@ -72,10 +80,10 @@ export const load = (moduleId) => {
       return import('../TextSearch/TextSearch.ipc.js')
     case ModuleId.WebSocketServer:
       return import('../WebSocketServer/WebSocketServer.ipc.js')
+    case ModuleId.Window:
+      return import('../Window/ElectronWindow.ipc.js')
     case ModuleId.Workspace:
       return import('../Workspace/Workspace.ipc.js')
-    case ModuleId.Performance:
-      return import('../Performance/Performance.ipc.js')
     default:
       throw new Error(`module ${moduleId} not found`)
   }

package/src/parts/ModuleId/ModuleId.js

@@ -24,14 +24,19 @@ export const IsAutoUpdateSupported = 23
 export const AutoUpdaterAppImage = 24
 export const AutoUpdaterWindowsNsis = 25
 export const RebuildNodePty = 26
+export const ElectronSafeStorage = 80
 export const ElectronInitialize = 27
 export const HandleWebSocket = 28
 export const Process = 29
 export const AttachDebugger = 30
 export const HandleElectronMessagePort = 31
+export const ElectronProcess = 70
 export const HandleNodeMessagePort = 32
 export const GetTerminalSpawnOptions = 33
 export const HandleCliArgs = 34
 export const ListProcessesWithMemoryUsage = 35
+export const ElectronContextMenu = 40
 export const IncrementalTextSearch = 36
 export const Performance = 37
+export const Window = 38
+export const PassThroughElectronMessagePort = 39

package/src/parts/ModuleMap/ModuleMap.js

@@ -3,6 +3,8 @@ import * as ModuleId from '../ModuleId/ModuleId.js'
 
 export const getModuleId = (commandId) => {
   switch (commandId) {
+    case 'PassthroughElectronMessagePort.passThroughElectronMessagePort':
+      return ModuleId.PassThroughElectronMessagePort
     case 'AttachDebugger.attachDebugger':
       return ModuleId.AttachDebugger
     case 'AutoUpdater.getAutoUpdateType':
@@ -22,6 +24,10 @@ export const getModuleId = (commandId) => {
     case 'ClipBoard.readFiles':
     case 'ClipBoard.writeFiles':
       return ModuleId.ClipBoard
+    case 'ElectronSafeStorage.encryptString':
+    case 'ElectronSafeStorage.decryptString':
+    case 'ElectronSafeStorage.isEncryptionAvailable':
+      return ModuleId.ElectronSafeStorage
     case 'Developer.allocateMemory':
     case 'Developer.crashSharedProcess':
     case 'Developer.createHeapSnapshot':
@@ -177,13 +183,25 @@ export const getModuleId = (commandId) => {
     case 'Terminal.resize':
     case 'Terminal.write':
       return ModuleId.Terminal
+    case 'ElectronProcess.getChromeVersion':
+    case 'ElectronProcess.getElectronVersion':
+      return ModuleId.ElectronProcess
     case 4820:
       return ModuleId.TextDocument
+    case 'ElectronContextMenu.openContextMenu':
+      return ModuleId.ElectronContextMenu
     case 'WebSocketServer.handleUpgrade':
       return ModuleId.WebSocketServer
     case 'Workspace.getHomeDir':
     case 'Workspace.resolveRoot':
       return ModuleId.Workspace
+    case 'ElectronWindow.minimize':
+    case 'ElectronWindow.maximize':
+    case 'ElectronWindow.toggleDevtools':
+    case 'ElectronWindow.unmaximize':
+    case 'ElectronWindow.close':
+    case 'ElectronWindow.reload':
+      return ModuleId.Window
     default:
       throw new CommandNotFoundError(commandId)
   }

package/src/parts/PassThroughElectronMessageForTerminalProcess/PassThroughElectronMessageForTerminalProcess.js

@@ -0,0 +1,29 @@
+import * as Assert from '../Assert/Assert.js'
+import * as GetTerminalProcessPath from '../GetTerminalProcessPath/GetTerminalProcessPath.js'
+import * as IpcParent from '../IpcParent/IpcParent.js'
+import * as IpcParentType from '../IpcParentType/IpcParentType.js'
+
+/**
+ *
+ * @returns
+ */
+export const handlePort = async (browserWindowPort, type, name) => {
+  Assert.object(browserWindowPort)
+  Assert.string(type)
+  Assert.string(name)
+  const ptyHostPath = GetTerminalProcessPath.getTerminalProcessPath()
+  const ipc = await IpcParent.create({
+    method: IpcParentType.ElectronUtilityProcess,
+    path: ptyHostPath,
+    name,
+  })
+  // TODO use connectIpc for better error handling
+  ipc.sendAndTransfer(
+    {
+      jsonrpc: '2.0',
+      method: 'HandleElectronMessagePort.handleElectronMessagePort',
+      params: [],
+    },
+    [browserWindowPort]
+  )
+}

package/src/parts/PassThroughElectronMessagePort/PassThroughElectronMessagePort.ipc.js

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

package/src/parts/PassThroughElectronMessagePort/PassThroughElectronMessagePort.js

@@ -0,0 +1,4 @@
+import * as Path from '../Path/Path.js'
+import * as Root from '../Root/Root.js'
+
+export const passThroughElectronMessagePort = () => {}

package/src/parts/PassThroughElectronMessagePortModule/PassThroughElectronMessagePortModule.js

@@ -0,0 +1,8 @@
+export const getModule = (type) => {
+  switch (type) {
+    case 'terminal-process':
+      return import('../PassThroughElectronMessageForTerminalProcess/PassThroughElectronMessageForTerminalProcess.js')
+    default:
+      return undefined
+  }
+}

package/src/parts/Platform/Platform.ipc.js

@@ -21,8 +21,8 @@ export const Commands = {
   getRecentlyOpenedPath: Platform.getRecentlyOpenedPath,
   getTestPath: Platform.getTestPath,
   getTmpDir: Platform.getTmpDir,
+  getUserKeyBindingsPath: Platform.getUserKeyBindingsPath,
   getUserSettingsPath: Platform.getUserSettingsPath,
   getVersion: Platform.getVersion,
   setEnvironmentVariables: Platform.setEnvironmentVariables,
-  getUserKeyBindingsPath: Platform.getUserKeyBindingsPath,
 }

package/src/parts/Platform/Platform.js

@@ -169,11 +169,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.16.17'
+export const version = '0.16.19'
 
-export const commit = '6f015ba'
+export const commit = '6594144'
 
-export const date = '2023-07-19T21:49:49.000Z'
+export const date = '2023-07-27T00:13:37.000Z'
 
 export const getVersion = () => {
   return version

package/src/parts/Preferences/Preferences.js

@@ -2,6 +2,7 @@ import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 import * as JsoncFile from '../JsoncFile/JsoncFile.js'
 import * as Platform from '../Platform/Platform.js'
 import * as Process from '../Process/Process.js'
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
 import { VError } from '../VError/VError.js'
 // TODO need jsonc parser for settings with comments
 
@@ -12,7 +13,7 @@ export const getUserPreferences = async () => {
     try {
       json = await JsoncFile.readJsonc(userSettingsPath)
     } catch (error) {
-      if (error && error.code === ErrorCodes.ENOENT) {
+      if (IsEnoentError.isEnoentError(error)) {
         return {}
       }
       throw error

package/src/parts/Process/Process.js

@@ -1,4 +1,5 @@
 import { VError } from '../VError/VError.js'
+import * as IsEsrchError from '../IsEsrchError/IsEsrchError.js'
 
 export const crash = (message) => {
   throw new Error(message)
@@ -34,6 +35,9 @@ export const kill = (pid, signal) => {
   try {
     process.kill(pid, signal)
   } catch (error) {
+    if (IsEsrchError.isEsrchError(error)) {
+      return
+    }
     throw new VError(error, `Failed to kill process ${pid} with signal ${signal}`)
   }
 }

package/src/parts/PtyHost/PtyHost.js

@@ -3,12 +3,13 @@ import * as Debug from '../Debug/Debug.js'
 import * as IpcParent from '../IpcParent/IpcParent.js'
 import * as IpcParentType from '../IpcParentType/IpcParentType.js'
 import * as PtyHostPath from '../PtyHostPath/PtyHostPath.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
 
 export const state = {
   /**
    * @type {any}
    */
-  ptyHost: undefined,
+  ipc: undefined,
   /**
    * @type {any}
    */
@@ -23,9 +24,9 @@ export const state = {
 }
 
 const cleanUpAll = () => {
-  if (state.ptyHost) {
-    state.ptyHost.dispose()
-    state.ptyHost = undefined
+  if (state.ipc) {
+    state.ipc.dispose()
+    state.ipc = undefined
   }
 }
 
@@ -46,11 +47,11 @@ const createPtyHost = async () => {
   })
   const handleClose = () => {
     ptyHost.off('close', handleClose)
-    state.ptyHost = undefined
+    state.ipc = undefined
     state.ptyHostPromise = undefined
   }
   ptyHost.on('close', handleClose)
-  state.ptyHost = ptyHost
+  state.ipc = ptyHost
   return ptyHost
 }
 
@@ -63,15 +64,15 @@ export const getOrCreate = () => {
 }
 
 export const getCurrentInstance = () => {
-  return state.ptyHost
+  return state.ipc
 }
 
 export const disposeAll = () => {
-  if (state.ptyHost) {
-    state.ptyHost.removeAllListeners()
-    if (state.ptyHost) {
-      state.ptyHost.dispose()
-      state.ptyHost = undefined
+  if (state.ipc) {
+    state.ipc.removeAllListeners()
+    if (state.ipc) {
+      state.ipc.dispose()
+      state.ipc = undefined
     }
     state.ptyHostState = /* None */ 0
     state.send = (message) => {
@@ -79,3 +80,7 @@ export const disposeAll = () => {
     }
   }
 }
+
+export const invoke = (method, ...params) => {
+  return JsonRpc.invoke(state.ipc, method, ...params)
+}

package/src/parts/RebuildForElectron/RebuildForElectron.js

@@ -0,0 +1,19 @@
+import { spawn } from 'node:child_process'
+import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+import * as GetElectronRebuildPath from '../GetElectronRebuildPath/GetElectronRebuildPath.js'
+import * as GetFirstNodeChildProcessEvent from '../GetFirstNodeChildProcessEvent/GetFirstNodeChildProcessEvent.js'
+
+/**
+ * @param {string} cwd
+ */
+export const rebuild = async (cwd) => {
+  const electronRebuildPath = GetElectronRebuildPath.getElectronRebuildPath()
+  const childProcess = spawn(electronRebuildPath, [], {
+    cwd,
+    stdio: 'inherit',
+  })
+  const { type, event } = await GetFirstNodeChildProcessEvent.getFirstNodeChildProcessEvent(childProcess)
+  if (type === FirstNodeWorkerEventType.Error) {
+    throw new Error(`Failed to rebuild native module: ${event}`)
+  }
+}

package/src/parts/RebuildForNode/RebuildForNode.js

@@ -0,0 +1,17 @@
+import { spawn } from 'node:child_process'
+import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+import * as GetFirstNodeChildProcessEvent from '../GetFirstNodeChildProcessEvent/GetFirstNodeChildProcessEvent.js'
+
+/**
+ * @param {string} cwd
+ */
+export const rebuild = async (cwd) => {
+  const childProcess = spawn('npm', ['rebuild'], {
+    cwd,
+    stdio: 'inherit',
+  })
+  const { type, event } = await GetFirstNodeChildProcessEvent.getFirstNodeChildProcessEvent(childProcess)
+  if (type === FirstNodeWorkerEventType.Error) {
+    throw new Error(`Failed to rebuild native module: ${event}`)
+  }
+}

package/src/parts/RebuildNodePty/RebuildNodePty.js

@@ -1,5 +1,3 @@
-import { spawn } from 'node:child_process'
-import * as GetElectronRebuildPath from '../GetElectronRebuildPath/GetElectronRebuildPath.js'
 import * as IsElectron from '../IsElectron/IsElectron.js'
 import * as Path from '../Path/Path.js'
 import * as Root from '../Root/Root.js'
@@ -9,40 +7,18 @@ const getPtyHostPath = () => {
   return Path.join(Root.root, 'packages', 'pty-host')
 }
 
-/**
- * @param {string} cwd
- */
-const rebuildNodePtyElectron = async (cwd) => {
-  const electronRebuildPath = GetElectronRebuildPath.getElectronRebuildPath()
-  const childProcess = spawn(electronRebuildPath, [], {
-    cwd,
-    stdio: 'inherit',
-  })
-  // TODO wait for child process to be finished
-}
-
-/**
- * @param {string} cwd
- */
-const rebuildNodePtyNode = async (cwd) => {
-  const childProcess = spawn('npm', ['rebuild'], {
-    cwd,
-    stdio: 'inherit',
-  })
-}
-
-const getFn = () => {
+const getModule = () => {
   if (IsElectron.isElectron()) {
-    return rebuildNodePtyElectron
+    return import('../RebuildForElectron/RebuildForElectron.js')
   }
-  return rebuildNodePtyNode
+  return import('../RebuildForNode/RebuildForNode.js')
 }
 
 export const rebuildNodePty = async () => {
   try {
     const ptyHostPath = getPtyHostPath()
-    const rebuild = getFn()
-    await rebuild(ptyHostPath)
+    const module = await getModule()
+    await module.rebuild(ptyHostPath)
   } catch (error) {
     throw new VError(error, `Failed to rebuild node-pty`)
   }

package/src/parts/RecentlyOpened/RecentlyOpened.js

@@ -5,6 +5,7 @@ import * as FileSystem from '../FileSystem/FileSystem.js'
 import * as Json from '../Json/Json.js'
 import * as JsonFile from '../JsonFile/JsonFile.js'
 import * as Platform from '../Platform/Platform.js'
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
 import { VError } from '../VError/VError.js'
 
 const addToArrayUnique = (recentlyOpened, path) => {
@@ -20,7 +21,7 @@ const getRecentlyOpened = async (recentlyOpenedPath) => {
     const parsed = await JsonFile.readJson(recentlyOpenedPath)
     return parsed
   } catch (error) {
-    if (error && error.code === ErrorCodes.ENOENT) {
+    if (IsEnoentError.isEnoentError(error)) {
       // ignore
     } else if (error && error.code === ErrorCodes.E_JSON_PARSE) {
       // ignore
@@ -36,7 +37,7 @@ const setRecentlyOpened = async (recentlyOpenedPath, newRecentlyOpened) => {
   try {
     await FileSystem.writeFile(recentlyOpenedPath, stringified)
   } catch (error) {
-    if (error && error.code === ErrorCodes.ENOENT) {
+    if (IsEnoentError.isEnoentError(error)) {
       await FileSystem.mkdir(dirname(recentlyOpenedPath))
       await FileSystem.writeFile(recentlyOpenedPath, stringified)
       return

package/src/parts/Terminal/Terminal.js

@@ -37,9 +37,11 @@ export const create = async (ipc, id, cwd, command, args) => {
     const ptyHost = await PtyHost.getOrCreate()
     const terminal = createTerminal(ptyHost, ipc)
     TerminalState.add(id, terminal)
-    // TODO use invoke
-    const message = JsonRpcEvent.create('Terminal.create', [id, cwd, command, args])
-    ptyHost.send(message)
+    // TODO improve ipc error handling and await promise
+    // current can't await promise because when process exits
+    // because of native module error, promise is not resolved
+    // causing application which waits on this promise to hang
+    PtyHost.invoke('Terminal.create', id, cwd, command, args)
   } catch (error) {
     throw new VError(error, `Failed to create terminal`)
   }

package/src/parts/WaitForProcessToExit/WaitForProcessToExit.js

@@ -1,29 +1,9 @@
 import * as ProcessExitEventType from '../ProcessExitEventType/ProcessExitEventType.js'
+import * as GetFirstEvent from '../GetFirstEvent/GetFirstEvent.js'
 
 export const waitForProcessToExit = async (childProcess) => {
-  const { type, event } = await new Promise((resolve, reject) => {
-    const cleanup = (value) => {
-      childProcess.off('close', handleClose)
-      childProcess.off('error', handleError)
-      resolve(value)
-    }
-    const handleClose = (event) => {
-      cleanup({
-        type: ProcessExitEventType.Exit,
-        event,
-      })
-    }
-    const handleError = (event) => {
-      cleanup({
-        type: ProcessExitEventType.Error,
-        event,
-      })
-    }
-    childProcess.on('close', handleClose)
-    childProcess.on('error', handleError)
+  return GetFirstEvent.getFirstEvent(childProcess, {
+    error: ProcessExitEventType.Error,
+    close: ProcessExitEventType.Exit,
   })
-  return {
-    type,
-    event,
-  }
 }

package/src/parts/WebSocketReadyState/WebSocketReadyState.js

@@ -0,0 +1,5 @@
+import { WebSocket } from 'ws'
+
+export const Open = WebSocket.OPEN
+
+export const Closed = WebSocket.CLOSED

package/src/parts/Window/ElectronWindow.ipc.js

@@ -0,0 +1,12 @@
+import * as ElectronWindow from './ElectronWindow.js'
+
+export const name = 'ElectronWindow'
+
+export const Commands = {
+  close: ElectronWindow.close,
+  maximize: ElectronWindow.maximize,
+  minimize: ElectronWindow.minimize,
+  reload: ElectronWindow.reload,
+  toggleDevtools: ElectronWindow.toggleDevtools,
+  unmaximize: ElectronWindow.unmaximize,
+}

package/src/parts/Window/ElectronWindow.js

@@ -0,0 +1,32 @@
+import * as Assert from '../Assert/Assert.js'
+import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+
+export const minimize = (windowId) => {
+  Assert.number(windowId)
+  return ParentIpc.invoke('ElectronWindow.minimize', windowId)
+}
+
+export const toggleDevtools = (windowId) => {
+  Assert.number(windowId)
+  return ParentIpc.invoke('ElectronWindow.toggleDevtools', windowId)
+}
+
+export const maximize = (windowId) => {
+  Assert.number(windowId)
+  return ParentIpc.invoke('ElectronWindow.maximize', windowId)
+}
+
+export const unmaximize = (windowId) => {
+  Assert.number(windowId)
+  return ParentIpc.invoke('ElectronWindow.unmaximize')
+}
+
+export const close = (windowId) => {
+  Assert.number(windowId)
+  return ParentIpc.invoke('ElectronWindow.close', windowId)
+}
+
+export const reload = (windowId) => {
+  Assert.number(windowId)
+  return ParentIpc.invoke('ElectronWindow.reload', windowId)
+}