@lvce-editor/shared-process 0.0.2

package/src/parts/Socket/Socket.js

@@ -0,0 +1,132 @@
+import VError from 'verror'
+import * as Command from '../Command/Command.js'
+import * as Error from '../Error/Error.js'
+import { requiresSocket } from '../RequiresSocket/RequiresSocket.js'
+
+export const state = {
+  /**
+   * @type {any}
+   */
+  socket: undefined,
+}
+
+export const send = (message) => {
+  if (!state.socket) {
+    console.warn('socket not yet available')
+    return
+  }
+  state.socket.send(message)
+}
+
+const handleMessage = async (event) => {
+  const object = JSON.parse(event.data)
+  if (object.id) {
+    if (!object.params) {
+      console.warn(
+        '[shared-process] invalid message 1',
+        typeof object,
+        object.params,
+        object
+      )
+      return
+    }
+    let result
+    try {
+      result = requiresSocket(object.method)
+        ? await Command.invoke(object.method, state.socket, ...object.params)
+        : await Command.invoke(object.method, ...object.params)
+    } catch (error) {
+      if (error instanceof Error.OperationalError) {
+        // console.log({ error })
+        const rawCause = error.cause()
+        const errorCause = rawCause ? rawCause.message : ''
+        const errorMessage = rawCause
+          ? error.message.slice(0, error.message.indexOf(errorCause))
+          : ''
+
+        // console.info('expected error', error)
+        send({
+          jsonrpc: '2.0',
+          id: object.id,
+          error: {
+            code: /* ExpectedError */ -32000,
+            message: error.message,
+            data: {
+              stack: error.originalStack,
+              codeFrame: error.originalCodeFrame,
+              category: error.category,
+              // @ts-ignore
+              stderr: error.stderr,
+            },
+          },
+        })
+      } else {
+        console.error(error)
+        // TODO check if socket is active
+        send({
+          jsonrpc: '2.0',
+          id: object.id,
+          error: {
+            code: /* UnexpectedError */ -32001,
+            // @ts-ignore
+            message: error.toString(),
+          },
+        })
+      }
+      return
+    }
+    send({
+      jsonrpc: '2.0',
+      result,
+      id: object.id,
+    })
+  } else {
+    if (!object.params) {
+      console.warn('invalid message', typeof object, object.params, object)
+      return
+    }
+    Command.execute(object.method, state.socket, ...object.params)
+  }
+}
+
+const handleError = (error) => {
+  console.log('EEERRR')
+  // console.error(error)
+  throw new VError(error, 'Shared Process Socket Error')
+
+  // console.error('[Shared Process: Socket Error]', event)
+}
+
+// TODO
+const createAbstractSocket = (socket) => {
+  return {
+    _socket: socket,
+    send(message) {
+      socket.send(JSON.stringify(message))
+    },
+    on(event, listener) {
+      switch (event) {
+        case 'message':
+          socket.on('message', listener)
+          break
+        case 'close':
+          socket.on('close', listener)
+          break
+        default:
+          console.warn('socket event not implemented', event, listener)
+          break
+      }
+    },
+  }
+}
+
+export const set = (socket) => {
+  socket.on('close', () => {
+    console.log('[shared-process] socket closed')
+  })
+  socket.onmessage = handleMessage
+  // socket.onerror = handleError
+  socket.on('error', handleError)
+  const abstractSocket = createAbstractSocket(socket)
+  state.socket = abstractSocket
+}

package/src/parts/Stats/Stats.js

@@ -0,0 +1,45 @@
+import * as Exec from '../Exec/Exec.js'
+
+// parse ps output based on vscode https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/node/ps.ts (License MIT)
+
+const parsePsOutputLine = (line) => {
+  const PID_CMD =
+    /^\s*([0-9]+)\s+([0-9]+)\s+([0-9]+\.[0-9]+)\s+([0-9]+\.[0-9]+)\s+(.+)$/
+  const matches = PID_CMD.exec(line.trim())
+  if (matches && matches.length === 6) {
+    return {
+      pid: parseInt(matches[1]),
+      ppid: parseInt(matches[2]),
+      cwd: matches[5],
+      load: parseInt(matches[3]),
+      mem: parseInt(matches[4]),
+    }
+  }
+}
+const parsePsOutput = (stdout, rootPid) => {
+  const lines = stdout.split('\n')
+  return lines.map(parsePsOutputLine)
+}
+
+const getPsOutput = async (rootPid) => {
+  const { stdout } = await Exec.exec(
+    'ps',
+    ['-g', `${rootPid}`, '-a', '-o', 'pid=,ppid=,pcpu=,pmem=,command='],
+    {
+      shell: true,
+    }
+  )
+  return stdout
+}
+
+export const listProcessesWithMemoryUsage = async (rootPid) => {
+  const stdout = await getPsOutput(rootPid)
+  const parsed = parsePsOutput(stdout, rootPid)
+  console.log(parsed)
+}
+
+const main = async () => {
+  await listProcessesWithMemoryUsage(process.pid)
+}
+
+main()

package/src/parts/Terminal/Terminal.ipc.js

@@ -0,0 +1,45 @@
+import * as Command from '../Command/Command.js'
+import * as Terminal from './Terminal.js'
+import * as Assert from '../Assert/Assert.js'
+
+const create = (socket, id, cwd) => {
+  Assert.object(socket)
+  if (!socket) {
+    console.log({socket, id, cwd})
+    console.warn('socket not available')
+    return
+  }
+  // terminalMap[id] = Terminal.create({
+  //   handleData(data) {
+  //     socket.send(
+  //       JSON.stringify({
+  //         jsonrpc: '2.0',
+  //         method: 2133,
+  //         params: ['Terminal', 'handleData', data],
+  //       })
+  //     )
+  //   },
+  //   cwd,
+  // })
+  Terminal.create(socket, id, cwd)
+}
+
+const write = ( id, input) => {
+  console.log({ id, input})
+  Terminal.write(id, input)
+}
+
+const resize = (socket, id, columns, rows) => {
+  Terminal.resize(id, columns, rows)
+}
+
+const dispose = (socket, id) => {
+  Terminal.dispose(id)
+}
+
+export const __initialize__ = () => {
+  Command.register('Terminal.create', create)
+  Command.register('Terminal.dispose', dispose)
+  Command.register('Terminal.write', write)
+  Command.register('Terminal.resize', resize)
+}

package/src/parts/Terminal/Terminal.js

@@ -0,0 +1,161 @@
+import { ChildProcess, fork } from 'node:child_process'
+import exitHook from 'exit-hook'
+import * as Debug from '../Debug/Debug.js'
+import * as Path from '../Path/Path.js'
+import * as Root from '../Root/Root.js'
+import * as Assert from '../Assert/Assert.js'
+import { ptyHostPath } from '@lvce-editor/pty-host'
+
+export const state = {
+  /**
+   * @type {ChildProcess|undefined}
+   */
+  ptyHost: undefined,
+  ptyHostState: /* None */ 0,
+  /**
+   * @type {any[]}
+   */
+  pendingMessages: [],
+  send(message) {
+    state.pendingMessages.push(message)
+  },
+}
+
+// const getSpawnOptions = () => {
+//   if (Platform.isWindows) {
+//     return {
+//       command: 'powershell.exe',
+//       args: [],
+//     }
+//   }
+//   return {
+//     command: 'bash',
+//     args: ['-i'],
+//   }
+// }
+
+const cleanUpAll = () => {
+  if (state.ptyHost) {
+    state.ptyHost.kill()
+  }
+}
+
+const handleProcessExit = () => {
+  Debug.debug('shared process exit, clean terminals')
+  cleanUpAll()
+}
+
+const createPtyHost = () => {
+  exitHook(handleProcessExit)
+  const ptyHost = fork(ptyHostPath, { stdio: 'inherit' })
+  return ptyHost
+}
+
+// const send = (method, ...params) => {
+
+//   state.ptyHost.send({
+//     jsonrpc: '2.0',
+//     method,
+//     params,
+//   })
+// }
+
+export const create = (socket, id, cwd) => {
+  Assert.object(socket)
+  Assert.number(id)
+  Assert.string(cwd)
+
+  console.log('create terminal')
+  Debug.debug('creating pty host')
+  switch (state.ptyHostState) {
+    case /* None */ 0: {
+      state.ptyHostState = /* Creating */ 1
+      const ptyHost = createPtyHost()
+      const handleFirstMessage = () => {
+        Debug.debug('pty host ready')
+        state.ptyHostState = /* Ready */ 2
+        const handleMessage = (message) => {
+          const data = message.params[1]
+          socket.send({
+            jsonrpc: '2.0',
+            method: 2133,
+            params: ['Terminal', 'handleData', data],
+          })
+        }
+        ptyHost.on('message', handleMessage)
+        state.send = (message) => {
+          ptyHost.send(message)
+        }
+        while (state.pendingMessages.length > 0) {
+          state.send(state.pendingMessages.shift())
+        }
+      }
+      ptyHost.once('message', handleFirstMessage)
+      state.ptyHost = ptyHost
+      break
+    }
+    case /* Creating */ 1: {
+      break
+    }
+    case /* Ready */ 2: {
+      break
+    }
+    default:
+      break
+  }
+  state.send({
+    jsonrpc: '2.0',
+    method: 'Terminal.create',
+    params: [id, cwd],
+  })
+  const handleClose = () => {
+    if (state.ptyHost) {
+      state.ptyHost.removeAllListeners()
+      state.ptyHost.kill()
+      state.ptyHost = undefined
+      state.ptyHostState = /* None */ 0
+      state.send = (message) => {
+        state.pendingMessages.push(message)
+      }
+    }
+  }
+  socket.on('close', handleClose)
+}
+
+export const write = (id, data) => {
+  Assert.number(id)
+  Assert.string(data)
+  if (!state.ptyHost) {
+    console.log('[shared-process] pty host not ready')
+    return
+  }
+  state.send({
+    jsonrpc: '2.0',
+    method: 'Terminal.write',
+    params: [id, data],
+  })
+}
+
+export const resize = (state, columns, rows) => {
+  // state.pty.resize(columns, rows)
+}
+
+export const dispose = (id) => {
+  state.send({
+    jsonrpc: '2.0',
+    method: 'Terminal.dispose',
+    params: [id],
+  })
+}
+
+export const disposeAll = () => {
+  if (state.ptyHost) {
+    state.ptyHost.removeAllListeners()
+    state.ptyHost.kill()
+    state.ptyHost = undefined
+    state.ptyHostState = /* None */ 0
+    state.send = (message) => {
+      state.pendingMessages.push(message)
+    }
+  }
+}

package/src/parts/TextDocument/TextDocument.ipc.js

@@ -0,0 +1,6 @@
+import * as Command from '../Command/Command.js'
+import * as TextDocument from './TextDocument.js'
+
+export const __initialize__ = () => {
+ Command.register(4820, TextDocument.applyEdit)
+}

package/src/parts/TextDocument/TextDocument.js

@@ -0,0 +1,37 @@
+export const state = {
+  textDocuments: Object.create(null),
+  /** @type{any[]} */
+  listeners: [],
+}
+
+// const toOffsetBasedEdit = (textDocument, documentEdit) => {
+//   let offset = 0
+//   let rowIndex = 0
+//   while (rowIndex++ < documentEdit.rowIndex) {
+//     offset += textDocument.lines[rowIndex].length
+//   }
+//   offset += documentEdit.columnIndex
+//   return {
+//     offset,
+//     inserted: documentEdit.inserted,
+//     deleted: documentEdit.deleted,
+//   }
+// }
+
+export const applyEdit = (socket, textDocument, documentEdits) => {
+  // TODO avoid extra object allocation and anonymous function
+  // const offsetBasedEdits = documentEdits.map((e) =>
+  //   toOffsetBasedEdit(textDocument, e)
+  // )
+  for (const listener of state.listeners) {
+    listener(textDocument, documentEdits)
+  }
+}
+
+export const getText = (textDocument) => {
+  return textDocument.lines.join('\n')
+}
+
+export const onChange = (listener) => {
+  state.listeners.push(listener)
+}

package/src/parts/Trace/Trace.js

@@ -0,0 +1,15 @@
+export const LEVEL = {
+  DEFAULT: 1,
+  VERBOSE: 2,
+}
+
+export const state = {
+  level: LEVEL.VERBOSE,
+}
+
+export const trace =
+  process.env.NODE_ENV === 'test'
+    ? () => {}
+    : (...args) => {
+        console.info('[Trace]', ...args)
+      }

package/src/parts/Trash/Trash.js

@@ -0,0 +1,11 @@
+import { default as _trash } from 'trash'
+import VError from 'verror'
+
+export const trash = async (path) => {
+  try {
+    await _trash(path)
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, 'Failed to move item to trash')
+  }
+}

package/src/parts/WebSocketServer/WebSocketServer.ipc.js

@@ -0,0 +1,6 @@
+import * as Command from '../Command/Command.js'
+import * as WebSocketServer from './WebSocketServer.js'
+
+export const __initialize__ = () => {
+ Command.register(5621, WebSocketServer.handleUpgrade)
+}

package/src/parts/WebSocketServer/WebSocketServer.js

@@ -0,0 +1,43 @@
+import { Buffer } from 'node:buffer'
+import * as _ws from 'ws'
+import * as Socket from '../Socket/Socket.js'
+
+// workaround for jest or node bug
+const WebSocketServer = _ws.WebSocketServer
+  ? _ws.WebSocketServer
+  : // @ts-ignore
+    _ws.default.WebSocketServer
+
+const encode = (commandId, callbackId) => (commandId << 16) | callbackId
+const decodeCommand = (encodedCommand) => encodedCommand >> 16
+const decodeCallback = (encodedCommand) => encodedCommand & 0x0000FFFF
+
+// console.log('ws', _ws)
+// console.log('server', ws.WebSocketServer)
+
+const webSocketServer = new WebSocketServer({
+  noServer: true,
+
+  // TODO not sure if ws compress is working at all
+  // perMessageDeflate: true
+})
+
+// TODO should not import command directly -> Websocket server should be independent of business logic
+
+const handleSocket = (socket) => {
+  Socket.set(socket)
+}
+
+webSocketServer.on('connection', handleSocket)
+
+export const handleUpgrade = (request, socket) => {
+  const upgradeCallback = (ws) => {
+    webSocketServer.emit('connection', ws, request)
+  }
+  webSocketServer.handleUpgrade(
+    request,
+    socket,
+    Buffer.alloc(0),
+    upgradeCallback
+  )
+}

package/src/parts/Workspace/Workspace.ipc.js

@@ -0,0 +1,7 @@
+import * as Command from '../Command/Command.js'
+import * as Workspace from './Workspace.js'
+
+export const __initialize__ = () => {
+  Command.register('Workspace.resolveRoot', Workspace.resolveRoot)
+  Command.register('Workspace.getHomeDir', Workspace.getHomeDir)
+}

package/src/parts/Workspace/Workspace.js

@@ -0,0 +1,107 @@
+import { createHash } from 'node:crypto'
+import { readFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import * as Env from '../Env/Env.js'
+import * as Platform from '../Platform/Platform.js'
+import * as Root from '../Root/Root.js'
+
+const RE_ABSOLUTE_URI = /^[a-z]+:\/\//
+
+const isAbsoluteUri = (path) => {
+  return RE_ABSOLUTE_URI.test(path)
+}
+
+const getAbsolutePath = (path) => {
+  if (isAbsoluteUri(path)) {
+    return path
+  }
+  if (path.startsWith('${cwd}')) {
+    path = Root.root + path.slice(5)
+  } else if (path.startsWith('~')) {
+    path = `${homedir()}${path.slice(1)}`
+  }
+  path = resolve(path)
+  return path
+}
+
+const getWorkspaceStorage = async (workspaceId) => {
+  try {
+    const workspaceStorage = JSON.parse(
+      await readFile(`/tmp/config/${workspaceId}`, 'utf-8')
+    )
+    return workspaceStorage
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * @deprecated use platform instead
+ */
+export const getHomeDir = () => {
+  if (Platform.isWindows) {
+    return ''
+  }
+  const homeDir = homedir()
+  return homeDir
+}
+
+const getWorkspaceId = (absolutePath) => {
+  return createHash('sha256').update(absolutePath).digest('hex').slice(0, 16)
+}
+
+const configs = {
+  messagePort1: {
+    folder: '/tmp',
+  },
+  messagePort2: {
+    folder: '~',
+  },
+}
+
+const toUri = (path) => {
+  return pathToFileURL(path).toString()
+}
+
+export const resolveRoot = async () => {
+  // TODO ask electron, electron can do mapping
+  // await
+
+  // TODO shared process should have no logic, this should probably be somewhere else
+  const folder = Env.getFolder()
+  if (!folder) {
+    const path = join(Root.root, 'playground')
+    return {
+      path,
+      uri: toUri(path),
+      workspaceId: getWorkspaceId(path),
+      homeDir: Platform.getHomeDir(),
+      pathSeparator: Platform.getPathSeparator(),
+      source: 'shared-process-env',
+    }
+  }
+  const absolutePath = getAbsolutePath(folder)
+  const workspaceId = getWorkspaceId(absolutePath)
+  // TODO this slows down startup a lot (~30-50ms)
+  // const workspaceStorage = await getWorkspaceStorage(workspaceId)
+  return {
+    path: absolutePath,
+    uri: toUri(absolutePath),
+    workspaceId,
+    homeDir: Platform.getHomeDir(),
+    pathSeparator: Platform.getPathSeparator(),
+    source: 'shared-process-default',
+  }
+}
+
+export const resolveUri = (uri) => {
+  const path = fileURLToPath(uri)
+  return {
+    path,
+    uri,
+    homeDir: Platform.getHomeDir(),
+    pathSeparator: Platform.getPathSeparator(),
+  }
+}

package/src/sharedProcessMain.js

@@ -0,0 +1,61 @@
+import * as ParentIpc from './parts/ParentIpc/ParentIpc.js'
+import * as PrettyError from './parts/PrettyError/PrettyError.js'
+
+// TODO handle structure: one shared process multiple extension hosts
+
+// TODO use named functions here
+
+const handleUncaughtExceptionMonitor = (error, origin) => {
+  console.info(`[shared process] uncaught exception: ${error.stack}`)
+  console.info('code', error.code)
+  if (error && error.code === 'EPIPE' && !process.connected) {
+    // parent process is disposed, ignore
+    return
+  }
+  if (error && error.code === 'ERR_IPC_CHANNEL_CLOSED' && !process.connected) {
+    // parent process is disposed, ignore
+    return
+  }
+  console.log(error)
+  const prettyError = PrettyError.prepare(error)
+  console.error(prettyError.message)
+  console.error(prettyError.codeFrame)
+  console.error(prettyError.stack)
+  process.exit(1)
+}
+
+const handleSigInt = () => {
+  console.info('[shared process] sigint')
+}
+
+const handleDisconnect = () => {
+  console.info('[shared process] disconnected')
+}
+
+const handleBeforeExit = () => {
+  console.info('[shared process] will exit now')
+}
+
+const handleSigTerm = () => {
+  console.info('[shared-process] sigterm')
+}
+
+const main = () => {
+  console.log('[shared process] started')
+  process.on('beforeExit', handleBeforeExit)
+  process.on('disconnect', handleDisconnect)
+  process.on('SIGINT', handleSigInt)
+  process.on('SIGTERM', handleSigTerm)
+
+  process.on('uncaughtExceptionMonitor', handleUncaughtExceptionMonitor)
+  ParentIpc.listen()
+  // ExtensionHost.start() // TODO start on demand, e.g. not when extensions should be disabled
+}
+
+main()
+
+// TODO when browser reloads or opens in new tab how does the window know which folder to open?
+
+// setTimeout(() => {
+//   throw new Error('oops')
+// }, 210)