sandbox-fs 1.0.0 → 1.1.0

package/src/operations/read.ts

@@ -1,319 +0,0 @@
-import * as fs from 'fs';
-import type { PathMapper } from '../PathMapper';
-import type { ResourceTracker } from '../ResourceTracker';
-import { filterError } from '../utils/ErrorFilter';
-import { VirtualDir } from '../wrappers/VirtualDir';
-
-/**
- * Create access denied error for write operations
- */
-function createEACCESError(syscall: string, path: string): NodeJS.ErrnoException {
-  const error = new Error(`${syscall}: operation not permitted, ${syscall} '${path}'`) as NodeJS.ErrnoException;
-  error.code = 'EACCES';
-  error.errno = -13;
-  error.syscall = syscall;
-  error.path = path;
-  return error;
-}
-
-/**
- * Wrap an async operation with error filtering and closed check
- */
-async function wrapOperation<T>(
-  operation: () => Promise<T>,
-  pathMapper: PathMapper,
-  resourceTracker: ResourceTracker
-): Promise<T> {
-  resourceTracker.assertNotClosed();
-  try {
-    return await operation();
-  } catch (error) {
-    throw filterError(error as Error, pathMapper);
-  }
-}
-
-/**
- * Read file operations
- */
-export function createReadFileOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker) {
-  return async (virtualPath: string, options?: any): Promise<Buffer | string> => {
-    return wrapOperation(async () => {
-      const realPath = pathMapper.toRealPath(virtualPath);
-      
-      // Handle AbortSignal if present
-      if (options?.signal) {
-        resourceTracker.registerAbortListener(options.signal, () => {});
-      }
-      
-      return fs.promises.readFile(realPath, options);
-    }, pathMapper, resourceTracker);
-  };
-}
-
-export function createReaddirOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker) {
-  return async (virtualPath: string, options?: any): Promise<string[] | Buffer[] | fs.Dirent[]> => {
-    return wrapOperation(async () => {
-      const realPath = pathMapper.toRealPath(virtualPath);
-      
-      if (options?.signal) {
-        resourceTracker.registerAbortListener(options.signal, () => {});
-      }
-      
-      return fs.promises.readdir(realPath, options);
-    }, pathMapper, resourceTracker);
-  };
-}
-
-export function createStatOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker) {
-  return async (virtualPath: string, options?: any): Promise<fs.Stats> => {
-    return wrapOperation(async () => {
-      const realPath = pathMapper.toRealPath(virtualPath);
-      
-      if (options?.signal) {
-        resourceTracker.registerAbortListener(options.signal, () => {});
-      }
-      
-      const stats = await fs.promises.stat(realPath, options);
-      
-      // Return EACCES for symlinks
-      if (stats.isSymbolicLink()) {
-        throw createEACCESError('stat', virtualPath);
-      }
-      
-      return stats;
-    }, pathMapper, resourceTracker);
-  };
-}
-
-export function createLstatOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker) {
-  return async (virtualPath: string, options?: any): Promise<fs.Stats> => {
-    return wrapOperation(async () => {
-      const realPath = pathMapper.toRealPath(virtualPath);
-      
-      if (options?.signal) {
-        resourceTracker.registerAbortListener(options.signal, () => {});
-      }
-      
-      const stats = await fs.promises.lstat(realPath, options);
-      
-      // Return EACCES for symlinks
-      if (stats.isSymbolicLink()) {
-        throw createEACCESError('lstat', virtualPath);
-      }
-      
-      return stats;
-    }, pathMapper, resourceTracker);
-  };
-}
-
-export function createAccessOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker) {
-  return async (virtualPath: string, mode?: number): Promise<void> => {
-    return wrapOperation(async () => {
-      const realPath = pathMapper.toRealPath(virtualPath);
-      return fs.promises.access(realPath, mode);
-    }, pathMapper, resourceTracker);
-  };
-}
-
-export function createRealpathOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker) {
-  return async (virtualPath: string, options?: any): Promise<string | Buffer> => {
-    return wrapOperation(async () => {
-      const realPath = pathMapper.toRealPath(virtualPath);
-      
-      if (options?.signal) {
-        resourceTracker.registerAbortListener(options.signal, () => {});
-      }
-      
-      const resolvedRealPath = await fs.promises.realpath(realPath, options);
-      
-      // Convert back to virtual path
-      const resolvedStr = Buffer.isBuffer(resolvedRealPath) ? resolvedRealPath.toString() : resolvedRealPath;
-      const resolvedVirtualPath = pathMapper.toVirtualPath(resolvedStr);
-      
-      // Return as buffer if encoding option is 'buffer'
-      if (options && typeof options === 'object' && options.encoding === 'buffer') {
-        return Buffer.from(resolvedVirtualPath) as any;
-      }
-      return resolvedVirtualPath as any;
-    }, pathMapper, resourceTracker);
-  };
-}
-
-export function createOpenOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker) {
-  return async (virtualPath: string, flags?: string | number, mode?: number): Promise<number> => {
-    return wrapOperation(async () => {
-      // Check if flags indicate write mode
-      const flagsStr = typeof flags === 'number' ? flags.toString() : (flags || 'r');
-      const isWriteMode = /w|a|\+/.test(flagsStr.toString());
-      
-      if (isWriteMode) {
-        throw createEACCESError('open', virtualPath);
-      }
-      
-      const realPath = pathMapper.toRealPath(virtualPath);
-      const fd = await fs.promises.open(realPath, flags, mode);
-      
-      // Track the file descriptor
-      resourceTracker.trackFD(fd.fd, {
-        virtualPath,
-        realPath,
-        flags: flags || 'r',
-        mode,
-        isStream: false,
-      });
-      
-      return fd.fd;
-    }, pathMapper, resourceTracker);
-  };
-}
-
-export function createReadOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker) {
-  return async (
-    fd: number,
-    buffer: NodeJS.ArrayBufferView,
-    offset: number,
-    length: number,
-    position: number | null
-  ): Promise<{ bytesRead: number; buffer: NodeJS.ArrayBufferView }> => {
-    return wrapOperation(async () => {
-      // Verify FD is tracked
-      if (!resourceTracker.isTracked(fd)) {
-        const error = new Error('bad file descriptor') as NodeJS.ErrnoException;
-        error.code = 'EBADF';
-        error.errno = -9;
-        error.syscall = 'read';
-        throw error;
-      }
-      
-      // Use fs.read with callback wrapped in promise
-      return new Promise<{ bytesRead: number; buffer: NodeJS.ArrayBufferView }>((resolve, reject) => {
-        fs.read(fd, buffer, offset, length, position, (err, bytesRead) => {
-          if (err) reject(err);
-          else resolve({ bytesRead, buffer });
-        });
-      });
-    }, pathMapper, resourceTracker);
-  };
-}
-
-export function createCloseOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker) {
-  return async (fd: number): Promise<void> => {
-    return wrapOperation(async () => {
-      // Untrack before closing
-      resourceTracker.untrackFD(fd);
-      return new Promise<void>((resolve, reject) => {
-        fs.close(fd, (err) => {
-          if (err) reject(err);
-          else resolve();
-        });
-      });
-    }, pathMapper, resourceTracker);
-  };
-}
-
-export function createFstatOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker) {
-  return async (fd: number, options?: any): Promise<fs.Stats> => {
-    return wrapOperation(async () => {
-      if (!resourceTracker.isTracked(fd)) {
-        const error = new Error('bad file descriptor') as NodeJS.ErrnoException;
-        error.code = 'EBADF';
-        error.errno = -9;
-        error.syscall = 'fstat';
-        throw error;
-      }
-      
-      if (options?.signal) {
-        resourceTracker.registerAbortListener(options.signal, () => {});
-      }
-      
-      // @ts-ignore - fstat exists but types may not match perfectly
-      return fs.promises.fstat(fd, options);
-    }, pathMapper, resourceTracker);
-  };
-}
-
-export function createOpendirOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker) {
-  return async (virtualPath: string, options?: any): Promise<VirtualDir> => {
-    return wrapOperation(async () => {
-      const realPath = pathMapper.toRealPath(virtualPath);
-      
-      if (options?.signal) {
-        resourceTracker.registerAbortListener(options.signal, () => {});
-      }
-      
-      const realDir = await fs.promises.opendir(realPath, options);
-      return new VirtualDir(realDir, virtualPath, pathMapper);
-    }, pathMapper, resourceTracker);
-  };
-}
-
-export function createExistsOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker) {
-  return async (virtualPath: string): Promise<boolean> => {
-    resourceTracker.assertNotClosed();
-    try {
-      const realPath = pathMapper.toRealPath(virtualPath);
-      await fs.promises.access(realPath);
-      return true;
-    } catch {
-      return false;
-    }
-  };
-}
-
-export function createCreateReadStreamOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker) {
-  return (virtualPath: string, options?: any): fs.ReadStream => {
-    resourceTracker.assertNotClosed();
-    
-    let realPath: string;
-    try {
-      realPath = pathMapper.toRealPath(virtualPath);
-    } catch (error) {
-      // Create a dummy stream that will emit an error
-      const stream = new (require('stream').Readable)({
-        read() {}
-      }) as fs.ReadStream;
-      
-      process.nextTick(() => {
-        stream.destroy(filterError(error as Error, pathMapper));
-      });
-      
-      return stream;
-    }
-    
-    const realStream = fs.createReadStream(realPath, options);
-    
-    // Track the stream
-    resourceTracker.trackStream(realStream);
-    
-    // Untrack when closed
-    realStream.on('close', () => {
-      resourceTracker.untrackStream(realStream);
-    });
-    
-    // Create a proxy to override the path property and filter errors
-    const streamProxy = new Proxy(realStream, {
-      get(target, prop) {
-        if (prop === 'path') {
-          return virtualPath;
-        }
-        
-        if (prop === 'on' || prop === 'once') {
-          return function(event: string, listener: any) {
-            if (event === 'error') {
-              // Wrap error listener to filter errors
-              const wrappedListener = (error: Error) => {
-                listener(filterError(error, pathMapper));
-              };
-              return target[prop as 'on'](event, wrappedListener);
-            }
-            return target[prop as 'on'](event, listener);
-          };
-        }
-        
-        return target[prop as keyof fs.ReadStream];
-      }
-    });
-    
-    return streamProxy;
-  };
-}

package/src/operations/symlink.ts

@@ -1,31 +0,0 @@
-/**
- * All symlink operations return EACCES (access denied)
- * This module provides all symlink-related fs operations
- */
-
-function createEACCESError(syscall: string, path: string): NodeJS.ErrnoException {
-  const error = new Error(`${syscall}: operation not permitted, ${syscall} '${path}'`) as NodeJS.ErrnoException;
-  error.code = 'EACCES';
-  error.errno = -13;
-  error.syscall = syscall;
-  error.path = path;
-  return error;
-}
-
-export function createSymlinkOperation() {
-  return async (target: string, path: string, type?: string): Promise<void> => {
-    throw createEACCESError('symlink', path);
-  };
-}
-
-export function createLinkOperation() {
-  return async (existingPath: string, newPath: string): Promise<void> => {
-    throw createEACCESError('link', newPath);
-  };
-}
-
-export function createReadlinkOperation() {
-  return async (path: string, options?: any): Promise<string | Buffer> => {
-    throw createEACCESError('readlink', path);
-  };
-}

package/src/operations/write.ts

@@ -1,189 +0,0 @@
-/**
- * All write operations return EACCES (access denied)
- * This module provides all write-related fs operations
- */
-
-function createEACCESError(syscall: string, path: string): NodeJS.ErrnoException {
-  const error = new Error(`${syscall}: operation not permitted, ${syscall} '${path}'`) as NodeJS.ErrnoException;
-  error.code = 'EACCES';
-  error.errno = -13;
-  error.syscall = syscall;
-  error.path = path;
-  return error;
-}
-
-export function createWriteFileOperation() {
-  return async (path: string, data: any, options?: any): Promise<void> => {
-    throw createEACCESError('open', path);
-  };
-}
-
-export function createAppendFileOperation() {
-  return async (path: string, data: any, options?: any): Promise<void> => {
-    throw createEACCESError('open', path);
-  };
-}
-
-export function createMkdirOperation() {
-  return async (path: string, options?: any): Promise<void | string> => {
-    throw createEACCESError('mkdir', path);
-  };
-}
-
-export function createRmdirOperation() {
-  return async (path: string, options?: any): Promise<void> => {
-    throw createEACCESError('rmdir', path);
-  };
-}
-
-export function createRmOperation() {
-  return async (path: string, options?: any): Promise<void> => {
-    throw createEACCESError('rm', path);
-  };
-}
-
-export function createUnlinkOperation() {
-  return async (path: string): Promise<void> => {
-    throw createEACCESError('unlink', path);
-  };
-}
-
-export function createRenameOperation() {
-  return async (oldPath: string, newPath: string): Promise<void> => {
-    throw createEACCESError('rename', oldPath);
-  };
-}
-
-export function createCopyFileOperation() {
-  return async (src: string, dest: string, mode?: number): Promise<void> => {
-    throw createEACCESError('copyfile', dest);
-  };
-}
-
-export function createTruncateOperation() {
-  return async (path: string, len?: number): Promise<void> => {
-    throw createEACCESError('open', path);
-  };
-}
-
-export function createFtruncateOperation() {
-  return async (fd: number, len?: number): Promise<void> => {
-    const error = new Error('ftruncate: operation not permitted') as NodeJS.ErrnoException;
-    error.code = 'EACCES';
-    error.errno = -13;
-    error.syscall = 'ftruncate';
-    throw error;
-  };
-}
-
-export function createChmodOperation() {
-  return async (path: string, mode: string | number): Promise<void> => {
-    throw createEACCESError('chmod', path);
-  };
-}
-
-export function createFchmodOperation() {
-  return async (fd: number, mode: string | number): Promise<void> => {
-    const error = new Error('fchmod: operation not permitted') as NodeJS.ErrnoException;
-    error.code = 'EACCES';
-    error.errno = -13;
-    error.syscall = 'fchmod';
-    throw error;
-  };
-}
-
-export function createLchmodOperation() {
-  return async (path: string, mode: string | number): Promise<void> => {
-    throw createEACCESError('lchmod', path);
-  };
-}
-
-export function createChownOperation() {
-  return async (path: string, uid: number, gid: number): Promise<void> => {
-    throw createEACCESError('chown', path);
-  };
-}
-
-export function createFchownOperation() {
-  return async (fd: number, uid: number, gid: number): Promise<void> => {
-    const error = new Error('fchown: operation not permitted') as NodeJS.ErrnoException;
-    error.code = 'EACCES';
-    error.errno = -13;
-    error.syscall = 'fchown';
-    throw error;
-  };
-}
-
-export function createLchownOperation() {
-  return async (path: string, uid: number, gid: number): Promise<void> => {
-    throw createEACCESError('lchown', path);
-  };
-}
-
-export function createUtimesOperation() {
-  return async (path: string, atime: string | number | Date, mtime: string | number | Date): Promise<void> => {
-    throw createEACCESError('utime', path);
-  };
-}
-
-export function createFutimesOperation() {
-  return async (fd: number, atime: string | number | Date, mtime: string | number | Date): Promise<void> => {
-    const error = new Error('futime: operation not permitted') as NodeJS.ErrnoException;
-    error.code = 'EACCES';
-    error.errno = -13;
-    error.syscall = 'futime';
-    throw error;
-  };
-}
-
-export function createLutimesOperation() {
-  return async (path: string, atime: string | number | Date, mtime: string | number | Date): Promise<void> => {
-    throw createEACCESError('lutime', path);
-  };
-}
-
-export function createWriteOperation() {
-  return async (fd: number, buffer: any, offset?: any, length?: any, position?: any): Promise<any> => {
-    const error = new Error('write: operation not permitted') as NodeJS.ErrnoException;
-    error.code = 'EACCES';
-    error.errno = -13;
-    error.syscall = 'write';
-    throw error;
-  };
-}
-
-export function createWritevOperation() {
-  return async (fd: number, buffers: NodeJS.ArrayBufferView[], position?: number): Promise<any> => {
-    const error = new Error('writev: operation not permitted') as NodeJS.ErrnoException;
-    error.code = 'EACCES';
-    error.errno = -13;
-    error.syscall = 'writev';
-    throw error;
-  };
-}
-
-export function createCreateWriteStreamOperation() {
-  return (path: string, options?: any): never => {
-    throw createEACCESError('open', path);
-  };
-}
-
-export function createFsyncOperation() {
-  return async (fd: number): Promise<void> => {
-    const error = new Error('fsync: operation not permitted') as NodeJS.ErrnoException;
-    error.code = 'EACCES';
-    error.errno = -13;
-    error.syscall = 'fsync';
-    throw error;
-  };
-}
-
-export function createFdatasyncOperation() {
-  return async (fd: number): Promise<void> => {
-    const error = new Error('fdatasync: operation not permitted') as NodeJS.ErrnoException;
-    error.code = 'EACCES';
-    error.errno = -13;
-    error.syscall = 'fdatasync';
-    throw error;
-  };
-}

package/src/utils/ErrorFilter.ts

@@ -1,57 +0,0 @@
-import type { PathMapper } from "../PathMapper";
-
-/**
- * Filter error messages to replace real paths with virtual paths
- */
-export function filterError(error: Error, pathMapper: PathMapper): Error {
-  const realRoot = pathMapper.getRoot();
-
-  // Create a regex to match the real root path
-  // Escape special regex characters and handle both forward and back slashes
-  const escapedRoot = realRoot.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const rootPattern = new RegExp(escapedRoot.replace(/\\/g, "\\\\"), "g");
-
-  // Filter the error message
-  if (error.message) {
-    error.message = error.message.replace(rootPattern, "");
-  }
-
-  // Filter the stack trace
-  if (error.stack) {
-    error.stack = error.stack.replace(rootPattern, "");
-  }
-
-  // Filter the path property if it exists
-  const errWithPath = error as NodeJS.ErrnoException;
-  if (errWithPath.path && typeof errWithPath.path === "string") {
-    try {
-      // Try to convert real path to virtual path
-      if (pathMapper.isWithinRoot(errWithPath.path)) {
-        errWithPath.path = pathMapper.toVirtualPath(errWithPath.path);
-      } else {
-        // If outside root, just strip the root prefix
-        errWithPath.path = errWithPath.path.replace(rootPattern, "");
-      }
-    } catch {
-      // If conversion fails, just strip the root prefix
-      errWithPath.path = errWithPath.path.replace(rootPattern, "");
-    }
-  }
-
-  // Filter the dest property if it exists (for copy operations)
-  if ("dest" in errWithPath && typeof errWithPath.dest === "string") {
-    try {
-      const destStr = errWithPath.dest as string;
-      if (pathMapper.isWithinRoot(destStr)) {
-        (errWithPath as any).dest = pathMapper.toVirtualPath(destStr);
-      } else {
-        (errWithPath as any).dest = destStr.replace(rootPattern, "");
-      }
-    } catch {
-      const destStr = errWithPath.dest as string;
-      (errWithPath as any).dest = destStr.replace(rootPattern, "");
-    }
-  }
-
-  return error;
-}

package/src/utils/callbackify.ts

@@ -1,54 +0,0 @@
-/**
- * Convert a promise-based function to a callback-based function
- */
-export function callbackify<T extends any[], R>(
-  fn: (...args: T) => Promise<R>
-): (...args: [...T, (err: Error | null, result?: R) => void]) => void {
-  return function (this: any, ...args: any[]) {
-    // Extract callback from arguments
-    const callback = args[args.length - 1];
-    
-    if (typeof callback !== 'function') {
-      throw new TypeError('The last argument must be a callback function');
-    }
-
-    // Get the actual arguments (without callback)
-    const actualArgs = args.slice(0, -1) as T;
-
-    // Call the promise function
-    fn.apply(this, actualArgs)
-      .then((result) => {
-        // Call callback with no error
-        callback(null, result);
-      })
-      .catch((err) => {
-        // Call callback with error
-        callback(err);
-      });
-  };
-}
-
-/**
- * Callbackify for void-returning promises
- */
-export function callbackifyVoid<T extends any[]>(
-  fn: (...args: T) => Promise<void>
-): (...args: [...T, (err: Error | null) => void]) => void {
-  return function (this: any, ...args: any[]) {
-    const callback = args[args.length - 1];
-    
-    if (typeof callback !== 'function') {
-      throw new TypeError('The last argument must be a callback function');
-    }
-
-    const actualArgs = args.slice(0, -1) as T;
-
-    fn.apply(this, actualArgs)
-      .then(() => {
-        callback(null);
-      })
-      .catch((err) => {
-        callback(err);
-      });
-  };
-}