@lvce-editor/pty-host 2.1.0 → 3.0.0

package/README.md

@@ -1 +1,3 @@
-# pty-host
+# Pty Host
+
+Terminal process used in Lvce Editor.

package/bin/ptyHost.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-import '../src/ptyHostMain.js'
+import '../dist/ptyHostMain.js'

package/dist/ptyHostMain.js

@@ -0,0 +1,386 @@
+import { execute, register } from '@lvce-editor/command';
+import { object, string, array, number } from '@lvce-editor/assert';
+import { handleJsonRpcMessage, resolve } from '@lvce-editor/json-rpc';
+import { IpcChildWithElectronMessagePort, IpcChildWithElectronUtilityProcess, IpcChildWithWebSocket, IpcChildWithNodeWorker, IpcChildWithNodeForkedProcess } from '@lvce-editor/ipc';
+import debugModule from 'debug';
+import { spawn } from 'node-pty';
+import { VError } from '@lvce-editor/verror';
+import { Console } from 'node:console';
+import { createWriteStream } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { prepare } from '@lvce-editor/pretty-error';
+
+const METHODS_THAT_REQUIRE_SOCKET = new Set(['Terminal.create']);
+const requiresSocket = method => {
+  return METHODS_THAT_REQUIRE_SOCKET.has(method);
+};
+
+const preparePrettyError = error => {
+  return error;
+};
+const logError = () => {
+  // PrintPrettyError.printPrettyError(prettyError, `[terminal-process] `)
+};
+const handleMessage = event => {
+  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, requiresSocket);
+};
+
+const handleIpc = ipc => {
+  object(ipc);
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('onmessage' in ipc) {
+    // deprecated
+    ipc.onmessage = handleMessage;
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
+};
+
+const NodeWorker = 1;
+const NodeForkedProcess = 2;
+const WebSocket = 3;
+const ElectronUtilityProcess = 4;
+const ElectronMessagePort = 5;
+const NodeMessagePort = 6;
+const Auto = () => {
+  const {
+    argv
+  } = process;
+  if (argv.includes('--ipc-type=node-worker')) {
+    return NodeWorker;
+  }
+  if (argv.includes('--ipc-type=node-forked-process')) {
+    return NodeForkedProcess;
+  }
+  if (argv.includes('--ipc-type=electron-utility-process')) {
+    return ElectronUtilityProcess;
+  }
+  throw new Error(`[pty-host] unknown ipc type`);
+};
+
+const getModule = method => {
+  switch (method) {
+    case NodeForkedProcess:
+      return IpcChildWithNodeForkedProcess;
+    case NodeWorker:
+      return IpcChildWithNodeWorker;
+    case WebSocket:
+      return IpcChildWithWebSocket;
+    case ElectronUtilityProcess:
+      return IpcChildWithElectronUtilityProcess;
+    case ElectronMessagePort:
+      return IpcChildWithElectronMessagePort;
+    default:
+      throw new Error('unexpected ipc type');
+  }
+};
+
+const listen$1 = async ({
+  method,
+  ...params
+}) => {
+  const module = getModule(method);
+  // @ts-ignore
+  const rawIpc = await module.listen(params);
+  // @ts-ignore
+  if (module.signal) {
+    // @ts-ignore
+    module.signal(rawIpc);
+  }
+  // @ts-ignore
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+
+const handleElectronMessagePort = async messagePort => {
+  object(messagePort);
+  const ipc = await listen$1({
+    method: ElectronMessagePort,
+    messagePort
+  });
+  handleIpc(ipc);
+};
+
+const handleNodeMessagePort = async messagePort => {
+  const ipc = await listen$1({
+    method: NodeMessagePort,
+    messagePort
+  });
+  handleIpc(ipc);
+};
+
+const handleWebSocket = async (handle, request) => {
+  object(handle);
+  object(request);
+  const ipc = await listen$1({
+    method: WebSocket,
+    request,
+    handle
+  });
+  handleIpc(ipc);
+};
+
+const debug = debugModule('pty-host');
+
+class DataEvent extends Event {
+  constructor(data) {
+    super('data');
+    this.data = data;
+  }
+}
+class ExitEvent extends Event {
+  constructor(data) {
+    super('exit');
+    this.data = data;
+  }
+}
+class Pty extends EventTarget {
+  /**
+   *
+   * @param {import('node-pty').IPty} pty
+   */
+  constructor(pty) {
+    super();
+    this.pty = pty;
+    const handleData = data => {
+      this.dispatchEvent(new DataEvent(data));
+    };
+    const handleExit = data => {
+      this.dispatchEvent(new ExitEvent(data));
+    };
+    this.pty.onData(handleData);
+    this.pty.onExit(handleExit);
+  }
+  resize(columns, rows) {
+    this.pty.resize(columns, rows);
+  }
+  dispose() {
+    this.pty.kill();
+  }
+  write(data) {
+    this.pty.write(data);
+  }
+}
+
+/**
+ *
+ * @param {*} param0
+ * @returns {any}
+ */
+const create$1 = ({
+  cwd,
+  command,
+  args
+} = {}) => {
+  try {
+    string(cwd);
+    string(command);
+    array(args);
+    const pty = spawn(command, args, {
+      encoding: null,
+      cwd
+      // cols: 10,
+      // rows: 10,
+    });
+    const wrapped = new Pty(pty);
+    return wrapped;
+  } catch (error) {
+    throw new VError(error, `Failed to create terminal`);
+  }
+};
+
+const state$1 = {
+  ptyMap: Object.create(null)
+};
+const set = (id, pty) => {
+  state$1.ptyMap[id] = pty;
+};
+const get = id => {
+  return state$1.ptyMap[id];
+};
+const remove = id => {
+  delete state$1.ptyMap[id];
+};
+
+// TODO maybe merge pty and pty controller
+const create = (ipc, id, cwd, command, args) => {
+  number(id);
+  string(cwd);
+  string(command);
+  array(args);
+  object(ipc);
+  debug(`create ${id} ${cwd}`);
+  // @ts-ignore
+  const pty = create$1({
+    cwd,
+    command,
+    args
+  });
+  const handleData = event => {
+    ipc.send({
+      jsonrpc: '2.0',
+      method: 'Viewlet.send',
+      params: [id, 'handleData', event.data]
+    });
+  };
+  pty.addEventListener('data', handleData);
+  set(id, pty);
+};
+const write = (id, data) => {
+  const pty = get(id);
+  if (!pty) {
+    throw new Error(`pty ${id} not found`);
+  }
+  pty.write(data);
+};
+const resize = (id, columns, rows) => {
+  const pty = get(id);
+  if (!pty) {
+    throw new Error(`pty ${id} not found`);
+  }
+  pty.resize(columns, rows);
+};
+const dispose = id => {
+  const pty = get(id);
+  if (!pty) {
+    throw new Error(`pty ${id} not found`);
+  }
+  pty.dispose();
+  remove(id);
+};
+
+const HandleElectronMessagePort = 'HandleElectronMessagePort.handleElectronMessagePort';
+const HandleNodeMessagePort = 'HandleNodeMessagePort.handleNodeMessagePort';
+const HandleWebSocket = 'HandleWebSocket.handleWebSocket';
+const TerminalCreate = 'Terminal.create';
+const TerminalResize = 'Terminal.resize';
+const TerminalWrite = 'Terminal.write';
+const TerminalDispose = 'Terminal.dispose';
+
+const commandMap = {
+  [HandleElectronMessagePort]: handleElectronMessagePort,
+  [HandleNodeMessagePort]: handleNodeMessagePort,
+  [HandleWebSocket]: handleWebSocket,
+  [TerminalCreate]: create,
+  [TerminalResize]: resize,
+  [TerminalWrite]: write,
+  [TerminalDispose]: dispose
+};
+
+const listen = async () => {
+  const ipc = await listen$1({
+    method: Auto()
+  });
+  handleIpc(ipc);
+};
+
+const NewLine = '\n';
+
+const Error$1 = 1;
+const Success = 0;
+
+/**
+ *
+ * @param {string} string
+ * @param {number|undefined} startIndex
+ * @returns
+ */
+const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine, startIndex);
+};
+
+const EPIPE = 'EPIPE';
+const ERR_IPC_CHANNEL_CLOSED = 'ERR_IPC_CHANNEL_CLOSED';
+
+const exit = code => {
+  process.exit(code);
+};
+const setExitCode = exitCode => {
+  process.exitCode = exitCode;
+};
+const isConnected = () => {
+  return process.connected;
+};
+
+const isIgnoredError = error => {
+  if (error && error.code === EPIPE && !process.connected) {
+    // parent process is disposed, ignore
+    return true;
+  }
+  if (error && error.code === ERR_IPC_CHANNEL_CLOSED && !isConnected()) {
+    // parent process is disposed, ignore
+    return true;
+  }
+  return false;
+};
+
+// TODO mock this module when used in unit tests
+
+const state = {
+  console: undefined
+};
+const createConsole = () => {
+  const logFile = `${tmpdir()}/log-terminal-process.txt`;
+  const writeStream = createWriteStream(logFile);
+  const logger = new Console(writeStream);
+  return logger;
+};
+const getOrCreateLogger = () => {
+  if (!state.console) {
+    state.console = createConsole();
+  }
+  return state.console;
+};
+const info = (...args) => {
+  const logger = getOrCreateLogger();
+  logger.info(...args);
+  console.info(...args);
+};
+const error = (...args) => {
+  const logger = getOrCreateLogger();
+  logger.error(...args);
+  console.error(...args);
+};
+
+const firstErrorLine = error => {
+  if (error.stack) {
+    return error.stack.slice(0, getNewLineIndex(error.stack));
+  }
+  if (error.message) {
+    return error.message;
+  }
+  return `${error}`;
+};
+
+// @ts-ignore
+const handleUncaughtExceptionMonitor$1 = error$1 => {
+  info(`[pty host] uncaught exception: ${firstErrorLine(error$1)}`);
+  if (isIgnoredError(error$1)) {
+    return;
+  }
+  const prettyError = prepare(error$1);
+  error(
+  // @ts-ignore
+  prettyError.codeFrame + NewLine + prettyError.stack + NewLine);
+  setExitCode(Error$1);
+};
+
+const handleDisconnect = () => {
+  console.info('[pty host] disconnected');
+  exit(Success);
+};
+const handleUncaughtExceptionMonitor = error => {
+  // @ts-ignore
+  handleUncaughtExceptionMonitor$1(error);
+};
+
+const main = async () => {
+  process.on('uncaughtExceptionMonitor', handleUncaughtExceptionMonitor);
+  process.on('disconnect', handleDisconnect);
+  register(commandMap);
+  await listen();
+};
+
+main();

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@lvce-editor/pty-host",
-  "version": "2.1.0",
+  "version": "3.0.0",
   "description": "",
-  "main": "src/ptyHostMain.js",
+  "main": "dist/ptyHostMain.js",
   "bin": "bin/ptyHost.js",
   "type": "module",
   "keywords": [
@@ -19,53 +19,15 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@lvce-editor/ipc": "^11.0.1",
-    "@lvce-editor/json-rpc": "^4.1.0",
+    "@lvce-editor/assert": "^1.3.0",
+    "@lvce-editor/command": "^1.2.0",
+    "@lvce-editor/ipc": "^11.3.0",
+    "@lvce-editor/json-rpc": "^5.2.0",
     "@lvce-editor/pretty-error": "^1.6.0",
-    "@lvce-editor/verror": "^1.4.0",
+    "@lvce-editor/verror": "^1.6.0",
     "debug": "^4.3.7"
   },
   "optionalDependencies": {
     "node-pty": "^1.1.0-beta20"
-  },
-  "xo": {
-    "rules": {
-      "unicorn/filename-case": "off",
-      "indent": "off",
-      "semi": "off",
-      "no-unused-vars": "off",
-      "unicorn/numeric-separators-style": "off",
-      "no-extra-semi": "off",
-      "arrow-body-style": "off",
-      "padded-blocks": "off",
-      "capitalized-comments": "off",
-      "padding-line-between-statements": "off",
-      "arrow-parens": "off",
-      "no-warning-comments": "off",
-      "array-bracket-spacing": "off",
-      "comma-spacing": "off",
-      "unicorn/no-array-callback-reference": "off",
-      "comma-dangle": "off",
-      "operator-linebreak": "off",
-      "no-case-declarations": "off",
-      "no-undef": "off",
-      "object-curly-spacing": "off",
-      "object-shorthand": "off",
-      "complexity": "off",
-      "no-labels": "off",
-      "no-multi-assign": "off",
-      "max-params": "off",
-      "no-bitwise": "off",
-      "unicorn/prefer-math-trunc": "off",
-      "no-await-in-loop": "off",
-      "unicorn/prefer-add-event-listener": "off",
-      "no-unused-expressions": "off",
-      "node/prefer-global/process": "off",
-      "unicorn/no-for-loop": "off",
-      "unicorn/prevent-abbreviations": "off"
-    },
-    "ignores": [
-      "distmin"
-    ]
   }
 }

package/src/parts/Assert/Assert.js

@@ -1,59 +0,0 @@
-import { AssertionError } from '../AssertionError/AssertionError.js'
-
-const getType = (value) => {
-  switch (typeof value) {
-    case 'number':
-      return 'number'
-    case 'function':
-      return 'function'
-    case 'string':
-      return 'string'
-    case 'object':
-      if (value === null) {
-        return 'null'
-      }
-      if (Array.isArray(value)) {
-        return 'array'
-      }
-      return 'object'
-    case 'boolean':
-      return 'boolean'
-    default:
-      return 'unknown'
-  }
-}
-
-export const object = (value) => {
-  const type = getType(value)
-  if (type !== 'object') {
-    throw new AssertionError('expected value to be of type object')
-  }
-}
-
-export const number = (value) => {
-  const type = getType(value)
-  if (type !== 'number') {
-    throw new AssertionError('expected value to be of type number')
-  }
-}
-
-export const array = (value) => {
-  const type = getType(value)
-  if (type !== 'array') {
-    throw new AssertionError('expected value to be of type array')
-  }
-}
-
-export const string = (value) => {
-  const type = getType(value)
-  if (type !== 'string') {
-    throw new AssertionError('expected value to be of type string')
-  }
-}
-
-export const boolean = (value) => {
-  const type = getType(value)
-  if (type !== 'boolean') {
-    throw new AssertionError('expected value to be of type boolean')
-  }
-}

package/src/parts/AssertionError/AssertionError.js

@@ -1,6 +0,0 @@
-export class AssertionError extends Error {
-  constructor(message) {
-    super(message)
-    this.name = 'AssertionError'
-  }
-}

package/src/parts/Callback/Callback.js

@@ -1 +0,0 @@
-export { resolve } from '@lvce-editor/json-rpc'

package/src/parts/Character/Character.js

@@ -1,11 +0,0 @@
-export const Backslash = '\\'
-export const Dash = '-'
-export const Dot = '.'
-export const EmptyString = ''
-export const NewLine = '\n'
-export const OpenAngleBracket = '<'
-export const Slash = '/'
-export const Space = ' '
-export const Tab = '\t'
-export const Underline = '_'
-export const T = 't'

package/src/parts/Command/Command.js

@@ -1,9 +0,0 @@
-import * as CommandState from '../CommandState/CommandState.js'
-
-export const execute = (command, ...args) => {
-  const fn = CommandState.getCommand(command)
-  if (!fn) {
-    throw new Error(`Command not found ${command}`)
-  }
-  return fn(...args)
-}

package/src/parts/CommandMap/CommandMap.js

@@ -1,17 +0,0 @@
-import * as HandleElectronMessagePort from '../HandleElectronMessagePort/HandleElectronMessagePort.js'
-import * as HandleNodeMessagePort from '../HandleNodeMessagePort/HandleNodeMessagePort.js'
-import * as HandleWebSocket from '../HandleWebSocket/HandleWebSocket.js'
-import * as PtyController from '../PtyController/PtyController.js'
-import * as TerminalProcessCommandType from '../TerminalProcessCommandType/TerminalProcessCommandType.js'
-
-export const commandMap = {
-  [TerminalProcessCommandType.HandleElectronMessagePort]:
-    HandleElectronMessagePort.handleElectronMessagePort,
-  [TerminalProcessCommandType.HandleNodeMessagePort]:
-    HandleNodeMessagePort.handleNodeMessagePort,
-  [TerminalProcessCommandType.HandleWebSocket]: HandleWebSocket.handleWebSocket,
-  [TerminalProcessCommandType.TerminalCreate]: PtyController.create,
-  [TerminalProcessCommandType.TerminalResize]: PtyController.resize,
-  [TerminalProcessCommandType.TerminalWrite]: PtyController.write,
-  [TerminalProcessCommandType.TerminalDispose]: PtyController.dispose,
-}

package/src/parts/CommandState/CommandState.js

@@ -1,17 +0,0 @@
-export const state = {
-  commands: Object.create(null),
-}
-
-export const registerCommand = (key, fn) => {
-  state.commands[key] = fn
-}
-
-export const registerCommands = (commandMap) => {
-  for (const [key, value] of Object.entries(commandMap)) {
-    registerCommand(key, value)
-  }
-}
-
-export const getCommand = (key) => {
-  return state.commands[key]
-}

package/src/parts/Debug/Debug.js

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

package/src/parts/ErrorCodes/ErrorCodes.js

@@ -1,19 +0,0 @@
-export const E_COLOR_THEME_NOT_FOUND = 'E_COLOR_THEME_NOT_FOUND'
-export const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND'
-export const E_ICON_THEME_NOT_FOUND = 'E_ICON_THEME_NOT_FOUND'
-export const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE'
-export const E_MANIFEST_NOT_FOUND = 'E_MANIFEST_NOT_FOUND'
-export const E_MODULES_NOT_SUPPORTED_IN_ELECTRON =
-  'E_MODULES_NOT_SUPPORTED_IN_ELECTRON'
-export const EACCES = 'EACCES'
-export const ECONNRESET = 'ECONNRESET'
-export const EEXIST = 'EEXIST'
-export const EISDIR = 'EISDIR'
-export const ELOOP = 'ELOOP'
-export const ENOENT = 'ENOENT'
-export const ENOTDIR = 'ENOTDIR'
-export const EPERM = 'EPERM'
-export const EPIPE = 'EPIPE'
-export const ERR_IPC_CHANNEL_CLOSED = 'ERR_IPC_CHANNEL_CLOSED'
-export const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND'
-export const EXDEV = 'EXDEV'

package/src/parts/ErrorHandling/ErrorHandling.js

@@ -1,75 +0,0 @@
-import * as Character from '../Character/Character.js'
-import * as ExitCode from '../ExitCode/ExitCode.js'
-import * as GetNewLineIndex from '../GetNewLineIndex/GetNewLineIndex.js'
-import * as IsIgnoredError from '../IsIgnoredError/IsIgnoredError.js'
-import * as Logger from '../Logger/Logger.js'
-import * as PrettyError from '../PrettyError/PrettyError.js'
-import * as Process from '../Process/Process.js'
-
-export const state = {
-  seenErrors: [],
-}
-
-const preparePrettyError = (error) => {
-  const cause = error.cause()
-  return {
-    message: error.message,
-    codeFrame: cause.codeFrame,
-    stack: cause.stack,
-  }
-}
-
-const printPrettyError = (prettyError) => {
-  console.error(
-    `${prettyError.message}\n${prettyError.codeFrame}\n${prettyError.stack}`,
-  )
-}
-
-export const handleError = (error) => {
-  // @ts-ignore
-  if (state.seenErrors.includes(error.message)) {
-    return
-  }
-  // @ts-ignore
-  state.seenErrors.push(error.message)
-  const prettyError = preparePrettyError(error)
-  // Socket.send({
-  //   jsonrpc: JsonRpcVersion.Two,
-  //   method: /* Dialog.showErrorDialogWithOptions */ 'Dialog.showMessage',
-  //   params: [
-  //     {
-  //       message: prettyError.message,
-  //       codeFrame: prettyError.codeFrame,
-  //       stack: prettyError.stack,
-  //     },
-  //   ],
-  // })
-  printPrettyError(prettyError)
-}
-
-const firstErrorLine = (error) => {
-  if (error.stack) {
-    return error.stack.slice(0, GetNewLineIndex.getNewLineIndex(error.stack))
-  }
-  if (error.message) {
-    return error.message
-  }
-  return `${error}`
-}
-
-// @ts-ignore
-export const handleUncaughtExceptionMonitor = (error, origin) => {
-  Logger.info(`[pty host] uncaught exception: ${firstErrorLine(error)}`)
-  if (IsIgnoredError.isIgnoredError(error)) {
-    return
-  }
-  const prettyError = PrettyError.prepare(error)
-  Logger.error(
-    // @ts-ignore
-    prettyError.codeFrame +
-      Character.NewLine +
-      prettyError.stack +
-      Character.NewLine,
-  )
-  Process.setExitCode(ExitCode.Error)
-}

package/src/parts/ExitCode/ExitCode.js

@@ -1,5 +0,0 @@
-export const Error = 1
-
-export const ExpectedError = 128
-
-export const Success = 0

package/src/parts/GetNewLineIndex/GetNewLineIndex.js

@@ -1,11 +0,0 @@
-import * as Character from '../Character/Character.js'
-
-/**
- *
- * @param {string} string
- * @param {number|undefined} startIndex
- * @returns
- */
-export const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(Character.NewLine, startIndex)
-}

package/src/parts/HandleElectronMessagePort/HandleElectronMessagePort.js

@@ -1,13 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as HandleIpc from '../HandleIpc/HandleIpc.js'
-import * as IpcChild from '../IpcChild/IpcChild.js'
-import * as IpcChildType from '../IpcChildType/IpcChildType.js'
-
-export const handleElectronMessagePort = async (messagePort) => {
-  Assert.object(messagePort)
-  const ipc = await IpcChild.listen({
-    method: IpcChildType.ElectronMessagePort,
-    messagePort,
-  })
-  HandleIpc.handleIpc(ipc)
-}

package/src/parts/HandleIpc/HandleIpc.js

@@ -1,15 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as HandleMessage from '../HandleMessage/HandleMessage.js'
-
-export const handleIpc = (ipc) => {
-  Assert.object(ipc)
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', HandleMessage.handleMessage)
-  } else if ('onmessage' in ipc) {
-    // deprecated
-    ipc.onmessage = HandleMessage.handleMessage
-  } else if ('on' in ipc) {
-    // deprecated
-    ipc.on('message', HandleMessage.handleMessage)
-  }
-}

package/src/parts/HandleMessage/HandleMessage.js

@@ -1,25 +0,0 @@
-import * as Callback from '../Callback/Callback.js'
-import * as Command from '../Command/Command.js'
-import * as JsonRpc from '../JsonRpc/JsonRpc.js'
-import * as PrintPrettyError from '../PrintPrettyError/PrintPrettyError.js'
-import * as RequiresSocket from '../RequiresSocket/RequiresSocket.js'
-
-const preparePrettyError = (error) => {
-  return error
-}
-
-const logError = (error, prettyError) => {
-  PrintPrettyError.printPrettyError(prettyError, `[terminal-process] `)
-}
-
-export const handleMessage = (event) => {
-  return JsonRpc.handleJsonRpcMessage(
-    event.target,
-    event.data,
-    Command.execute,
-    Callback.resolve,
-    preparePrettyError,
-    logError,
-    RequiresSocket.requiresSocket,
-  )
-}

package/src/parts/HandleNodeMessagePort/HandleNodeMessagePort.js

@@ -1,11 +0,0 @@
-import * as HandleIpc from '../HandleIpc/HandleIpc.js'
-import * as IpcChild from '../IpcChild/IpcChild.js'
-import * as IpcChildType from '../IpcChildType/IpcChildType.js'
-
-export const handleNodeMessagePort = async (messagePort) => {
-  const ipc = await IpcChild.listen({
-    method: IpcChildType.NodeMessagePort,
-    messagePort,
-  })
-  HandleIpc.handleIpc(ipc)
-}

package/src/parts/HandleWebSocket/HandleWebSocket.js

@@ -1,15 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as HandleIpc from '../HandleIpc/HandleIpc.js'
-import * as IpcChild from '../IpcChild/IpcChild.js'
-import * as IpcChildType from '../IpcChildType/IpcChildType.js'
-
-export const handleWebSocket = async (handle, request) => {
-  Assert.object(handle)
-  Assert.object(request)
-  const ipc = await IpcChild.listen({
-    method: IpcChildType.WebSocket,
-    request,
-    handle,
-  })
-  HandleIpc.handleIpc(ipc)
-}

package/src/parts/IpcChild/IpcChild.js

@@ -1,15 +0,0 @@
-import * as IpcChildModule from '../IpcChildModule/IpcChildModule.js'
-
-export const listen = async ({ method, ...params }) => {
-  const module = await IpcChildModule.getModule(method)
-  // @ts-ignore
-  const rawIpc = await module.listen(params)
-  // @ts-ignore
-  if (module.signal) {
-    // @ts-ignore
-    module.signal(rawIpc)
-  }
-  // @ts-ignore
-  const ipc = module.wrap(rawIpc)
-  return ipc
-}

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -1,25 +0,0 @@
-import {
-  IpcChildWithElectronMessagePort,
-  IpcChildWithElectronUtilityProcess,
-  IpcChildWithNodeForkedProcess,
-  IpcChildWithNodeWorker,
-  IpcChildWithWebSocket,
-} from '@lvce-editor/ipc'
-import * as IpcChildType from '../IpcChildType/IpcChildType.js'
-
-export const getModule = (method) => {
-  switch (method) {
-    case IpcChildType.NodeForkedProcess:
-      return IpcChildWithNodeForkedProcess
-    case IpcChildType.NodeWorker:
-      return IpcChildWithNodeWorker
-    case IpcChildType.WebSocket:
-      return IpcChildWithWebSocket
-    case IpcChildType.ElectronUtilityProcess:
-      return IpcChildWithElectronUtilityProcess
-    case IpcChildType.ElectronMessagePort:
-      return IpcChildWithElectronMessagePort
-    default:
-      throw new Error('unexpected ipc type')
-  }
-}

package/src/parts/IpcChildType/IpcChildType.js

@@ -1,20 +0,0 @@
-export const NodeWorker = 1
-export const NodeForkedProcess = 2
-export const WebSocket = 3
-export const ElectronUtilityProcess = 4
-export const ElectronMessagePort = 5
-export const NodeMessagePort = 6
-
-export const Auto = () => {
-  const { argv } = process
-  if (argv.includes('--ipc-type=node-worker')) {
-    return NodeWorker
-  }
-  if (argv.includes('--ipc-type=node-forked-process')) {
-    return NodeForkedProcess
-  }
-  if (argv.includes('--ipc-type=electron-utility-process')) {
-    return ElectronUtilityProcess
-  }
-  throw new Error(`[pty-host] unknown ipc type`)
-}

package/src/parts/IsIgnoredError/IsIgnoredError.js

@@ -1,18 +0,0 @@
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-import * as Process from '../Process/Process.js'
-
-export const isIgnoredError = (error) => {
-  if (error && error.code === ErrorCodes.EPIPE && !process.connected) {
-    // parent process is disposed, ignore
-    return true
-  }
-  if (
-    error &&
-    error.code === ErrorCodes.ERR_IPC_CHANNEL_CLOSED &&
-    !Process.isConnected()
-  ) {
-    // parent process is disposed, ignore
-    return true
-  }
-  return false
-}

package/src/parts/JsonRpc/JsonRpc.js

@@ -1 +0,0 @@
-export * from '@lvce-editor/json-rpc'

package/src/parts/Listen/Listen.js

@@ -1,8 +0,0 @@
-import * as HandleIpc from '../HandleIpc/HandleIpc.js'
-import * as IpcChild from '../IpcChild/IpcChild.js'
-import * as IpcChildType from '../IpcChildType/IpcChildType.js'
-
-export const listen = async () => {
-  const ipc = await IpcChild.listen({ method: IpcChildType.Auto() })
-  HandleIpc.handleIpc(ipc)
-}

package/src/parts/Logger/Logger.js

@@ -1,50 +0,0 @@
-import { Console } from 'node:console'
-import { createWriteStream } from 'node:fs'
-import { tmpdir } from 'node:os'
-
-// TODO mock this module when used in unit tests
-
-const state = {
-  /**
-   * @type {Console|undefined}
-   */
-  console: undefined,
-}
-
-const createConsole = () => {
-  const logFile = `${tmpdir()}/log-terminal-process.txt`
-  const writeStream = createWriteStream(logFile)
-  const logger = new Console(writeStream)
-  return logger
-}
-
-const getOrCreateLogger = () => {
-  if (!state.console) {
-    state.console = createConsole()
-  }
-  return state.console
-}
-
-export const log = (...args) => {
-  const logger = getOrCreateLogger()
-  logger.log(...args)
-  console.log(...args)
-}
-
-export const info = (...args) => {
-  const logger = getOrCreateLogger()
-  logger.info(...args)
-  console.info(...args)
-}
-
-export const warn = (...args) => {
-  const logger = getOrCreateLogger()
-  logger.warn(...args)
-  console.warn(...args)
-}
-
-export const error = (...args) => {
-  const logger = getOrCreateLogger()
-  logger.error(...args)
-  console.error(...args)
-}

package/src/parts/Main/Main.js

@@ -1,14 +0,0 @@
-import * as CommandMap from '../CommandMap/CommandMap.js'
-import * as CommandState from '../CommandState/CommandState.js'
-import * as Listen from '../Listen/Listen.js'
-import * as ProcessListeners from '../ProcessListeners/ProcessListeners.js'
-
-export const main = async () => {
-  process.on(
-    'uncaughtExceptionMonitor',
-    ProcessListeners.handleUncaughtExceptionMonitor,
-  )
-  process.on('disconnect', ProcessListeners.handleDisconnect)
-  CommandState.registerCommands(CommandMap.commandMap)
-  await Listen.listen()
-}

package/src/parts/NodePty/NodePty.js

@@ -1,72 +0,0 @@
-import { spawn } from 'node-pty'
-import { VError } from '../VError/VError.js'
-import * as Assert from '../Assert/Assert.js'
-
-class DataEvent extends Event {
-  constructor(data) {
-    super('data')
-    this.data = data
-  }
-}
-
-class ExitEvent extends Event {
-  constructor(data) {
-    super('exit')
-    this.data = data
-  }
-}
-
-class Pty extends EventTarget {
-  /**
-   *
-   * @param {import('node-pty').IPty} pty
-   */
-  constructor(pty) {
-    super()
-    this.pty = pty
-
-    const handleData = (data) => {
-      this.dispatchEvent(new DataEvent(data))
-    }
-    const handleExit = (data) => {
-      this.dispatchEvent(new ExitEvent(data))
-    }
-    this.pty.onData(handleData)
-    this.pty.onExit(handleExit)
-  }
-
-  resize(columns, rows) {
-    this.pty.resize(columns, rows)
-  }
-
-  dispose() {
-    this.pty.kill()
-  }
-
-  write(data) {
-    this.pty.write(data)
-  }
-}
-
-/**
- *
- * @param {*} param0
- * @returns {any}
- */
-export const create = ({ env = {}, cwd, command, args } = {}) => {
-  try {
-    Assert.string(cwd)
-    Assert.string(command)
-    Assert.array(args)
-    const pty = spawn(command, args, {
-      encoding: null,
-      cwd,
-      // cols: 10,
-      // rows: 10,
-    })
-    const wrapped = new Pty(pty)
-    return wrapped
-  } catch (error) {
-    throw new VError(error, `Failed to create terminal`)
-  }
-}

package/src/parts/PrettyError/PrettyError.js

@@ -1 +0,0 @@
-export { prepare, prepareJsonError } from '@lvce-editor/pretty-error'

package/src/parts/PrintPrettyError/PrintPrettyError.js

@@ -1,7 +0,0 @@
-import * as Logger from '../Logger/Logger.js'
-
-export const printPrettyError = (prettyError, prefix = '') => {
-  Logger.error(
-    `${prefix}${prettyError.type}: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}\n`,
-  )
-}

package/src/parts/Process/Process.js

@@ -1,17 +0,0 @@
-export const exit = (code) => {
-  process.exit(code)
-}
-
-export const setExitCode = (exitCode) => {
-  process.exitCode = exitCode
-}
-
-export const { argv } = process
-
-export const isConnected = () => {
-  return process.connected
-}
-
-export const getPid = () => {
-  return process.pid
-}

package/src/parts/ProcessListeners/ProcessListeners.js

@@ -1,17 +0,0 @@
-import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
-import * as ExitCode from '../ExitCode/ExitCode.js'
-import * as Process from '../Process/Process.js'
-
-export const handleDisconnect = () => {
-  console.info('[pty host] disconnected')
-  Process.exit(ExitCode.Success)
-}
-
-export const handleSigTerm = () => {
-  console.info('[pty host] sigterm')
-  Process.exit(ExitCode.Success)
-}
-
-export const handleUncaughtExceptionMonitor = (error) => {
-  ErrorHandling.handleUncaughtExceptionMonitor(error)
-}

package/src/parts/Pty/Pty.js

@@ -1 +0,0 @@
-export * from '../NodePty/NodePty.js'

package/src/parts/PtyController/PtyController.js

@@ -1,57 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as Debug from '../Debug/Debug.js'
-import * as Pty from '../Pty/Pty.js'
-import * as PtyState from '../PtyState/PtyState.js'
-
-// TODO maybe merge pty and pty controller
-export const create = (ipc, id, cwd, command, args) => {
-  Assert.number(id)
-  Assert.string(cwd)
-  Assert.string(command)
-  Assert.array(args)
-  Assert.object(ipc)
-  Debug.debug(`create ${id} ${cwd}`)
-  // @ts-ignore
-  const pty = Pty.create({ cwd, command, args })
-  const handleData = (event) => {
-    ipc.send({
-      jsonrpc: '2.0',
-      method: 'Viewlet.send',
-      params: [id, 'handleData', event.data],
-    })
-  }
-
-  pty.addEventListener('data', handleData)
-  PtyState.set(id, pty)
-}
-
-export const write = (id, data) => {
-  const pty = PtyState.get(id)
-  if (!pty) {
-    throw new Error(`pty ${id} not found`)
-  }
-  pty.write(data)
-}
-
-export const resize = (id, columns, rows) => {
-  const pty = PtyState.get(id)
-  if (!pty) {
-    throw new Error(`pty ${id} not found`)
-  }
-  pty.resize(columns, rows)
-}
-
-export const dispose = (id) => {
-  const pty = PtyState.get(id)
-  if (!pty) {
-    throw new Error(`pty ${id} not found`)
-  }
-  pty.dispose()
-  PtyState.remove(id)
-}
-
-export const disposeAll = () => {
-  for (const id in PtyState.getAll()) {
-    dispose(id)
-  }
-}

package/src/parts/PtyState/PtyState.js

@@ -1,19 +0,0 @@
-export const state = {
-  ptyMap: Object.create(null),
-}
-
-export const set = (id, pty) => {
-  state.ptyMap[id] = pty
-}
-
-export const get = (id) => {
-  return state.ptyMap[id]
-}
-
-export const remove = (id) => {
-  delete state.ptyMap[id]
-}
-
-export const getAll = () => {
-  return state.ptyMap
-}

package/src/parts/RequiresSocket/RequiresSocket.js

@@ -1,5 +0,0 @@
-const METHODS_THAT_REQUIRE_SOCKET = new Set(['Terminal.create'])
-
-export const requiresSocket = (method) => {
-  return METHODS_THAT_REQUIRE_SOCKET.has(method)
-}

package/src/parts/TerminalProcessCommandType/TerminalProcessCommandType.js

@@ -1,9 +0,0 @@
-export const HandleElectronMessagePort =
-  'HandleElectronMessagePort.handleElectronMessagePort'
-export const HandleNodeMessagePort =
-  'HandleNodeMessagePort.handleNodeMessagePort'
-export const HandleWebSocket = 'HandleWebSocket.handleWebSocket'
-export const TerminalCreate = 'Terminal.create'
-export const TerminalResize = 'Terminal.resize'
-export const TerminalWrite = 'Terminal.write'
-export const TerminalDispose = 'Terminal.dispose'

package/src/parts/VError/VError.js

@@ -1 +0,0 @@
-export * from '@lvce-editor/verror'

package/src/ptyHostMain.js

@@ -1,3 +0,0 @@
-import * as Main from './parts/Main/Main.js'
-
-Main.main()