@lvce-editor/file-system-process 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Lvce Editor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# File System Process
+
+File System Process
+
+## Gitpod
+
+[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/lvce-editor/file-system-process)

package/bin/fileSystemProcess.js

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

package/dist/index.js

@@ -0,0 +1,445 @@
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { string } from '@lvce-editor/assert';
+import { VError } from '@lvce-editor/verror';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { NodeWebSocketRpcClient, ElectronMessagePortRpcClient, ElectronUtilityProcessRpcClient, NodeWorkerRpcClient, NodeForkedProcessRpcClient } from '@lvce-editor/rpc';
+import { invoke as invoke$1 } from '@lvce-editor/json-rpc';
+import _trash from 'trash';
+
+const Utf8 = 'utf8';
+
+const ENOENT = 'ENOENT';
+const EXDEV = 'EXDEV';
+
+// @ts-ignore
+const getDisplayPath = path => {
+  if (path === '') {
+    return '<empty string>';
+  }
+  return path;
+};
+class FileNotFoundError extends VError {
+  // @ts-ignore
+  constructor(path) {
+    super(`File not found: '${getDisplayPath(path)}'`);
+    // @ts-ignore
+    this.code = ENOENT;
+  }
+}
+
+const BlockDevice = 1;
+const CharacterDevice = 2;
+const Directory = 3;
+const Fifo = 6;
+const File = 7;
+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;
+  }
+  if (dirent.isDirectory()) {
+    return Directory;
+  }
+  if (dirent.isSymbolicLink()) {
+    return Symlink;
+  }
+  if (dirent.isSocket()) {
+    return Socket;
+  }
+  if (dirent.isBlockDevice()) {
+    return BlockDevice;
+  }
+  if (dirent.isCharacterDevice()) {
+    return CharacterDevice;
+  }
+  if (dirent.isFIFO()) {
+    return Fifo;
+  }
+  return Unknown;
+};
+
+const getFolderSizeInternal = async path => {
+  if (path === '/') {
+    throw new Error('Invalid path for folder size');
+  }
+  let total = 0;
+  try {
+    const stats = await fs.stat(path);
+    total += stats.size;
+    if (stats.isDirectory() && !stats.isSymbolicLink()) {
+      const dirents = await fs.readdir(path);
+      for (const dirent of dirents) {
+        total += await getFolderSizeInternal(join(path, dirent));
+      }
+    }
+  } catch {
+    return 0;
+  }
+  return total;
+};
+
+// @ts-ignore
+const isEnoentErrorWindows = error => {
+  return error && error.message && error.message.includes('The system cannot find the path specified.');
+};
+
+// @ts-ignore
+const isEnoentErrorLinux = error => {
+  return error.code === ENOENT;
+};
+
+// @ts-ignore
+const isEnoentError = error => {
+  if (!error) {
+    return false;
+  }
+  return isEnoentErrorLinux(error) || isEnoentErrorWindows(error);
+};
+
+const getElectronRunAsNode = () => {
+  return process.env.ELECTRON_RUN_AS_NODE;
+};
+process;
+
+const isElectron = Boolean(getElectronRunAsNode()) || 'electron' in process.versions;
+
+const NodeWorker = 1;
+const NodeForkedProcess = 2;
+const ElectronUtilityProcess = 3;
+const ElectronMessagePort = 4;
+const WebSocket = 6;
+const Auto = argv => {
+  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(`[file-system-process] unknown ipc type`);
+};
+
+const getModule = method => {
+  switch (method) {
+    case NodeForkedProcess:
+      return NodeForkedProcessRpcClient;
+    case NodeWorker:
+      return NodeWorkerRpcClient;
+    case ElectronUtilityProcess:
+      return ElectronUtilityProcessRpcClient;
+    case ElectronMessagePort:
+      return ElectronMessagePortRpcClient;
+    case WebSocket:
+      return NodeWebSocketRpcClient;
+    default:
+      throw new Error('unexpected ipc type');
+  }
+};
+
+const listen$1 = async ({
+  method,
+  ...params
+}) => {
+  const module = getModule(method);
+  const rpc = await module.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 commandMap = {
+  chmod: chmod,
+  copy: copy,
+  getPathSeparator: getPathSeparator,
+  mkdir: mkdir,
+  readDirWithFileTypes: readDirWithFileTypes,
+  readFile: readFile,
+  readJson: readJson,
+  remove: remove,
+  rename: rename,
+  stat: stat,
+  writeFile: writeFile,
+  getFolderSize: getFolderSize
+};
+
+const listen = async argv => {
+  await listen$1({
+    method: Auto(argv),
+    commandMap: commandMap
+  });
+};
+
+const main = async () => {
+  await listen(process.argv);
+};
+
+main();

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@lvce-editor/file-system-process",
+  "version": "1.0.0",
+  "description": "File System Process",
+  "keywords": [
+    "Lvce Editor",
+    "File System"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lvce-editor/file-system-process.git"
+  },
+  "license": "MIT",
+  "author": "Lvce Editor",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "file-system-process": "bin/fileSystemProcess.js"
+  },
+  "dependencies": {
+    "@lvce-editor/assert": "^1.3.0",
+    "@lvce-editor/json-rpc": "^5.4.0",
+    "@lvce-editor/rpc": "^1.27.0",
+    "@lvce-editor/verror": "^1.6.0",
+    "execa": "^9.5.2",
+    "open": "^10.1.1",
+    "tail": "^2.2.6",
+    "tmp-promise": "^3.0.3",
+    "trash": "^9.0.0"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}