fix: resolve security regex issue and constructor bug in FSA classes

Co-authored-by: streamich <[email protected]>

Author: Copilot

src/fsa/CoreFileSystemDirectoryHandle.ts

@@ -9,7 +9,7 @@ import {
   newTypeMismatchError,
 } from './util';
 import { CoreFileSystemFileHandle } from './CoreFileSystemFileHandle';
-import type { 
+import type {
   CoreFsaContext,
   GetDirectoryHandleOptions,
   GetFileHandleOptions,
@@ -247,6 +247,9 @@ export class CoreFileSystemDirectoryHandle extends CoreFileSystemHandle implemen
       possibleDescendant instanceof CoreFileSystemDirectoryHandle ||
       possibleDescendant instanceof CoreFileSystemFileHandle
     ) {
+      // First check if they are from the same core instance
+      if ((possibleDescendant as any)._core !== this._core) return null;
+
       const path = this.__path;
       const childPath = possibleDescendant.__path;
       if (!childPath.startsWith(path)) return null;
@@ -271,4 +274,4 @@ export class CoreFileSystemDirectoryHandle extends CoreFileSystemHandle implemen
     }
     throw error;
   }
-}
+}

src/fsa/CoreFileSystemFileHandle.ts

@@ -2,11 +2,11 @@ import { CoreFileSystemHandle } from './CoreFileSystemHandle';
 import { CoreFileSystemSyncAccessHandle } from './CoreFileSystemSyncAccessHandle';
 import { assertCanWrite, basename, ctx as createCtx, newNotAllowedError } from './util';
 import { CoreFileSystemWritableFileStream } from './CoreFileSystemWritableFileStream';
-import type { 
-  CoreFsaContext, 
+import type {
+  CoreFsaContext,
   CreateWritableOptions,
-  IFileSystemFileHandle, 
-  IFileSystemSyncAccessHandle 
+  IFileSystemFileHandle,
+  IFileSystemSyncAccessHandle,
 } from './types';
 import type { Superblock } from '../core/Superblock';
 import { Buffer } from '../internal/buffer';
@@ -36,18 +36,18 @@ export class CoreFileSystemFileHandle extends CoreFileSystemHandle implements IF
       const path = this.__path;
       const link = this._core.getResolvedLinkOrThrow(path);
       const node = link.getNode();
-      
+
       if (!node.isFile()) {
         throw new Error('Not a file');
       }
 
       // Get file stats for lastModified
       const lastModified = node.mtime ? node.mtime.getTime() : Date.now();
-      
+
       // Read file content
       const buffer = node.getBuffer();
       const data = new Uint8Array(buffer);
-      
+
       const file = new File([data], this.name, { lastModified });
       return file;
     } catch (error) {
@@ -79,4 +79,4 @@ export class CoreFileSystemFileHandle extends CoreFileSystemHandle implements IF
     assertCanWrite(this.ctx.mode);
     return new CoreFileSystemWritableFileStream(this._core, this.__path, keepExistingData);
   }
-}
+}

src/fsa/CoreFileSystemHandle.ts

@@ -48,4 +48,4 @@ export abstract class CoreFileSystemHandle implements IFileSystemHandle {
   ): CorePermissionStatus {
     throw new Error('Not implemented');
   }
-}
+}

src/fsa/CoreFileSystemSyncAccessHandle.ts

@@ -69,10 +69,7 @@ export class CoreFileSystemSyncAccessHandle implements IFileSystemSyncAccessHand
   /**
    * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemSyncAccessHandle/read
    */
-  public async read(
-    buffer: ArrayBuffer | ArrayBufferView,
-    options: FileSystemReadWriteOptions = {},
-  ): Promise<number> {
+  public async read(buffer: ArrayBuffer | ArrayBufferView, options: FileSystemReadWriteOptions = {}): Promise<number> {
     const fd = this._ensureOpen();
     const { at: position = 0 } = options;
 
@@ -131,4 +128,4 @@ export class CoreFileSystemSyncAccessHandle implements IFileSystemSyncAccessHand
       throw error;
     }
   }
-}
+}

src/fsa/CoreFileSystemWritableFileStream.ts

@@ -15,17 +15,15 @@ export class CoreFileSystemWritableFileStream extends WritableStream implements
   private readonly _core: Superblock;
   private readonly _path: string;
 
-  constructor(
-    core: Superblock,
-    path: string,
-    keepExistingData: boolean = false,
-  ) {
+  constructor(core: Superblock, path: string, keepExistingData: boolean = false) {
+    let fd: number | undefined;
+
     super({
-      start: (controller) => {
+      start: controller => {
         // Open file for writing
         const flags = keepExistingData ? FLAGS['r+'] : FLAGS.w;
         try {
-          this._fd = core.open(path, flags, MODE.FILE);
+          fd = core.open(path, flags, MODE.FILE);
         } catch (error) {
           if (error && typeof error === 'object' && error.code === ERROR_CODE.EACCES) {
             throw newNotAllowedError();
@@ -49,8 +47,10 @@ export class CoreFileSystemWritableFileStream extends WritableStream implements
         }
       },
     });
+
     this._core = core;
     this._path = path;
+    this._fd = fd;
   }
 
   /**
@@ -166,4 +166,4 @@ export class CoreFileSystemWritableFileStream extends WritableStream implements
     }
     throw new Error('Unsupported data type');
   }
-}
+}

src/fsa/CorePermissionStatus.ts

@@ -11,4 +11,4 @@ export class CorePermissionStatus implements IPermissionStatus {
     this.name = name;
     this.state = state;
   }
-}
+}

src/fsa/__tests__/CoreFileSystemDirectoryHandle.test.ts

@@ -120,7 +120,9 @@ onlyOnNode20('CoreFileSystemDirectoryHandle', () => {
 
     test('throws error when directory does not exist and create is false', async () => {
       const { dir } = setup();
-      await expect(dir.getDirectoryHandle('nonexistent')).rejects.toThrow('A requested file or directory could not be found');
+      await expect(dir.getDirectoryHandle('nonexistent')).rejects.toThrow(
+        'A requested file or directory could not be found',
+      );
     });
   });
 
@@ -141,7 +143,9 @@ onlyOnNode20('CoreFileSystemDirectoryHandle', () => {
 
     test('throws error when file does not exist and create is false', async () => {
       const { dir } = setup();
-      await expect(dir.getFileHandle('nonexistent.txt')).rejects.toThrow('A requested file or directory could not be found');
+      await expect(dir.getFileHandle('nonexistent.txt')).rejects.toThrow(
+        'A requested file or directory could not be found',
+      );
     });
   });
 
@@ -155,13 +159,17 @@ onlyOnNode20('CoreFileSystemDirectoryHandle', () => {
     test('can remove an empty directory', async () => {
       const { dir } = setup({ folder: null });
       await dir.removeEntry('folder');
-      await expect(dir.getDirectoryHandle('folder')).rejects.toThrow('A requested file or directory could not be found');
+      await expect(dir.getDirectoryHandle('folder')).rejects.toThrow(
+        'A requested file or directory could not be found',
+      );
     });
 
     test('can remove directory recursively', async () => {
       const { dir } = setup({ 'folder/file.txt': 'content' });
       await dir.removeEntry('folder', { recursive: true });
-      await expect(dir.getDirectoryHandle('folder')).rejects.toThrow('A requested file or directory could not be found');
+      await expect(dir.getDirectoryHandle('folder')).rejects.toThrow(
+        'A requested file or directory could not be found',
+      );
     });
   });
 
@@ -183,19 +191,19 @@ onlyOnNode20('CoreFileSystemDirectoryHandle', () => {
 
     test('returns null for non-descendant', async () => {
       const { dir: dir1 } = setup({ 'file1.txt': 'content' });
-      
+
       // Create completely different core and root path
       const core2 = Superblock.fromJSON({ 'different/file2.txt': 'content' }, '/');
       // Use a different path that does not start with dir1's path
       const dir2 = new CoreFileSystemDirectoryHandle(core2, '/some-completely-different-path/', { mode: 'readwrite' });
-      
+
       // This will try to get file2.txt from /some-completely-different-path/ which doesn't exist
       // So we need to actually create the file in the expected location
       const actualDir2 = new CoreFileSystemDirectoryHandle(core2, '/different/', { mode: 'readwrite' });
       const file2 = await actualDir2.getFileHandle('file2.txt');
-      
+
       const resolved = await dir1.resolve(file2);
       expect(resolved).toBeNull();
     });
   });
-});
+});

src/fsa/__tests__/CoreFileSystemFileHandle.test.ts

@@ -36,11 +36,11 @@ onlyOnNode20('CoreFileSystemFileHandle', () => {
       const { core } = setup();
       // Create file with binary content
       core.writeFile('/binary.dat', content, 0x200 | 0x40 | 0x1, 0o644); // O_CREAT | O_TRUNC | O_WRONLY
-      
+
       const dir = new CoreFileSystemDirectoryHandle(core, '/', { mode: 'readwrite' });
       const fileHandle = await dir.getFileHandle('binary.dat');
       const file = await fileHandle.getFile();
-      
+
       expect(file.size).toBe(5);
       const arrayBuffer = await file.arrayBuffer();
       const uint8Array = new Uint8Array(arrayBuffer);
@@ -54,10 +54,10 @@ onlyOnNode20('CoreFileSystemFileHandle', () => {
       const fileHandle = await dir.getFileHandle('test.txt');
       const writable = await fileHandle.createWritable();
       expect(writable).toBeDefined();
-      
+
       await writable.write('new content');
       await writable.close();
-      
+
       const file = await fileHandle.getFile();
       expect(await file.text()).toBe('new content');
     });
@@ -67,11 +67,11 @@ onlyOnNode20('CoreFileSystemFileHandle', () => {
       const fileHandle = await dir.getFileHandle('test.txt');
       const writable = await fileHandle.createWritable({ keepExistingData: true });
       expect(writable).toBeDefined();
-      
+
       await writable.seek(8); // Move past "initial "
       await writable.write('new data');
       await writable.close();
-      
+
       const file = await fileHandle.getFile();
       expect(await file.text()).toBe('initial new data');
     });
@@ -86,9 +86,9 @@ onlyOnNode20('CoreFileSystemFileHandle', () => {
 
     test('returns function when sync handle allowed', async () => {
       const core = Superblock.fromJSON({ 'test.txt': 'content' }, '/');
-      const dir = new CoreFileSystemDirectoryHandle(core, '/', { 
-        mode: 'readwrite', 
-        syncHandleAllowed: true 
+      const dir = new CoreFileSystemDirectoryHandle(core, '/', {
+        mode: 'readwrite',
+        syncHandleAllowed: true,
       });
       const fileHandle = await dir.getFileHandle('test.txt');
       expect(fileHandle.createSyncAccessHandle).toBeDefined();
@@ -113,4 +113,4 @@ onlyOnNode20('CoreFileSystemFileHandle', () => {
       expect(await file.text()).toBe('content');
     });
   });
-});
+});

src/fsa/__tests__/CoreFileSystemHandle.test.ts

@@ -33,19 +33,19 @@ onlyOnNode20('CoreFileSystemHandle', () => {
   });
 
   test('isSameEntry returns false for different handles', async () => {
-    const { dir } = setup({ 
+    const { dir } = setup({
       'test1.txt': 'content1',
-      'test2.txt': 'content2'
+      'test2.txt': 'content2',
     });
     const file1 = await dir.getFileHandle('test1.txt');
     const file2 = await dir.getFileHandle('test2.txt');
     expect(file1.isSameEntry(file2)).toBe(false);
   });
 
   test('isSameEntry returns false for different types', async () => {
-    const { dir } = setup({ 
+    const { dir } = setup({
       'test.txt': 'content',
-      folder: null
+      folder: null,
     });
     const file = await dir.getFileHandle('test.txt');
     const folder = await dir.getDirectoryHandle('folder');
@@ -69,4 +69,4 @@ onlyOnNode20('CoreFileSystemHandle', () => {
     const file = await dir.getFileHandle('test.txt');
     await expect(file.remove()).rejects.toThrow('Not implemented');
   });
-});
+});