@google/gemini-cli-core 0.1.21 → 0.2.0-preview.0

package/dist/src/utils/workspaceContext.js

@@ -3,6 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { isNodeError } from '../utils/errors.js';
 import * as fs from 'fs';
 import * as path from 'path';
 /**
@@ -11,21 +12,42 @@ import * as path from 'path';
  * in a single session.
  */
 export class WorkspaceContext {
-    directories;
+    directories = new Set();
     initialDirectories;
+    onDirectoriesChangedListeners = new Set();
     /**
      * Creates a new WorkspaceContext with the given initial directory and optional additional directories.
-     * @param initialDirectory The initial working directory (usually cwd)
+     * @param directory The initial working directory (usually cwd)
      * @param additionalDirectories Optional array of additional directories to include
      */
-    constructor(initialDirectory, additionalDirectories = []) {
-        this.directories = new Set();
-        this.initialDirectories = new Set();
-        this.addDirectoryInternal(initialDirectory);
-        this.addInitialDirectoryInternal(initialDirectory);
-        for (const dir of additionalDirectories) {
-            this.addDirectoryInternal(dir);
-            this.addInitialDirectoryInternal(dir);
+    constructor(directory, additionalDirectories = []) {
+        this.addDirectory(directory);
+        for (const additionalDirectory of additionalDirectories) {
+            this.addDirectory(additionalDirectory);
+        }
+        this.initialDirectories = new Set(this.directories);
+    }
+    /**
+     * Registers a listener that is called when the workspace directories change.
+     * @param listener The listener to call.
+     * @returns A function to unsubscribe the listener.
+     */
+    onDirectoriesChanged(listener) {
+        this.onDirectoriesChangedListeners.add(listener);
+        return () => {
+            this.onDirectoriesChangedListeners.delete(listener);
+        };
+    }
+    notifyDirectoriesChanged() {
+        // Iterate over a copy of the set in case a listener unsubscribes itself or others.
+        for (const listener of [...this.onDirectoriesChangedListeners]) {
+            try {
+                listener();
+            }
+            catch (e) {
+                // Don't let one listener break others.
+                console.error('Error in WorkspaceContext listener:', e);
+            }
         }
     }
     /**
@@ -34,32 +56,14 @@ export class WorkspaceContext {
      * @param basePath Optional base path for resolving relative paths (defaults to cwd)
      */
     addDirectory(directory, basePath = process.cwd()) {
-        this.addDirectoryInternal(directory, basePath);
-    }
-    /**
-     * Internal method to add a directory with validation.
-     */
-    addDirectoryInternal(directory, basePath = process.cwd()) {
-        const absolutePath = path.isAbsolute(directory)
-            ? directory
-            : path.resolve(basePath, directory);
-        if (!fs.existsSync(absolutePath)) {
-            throw new Error(`Directory does not exist: ${absolutePath}`);
-        }
-        const stats = fs.statSync(absolutePath);
-        if (!stats.isDirectory()) {
-            throw new Error(`Path is not a directory: ${absolutePath}`);
-        }
-        let realPath;
-        try {
-            realPath = fs.realpathSync(absolutePath);
-        }
-        catch (_error) {
-            throw new Error(`Failed to resolve path: ${absolutePath}`);
+        const resolved = this.resolveAndValidateDir(directory, basePath);
+        if (this.directories.has(resolved)) {
+            return;
         }
-        this.directories.add(realPath);
+        this.directories.add(resolved);
+        this.notifyDirectoriesChanged();
     }
-    addInitialDirectoryInternal(directory, basePath = process.cwd()) {
+    resolveAndValidateDir(directory, basePath = process.cwd()) {
         const absolutePath = path.isAbsolute(directory)
             ? directory
             : path.resolve(basePath, directory);
@@ -70,14 +74,7 @@ export class WorkspaceContext {
         if (!stats.isDirectory()) {
             throw new Error(`Path is not a directory: ${absolutePath}`);
         }
-        let realPath;
-        try {
-            realPath = fs.realpathSync(absolutePath);
-        }
-        catch (_error) {
-            throw new Error(`Failed to resolve path: ${absolutePath}`);
-        }
-        this.initialDirectories.add(realPath);
+        return fs.realpathSync(absolutePath);
     }
     /**
      * Gets a copy of all workspace directories.
@@ -90,9 +87,14 @@ export class WorkspaceContext {
         return Array.from(this.initialDirectories);
     }
     setDirectories(directories) {
-        this.directories.clear();
+        const newDirectories = new Set();
         for (const dir of directories) {
-            this.addDirectoryInternal(dir);
+            newDirectories.add(this.resolveAndValidateDir(dir));
+        }
+        if (newDirectories.size !== this.directories.size ||
+            ![...newDirectories].every((d) => this.directories.has(d))) {
+            this.directories = newDirectories;
+            this.notifyDirectoriesChanged();
         }
     }
     /**
@@ -102,18 +104,9 @@ export class WorkspaceContext {
      */
     isPathWithinWorkspace(pathToCheck) {
         try {
-            const absolutePath = path.resolve(pathToCheck);
-            let resolvedPath = absolutePath;
-            if (fs.existsSync(absolutePath)) {
-                try {
-                    resolvedPath = fs.realpathSync(absolutePath);
-                }
-                catch (_error) {
-                    return false;
-                }
-            }
+            const fullyResolvedPath = this.fullyResolvedPath(pathToCheck);
             for (const dir of this.directories) {
-                if (this.isPathWithinRoot(resolvedPath, dir)) {
+                if (this.isPathWithinRoot(fullyResolvedPath, dir)) {
                     return true;
                 }
             }
@@ -123,6 +116,28 @@ export class WorkspaceContext {
             return false;
         }
     }
+    /**
+     * Fully resolves a path, including symbolic links.
+     * If the path does not exist, it returns the fully resolved path as it would be
+     * if it did exist.
+     */
+    fullyResolvedPath(pathToCheck) {
+        try {
+            return fs.realpathSync(pathToCheck);
+        }
+        catch (e) {
+            if (isNodeError(e) &&
+                e.code === 'ENOENT' &&
+                e.path &&
+                // realpathSync does not set e.path correctly for symlinks to
+                // non-existent files.
+                !this.isFileSymlink(e.path)) {
+                // If it doesn't exist, e.path contains the fully resolved path.
+                return e.path;
+            }
+            throw e;
+        }
+    }
     /**
      * Checks if a path is within a given root directory.
      * @param pathToCheck The absolute path to check
@@ -135,5 +150,16 @@ export class WorkspaceContext {
             relative !== '..' &&
             !path.isAbsolute(relative));
     }
+    /**
+     * Checks if a file path is a symbolic link that points to a file.
+     */
+    isFileSymlink(filePath) {
+        try {
+            return !fs.readlinkSync(filePath).endsWith('/');
+        }
+        catch (_error) {
+            return false;
+        }
+    }
 }
 //# sourceMappingURL=workspaceContext.js.map

package/dist/src/utils/workspaceContext.js.map

@@ -1 +1 @@
-{"version":3,"file":"workspaceContext.js","sourceRoot":"","sources":["../../../src/utils/workspaceContext.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"workspaceContext.js","sourceRoot":"","sources":["../../../src/utils/workspaceContext.ts"],"names":[],"mappings":"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"}

package/dist/src/utils/workspaceContext.test.js

@@ -3,206 +3,290 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import { WorkspaceContext } from './workspaceContext.js';
-vi.mock('fs');
-describe('WorkspaceContext', () => {
-    let workspaceContext;
-    // Use path module to create platform-agnostic paths
-    const mockCwd = path.resolve(path.sep, 'home', 'user', 'project');
-    const mockExistingDir = path.resolve(path.sep, 'home', 'user', 'other-project');
-    const mockNonExistentDir = path.resolve(path.sep, 'home', 'user', 'does-not-exist');
-    const mockSymlinkDir = path.resolve(path.sep, 'home', 'user', 'symlink');
-    const mockRealPath = path.resolve(path.sep, 'home', 'user', 'real-directory');
+describe('WorkspaceContext with real filesystem', () => {
+    let tempDir;
+    let cwd;
+    let otherDir;
     beforeEach(() => {
-        vi.resetAllMocks();
-        // Mock fs.existsSync
-        vi.mocked(fs.existsSync).mockImplementation((path) => {
-            const pathStr = path.toString();
-            return (pathStr === mockCwd ||
-                pathStr === mockExistingDir ||
-                pathStr === mockSymlinkDir ||
-                pathStr === mockRealPath);
-        });
-        // Mock fs.statSync
-        vi.mocked(fs.statSync).mockImplementation((path) => {
-            const pathStr = path.toString();
-            if (pathStr === mockNonExistentDir) {
-                throw new Error('ENOENT');
-            }
-            return {
-                isDirectory: () => true,
-            };
-        });
-        // Mock fs.realpathSync
-        vi.mocked(fs.realpathSync).mockImplementation((path) => {
-            const pathStr = path.toString();
-            if (pathStr === mockSymlinkDir) {
-                return mockRealPath;
-            }
-            return pathStr;
-        });
+        // os.tmpdir() can return a path using a symlink (this is standard on macOS)
+        // Use fs.realpathSync to fully resolve the absolute path.
+        tempDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'workspace-context-test-')));
+        cwd = path.join(tempDir, 'project');
+        otherDir = path.join(tempDir, 'other-project');
+        fs.mkdirSync(cwd, { recursive: true });
+        fs.mkdirSync(otherDir, { recursive: true });
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
     });
     describe('initialization', () => {
         it('should initialize with a single directory (cwd)', () => {
-            workspaceContext = new WorkspaceContext(mockCwd);
+            const workspaceContext = new WorkspaceContext(cwd);
             const directories = workspaceContext.getDirectories();
-            expect(directories).toHaveLength(1);
-            expect(directories[0]).toBe(mockCwd);
+            expect(directories).toEqual([cwd]);
         });
         it('should validate and resolve directories to absolute paths', () => {
-            const absolutePath = path.join(mockCwd, 'subdir');
-            vi.mocked(fs.existsSync).mockImplementation((p) => p === mockCwd || p === absolutePath);
-            vi.mocked(fs.realpathSync).mockImplementation((p) => p.toString());
-            workspaceContext = new WorkspaceContext(mockCwd, [absolutePath]);
+            const workspaceContext = new WorkspaceContext(cwd, [otherDir]);
             const directories = workspaceContext.getDirectories();
-            expect(directories).toContain(absolutePath);
+            expect(directories).toEqual([cwd, otherDir]);
         });
         it('should reject non-existent directories', () => {
+            const nonExistentDir = path.join(tempDir, 'does-not-exist');
             expect(() => {
-                new WorkspaceContext(mockCwd, [mockNonExistentDir]);
+                new WorkspaceContext(cwd, [nonExistentDir]);
             }).toThrow('Directory does not exist');
         });
         it('should handle empty initialization', () => {
-            workspaceContext = new WorkspaceContext(mockCwd, []);
+            const workspaceContext = new WorkspaceContext(cwd, []);
             const directories = workspaceContext.getDirectories();
             expect(directories).toHaveLength(1);
-            expect(directories[0]).toBe(mockCwd);
+            expect(fs.realpathSync(directories[0])).toBe(cwd);
         });
     });
     describe('adding directories', () => {
-        beforeEach(() => {
-            workspaceContext = new WorkspaceContext(mockCwd);
-        });
         it('should add valid directories', () => {
-            workspaceContext.addDirectory(mockExistingDir);
+            const workspaceContext = new WorkspaceContext(cwd);
+            workspaceContext.addDirectory(otherDir);
             const directories = workspaceContext.getDirectories();
-            expect(directories).toHaveLength(2);
-            expect(directories).toContain(mockExistingDir);
+            expect(directories).toEqual([cwd, otherDir]);
         });
         it('should resolve relative paths to absolute', () => {
-            // Since we can't mock path.resolve, we'll test with absolute paths
-            workspaceContext.addDirectory(mockExistingDir);
+            const workspaceContext = new WorkspaceContext(cwd);
+            const relativePath = path.relative(cwd, otherDir);
+            workspaceContext.addDirectory(relativePath, cwd);
             const directories = workspaceContext.getDirectories();
-            expect(directories).toContain(mockExistingDir);
+            expect(directories).toEqual([cwd, otherDir]);
         });
         it('should reject non-existent directories', () => {
+            const nonExistentDir = path.join(tempDir, 'does-not-exist');
+            const workspaceContext = new WorkspaceContext(cwd);
             expect(() => {
-                workspaceContext.addDirectory(mockNonExistentDir);
+                workspaceContext.addDirectory(nonExistentDir);
             }).toThrow('Directory does not exist');
         });
         it('should prevent duplicate directories', () => {
-            workspaceContext.addDirectory(mockExistingDir);
-            workspaceContext.addDirectory(mockExistingDir);
+            const workspaceContext = new WorkspaceContext(cwd);
+            workspaceContext.addDirectory(otherDir);
+            workspaceContext.addDirectory(otherDir);
             const directories = workspaceContext.getDirectories();
-            expect(directories.filter((d) => d === mockExistingDir)).toHaveLength(1);
+            expect(directories).toHaveLength(2);
         });
         it('should handle symbolic links correctly', () => {
-            workspaceContext.addDirectory(mockSymlinkDir);
+            const realDir = path.join(tempDir, 'real');
+            fs.mkdirSync(realDir, { recursive: true });
+            const symlinkDir = path.join(tempDir, 'symlink-to-real');
+            fs.symlinkSync(realDir, symlinkDir, 'dir');
+            const workspaceContext = new WorkspaceContext(cwd);
+            workspaceContext.addDirectory(symlinkDir);
             const directories = workspaceContext.getDirectories();
-            expect(directories).toContain(mockRealPath);
-            expect(directories).not.toContain(mockSymlinkDir);
+            expect(directories).toEqual([cwd, realDir]);
         });
     });
     describe('path validation', () => {
-        beforeEach(() => {
-            workspaceContext = new WorkspaceContext(mockCwd, [mockExistingDir]);
-        });
         it('should accept paths within workspace directories', () => {
-            const validPath1 = path.join(mockCwd, 'src', 'file.ts');
-            const validPath2 = path.join(mockExistingDir, 'lib', 'module.js');
+            const workspaceContext = new WorkspaceContext(cwd, [otherDir]);
+            const validPath1 = path.join(cwd, 'src', 'file.ts');
+            const validPath2 = path.join(otherDir, 'lib', 'module.js');
+            fs.mkdirSync(path.dirname(validPath1), { recursive: true });
+            fs.writeFileSync(validPath1, 'content');
+            fs.mkdirSync(path.dirname(validPath2), { recursive: true });
+            fs.writeFileSync(validPath2, 'content');
+            expect(workspaceContext.isPathWithinWorkspace(validPath1)).toBe(true);
+            expect(workspaceContext.isPathWithinWorkspace(validPath2)).toBe(true);
+        });
+        it('should accept non-existent paths within workspace directories', () => {
+            const workspaceContext = new WorkspaceContext(cwd, [otherDir]);
+            const validPath1 = path.join(cwd, 'src', 'file.ts');
+            const validPath2 = path.join(otherDir, 'lib', 'module.js');
             expect(workspaceContext.isPathWithinWorkspace(validPath1)).toBe(true);
             expect(workspaceContext.isPathWithinWorkspace(validPath2)).toBe(true);
         });
         it('should reject paths outside workspace', () => {
-            const invalidPath = path.resolve(path.dirname(mockCwd), 'outside-workspace', 'file.txt');
+            const workspaceContext = new WorkspaceContext(cwd, [otherDir]);
+            const invalidPath = path.join(tempDir, 'outside-workspace', 'file.txt');
             expect(workspaceContext.isPathWithinWorkspace(invalidPath)).toBe(false);
         });
-        it('should resolve symbolic links before validation', () => {
-            const symlinkPath = path.join(mockCwd, 'symlink-file');
-            const realPath = path.join(mockCwd, 'real-file');
-            vi.mocked(fs.existsSync).mockReturnValue(true);
-            vi.mocked(fs.realpathSync).mockImplementation((p) => {
-                if (p === symlinkPath) {
-                    return realPath;
-                }
-                return p.toString();
-            });
-            expect(workspaceContext.isPathWithinWorkspace(symlinkPath)).toBe(true);
+        it('should reject non-existent paths outside workspace', () => {
+            const workspaceContext = new WorkspaceContext(cwd, [otherDir]);
+            const invalidPath = path.join(tempDir, 'outside-workspace', 'file.txt');
+            expect(workspaceContext.isPathWithinWorkspace(invalidPath)).toBe(false);
         });
         it('should handle nested directories correctly', () => {
-            const nestedPath = path.join(mockCwd, 'deeply', 'nested', 'path', 'file.txt');
+            const workspaceContext = new WorkspaceContext(cwd, [otherDir]);
+            const nestedPath = path.join(cwd, 'deeply', 'nested', 'path', 'file.txt');
             expect(workspaceContext.isPathWithinWorkspace(nestedPath)).toBe(true);
         });
         it('should handle edge cases (root, parent references)', () => {
-            const rootPath = '/';
-            const parentPath = path.dirname(mockCwd);
+            const workspaceContext = new WorkspaceContext(cwd, [otherDir]);
+            const rootPath = path.parse(tempDir).root;
+            const parentPath = path.dirname(cwd);
             expect(workspaceContext.isPathWithinWorkspace(rootPath)).toBe(false);
             expect(workspaceContext.isPathWithinWorkspace(parentPath)).toBe(false);
         });
         it('should handle non-existent paths correctly', () => {
-            const nonExistentPath = path.join(mockCwd, 'does-not-exist.txt');
-            vi.mocked(fs.existsSync).mockImplementation((p) => p !== nonExistentPath);
-            // Should still validate based on path structure
+            const workspaceContext = new WorkspaceContext(cwd, [otherDir]);
+            const nonExistentPath = path.join(cwd, 'does-not-exist.txt');
             expect(workspaceContext.isPathWithinWorkspace(nonExistentPath)).toBe(true);
         });
+        describe('with symbolic link', () => {
+            describe('in the workspace', () => {
+                let realDir;
+                let symlinkDir;
+                beforeEach(() => {
+                    realDir = path.join(cwd, 'real-dir');
+                    fs.mkdirSync(realDir, { recursive: true });
+                    symlinkDir = path.join(cwd, 'symlink-file');
+                    fs.symlinkSync(realDir, symlinkDir, 'dir');
+                });
+                it('should accept dir paths', () => {
+                    const workspaceContext = new WorkspaceContext(cwd);
+                    expect(workspaceContext.isPathWithinWorkspace(symlinkDir)).toBe(true);
+                });
+                it('should accept non-existent paths', () => {
+                    const filePath = path.join(symlinkDir, 'does-not-exist.txt');
+                    const workspaceContext = new WorkspaceContext(cwd);
+                    expect(workspaceContext.isPathWithinWorkspace(filePath)).toBe(true);
+                });
+                it('should accept non-existent deep paths', () => {
+                    const filePath = path.join(symlinkDir, 'deep', 'does-not-exist.txt');
+                    const workspaceContext = new WorkspaceContext(cwd);
+                    expect(workspaceContext.isPathWithinWorkspace(filePath)).toBe(true);
+                });
+            });
+            describe('outside the workspace', () => {
+                let realDir;
+                let symlinkDir;
+                beforeEach(() => {
+                    realDir = path.join(tempDir, 'real-dir');
+                    fs.mkdirSync(realDir, { recursive: true });
+                    symlinkDir = path.join(cwd, 'symlink-file');
+                    fs.symlinkSync(realDir, symlinkDir, 'dir');
+                });
+                it('should reject dir paths', () => {
+                    const workspaceContext = new WorkspaceContext(cwd);
+                    expect(workspaceContext.isPathWithinWorkspace(symlinkDir)).toBe(false);
+                });
+                it('should reject non-existent paths', () => {
+                    const filePath = path.join(symlinkDir, 'does-not-exist.txt');
+                    const workspaceContext = new WorkspaceContext(cwd);
+                    expect(workspaceContext.isPathWithinWorkspace(filePath)).toBe(false);
+                });
+                it('should reject non-existent deep paths', () => {
+                    const filePath = path.join(symlinkDir, 'deep', 'does-not-exist.txt');
+                    const workspaceContext = new WorkspaceContext(cwd);
+                    expect(workspaceContext.isPathWithinWorkspace(filePath)).toBe(false);
+                });
+                it('should reject partially non-existent deep paths', () => {
+                    const deepDir = path.join(symlinkDir, 'deep');
+                    fs.mkdirSync(deepDir, { recursive: true });
+                    const filePath = path.join(deepDir, 'does-not-exist.txt');
+                    const workspaceContext = new WorkspaceContext(cwd);
+                    expect(workspaceContext.isPathWithinWorkspace(filePath)).toBe(false);
+                });
+            });
+            it('should reject symbolic file links outside the workspace', () => {
+                const realFile = path.join(tempDir, 'real-file.txt');
+                fs.writeFileSync(realFile, 'content');
+                const symlinkFile = path.join(cwd, 'symlink-to-real-file');
+                fs.symlinkSync(realFile, symlinkFile, 'file');
+                const workspaceContext = new WorkspaceContext(cwd);
+                expect(workspaceContext.isPathWithinWorkspace(symlinkFile)).toBe(false);
+            });
+            it('should reject non-existent symbolic file links outside the workspace', () => {
+                const realFile = path.join(tempDir, 'real-file.txt');
+                const symlinkFile = path.join(cwd, 'symlink-to-real-file');
+                fs.symlinkSync(realFile, symlinkFile, 'file');
+                const workspaceContext = new WorkspaceContext(cwd);
+                expect(workspaceContext.isPathWithinWorkspace(symlinkFile)).toBe(false);
+            });
+            it('should handle circular symlinks gracefully', () => {
+                const workspaceContext = new WorkspaceContext(cwd);
+                const linkA = path.join(cwd, 'link-a');
+                const linkB = path.join(cwd, 'link-b');
+                // Create a circular dependency: linkA -> linkB -> linkA
+                fs.symlinkSync(linkB, linkA, 'dir');
+                fs.symlinkSync(linkA, linkB, 'dir');
+                // fs.realpathSync should throw ELOOP, and isPathWithinWorkspace should
+                // handle it gracefully and return false.
+                expect(workspaceContext.isPathWithinWorkspace(linkA)).toBe(false);
+                expect(workspaceContext.isPathWithinWorkspace(linkB)).toBe(false);
+            });
+        });
+    });
+    describe('onDirectoriesChanged', () => {
+        it('should call listener when adding a directory', () => {
+            const workspaceContext = new WorkspaceContext(cwd);
+            const listener = vi.fn();
+            workspaceContext.onDirectoriesChanged(listener);
+            workspaceContext.addDirectory(otherDir);
+            expect(listener).toHaveBeenCalledOnce();
+        });
+        it('should not call listener when adding a duplicate directory', () => {
+            const workspaceContext = new WorkspaceContext(cwd);
+            workspaceContext.addDirectory(otherDir);
+            const listener = vi.fn();
+            workspaceContext.onDirectoriesChanged(listener);
+            workspaceContext.addDirectory(otherDir);
+            expect(listener).not.toHaveBeenCalled();
+        });
+        it('should call listener when setting different directories', () => {
+            const workspaceContext = new WorkspaceContext(cwd);
+            const listener = vi.fn();
+            workspaceContext.onDirectoriesChanged(listener);
+            workspaceContext.setDirectories([otherDir]);
+            expect(listener).toHaveBeenCalledOnce();
+        });
+        it('should not call listener when setting same directories', () => {
+            const workspaceContext = new WorkspaceContext(cwd);
+            const listener = vi.fn();
+            workspaceContext.onDirectoriesChanged(listener);
+            workspaceContext.setDirectories([cwd]);
+            expect(listener).not.toHaveBeenCalled();
+        });
+        it('should support multiple listeners', () => {
+            const workspaceContext = new WorkspaceContext(cwd);
+            const listener1 = vi.fn();
+            const listener2 = vi.fn();
+            workspaceContext.onDirectoriesChanged(listener1);
+            workspaceContext.onDirectoriesChanged(listener2);
+            workspaceContext.addDirectory(otherDir);
+            expect(listener1).toHaveBeenCalledOnce();
+            expect(listener2).toHaveBeenCalledOnce();
+        });
+        it('should allow unsubscribing a listener', () => {
+            const workspaceContext = new WorkspaceContext(cwd);
+            const listener = vi.fn();
+            const unsubscribe = workspaceContext.onDirectoriesChanged(listener);
+            unsubscribe();
+            workspaceContext.addDirectory(otherDir);
+            expect(listener).not.toHaveBeenCalled();
+        });
+        it('should not fail if a listener throws an error', () => {
+            const workspaceContext = new WorkspaceContext(cwd);
+            const errorListener = () => {
+                throw new Error('test error');
+            };
+            const listener = vi.fn();
+            workspaceContext.onDirectoriesChanged(errorListener);
+            workspaceContext.onDirectoriesChanged(listener);
+            expect(() => {
+                workspaceContext.addDirectory(otherDir);
+            }).not.toThrow();
+            expect(listener).toHaveBeenCalledOnce();
+        });
     });
     describe('getDirectories', () => {
         it('should return a copy of directories array', () => {
-            workspaceContext = new WorkspaceContext(mockCwd);
+            const workspaceContext = new WorkspaceContext(cwd);
             const dirs1 = workspaceContext.getDirectories();
             const dirs2 = workspaceContext.getDirectories();
-            expect(dirs1).not.toBe(dirs2); // Different array instances
-            expect(dirs1).toEqual(dirs2); // Same content
-        });
-    });
-    describe('symbolic link security', () => {
-        beforeEach(() => {
-            workspaceContext = new WorkspaceContext(mockCwd);
-        });
-        it('should follow symlinks but validate resolved path', () => {
-            const symlinkInsideWorkspace = path.join(mockCwd, 'link-to-subdir');
-            const resolvedInsideWorkspace = path.join(mockCwd, 'subdir');
-            vi.mocked(fs.existsSync).mockReturnValue(true);
-            vi.mocked(fs.realpathSync).mockImplementation((p) => {
-                if (p === symlinkInsideWorkspace) {
-                    return resolvedInsideWorkspace;
-                }
-                return p.toString();
-            });
-            expect(workspaceContext.isPathWithinWorkspace(symlinkInsideWorkspace)).toBe(true);
-        });
-        it('should prevent sandbox escape via symlinks', () => {
-            const symlinkEscape = path.join(mockCwd, 'escape-link');
-            const resolvedOutside = path.resolve(mockCwd, '..', 'outside-file');
-            vi.mocked(fs.existsSync).mockImplementation((p) => {
-                const pathStr = p.toString();
-                return (pathStr === symlinkEscape ||
-                    pathStr === resolvedOutside ||
-                    pathStr === mockCwd);
-            });
-            vi.mocked(fs.realpathSync).mockImplementation((p) => {
-                if (p.toString() === symlinkEscape) {
-                    return resolvedOutside;
-                }
-                return p.toString();
-            });
-            vi.mocked(fs.statSync).mockImplementation((p) => ({
-                isDirectory: () => p.toString() !== resolvedOutside,
-            }));
-            workspaceContext = new WorkspaceContext(mockCwd);
-            expect(workspaceContext.isPathWithinWorkspace(symlinkEscape)).toBe(false);
-        });
-        it('should handle circular symlinks', () => {
-            const circularLink = path.join(mockCwd, 'circular');
-            vi.mocked(fs.existsSync).mockReturnValue(true);
-            vi.mocked(fs.realpathSync).mockImplementation(() => {
-                throw new Error('ELOOP: too many symbolic links encountered');
-            });
-            // Should handle the error gracefully
-            expect(workspaceContext.isPathWithinWorkspace(circularLink)).toBe(false);
+            expect(dirs1).not.toBe(dirs2);
+            expect(dirs1).toEqual(dirs2);
         });
     });
 });