@lvce-editor/shared-process 0.0.2

package/src/parts/Command/Command.js

@@ -0,0 +1,264 @@
+const MODULE_FILE_SYSTEM = 1
+const MODULE_WORKSPACE = 2
+const MODULE_TERMINAL = 3
+const MODULE_SEARCH = 5
+const MODULE_SEARCH_FILE = 6
+const MODULE_OUTPUT_CHANNEL = 7
+const MODULE_DEVELOPER = 8
+const MODULE_EXTENSION_MANAGEMENT = 9
+const MODULE_EXTENSION_HOST = 10
+const MODULE_PREFERENCES = 11
+const MODULE_NATIVE = 12
+const MODULE_CLIPBOARD = 13
+const MODULE_TEXT_DOCUMENT = 14
+const MODULE_ELECTRON = 15
+const MODULE_WEBSOCKET_SERVER = 16
+const MODULE_PLATFORM = 17
+
+const commands = Object.create(null)
+const invocables = Object.create(null)
+
+const pendingModules = Object.create(null)
+
+const loadModule = (moduleId) => {
+  switch (moduleId) {
+    case MODULE_FILE_SYSTEM:
+      return import('../FileSystem/FileSystem.ipc.js')
+    case MODULE_WORKSPACE:
+      return import('../Workspace/Workspace.ipc.js')
+    case MODULE_TERMINAL:
+      return import('../Terminal/Terminal.ipc.js')
+    case MODULE_SEARCH:
+      return import('../Search/Search.ipc.js')
+    case MODULE_SEARCH_FILE:
+      return import('../SearchFile/SearchFile.ipc.js')
+    case MODULE_OUTPUT_CHANNEL:
+      return import('../OutputChannel/OutputChannel.ipc.js')
+    case MODULE_DEVELOPER:
+      return import('../Developer/Developer.ipc.js')
+    case MODULE_EXTENSION_MANAGEMENT:
+      return import('../ExtensionManagement/ExtensionManagement.ipc.js')
+    case MODULE_EXTENSION_HOST:
+      return import('../ExtensionHost/ExtensionHost.ipc.js')
+    case MODULE_PREFERENCES:
+      return import('../Preferences/Preferences.ipc.js')
+    case MODULE_NATIVE:
+      return import('../Native/Native.ipc.js')
+    case MODULE_CLIPBOARD:
+      return import('../ClipBoard/ClipBoard.ipc.js')
+    case MODULE_TEXT_DOCUMENT:
+      return import('../TextDocument/TextDocument.ipc.js')
+    case MODULE_ELECTRON:
+      return import('../Electron/Electron.ipc.js')
+    case MODULE_WEBSOCKET_SERVER:
+      return import('../WebSocketServer/WebSocketServer.ipc.js')
+    case MODULE_PLATFORM:
+      return import('../Platform/Platform.ipc.js')
+    default:
+      throw new Error(`unknown module ${moduleId}`)
+  }
+}
+
+const getOrLoadModule = (moduleId) => {
+  if (!pendingModules[moduleId]) {
+    const importPromise = loadModule(moduleId)
+    pendingModules[moduleId] = importPromise
+      .then((module) => module.__initialize__())
+      .catch((error) => {
+        console.error(error)
+      })
+  }
+  return pendingModules[moduleId]
+}
+
+const getModuleId = (commandId) => {
+  switch (commandId) {
+    case 'FileSystem.readFile':
+    case 'FileSystem.writeFile':
+    case 'FileSystem.readDirWithFileTypes':
+    case 'FileSystem.remove':
+    case 'FileSystem.mkdir':
+    case 'FileSystem.createFile':
+    case 'FileSystem.createFolder':
+    case 'FileSystem.rename':
+    case 'FileSystem.ensureFile':
+    case 'FileSystem.copy':
+    case 'FileSystem.getPathSeparator':
+      return MODULE_FILE_SYSTEM
+    case 'Workspace.resolveRoot':
+    case 'Workspace.getHomeDir':
+      return MODULE_WORKSPACE
+    case 'Native.openFolder':
+      return MODULE_NATIVE
+    case 'ClipBoard.readFiles':
+    case 'ClipBoard.writeFiles':
+      return MODULE_CLIPBOARD
+    case 'Developer.sharedProcessStartupPerformance':
+    case 'Developer.sharedProcessMemoryUsage':
+    case 'Developer.allocateMemory':
+    case 'Developer.crashSharedProcess':
+    case 'Developer.createHeapSnapshot':
+    case 'Developer.createProfile':
+    case 'Developer.getNodeStartupTiming':
+      return MODULE_DEVELOPER
+    case 'ExtensionHost.getColorThemeJson':
+    case 'ExtensionHost.getIconThemeJson':
+    case 'ExtensionHost.executeTabCompletionProvider':
+    case 'ExtensionHostLanguages.getLanguages':
+    case 'ExtensionHost.getIconTheme':
+    case 'ExtensionHostKeyBindings.getKeyBindings':
+    case 'ExtensionHost.executeCommand':
+    case 'ExtensionHost.getColorThemeJson':
+    case 'ExtensionHost.getColorThemeNames':
+    case 'ExtensionHost.getMemoryUsage':
+    case 'ExtensionHost.getSourceControlBadgeCount':
+    case 'ExtensionHost.format':
+    case 'ExtensionHost.executeCommand':
+    case 'ExtensionHost.getSourceControlBadgeCount':
+    case 'ExtensionHost.getLanguageConfiguration':
+    case 'ExtensionHost.getColorThemes':
+    case 'ExtensionHostTextDocument.syncInitial':
+    case 'ExtensionHostHover.execute':
+    case 'ExtensionHostDiagnostic.execute':
+    case 'ExtensionHostTextDocument':
+    case 'EXtensionHostRename.executePrepareRename':
+    case 'ExtensionHostRename.executeRename':
+    case 'ExtensionHostDefinition.executeDefinitionProvider':
+    case 'ExtensionHostFileSystem.readFile':
+    case 'ExtensionHostFileSystem.writeFile':
+    case 'ExtensionHostFileSystem.readDirWithFileTypes':
+    case 'ExtensionHostFileSystem.remove':
+    case 'ExtensionHostFileSystem.rename':
+    case 'ExtensionHostSourceControl.acceptInput':
+    case 'ExtensionHost.start':
+    case 'ExtensionHostManagement.activateAll':
+    case 'ExtensionHostManagement.enableExtensions':
+    case 'ExtensionHostFileSystem.getPathSeparator':
+    case 'ExtensionHostWorkspace.setWorkspacePath':
+    case 'ExtensionHostOutput.getOutputChannels':
+    case 'ExtensionHost.getStatusBarItems':
+    case 'ExtensionHost.registerChangeListener':
+    case 'ExtensionHostTextDocument.setLanguageId':
+    case 'ExtensionHostQuickPick.handleQuickPickResult':
+    case 'ExtensionHostBraceCompletion.executeBraceCompletionProvider':
+    case 'ExtensionHostReferences.executeReferenceProvider':
+    case 'ExtensionHostImplementation.executeImplementationProvider':
+    case 'ExtensionHostClosingTag.executeTypeDefinitionProvider':
+    case 'ExtensionHostClosingTag.execute':
+    case 'ExtensionHostTextDocument.syncFull':
+    case 'ExtensionHost.setWorkspacePath':
+    case 'ExtensionHost.enableExtension':
+    case 'ExtensionHost.getIconThemeJson':
+    case 'ExtensionHost.getLanguages':
+    case 'ExtensionHostCompletion.execute':
+    case 'ExtensionHostTextDocument.syncIncremental':
+    case 'ExtensionHostClosingTag.executeClosingTagProvider':
+    case 'ExtensionHost.sourceControlGetChangedFiles':
+    case 'ExtensionHostSemanticTokens.executeSemanticTokenProvider':
+      return MODULE_EXTENSION_HOST
+    case 'ExtensionManagement.install':
+    case 'ExtensionManagement.uninstall':
+    case 'ExtensionManagement.enable':
+    case 'ExtensionManagement.disable':
+    case 'ExtensionManagement.getAllExtensions':
+    case 'ExtensionManagement.getExtensions':
+      return MODULE_EXTENSION_MANAGEMENT
+    case 'Search.search':
+      return MODULE_SEARCH
+    case 'Platform.getConfigDir':
+    case 'Platform.getAppDir':
+    case 'Platform.getHomeDir':
+    case 'Platform.getDataDir':
+    case 'Platform.getExtensionsPath':
+    case 'Platform.getBuiltinExtensionsPath':
+    case 'Platform.getDisabledExtensionsPath':
+    case 'Platform.getCachedExtensionsPath':
+    case 'Platform.getMarketplaceUrl':
+    case 'Platform.getLogsDir':
+    case 'Platform.getUserSettingsPath':
+    case 'Platform.getRecentlyOpenedPath':
+    case 'Platform.getCacheDir':
+      return MODULE_PLATFORM
+    case 'Terminal.create':
+    case 'Terminal.dispose':
+    case 'Terminal.write':
+    case 'Terminal.resize':
+      return MODULE_TERMINAL
+    case 'Preferences.getAll':
+      return MODULE_PREFERENCES
+    case 4820:
+      return MODULE_TEXT_DOCUMENT
+    case 5621:
+      return MODULE_WEBSOCKET_SERVER
+    case 'SearchFile.searchFile':
+      return MODULE_SEARCH_FILE
+    case 'OutputChannel.open':
+    case 'OutputChannel.close':
+      return MODULE_OUTPUT_CHANNEL
+    case 'Electron.toggleDevtools':
+    case 'Electron.windowMinimize':
+    case 'Electron.windowMaximize':
+    case 'Electron.windowUnmaximize':
+    case 'Electron.windowClose':
+    case 'Electron.about':
+    case 'Electron.showOpenDialog':
+    case 'Electron.windowReload':
+    case 'Electron.getPerformanceEntries':
+    case 'Electron.crashMainProcess':
+    case 'Electron.showMessageBox':
+    case 'Electron.windowOpenNew':
+    case 'Electron.exit':
+    case 'Electron.openProcessExplorer':
+      return MODULE_ELECTRON
+    default:
+      throw new Error(`command ${commandId} not found`)
+  }
+}
+
+const loadCommand = (command) => getOrLoadModule(getModuleId(command))
+
+export const register = (commandId, listener) => {
+  commands[commandId] = listener
+}
+
+export const registerInvocable = (commandId, listener) => {
+  invocables[commandId] = listener
+}
+
+export const invoke = async (command, ...args) => {
+  if (!(command in commands)) {
+    await loadCommand(command)
+    if (!(command in commands)) {
+      console.warn(`[shared process] Unknown command "${command}"`)
+      return
+    }
+  }
+  if (typeof commands[command] !== 'function') {
+    throw new Error(`Command ${command} is not a function`)
+  }
+  return commands[command](...args)
+}
+
+export const execute = (command, ...args) => {
+  if (command in commands) {
+    commands[command](...args)
+  } else {
+    loadCommand(command)
+      // TODO can skip then block in prod (only to prevent endless loop in dev)
+      .then(() => {
+        if (!(command in commands)) {
+          console.warn(`Unknown command "${command}"`)
+          return
+        }
+        try {
+          execute(command, ...args)
+        } catch (error) {
+          console.error('[shared process] command failed to execute')
+          console.error(error)
+        }
+      })
+      .catch((error) => {
+        console.error(error)
+      })
+  }
+}

package/src/parts/Configuration/Configuration.ipc.js

@@ -0,0 +1,7 @@
+import * as Command from '../Command/Command.js'
+import * as Configuration from './Configuration.js'
+
+export const __initialize = () => {
+  Command.register(-1, Configuration.get)
+  Command.register(-1, Configuration.set)
+}

package/src/parts/Configuration/Configuration.js

@@ -0,0 +1,39 @@
+import { readFile } from 'node:fs/promises'
+import { writeFile } from '../FileSystem/FileSystem.js'
+import * as ReadJson from '../JsonFile/JsonFile.js'
+
+let settings
+let settingsPromise
+
+const readSettings = async () => {
+  // TODO allow jsonc
+  if (!settings) {
+    if (!settingsPromise) {
+      settingsPromise = ReadJson.readJson('/tmp/settings.json')
+    }
+    await settingsPromise
+  }
+  return settings
+}
+
+const writeSettings = async () => {
+  // TODO jsonc
+  await writeFile(
+    '/tmp/settings.json',
+    JSON.stringify(settings, null, 2) + '\n'
+  )
+}
+
+export const get = async (key) => {
+  await readSettings()
+  // TODO allow nested object get
+  return settings[key]
+}
+
+export const set = async (key, value) => {
+  await readSettings()
+  // TODO allow nested object set?
+  // how does vscode do it?
+  settings[key] = value
+  await writeSettings()
+}

package/src/parts/Credentials/Credentials.ipc.js

@@ -0,0 +1,10 @@
+import * as Command from '../Command/Command.js'
+import * as Credentials from './Credentials.js'
+
+export const __initialize__ = () => {
+  Command.register(801, Credentials.getPassword)
+  Command.register(802, Credentials.setPassword)
+  Command.register(803, Credentials.deletePassword)
+  Command.register(804, Credentials.findPassword)
+  Command.register(805, Credentials.findCredentials)
+}

package/src/parts/Credentials/Credentials.js

@@ -0,0 +1,69 @@
+import keytar from 'keytar'
+import VError from 'verror'
+
+/**
+ * @param {string} service
+ * @param {string} account
+ */
+export const deletePassword = async (service, account) => {
+  try {
+    return await keytar.deletePassword(service, account)
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, `Failed to delete password from service ${service}`)
+  }
+}
+
+/**
+ * @param {string} service
+ */
+export const findCredentials = async (service) => {
+  try {
+    return keytar.findCredentials(service)
+  } catch (error) {
+    throw new VError(
+      // @ts-ignore
+      error,
+      `Failed to find credentials from service ${service}`
+    )
+  }
+}
+
+/**
+ * @param {string} service
+ */
+export const findPassword = async (service) => {
+  try {
+    return await keytar.findPassword(service)
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, `Failed to find password from service ${service}`)
+  }
+}
+
+/**
+ * @param {string} service
+ * @param {string} account
+ */
+export const getPassword = async (service, account) => {
+  try {
+    return await keytar.getPassword(service, account)
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, `Failed to get password from service ${service}`)
+  }
+}
+
+/**
+ * @param {string} service
+ * @param {string} account
+ * @param {string} password
+ */
+export const setPassword = async (service, account, password) => {
+  try {
+    return await keytar.setPassword(service, account, password)
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, `Failed to set password for service ${service}`)
+  }
+}

package/src/parts/Debug/Debug.js

@@ -0,0 +1,3 @@
+import debugModule from 'debug'
+
+export const debug = debugModule('shared-process')

package/src/parts/Developer/Developer.ipc.js

@@ -0,0 +1,20 @@
+import * as Command from '../Command/Command.js'
+import * as Developer from './Developer.js'
+
+export const __initialize__ = () => {
+  // Command.register(
+  //   281,
+  //   Developer.measureLatencyBetweenExtensionHostAndSharedProcess
+  // )
+  // Command.register(
+  //   282,
+  //   Developer.measureLatencyBetweenSharedProcessAndRendererProcess
+  // )
+  Command.register('Developer.sharedProcessStartupPerformance', Developer.sharedProcessStartupPerformance)
+  Command.register('Developer.sharedProcessMemoryUsage', Developer.sharedProcessMemoryUsage)
+  Command.register('Developer.allocateMemory', Developer.allocateMemory)
+  Command.register('Developer.crashSharedProcess', Developer.crashSharedProcess)
+  Command.register('Developer.createHeapSnapshot', Developer.createHeapSnapshot)
+  Command.register('Developer.createProfile', Developer.createProfile)
+  Command.register('Developer.getNodeStartupTiming', Developer.getNodeStartupTiming)
+}

package/src/parts/Developer/Developer.js

@@ -0,0 +1,132 @@
+import { createWriteStream, writeFileSync } from 'node:fs'
+import { performance } from 'node:perf_hooks'
+import * as ExtensionHost from '../ExtensionHost/ExtensionHost.js'
+
+export const measureLatencyBetweenExtensionHostAndSharedProcess = async (
+  socket,
+  id
+) => {
+  // TODO lazy load extension host
+  const latency = await ExtensionHost.measureLatency()
+  socket.send([/* callback */ id, /* latency */ latency])
+}
+
+export const measureLatencyBetweenSharedProcessAndRendererProcess = async (
+  socket,
+  id
+) => {
+  // const start = performance.now()
+  // await new Promise((resolve) => {
+  //   const callbackId = Callback.register(resolve)
+  //   socket.send(JSON.stringify([/* ping */ 1, /* callbackId */ callbackId]))
+  // })
+  // const end = performance.now()
+  // const latency = end - start
+  const latency = 200
+  socket.send([/* callback */ id, /* latency */ latency])
+}
+
+export const sharedProcessStartupPerformance = () => {
+  // TODO
+  // performance.eventLoopUtilization
+}
+
+export const getNodeStartupTiming = () => {
+  const {
+    name,
+    entryType,
+    startTime,
+    duration,
+    // @ts-ignore
+    nodeStart,
+    v8Start,
+    bootstrapComplete,
+    environment,
+    loopStart,
+    loopExit,
+    idleTime,
+  } = performance.nodeTiming
+  return {
+    name,
+    entryType,
+    startTime,
+    duration,
+    nodeStart,
+    v8Start,
+    bootstrapComplete,
+    environment,
+    loopStart,
+    loopExit,
+    idleTime,
+  }
+}
+
+export const sharedProcessMemoryUsage = () => {
+  // TODO also print out number of watched files
+  return process.memoryUsage()
+}
+
+// TODO not sure if this is actually useful
+
+/* istanbul ignore next */
+export const allocateMemory = () => {
+  const array = Array.from({ length: 1e7 }).fill('some string')
+  globalThis.arr = array
+}
+
+/* istanbul ignore next */
+export const crashSharedProcess = () => {
+  setTimeout(() => {
+    throw new Error('oops')
+  }, 0)
+}
+
+export const osStats = () => {
+  // TODO stats
+  // - os name
+  // - uptime
+  // - cpu usage
+  // - ram usage
+  // - cpu temperature
+  // - network usage
+}
+
+/* istanbul ignore next */
+export const createHeapSnapshot = async () => {
+  const { getHeapSnapshot } = await import('node:v8')
+  const { pipeline } = await import('node:stream/promises')
+  await pipeline(
+    getHeapSnapshot(),
+    // TODO get tmp dir from env
+    createWriteStream(`/tmp/vscode-${Date.now()}.heapsnapshot`)
+  )
+}
+
+export const createProfile = async () => {
+  const inspector = await import('node:inspector')
+  const session = new inspector.Session()
+  session.connect()
+
+  await new Promise((resolve) => {
+    session.post('Profiler.enable', () => {
+      session.post('Profiler.start', () => {
+        // Invoke business logic under measurement here...
+
+        setTimeout(() => {
+          session.post('Profiler.stop', (error, { profile }) => {
+            // Write profile to disk, upload, etc.
+            if (!error) {
+              writeFileSync(
+                '/tmp/vscode-profile.cpuprofile',
+                JSON.stringify(profile)
+              )
+            }
+          })
+        }, 15000)
+        // some time later...
+      })
+    })
+  })
+}
+
+// require('inspector').open()

package/src/parts/Download/Download.js

@@ -0,0 +1,33 @@
+import { createReadStream, createWriteStream } from 'node:fs'
+import { mkdir, rm } from 'node:fs/promises'
+import { pipeline } from 'node:stream/promises'
+import { createBrotliDecompress } from 'node:zlib'
+import got from 'got'
+import tar from 'tar-fs'
+import * as Error from '../Error/Error.js'
+import * as Path from '../Path/Path.js'
+
+export const download = async (url, outFile) => {
+  try {
+    await mkdir(Path.dirname(outFile), { recursive: true })
+    await pipeline(got.stream(url), createWriteStream(outFile))
+  } catch (error) {
+    try {
+      await rm(outFile)
+    } catch {}
+    throw new Error.OperationalError({
+      cause: error,
+      code: 'E_DOWNLOAD_FAILED',
+      message: `Failed to download "${url}"`,
+    })
+  }
+}
+
+export const extract = async (inFile, outDir) => {
+  await mkdir(outDir, { recursive: true })
+  await pipeline(
+    createReadStream(inFile),
+    createBrotliDecompress(),
+    tar.extract(outDir)
+  )
+}

package/src/parts/Electron/Electron.ipc.js

@@ -0,0 +1,19 @@
+import * as Command from '../Command/Command.js'
+import * as Electron from './Electron.js'
+
+export const __initialize__ = () => {
+  Command.register('Electron.toggleDevtools', Electron.toggleDevtools)
+  Command.register('Electron.windowMinimize', Electron.windowMinimize)
+  Command.register('Electron.windowMaximize', Electron.windowMaximize)
+  Command.register('Electron.windowUnmaximize', Electron.windowUnmaximize)
+  Command.register('Electron.windowClose', Electron.windowClose)
+  Command.register('Electron.about', Electron.about)
+  Command.register('Electron.showOpenDialog', Electron.showOpenDialog)
+  Command.register('Electron.windowReload', Electron.windowReload)
+  Command.register('Electron.getPerformanceEntries', Electron.getPerformanceEntries)
+  Command.register('Electron.crashMainProcess', Electron.crashMainProcess)
+  Command.register('Electron.showMessageBox', Electron.showMessageBox)
+  Command.register('Electron.windowOpenNew', Electron.windowOpenNew)
+  Command.register('Electron.exit', Electron.exit)
+  Command.register('Electron.openProcessExplorer', Electron.openProcessExplorer)
+}