@lvce-editor/shared-process 0.0.2

package/src/parts/FileSystem/FileSystem.js

@@ -0,0 +1,228 @@
+// 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 chokidar from 'chokidar'
+import * as Error from '../Error/Error.js'
+import * as Path from '../Path/Path.js'
+import * as Trash from '../Trash/Trash.js'
+import * as Platform from '../Platform/Platform.js'
+
+export const state = {
+  watcherMap: Object.create(null),
+}
+
+export const copy = async (source, target) => {
+  const { copy } = await import('fs-extra')
+  try {
+    await copy(source, target, { recursive: true })
+  } catch (error) {
+    throw new Error.OperationalError({
+      cause: error,
+      code: 'E_FILE_SYSTEM_ERROR',
+      message: `Failed to copy "${source}" to "${target}"`,
+      category: 'File System Error',
+    })
+  }
+}
+
+export const readFile = async (path) => {
+  try {
+    const content = await fs.readFile(path, 'utf-8')
+    return content
+  } catch (error) {
+    throw new Error.OperationalError({
+      cause: error,
+      code: 'E_FILE_SYSTEM_ERROR',
+      message: `Failed to read file "${path}"`,
+      category: 'File System Error',
+    })
+  }
+}
+
+export const writeFile = async (path, content) => {
+  try {
+    // queue would be more correct for concurrent writes but also slower
+    // Queue.add(`writeFile/${path}`, () =>
+    await fs.writeFile(path, content)
+  } catch (error) {
+    throw new Error.OperationalError({
+      cause: error,
+      code: 'E_FILE_SYSTEM_ERROR',
+      message: `Failed to write to file "${path}"`,
+      category: 'File System Error',
+    })
+  }
+}
+
+export const ensureFile = async (path, content) => {
+  try {
+    await fs.mkdir(Path.dirname(path), { recursive: true })
+    await fs.writeFile(path, content)
+  } catch (error) {
+    throw new Error.OperationalError({
+      cause: error,
+      code: 'E_FILE_SYSTEM_ERROR',
+      message: `Failed to write to file "${path}"`,
+      category: 'File System Error',
+    })
+  }
+}
+
+export const createFile = async (path) => {
+  try {
+    await fs.writeFile(path, '', { flag: 'wx' })
+  } catch (error) {
+    throw new Error.OperationalError({
+      cause: error,
+      code: 'E_FILE_SYSTEM_ERROR',
+      message: `Failed to create file "${path}"`,
+      category: 'File System Error',
+    })
+  }
+}
+
+export const createFolder = async (path, options) => {
+  try {
+    await fs.mkdir(path, options)
+  } catch (error) {
+    throw new Error.OperationalError({
+      cause: error,
+      code: 'E_FILE_SYSTEM_ERROR',
+      message: `Failed to create folder "${path}"`,
+      category: 'File System Error',
+    })
+  }
+}
+
+const isOkayToRemove = (path) => {
+  if (path === '/') {
+    return false
+  }
+  if (path === '~') {
+    return false
+  }
+  if (path === os.homedir()) {
+    return false
+  }
+  return true
+}
+
+export const remove = async (path) => {
+  if (!isOkayToRemove(path)) {
+    console.warn('not removing path')
+    return
+  }
+
+  // TODO lazyload trash (doesn't work currently because of bug with jest)
+  // const { trash } = await import('../../wrap/trash.js')
+  try {
+    await Trash.trash(path)
+  } catch (error) {
+    throw new Error.OperationalError({
+      cause: error,
+      code: 'E_FILE_REMOVE_SYSTEM_ERROR',
+      message: `Failed to remove "${path}"`,
+      category: 'File System Error',
+    })
+  }
+}
+
+export const exists = async (path) => {
+  try {
+    await fs.access(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+const getType = (dirent) => {
+  if (dirent.isFile()) {
+    return 'file'
+  }
+  if (dirent.isDirectory()) {
+    return 'directory'
+  }
+  return 'unknown'
+}
+
+const toPrettyDirent = (dirent) => {
+  return {
+    name: dirent.name,
+    type: getType(dirent),
+  }
+}
+
+export const readDirWithFileTypes = async (path) => {
+  try {
+    const dirents = await fs.readdir(path, { withFileTypes: true })
+    const prettyDirents = dirents.map(toPrettyDirent)
+    return prettyDirents
+  } catch (error) {
+    throw new Error.OperationalError({
+      cause: error,
+      code: 'E_FILE_READ_DIR_SYSTEM_ERROR',
+      message: `Failed to read directory "${path}"`,
+      category: 'File System Error',
+    })
+  }
+}
+
+export const mkdir = async (path) => {
+  try {
+    await fs.mkdir(path)
+  } catch (error) {
+    throw new Error.OperationalError({
+      cause: error,
+      code: 'E_CREATE_DIRECTORY_FAILED',
+      message: `Failed to create directory "${path}"`,
+      category: 'File System Error',
+    })
+  }
+}
+
+export const rename = async (oldPath, newPath) => {
+  try {
+    await fs.rename(oldPath, newPath)
+  } catch (error) {
+    throw new Error.OperationalError({
+      cause: error,
+      code: 'E_RENAME_FAILED',
+      message: `Failed to rename "${oldPath}" to "${newPath}"`,
+      category: 'File System Error',
+    })
+  }
+}
+
+export const watch = (path, options) => {
+  // let state = 'loading'
+
+  const watcher = chokidar.watch(`${path}`, {
+    ignoreInitial: true,
+  })
+
+  if (options.onAll) {
+    watcher.on('all', options.onAll)
+  }
+  return watcher
+
+  // const { default: chokidar } = await import('chokidar')
+}
+
+export const getPathSeparator = () => {
+  return Platform.getPathSeparator()
+}
+
+// export const unwatch = (id) => {
+//   state.watchers[id].close()
+//   delete state.watchers[id]
+// }
+
+// export const unwatchAll = () => {
+//   for (const key in state.watchers) {
+//     unwatch(key)
+//   }
+// }
+
+// TODO ui should show useful error message when file cannot be saved
+// and for permission denied error it should use that npm module that allows root

package/src/parts/Git/Git.js

@@ -0,0 +1,58 @@
+export const id = 'git'
+
+export const label = 'Git'
+
+export const acceptInputCommand = 'git.commit'
+
+const RE_ONLY_WHITESPACE = /^\s+$/
+
+export const validateInput = (text) => {
+  if (RE_ONLY_WHITESPACE.test(text)) {
+    return {
+      message: 'Current commit message only contains whitespace characters',
+      type: 'warning',
+    }
+  }
+  return undefined
+}
+
+const vscode = {}
+
+export const activate = () => {
+  const sourceControlProvider = vscode.createSourceControlProvider({
+    providerId: 'git',
+    label: 'Git',
+    acceptInput(text) {},
+    validateInput,
+  })
+
+  const mergeGroup = vscode.createSourceControlResourceGroup({
+    providerId: 'git',
+    groupId: 'merge',
+    label: 'Merge Changes',
+  })
+
+  const indexGroup = vscode.createSourceControlResourceGroup({
+    providerId: 'git',
+    groupId: 'index',
+    label: 'Staged Changes',
+  })
+
+  const workingTreeGroup = vscode.createSourceControlResourceGroup({
+    providerId: 'git',
+    groupId: 'workingTree',
+    label: 'Untracked Changes',
+  })
+
+  const untrackedGroup = vscode.createSourceControlResourceGroup({
+    providerId: 'git',
+    groupId: 'untracked',
+    label: 'Untracked Changes',
+  })
+
+  sourceControlProvider.setCount(111)
+}
+
+export const deactivate = () => {
+  vscode.unregisterSourceControlProvider('git')
+}

package/src/parts/Json/Json.js

@@ -0,0 +1,67 @@
+import fallback from 'json-parse-even-better-errors'
+import { codeFrameColumns } from '@babel/code-frame'
+import { LinesAndColumns } from 'lines-and-columns'
+
+// parsing error handling based on https://github.com/sindresorhus/parse-json/blob/main/index.js
+
+export const parse = async (string, filePath) => {
+  try {
+    try {
+      return JSON.parse(string)
+    } catch (error) {
+      fallback(string)
+      throw error
+    }
+  } catch (error) {
+    error.message = error.message.replace(/\n/g, '')
+    const indexMatch = error.message.match(
+      /in JSON at position (\d+) while parsing/
+    )
+    let topMessage = error.message
+    let bottomMessage = error.message
+    if (topMessage.startsWith('Unexpected token')) {
+      topMessage = 'JSON parsing error:'
+    }
+    if (bottomMessage.includes('while parsing "{')) {
+      bottomMessage = bottomMessage.slice(
+        0,
+        bottomMessage.indexOf('while parsing "{')
+      )
+    }
+    if (bottomMessage.includes(' (0x7D) ')) {
+      bottomMessage = bottomMessage.replace(' (0x7D) ', ' ')
+    }
+    bottomMessage = bottomMessage.trim()
+    const jsonError = new Error(topMessage)
+    if (indexMatch && indexMatch.length > 0) {
+      const lines = new LinesAndColumns(string)
+      const index = Number(indexMatch[1])
+      const location = lines.locationForIndex(index)
+      const codeFrame = codeFrameColumns(
+        string,
+        { start: { line: location.line + 1, column: location.column + 1 } },
+        { highlightCode: true }
+      )
+      jsonError.codeFrame = codeFrame
+    }
+    // console.log({ bottomMessage, message: error.message })
+    jsonError.stack = `${bottomMessage}\n    at ${filePath}`
+    throw jsonError
+  }
+
+  // try {
+  //   return JSON.parse(json)
+  // } catch (error) {
+  //   const parseJsonBetterErrors = await import('parse-json')
+  //   try {
+  //     return parseJsonBetterErrors.default(json, filePath)
+  //   } catch (error) {
+  //     console.log({ frame: error.codeFrame })
+  //     throw error
+  //   }
+  // }
+}
+
+export const stringify = (value) => {
+  return JSON.stringify(value, null, 2) + '\n'
+}

package/src/parts/JsonFile/JsonFile.js

@@ -0,0 +1,14 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import * as Path from '../Path/Path.js'
+import * as Json from '../Json/Json.js'
+
+export const readJson = async (absolutePath) => {
+  const content = await readFile(absolutePath, 'utf-8')
+  const json = await Json.parse(content, absolutePath)
+  return json
+}
+
+export const writeJson = async (absolutePath, value) => {
+  await mkdir(Path.dirname(absolutePath), { recursive: true })
+  await writeFile(absolutePath, Json.stringify(value))
+}

package/src/parts/JsonRpc/JsonRpc.js

@@ -0,0 +1,22 @@
+import * as Callback from '../Callback/Callback.js'
+
+export const send = (transport, method, ...params) => {
+  transport.send({
+    jsonrpc: '2.0',
+    method,
+    params,
+  })
+}
+
+export const invoke = (transport, method, ...params) => {
+  return new Promise((resolve, reject) => {
+    // TODO use one map instead of two
+    const callbackId = Callback.register(resolve, reject)
+    transport.send({
+      jsonrpc: '2.0',
+      method,
+      params,
+      id: callbackId,
+    })
+  })
+}

package/src/parts/Native/Native.ipc.js

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

package/src/parts/Native/Native.js

@@ -0,0 +1,14 @@
+import open from 'open'
+import * as Error from '../Error/Error.js'
+
+export const openFolder = async (path) => {
+  try {
+    await open(path)
+  } catch (error) {
+    throw new Error.OperationalError({
+      cause: error,
+      code: 'E_OPEN_SYSTEM_ERROR',
+      message: `Failed to open ${path}`,
+    })
+  }
+}

package/src/parts/OutputChannel/OutputChannel.ipc.js

@@ -0,0 +1,51 @@
+import * as Assert from '../Assert/Assert.js'
+import * as Command from '../Command/Command.js'
+import * as OutputChannel from './OutputChannel.js'
+
+export const state = {
+  outputChannels: Object.create(null)
+}
+
+const open = (socket, id, path) => {
+  console.log({path})
+  Assert.object(socket)
+  // Assert.string(id)
+  Assert.string(path )
+  if (!socket) {
+    console.warn('socket not available')
+    return
+  }
+  if (state.outputChannels[id]) {
+    OutputChannel.dispose(state.outputChannels[id])
+  }
+  const onData = (data) => {
+    console.log('send data', data)
+    socket.send(
+      {
+        jsonrpc: '2.0',
+        method: 2133,
+        params: ['Output', 'handleData', data],
+      }
+    )
+  }
+  const onError = (error) => {
+    console.info(`[shared process] output channel error: ${error}`)
+    socket.send(
+      {
+        jsonrpc: '2.0',
+        method: 2133,
+        params: ['Output', 'handleError', error],
+      })
+  }
+  state.outputChannels[id] = OutputChannel.open(path, onData, onError)
+}
+
+const close = (socket, id) => {
+  OutputChannel.dispose(state.outputChannels[id])
+  delete state.outputChannels[id]
+}
+
+export const __initialize__ = () => {
+  Command.register('OutputChannel.open', open)
+  Command.register('OutputChannel.close', close)
+}

package/src/parts/OutputChannel/OutputChannel.js

@@ -0,0 +1,37 @@
+import { Tail } from 'tail'
+
+// TODO
+// option 1: use tail child process
+// option 2: https://www.npmjs.com/package/@logdna/tail-file
+// option 3: node tail
+
+export const open = (path, onData, onError) => {
+  let tail
+  try {
+    tail = new Tail(path, {
+      separator: null,
+      fromBeginning: true,
+    })
+  } catch (error) {
+    // @ts-ignore
+    onError(error.toString())
+  }
+
+  if (tail) {
+    tail.on('line', onData)
+
+    tail.on('error', (error) => {
+      onError(error.toString())
+    })
+  }
+  const state = {
+    tail,
+  }
+  return state
+}
+
+export const dispose = (state) => {
+  if (state.tail) {
+    state.tail.unwatch()
+  }
+}

package/src/parts/ParentIpc/ParentIpc.js

@@ -0,0 +1,203 @@
+import { MessagePort, parentPort } from 'node:worker_threads'
+import * as Callback from '../Callback/Callback.js'
+import * as Command from '../Command/Command.js'
+import * as Debug from '../Debug/Debug.js'
+import * as Error from '../Error/Error.js'
+import { requiresSocket } from '../RequiresSocket/RequiresSocket.js'
+
+// TODO add tests for this
+
+// TODO handle structure: one shared process multiple extension hosts
+
+// TODO pass socket / port handle also in electron
+
+export const state = {
+  electronPortMap: new Map(),
+}
+
+export const electronSend = (message) => {
+  // @ts-ignore
+  // process.send(message)
+  parentPort.postMessage(message)
+}
+
+const handleMessageFromParentProcess = async (message, handle) => {
+  if (handle) {
+    handle.on('error', (error) => {
+      if (error && error.code === 'ECONNRESET') {
+        return
+      }
+      console.info('[info shared process: handle error]', error)
+    })
+    Command.execute(
+      /* WebSocketServer.handleUpgrade */ 5621,
+      /* message */ message,
+      /* handle */ handle
+    )
+  } else if (message.result) {
+    Callback.resolve(message.id, message.result)
+  } else if (message.method) {
+    console.log({ message })
+    if (message.id) {
+      try {
+        console.log('INISDE HERE')
+        const result = requiresSocket(message.method)
+          ? await Command.invoke(message.method, handle, ...message.params)
+          : await Command.invoke(message.method, ...message.params)
+        electronSend({
+          jsonrpc: '2.0',
+          id: message.id,
+          result: result ?? null,
+        })
+      } catch (error) {
+        console.error('[shared process] command failed to execute')
+        console.error(error)
+        electronSend({
+          jsonrpc: '2.0',
+          code: /* ExpectedError */ -32000,
+          id: message.id,
+          error: 'ExpectedError',
+          // @ts-ignore
+          data: error.toString(),
+        })
+      }
+    } else {
+      // TODO handle error
+      Command.execute(message.method, null, ...message.params)
+    }
+  } else {
+    console.warn('unknown message', message)
+  }
+}
+
+/**
+ *
+ * @param {{initialize:{port: MessagePort, folder:string}}} initializeMessage
+ */
+const electronInitialize = (initializeMessage) => {
+  const port = initializeMessage.initialize.port
+  // 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) {
+        try {
+          const result = requiresSocket(message.method)
+            ? await Command.invoke(
+                message.method,
+                fakeSocket,
+                ...message.params
+              )
+            : await Command.invoke(message.method, ...message.params)
+
+          port.postMessage({
+            jsonrpc: '2.0',
+            id: message.id,
+            result: result ?? null,
+          })
+        } catch (error) {
+          // TODO duplicate code with Socket.js, clean this up
+          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)
+            port.postMessage({
+              jsonrpc: '2.0',
+              id: message.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('[shared process] command failed to execute')
+            console.error(error)
+            // TODO check if socket is active
+            port.postMessage({
+              jsonrpc: '2.0',
+              id: message.id,
+              error: {
+                code: /* UnexpectedError */ -32001,
+                // @ts-ignore
+                message: error.toString(),
+              },
+            })
+          }
+          return
+        }
+      } else {
+        Command.execute(message.method, fakeSocket, ...message.params)
+      }
+    } else {
+      console.warn('unknown message', message)
+    }
+  }
+  port.on('message', handleOtherMessagesFromMessagePort)
+}
+
+const handleMessageFromParentProcessElectron = async (message) => {
+  if (message.initialize) {
+    electronInitialize(message)
+    return
+  }
+  console.log({ message })
+  if ('result' in message) {
+    Callback.resolve(message.id, message.result)
+    return
+  }
+
+  console.log('unknown message from electron', message)
+  console.log({ message })
+}
+
+// TODO maybe rename to hydrate
+export const listen = () => {
+  // TODO tree-shake out if-else
+  // console.log({ ...process.env })
+  if (process.env.ELECTRON_RUN_AS_NODE && parentPort) {
+    // electron process listens to main process ipc
+    Debug.debug('is electron')
+    // @ts-ignore
+    parentPort.on('message', handleMessageFromParentProcessElectron)
+    electronSend('ready')
+  } else {
+    Debug.debug('is not electron')
+    // otherwise listen to web process ipc
+    // and when a socket is transferred,
+    // listen to socket messages also
+    process.on('message', handleMessageFromParentProcess)
+    if (process.send) {
+      process.send('ready')
+    }
+  }
+}