@lvce-editor/file-system-process 2.0.0 → 2.2.0

package/dist/index.js

@@ -108,7 +108,6 @@ class VError extends Error {
   }
 }
 
-// @ts-ignore
 const getDisplayPath = path => {
   if (path === '') {
     return '<empty string>';
@@ -116,10 +115,8 @@ const getDisplayPath = path => {
   return path;
 };
 class FileNotFoundError extends VError {
-  // @ts-ignore
   constructor(path) {
     super(`File not found: '${getDisplayPath(path)}'`);
-    // @ts-ignore
     this.code = ENOENT;
   }
 }
@@ -133,10 +130,6 @@ const Socket = 8;
 const Symlink = 9;
 const Unknown = 12;
 
-/**
- * @param {import('fs').Dirent|import('fs').StatsBase} dirent
- */
-// @ts-ignore
 const getDirentType = dirent => {
   if (dirent.isFile()) {
     return File;
@@ -200,13 +193,259 @@ const isEnoentError = error => {
   return isEnoentErrorLinux(error) || isEnoentErrorWindows(error);
 };
 
+const rpcs = Object.create(null);
+const set$f = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get$1 = id => {
+  return rpcs[id];
+};
+
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+
+const create$6 = rpcId => {
+  return {
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get$1(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get$1(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    set(rpc) {
+      set$f(rpcId, rpc);
+    },
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
+    }
+  };
+};
+const MainProcess$1 = -5;
+const {
+  invoke: invoke$6,
+  set: set$6} = create$6(MainProcess$1);
+const MainProcess = {
+  __proto__: null,
+  invoke: invoke$6,
+  set: set$6
+};
+
+const {
+  invoke: invoke$1,
+  set: set$1
+} = MainProcess;
+
+const trash$2 = async path => {
+  if (!existsSync(path)) {
+    return;
+  }
+  // @ts-ignore
+  await invoke$1('Trash.trash', path);
+};
+
+// @ts-ignore
+const trash$1 = async path => {
+  await _trash(path);
+};
+
+const getTrashFn = isElectron => {
+  if (isElectron) {
+    return trash$2;
+  }
+  return trash$1;
+};
+
 const getElectronRunAsNode = () => {
   return process.env.ELECTRON_RUN_AS_NODE;
 };
-process;
 
 const isElectron = Boolean(getElectronRunAsNode()) || 'electron' in process.versions;
 
+const trash = async path => {
+  try {
+    const fn = getTrashFn(isElectron);
+    await fn(path);
+  } catch (error) {
+    throw new VError(error, 'Failed to move item to trash');
+  }
+};
+
+// TODO lazyload chokidar and trash (but doesn't work currently because of bug with jest)
+const assertUri = uri => {
+  if (!uri.startsWith('file://')) {
+    throw new Error(`path must be a valid file uri`);
+  }
+};
+const copy = async (sourceUri, targetUri) => {
+  try {
+    assertUri(sourceUri);
+    assertUri(targetUri);
+    const source = fileURLToPath(sourceUri);
+    const target = fileURLToPath(targetUri);
+    await fs.cp(source, target, {
+      recursive: true
+    });
+  } catch (error) {
+    if (error && error.message && error.message.startsWith('Invalid src or dest: cp returned EINVAL (src and dest cannot be the same)')) {
+      throw new VError(`Failed to copy "${sourceUri}" to "${targetUri}": src and dest cannot be the same`);
+    }
+    throw new VError(error, `Failed to copy "${sourceUri}" to "${targetUri}"`);
+  }
+};
+const readFile = async (uri, encoding = Utf8) => {
+  try {
+    string(uri);
+    assertUri(uri);
+    const path = fileURLToPath(uri);
+    const content = await fs.readFile(path, encoding);
+    return content;
+  } catch (error) {
+    if (isEnoentError(error)) {
+      throw new FileNotFoundError(uri);
+    }
+    throw new VError(error, `Failed to read file "${uri}"`);
+  }
+};
+const writeFile = async (uri, content, encoding = Utf8) => {
+  try {
+    assertUri(uri);
+    string(uri);
+    string(content);
+    const path = fileURLToPath(uri);
+    // queue would be more correct for concurrent writes but also slower
+    // Queue.add(`writeFile/${path}`, () =>
+    await fs.writeFile(path, content, encoding);
+  } catch (error) {
+    if (isEnoentError(error)) {
+      throw new FileNotFoundError(uri);
+    }
+    throw new VError(error, `Failed to write to file "${uri}"`);
+  }
+};
+const isOkayToRemove = path => {
+  if (path === '/') {
+    return false;
+  }
+  if (path === '~') {
+    return false;
+  }
+  if (path === os.homedir()) {
+    return false;
+  }
+  return true;
+};
+const remove$1 = async uri => {
+  assertUri(uri);
+  const path = fileURLToPath(uri);
+  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(path);
+  } catch (error) {
+    throw new VError(error, `Failed to remove "${uri}"`);
+  }
+};
+const toPrettyDirent = dirent => {
+  return {
+    name: dirent.name,
+    type: getDirentType(dirent)
+  };
+};
+const readDirWithFileTypes = async uri => {
+  try {
+    assertUri(uri);
+    const path = fileURLToPath(uri);
+    const dirents = await fs.readdir(path, {
+      withFileTypes: true
+    });
+    const prettyDirents = dirents.map(toPrettyDirent);
+    return prettyDirents;
+  } catch (error) {
+    throw new VError(error, `Failed to read directory "${uri}"`);
+  }
+};
+const mkdir = async uri => {
+  try {
+    assertUri(uri);
+    const path = fileURLToPath(uri);
+    await fs.mkdir(path, {
+      recursive: true
+    });
+  } catch (error) {
+    throw new VError(error, `Failed to create directory "${uri}"`);
+  }
+};
+const fallbackRename = async (oldUri, newUri) => {
+  try {
+    const oldPath = fileURLToPath(oldUri);
+    const newPath = fileURLToPath(newUri);
+    await fs.cp(oldPath, newPath, {
+      recursive: true
+    });
+    await fs.rm(oldPath, {
+      recursive: true
+    });
+  } catch (error) {
+    throw new VError(error, `Failed to rename "${oldUri}" to "${newUri}"`);
+  }
+};
+const rename = async (oldUri, newUri) => {
+  try {
+    const oldPath = fileURLToPath(oldUri);
+    const newPath = fileURLToPath(newUri);
+    await fs.rename(oldPath, newPath);
+  } catch (error) {
+    if (error && error.code === EXDEV) {
+      return fallbackRename(oldUri, newUri);
+    }
+    throw new VError(error, `Failed to rename "${oldUri}" to "${newUri}"`);
+  }
+};
+const getPathSeparator = () => {
+  return '/';
+};
+const stat = async uri => {
+  const path = fileURLToPath(uri);
+  const stats = await fs.stat(path);
+  const type = getDirentType(stats);
+  return type;
+};
+const chmod = async (uri, permissions) => {
+  const path = fileURLToPath(uri);
+  await fs.chmod(path, permissions);
+};
+const readJson = async uri => {
+  try {
+    string(uri);
+    assertUri(uri);
+    const path = fileURLToPath(uri);
+    const content = await fs.readFile(path, 'utf8');
+    const parsed = JSON.parse(content);
+    return parsed;
+  } catch (error) {
+    if (isEnoentError(error)) {
+      throw new FileNotFoundError(uri);
+    }
+    throw new VError(error, `Failed to read file as json "${uri}"`);
+  }
+};
+const getFolderSize = async uri => {
+  const path = fileURLToPath(uri);
+  const total = await getFolderSizeInternal(path);
+  return total;
+};
+
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -629,7 +868,7 @@ const listen$3 = async () => {
     parentPort
   } = await import('node:worker_threads');
   if (!parentPort) {
-    throw new IpcError('parentPort is required');
+    throw new IpcError('parentPort is required for node worker threads ipc');
   }
   return parentPort;
 };
@@ -764,8 +1003,6 @@ const handleUpgrade$1 = async (...args) => {
   // @ts-ignore
   return module.handleUpgrade(...args);
 };
-
-// @ts-ignore
 const listen$1$1 = async ({
   request,
   handle
@@ -786,8 +1023,6 @@ const listen$1$1 = async ({
 const signal$4 = webSocket => {
   webSocket.resume();
 };
-
-// @ts-ignore
 const wrap$9 = webSocket => {
   return {
     webSocket,
@@ -856,7 +1091,7 @@ const set = (id, fn) => {
 const get = id => {
   return callbacks[id];
 };
-const remove$1 = id => {
+const remove = id => {
   delete callbacks[id];
 };
 let id = 0;
@@ -942,6 +1177,16 @@ const constructError = (message, type, name) => {
   }
   return new ErrorConstructor(message);
 };
+const joinLines = lines => {
+  return lines.join(NewLine);
+};
+const splitLines = lines => {
+  return lines.split(NewLine);
+};
+const getCurrentStack = () => {
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(2));
+  return currentStack;
+};
 const getNewLineIndex = (string, startIndex = undefined) => {
   return string.indexOf(NewLine, startIndex);
 };
@@ -952,19 +1197,16 @@ const getParentStack = error => {
   }
   return parentStack;
 };
-const joinLines = lines => {
-  return lines.join(NewLine);
-};
 const MethodNotFound = -32601;
 const Custom = -32001;
-const splitLines = lines => {
-  return lines.split(NewLine);
-};
 const restoreJsonRpcError = error => {
+  const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
+    if (typeof error.stack === 'string') {
+      error.stack = error.stack + NewLine + currentStack;
+    }
     return error;
   }
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(1));
   if (error && error.code && error.code === MethodNotFound) {
     const restoredError = new JsonRpcError(error.message);
     const parentStack = getParentStack(error);
@@ -1033,7 +1275,7 @@ const resolve = (id, response) => {
     return;
   }
   fn(response);
-  remove$1(id);
+  remove(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -1045,6 +1287,17 @@ const getErrorType = prettyError => {
   }
   return undefined;
 };
+const isAlreadyStack = line => {
+  return line.trim().startsWith('at ');
+};
+const getStack = prettyError => {
+  const stackString = prettyError.stack || '';
+  const newLineIndex = stackString.indexOf('\n');
+  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
+    return stackString.slice(newLineIndex + 1);
+  }
+  return stackString;
+};
 const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
@@ -1057,7 +1310,7 @@ const getErrorProperty = (error, prettyError) => {
     code: Custom,
     message: prettyError.message,
     data: {
-      stack: prettyError.stack,
+      stack: getStack(prettyError),
       codeFrame: prettyError.codeFrame,
       type: getErrorType(prettyError),
       code: prettyError.code,
@@ -1065,18 +1318,18 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1 = (message, error) => {
+const create$1 = (id, error) => {
   return {
     jsonrpc: Two,
-    id: message.id,
+    id,
     error
   };
 };
-const getErrorResponse = (message, error, preparePrettyError, logError) => {
+const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1(message, errorProperty);
+  return create$1(id, errorProperty);
 };
 const create = (message, result) => {
   return {
@@ -1089,12 +1342,27 @@ const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
   return create(message, resultProperty);
 };
+const getErrorResponseSimple = (id, error) => {
+  return {
+    jsonrpc: Two,
+    id,
+    error: {
+      code: Custom,
+      // @ts-ignore
+      message: error.message,
+      data: error
+    }
+  };
+};
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
   try {
     const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
     return getSuccessResponse(message, result);
   } catch (error) {
-    return getErrorResponse(message, error, preparePrettyError, logError);
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
+    }
+    return getErrorResponse(message.id, error, preparePrettyError, logError);
   }
 };
 const defaultPreparePrettyError = error => {
@@ -1149,7 +1417,7 @@ const handleJsonRpcMessage = async (...args) => {
       try {
         ipc.send(response);
       } catch (error) {
-        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
         ipc.send(errorResponse);
       }
       return;
@@ -1180,7 +1448,7 @@ const send = (transport, method, ...params) => {
   const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke$1 = (ipc, method, ...params) => {
+const invoke = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer = (ipc, method, ...params) => {
@@ -1213,7 +1481,7 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$1(ipc, method, ...params);
+      return invoke(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
       return invokeAndTransfer(ipc, method, ...params);
@@ -1254,24 +1522,28 @@ const listen$2 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$c = async ({
+const create$e = async ({
   commandMap,
-  messagePort
+  messagePort,
+  requiresSocket
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
   const ipc = await listen$2(IpcChildWithElectronMessagePort$1, {
     messagePort
   });
+  if (requiresSocket) {
+    ipc.requiresSocket = requiresSocket;
+  }
   handleIpc(ipc);
   const rpc = createRpc(ipc);
   return rpc;
 };
 const ElectronMessagePortRpcClient = {
   __proto__: null,
-  create: create$c
+  create: create$e
 };
-const create$b = async ({
+const create$d = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1283,7 +1555,7 @@ const create$b = async ({
 };
 const ElectronUtilityProcessRpcClient = {
   __proto__: null,
-  create: create$b
+  create: create$d
 };
 const create$7 = async ({
   commandMap
@@ -1302,7 +1574,8 @@ const NodeForkedProcessRpcClient = {
 const create$5 = async ({
   commandMap,
   request,
-  handle
+  handle,
+  requiresSocket
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
@@ -1310,6 +1583,9 @@ const create$5 = async ({
     request,
     handle
   });
+  if (requiresSocket) {
+    ipc.requiresSocket = requiresSocket;
+  }
   handleIpc(ipc);
   const rpc = createRpc(ipc);
   return rpc;
@@ -1354,15 +1630,15 @@ const Auto = argv => {
 const getModule = method => {
   switch (method) {
     case NodeForkedProcess:
-      return NodeForkedProcessRpcClient;
+      return NodeForkedProcessRpcClient.create;
     case NodeWorker:
-      return NodeWorkerRpcClient;
+      return NodeWorkerRpcClient.create;
     case ElectronUtilityProcess:
-      return ElectronUtilityProcessRpcClient;
+      return ElectronUtilityProcessRpcClient.create;
     case ElectronMessagePort:
-      return ElectronMessagePortRpcClient;
+      return ElectronMessagePortRpcClient.create;
     case WebSocket:
-      return NodeWebSocketRpcClient;
+      return NodeWebSocketRpcClient.create;
     default:
       throw new Error('unexpected ipc type');
   }
@@ -1372,268 +1648,17 @@ const listen$1 = async ({
   method,
   ...params
 }) => {
-  const module = getModule(method);
-  const rpc = await module.create(params);
+  const create = getModule(method);
+  const rpc = await create(params);
   return rpc;
 };
 
-// TODO add tests for this
-
-// TODO handle structure: one shared process multiple extension hosts
-
-// TODO pass socket / port handle also in electron
-
-const state = {
-  ipc: undefined
-};
-const invoke = (method, ...params) => {
-  return invoke$1(state.ipc, method, ...params);
-};
-
-// @ts-ignore
-const trash$2 = async path => {
-  if (!existsSync(path)) {
-    return;
-  }
-  await invoke('Trash.trash', path);
-};
-
-// @ts-ignore
-const trash$1 = async path => {
-  await _trash(path);
-};
-
-const getFn = () => {
-  if (isElectron) {
-    return trash$2;
-  }
-  return trash$1;
-};
-
-// @ts-ignore
-const trash = async path => {
-  try {
-    const fn = getFn();
-    await fn(path);
-  } catch (error) {
-    throw new VError(error, 'Failed to move item to trash');
-  }
-};
-
-// TODO lazyload chokidar and trash (but doesn't work currently because of bug with jest)
-
-// @ts-ignore
-const assertUri = uri => {
-  if (!uri.startsWith('file://')) {
-    throw new Error(`path must be a valid file uri`);
-  }
-};
-const copy = async (sourceUri, targetUri) => {
-  try {
-    assertUri(sourceUri);
-    assertUri(targetUri);
-    const source = fileURLToPath(sourceUri);
-    const target = fileURLToPath(targetUri);
-    await fs.cp(source, target, {
-      recursive: true
-    });
-  } catch (error) {
-    if (error && error.message && error.message.startsWith('Invalid src or dest: cp returned EINVAL (src and dest cannot be the same)')) {
-      throw new VError(`Failed to copy "${sourceUri}" to "${targetUri}": src and dest cannot be the same`);
-    }
-    throw new VError(error, `Failed to copy "${sourceUri}" to "${targetUri}"`);
-  }
-};
-
-/**
- *
- * @param {string} uri
- * @param {BufferEncoding} encoding
- * @returns
- */
-// @ts-ignore
-const readFile = async (uri, encoding = Utf8) => {
-  try {
-    string(uri);
-    assertUri(uri);
-    const path = fileURLToPath(uri);
-    // @ts-ignore
-    const content = await fs.readFile(path, encoding);
-    return content;
-  } catch (error) {
-    if (isEnoentError(error)) {
-      throw new FileNotFoundError(uri);
-    }
-    throw new VError(error, `Failed to read file "${uri}"`);
-  }
-};
-
-/**
- *
- * @param {string} uri
- * @param {string} content
- * @param {BufferEncoding} encoding
- */
-// @ts-ignore
-const writeFile = async (uri, content, encoding = Utf8) => {
-  try {
-    assertUri(uri);
-    string(uri);
-    string(content);
-    const path = fileURLToPath(uri);
-    // queue would be more correct for concurrent writes but also slower
-    // Queue.add(`writeFile/${path}`, () =>
-    // @ts-ignore
-    await fs.writeFile(path, content, encoding);
-  } catch (error) {
-    if (isEnoentError(error)) {
-      throw new FileNotFoundError(uri);
-    }
-    throw new VError(error, `Failed to write to file "${uri}"`);
-  }
-};
-
-// @ts-ignore
-const isOkayToRemove = path => {
-  if (path === '/') {
-    return false;
-  }
-  if (path === '~') {
-    return false;
-  }
-  if (path === os.homedir()) {
-    return false;
-  }
-  return true;
-};
-
-// @ts-ignore
-const remove = async uri => {
-  assertUri(uri);
-  const path = fileURLToPath(uri);
-  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(path);
-  } catch (error) {
-    throw new VError(error, `Failed to remove "${uri}"`);
-  }
-};
-
-/**
- * @param {import('fs').Dirent} dirent
- */
-// @ts-ignore
-const toPrettyDirent = dirent => {
-  return {
-    name: dirent.name,
-    type: getDirentType(dirent)
-  };
-};
-
-// @ts-ignore
-const readDirWithFileTypes = async uri => {
-  try {
-    assertUri(uri);
-    const path = fileURLToPath(uri);
-    const dirents = await fs.readdir(path, {
-      withFileTypes: true
-    });
-    const prettyDirents = dirents.map(toPrettyDirent);
-    return prettyDirents;
-  } catch (error) {
-    throw new VError(error, `Failed to read directory "${uri}"`);
-  }
-};
-
-// @ts-ignore
-const mkdir = async uri => {
-  try {
-    assertUri(uri);
-    const path = fileURLToPath(uri);
-    await fs.mkdir(path, {
-      recursive: true
-    });
-  } catch (error) {
-    throw new VError(error, `Failed to create directory "${uri}"`);
-  }
-};
-
-// @ts-ignore
-const fallbackRename = async (oldUri, newUri) => {
-  try {
-    const oldPath = fileURLToPath(oldUri);
-    const newPath = fileURLToPath(newUri);
-    await fs.cp(oldPath, newPath, {
-      recursive: true
-    });
-    await fs.rm(oldPath, {
-      recursive: true
-    });
-  } catch (error) {
-    throw new VError(error, `Failed to rename "${oldUri}" to "${newUri}"`);
-  }
-};
-
-// @ts-ignore
-const rename = async (oldUri, newUri) => {
-  try {
-    const oldPath = fileURLToPath(oldUri);
-    const newPath = fileURLToPath(newUri);
-    await fs.rename(oldPath, newPath);
-  } catch (error) {
-    if (error && error.code === EXDEV) {
-      return fallbackRename(oldUri, newUri);
-    }
-    throw new VError(error, `Failed to rename "${oldUri}" to "${newUri}"`);
-  }
-};
-const getPathSeparator = () => {
-  return '/';
-};
-
-// TODO handle error
-// @ts-ignore
-const stat = async uri => {
-  const path = fileURLToPath(uri);
-  const stats = await fs.stat(path);
-  const type = getDirentType(stats);
-  return type;
-};
-
-// @ts-ignore
-const chmod = async (uri, permissions) => {
-  const path = fileURLToPath(uri);
-  await fs.chmod(path, permissions);
-};
-
-// @ts-ignore
-const readJson = async uri => {
-  try {
-    string(uri);
-    assertUri(uri);
-    const path = fileURLToPath(uri);
-    const content = await fs.readFile(path, 'utf8');
-    const parsed = JSON.parse(content);
-    return parsed;
-  } catch (error) {
-    if (isEnoentError(error)) {
-      throw new FileNotFoundError(uri);
-    }
-    throw new VError(error, `Failed to read file as json "${uri}"`);
-  }
-};
-
-// @ts-ignore
-const getFolderSize = async uri => {
-  const path = fileURLToPath(uri);
-  const total = await getFolderSizeInternal(path);
-  return total;
+const handleElectronMessagePort = async (messagePort, ...params) => {
+  object(messagePort);
+  await listen$1({
+    method: ElectronMessagePort,
+    messagePort
+  });
 };
 
 const handleWebSocket = async (handle, request) => {
@@ -1646,6 +1671,24 @@ const handleWebSocket = async (handle, request) => {
   });
 };
 
+const createMainProcessRpc = async port => {
+  try {
+    const rpc = await ElectronMessagePortRpcClient.create({
+      commandMap: {},
+      messagePort: port
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create main process rpc`);
+  }
+};
+
+const initialize = async port => {
+  // TODO only connect to main process if platform is electron else not
+  const rpc = await createMainProcessRpc(port);
+  set$1(rpc);
+};
+
 const commandMap = {
   'FileSystem.chmod': chmod,
   'FileSystem.copy': copy,
@@ -1655,11 +1698,13 @@ const commandMap = {
   'FileSystem.readDirWithFileTypes': readDirWithFileTypes,
   'FileSystem.readFile': readFile,
   'FileSystem.readJson': readJson,
-  'FileSystem.remove': remove,
+  'FileSystem.remove': remove$1,
   'FileSystem.rename': rename,
   'FileSystem.stat': stat,
   'FileSystem.writeFile': writeFile,
-  'HandleWebSocket.handleWebSocket': handleWebSocket
+  'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort,
+  'HandleWebSocket.handleWebSocket': handleWebSocket,
+  'Initialize.initialize': initialize
 };
 
 const listen = async argv => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-system-process",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "File System Process",
   "keywords": [
     "Lvce Editor",
@@ -18,10 +18,6 @@
     "file-system-process": "bin/fileSystemProcess.js"
   },
   "dependencies": {
-    "execa": "^9.5.2",
-    "open": "^10.1.2",
-    "tail": "^2.2.6",
-    "tmp-promise": "^3.0.3",
     "trash": "^9.0.0"
   },
   "engines": {