fileditor-mcp 1.0.0

package/test/SetWorkspaceHandler.test.js

@@ -0,0 +1,290 @@
+import { SetWorkspaceHandler } from '../src/handlers/setWorkspace.js';
+import { FileUtils } from '../src/utils/fileUtils.js';
+import { describe, it, beforeEach, after } from 'node:test';
+import assert from 'node:assert';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { promises as fs } from 'fs';
+
+/**
+ * Test suite for SetWorkspaceHandler.
+ * Tests the workspace setting functionality.
+ */
+describe('SetWorkspaceHandler', () => {
+
+    beforeEach(() => {
+        // Reset workspace state
+        FileUtils.setWorkspaceRoot(process.cwd());
+    });
+
+    describe('handle method', () => {
+        it('should successfully set the workspace root directory', async () => {
+            const testPath = process.cwd(); // Use the current directory, ensure it exists
+            const args = { path: testPath };
+
+            const result = await SetWorkspaceHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('Successfully set workspace root to:'));
+            assert.ok(result.content[0].text.includes(testPath));
+            assert.strictEqual(FileUtils.getWorkspaceRoot(), testPath);
+        }); it('should handle Windows path format', async () => {
+            if (process.platform !== 'win32') {
+                // Skip this test on non-Windows platforms
+                console.log('Skipping Windows path format test: not on a Windows platform');
+                return;
+            }
+            const testPath = 'C:\\'; // Use the root directory, usually exists on Windows
+            const args = { path: testPath };
+
+            try {
+                const result = await SetWorkspaceHandler.handle(args);
+
+                assert.strictEqual(result.content[0].type, 'text');
+                assert.ok(result.content[0].text.includes('Successfully set workspace root to:'));
+            } catch (error) {
+                // If C:\ does not exist (very rare), it should throw a directory not found error
+                assert.ok(error.message.includes('Workspace directory does not exist'));
+            }
+        }); it('should handle relative paths', async () => {
+            const testPath = '.'; // Use the current directory
+            const args = { path: testPath };
+
+            const result = await SetWorkspaceHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('Successfully set workspace root to:'));
+            // Relative paths are resolved to absolute paths
+            assert.ok(FileUtils.getWorkspaceRoot().includes(process.cwd()));
+        }); it('should throw an error when the directory does not exist', async () => {
+            const testPath = './nonexistent/directory';
+            const args = { path: testPath };
+
+            try {
+                await SetWorkspaceHandler.handle(args);
+                assert.fail('Should have thrown an error');
+            } catch (error) {
+                assert.ok(error.message.includes('Workspace directory does not exist'));
+            }
+        }); it('should throw an error when the path contains a non-existent directory with special characters', async () => {
+            const testPath = '/path/with spaces/and-symbols_123';
+            const args = { path: testPath };
+
+            try {
+                await SetWorkspaceHandler.handle(args);
+                assert.fail('Should have thrown an error');
+            } catch (error) {
+                assert.ok(error.message.includes('Workspace directory does not exist'));
+            }
+        });
+
+        it('should throw an error when the path parameter is missing', async () => {
+            const args = {};
+
+            try {
+                await SetWorkspaceHandler.handle(args);
+                assert.fail('Should have thrown an error');
+            } catch (error) {
+                assert.ok(error.message.includes('Failed to set workspace'));
+            }
+        });
+
+    });
+
+    describe('Edge cases', () => {
+
+        it('should handle null path', async () => {
+            const args = { path: null };
+
+            try {
+                await SetWorkspaceHandler.handle(args);
+                // If no error is thrown, check the result
+                assert.strictEqual(FileUtils.getWorkspaceRoot(), null);
+            } catch (error) {
+                // If an error is thrown, ensure it is a reasonable error message
+                assert.ok(error.message.includes('Failed to set workspace'));
+            }
+        });
+
+        it('should handle undefined path', async () => {
+            const args = { path: undefined };
+
+            try {
+                await SetWorkspaceHandler.handle(args);
+                assert.fail('Should have thrown an error');
+            } catch (error) {
+                assert.ok(error.message.includes('Failed to set workspace'));
+            }
+        });
+
+    });
+
+    describe('Path security tests', () => {
+        let testWorkspace;
+
+        beforeEach(async () => {
+            testWorkspace = join(tmpdir(), `mcp-security-test-${Date.now()}`);
+            await fs.mkdir(testWorkspace, { recursive: true });
+
+            // Create test directory structure
+            await fs.mkdir(join(testWorkspace, 'safe'), { recursive: true });
+            await fs.mkdir(join(testWorkspace, 'safe', 'nested'), { recursive: true });
+            await fs.writeFile(join(testWorkspace, 'safe', 'test.txt'), 'safe content');
+            await fs.writeFile(join(testWorkspace, 'safe', 'nested', 'deep.txt'), 'deep content');
+
+            // Create a file outside the workspace
+            await fs.writeFile(join(tmpdir(), 'outside.txt'), 'outside content');
+
+            FileUtils.setWorkspaceRoot(testWorkspace);
+        });
+
+        after(async () => {
+            try {
+                await fs.rm(testWorkspace, { recursive: true, force: true });
+                await fs.rm(join(tmpdir(), 'outside.txt'), { force: true });
+            } catch (error) {
+                // Ignore cleanup errors
+            }
+        });
+
+        it('should succeed for normal path access', async () => {
+            // Test relative path
+            const safePath1 = FileUtils.getSecurePath('safe/test.txt');
+            assert.ok(safePath1.includes('test.txt'));
+
+            // Test nested path
+            const safePath2 = FileUtils.getSecurePath('safe/nested/deep.txt');
+            assert.ok(safePath2.includes('deep.txt'));
+
+            // Test current directory
+            const safePath3 = FileUtils.getSecurePath('.');
+            assert.strictEqual(safePath3, testWorkspace);
+        });
+
+        it('should prevent path traversal attacks', async () => {
+            const traversalAttempts = [
+                '../outside.txt',                    // Basic traversal
+                '../../outside.txt',                 // Deep traversal
+                'safe/../../../outside.txt',         // Mixed traversal
+                'safe/../../outside.txt',            // Nested traversal
+                '/etc/passwd',                       // Absolute path attack (Unix)
+            ];
+            if (process.platform === 'win32') {
+                traversalAttempts.push(
+                    'C:\\Windows\\System32\\config\\SAM', // Absolute path attack (Windows)
+                    '..\\..\\outside.txt',               // Windows-style traversal
+                    'safe\\..\\..\\outside.txt',         // Windows mixed traversal
+                );
+            }
+            for (const maliciousPath of traversalAttempts) {
+                await assert.rejects(
+                    async () => FileUtils.getSecurePath(maliciousPath),
+                    (error) => {
+                        return error.message.includes('Access denied') ||
+                            error.message.includes('outside the workspace');
+                    },
+                    `Path traversal attack should be blocked: ${maliciousPath}`
+                );
+            }
+        });
+
+        it('should reject dangerous characters', async () => {
+            const dangerousInputs = [
+                'test\0file.txt',           // Null byte
+                'test\x00file.txt',         // Hex null byte
+                '',                         // Empty string
+                null,                       // Null value
+                undefined,                  // Undefined value
+                123,                        // Number type
+            ];
+
+            for (const dangerousInput of dangerousInputs) {
+                await assert.rejects(
+                    async () => FileUtils.getSecurePath(dangerousInput),
+                    (error) => {
+                        return error.message.includes('Invalid file path') ||
+                            error.message.includes('null bytes');
+                    },
+                    `Dangerous input should be rejected: ${dangerousInput}`
+                );
+            }
+        });
+
+        // it('should prevent symlink traversal', async () => {
+        //     // Create a symlink pointing outside the workspace
+        //     const symlinkPath = join(testWorkspace, 'malicious_link');
+        //     const outsidePath = join(tmpdir(), 'outside.txt');
+        //
+        //     try {
+        //         await fs.symlink(outsidePath, symlinkPath);
+        //
+        //         // Attempt to access the file outside the workspace via the symlink
+        //         await assert.rejects(
+        //             async () => FileUtils.getSecurePath('malicious_link'),
+        //             (error) => error.message.includes('Access denied') ||
+        //                 error.message.includes('outside the workspace'),
+        //             'Symlink traversal attack should be blocked'
+        //         );
+        //     } catch (error) {
+        //         // Some systems may not support creating symlinks, skip this test
+        //         if (error.code === 'EPERM' || error.code === 'ENOENT') {
+        //             console.log('Skipping symlink test: system does not support or permission denied');
+        //             return;
+        //         }
+        //         throw error;
+        //     }
+        // });
+
+        it('should work correctly for workspace validation', async () => {
+            // Test invalid workspace settings
+            await assert.rejects(
+                async () => FileUtils.setWorkspaceRoot(''),
+                (error) => error.message.includes('Invalid workspace root'),
+                'Empty workspace path should be rejected'
+            );
+
+            await assert.rejects(
+                async () => FileUtils.setWorkspaceRoot(null),
+                (error) => error.message.includes('Invalid workspace root'),
+                'Null workspace path should be rejected'
+            );
+
+            await assert.rejects(
+                async () => FileUtils.setWorkspaceRoot('/nonexistent/directory'),
+                (error) => error.message.includes('does not exist'),
+                'Non-existent directory should be rejected'
+            );
+
+            // Test file as workspace
+            const tempFile = join(tmpdir(), `test-file-${Date.now()}.txt`);
+            await fs.writeFile(tempFile, 'test');
+
+            try {
+                await assert.rejects(
+                    async () => FileUtils.setWorkspaceRoot(tempFile),
+                    (error) => error.message.includes('not a directory'),
+                    'File path as workspace should be rejected'
+                );
+            } finally {
+                await fs.rm(tempFile, { force: true });
+            }
+        });
+
+        it('should deny access when workspace is not set', async () => {
+            // Temporarily clear workspace setting
+            const originalWorkspace = FileUtils.WORKSPACE_ROOT;
+            FileUtils.WORKSPACE_ROOT = null;
+
+            try {
+                await assert.rejects(
+                    async () => FileUtils.getSecurePath('test.txt'),
+                    (error) => error.message.includes('Workspace not set'),
+                    'Access should be denied when workspace is not set'
+                );
+            } finally {
+                // Restore workspace setting
+                FileUtils.WORKSPACE_ROOT = originalWorkspace;
+            }
+        });
+    });
+});

package/test/WriteFileHandler.test.js

@@ -0,0 +1,289 @@
+import { WriteFileHandler } from '../src/handlers/writeFile.js';
+import { FileUtils } from '../src/utils/fileUtils.js';
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import fs from 'fs/promises';
+import { join } from 'path';
+import { existsSync } from 'fs';
+
+/**
+ * WriteFileHandler 测试类
+ * 测试文件写入功能
+ */
+describe('WriteFileHandler', () => {
+
+    const testDir = './test_files_write';
+    const testFile1 = join(testDir, 'test1.txt');
+    const testFile2 = join(testDir, 'test2.txt');
+
+    beforeEach(async () => {
+        // 设置测试工作区
+        FileUtils.setWorkspaceRoot(process.cwd());
+
+        // 创建测试目录
+        if (!existsSync(testDir)) {
+            await fs.mkdir(testDir, { recursive: true });
+        }
+    });
+
+    afterEach(async () => {
+        // 清理测试文件
+        try {
+            if (existsSync(testFile1)) await fs.unlink(testFile1);
+            if (existsSync(testFile2)) await fs.unlink(testFile2);
+            if (existsSync(testDir)) await fs.rmdir(testDir);
+        } catch (error) {
+            console.warn('清理测试文件失败:', error.message);
+        }
+    });
+
+    describe('单文件写入', () => {
+
+        it('应该成功创建新文件', async () => {
+            const content = 'Line 1\nLine 2\nLine 3';
+            const args = {
+                path: testFile1,
+                content: content,
+                line_count: 3
+            };
+
+            const result = await WriteFileHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('File written successfully'));
+            assert.ok(result.content[0].text.includes('3 lines'));
+
+            // 验证文件内容
+            const writtenContent = await fs.readFile(testFile1, 'utf8');
+            assert.strictEqual(writtenContent, content);
+        });
+
+        it('应该覆盖现有文件', async () => {
+            // 先创建一个文件
+            await fs.writeFile(testFile1, 'Old content', 'utf8');
+
+            const newContent = 'New content\nSecond line';
+            const args = {
+                path: testFile1,
+                content: newContent,
+                line_count: 2
+            };
+
+            const result = await WriteFileHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('File written successfully'));
+
+            // 验证文件内容被覆盖
+            const writtenContent = await fs.readFile(testFile1, 'utf8');
+            assert.strictEqual(writtenContent, newContent);
+        });
+
+        it('应该处理空文件写入', async () => {
+            const args = {
+                path: testFile1,
+                content: '',
+                line_count: 0
+            };
+
+            const result = await WriteFileHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('File written successfully'));
+
+            // 验证文件为空
+            const writtenContent = await fs.readFile(testFile1, 'utf8');
+            assert.strictEqual(writtenContent, '');
+        });
+
+        it('应该发出警告当行数不匹配时', async () => {
+            const content = 'Line 1\nLine 2\nLine 3';
+            const args = {
+                path: testFile1,
+                content: content,
+                line_count: 5 // 错误的行数
+            };
+
+            const result = await WriteFileHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('File written successfully'));
+            // 注意：警告是通过console.warn输出的，这里检查结果仍然成功
+        });
+
+    });
+
+    describe('多文件写入', () => {
+
+        it('应该成功写入多个文件（相同内容）', async () => {
+            const content = 'Shared content\nLine 2';
+            const args = {
+                path: [testFile1, testFile2],
+                content: content,
+                line_count: 2
+            };
+
+            const result = await WriteFileHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('Successfully wrote 2 files'));
+            assert.ok(result.content[0].text.includes('4 total lines'));
+
+            // 验证两个文件内容
+            const content1 = await fs.readFile(testFile1, 'utf8');
+            const content2 = await fs.readFile(testFile2, 'utf8');
+            assert.strictEqual(content1, content);
+            assert.strictEqual(content2, content);
+        });
+
+        it('应该成功写入多个文件（不同内容）', async () => {
+            const content1 = 'File 1 content';
+            const content2 = 'File 2 content\nSecond line';
+            const args = {
+                path: [testFile1, testFile2],
+                content: [content1, content2],
+                line_count: [1, 2]
+            };
+
+            const result = await WriteFileHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('Successfully wrote 2 files'));
+            assert.ok(result.content[0].text.includes('3 total lines'));
+
+            // 验证文件内容
+            const writtenContent1 = await fs.readFile(testFile1, 'utf8');
+            const writtenContent2 = await fs.readFile(testFile2, 'utf8');
+            assert.strictEqual(writtenContent1, content1);
+            assert.strictEqual(writtenContent2, content2);
+        });
+
+        it('应该抛出错误当路径和内容数组长度不匹配时', async () => {
+            const args = {
+                path: [testFile1, testFile2],
+                content: ['Content 1'], // 只有一个内容，但有两个路径
+                line_count: [1, 1]
+            };
+
+            await assert.rejects(
+                () => WriteFileHandler.handle(args),
+                (error) => error.message.includes("doesn't match content count")
+            );
+        });
+
+        it('应该抛出错误当路径和行数数组长度不匹配时', async () => {
+            const args = {
+                path: [testFile1, testFile2],
+                content: ['Content 1', 'Content 2'],
+                line_count: [1] // 只有一个行数，但有两个路径
+            };
+
+            await assert.rejects(
+                () => WriteFileHandler.handle(args),
+                (error) => error.message.includes("doesn't match line_count array length")
+            );
+        });
+
+    });
+
+    describe('错误处理', () => {
+
+        it('应该处理写入失败的情况', async () => {
+            // 使用无效路径
+            const invalidPath = '/invalid/path/that/does/not/exist/file.txt';
+            const args = {
+                path: invalidPath,
+                content: 'Some content',
+                line_count: 1
+            };
+
+            await assert.rejects(
+                () => WriteFileHandler.handle(args),
+                (error) => error.message.includes('Failed to write file(s)')
+            );
+        });
+
+        it('应该处理部分文件写入失败的情况', async () => {
+            const validPath = testFile1;
+            const invalidPath = '/invalid/path/file.txt';
+            const args = {
+                path: [validPath, invalidPath],
+                content: ['Valid content', 'Invalid content'],
+                line_count: [1, 1]
+            };
+
+            await assert.rejects(
+                () => WriteFileHandler.handle(args),
+                (error) => error.message.includes('Failed to write') &&
+                    error.message.includes('file(s)')
+            );
+        });
+
+    });
+
+    describe('边界情况', () => {
+
+        it('应该处理包含特殊字符的内容', async () => {
+            const content = 'Special chars: áéíóú 中文 @#$%^&*()';
+            const args = {
+                path: testFile1,
+                content: content,
+                line_count: 1
+            };
+
+            const result = await WriteFileHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('File written successfully'));
+
+            // 验证特殊字符被正确写入
+            const writtenContent = await fs.readFile(testFile1, 'utf8');
+            assert.strictEqual(writtenContent, content);
+        });
+
+        it('应该处理大文件写入', async () => {
+            const bigContent = Array.from({ length: 1000 }, (_, i) => `Line ${i + 1}`).join('\n');
+            const args = {
+                path: testFile1,
+                content: bigContent,
+                line_count: 1000
+            };
+
+            const result = await WriteFileHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('File written successfully'));
+            assert.ok(result.content[0].text.includes('1000 lines'));
+
+            // 验证大文件内容
+            const writtenContent = await fs.readFile(testFile1, 'utf8');
+            assert.strictEqual(writtenContent, bigContent);
+        });
+
+        it('应该创建不存在的目录', async () => {
+            const deepPath = join(testDir, 'deep', 'nested', 'file.txt');
+            const args = {
+                path: deepPath,
+                content: 'Deep file content',
+                line_count: 1
+            };
+
+            const result = await WriteFileHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('File written successfully'));
+
+            // 验证文件和目录被创建
+            assert.ok(existsSync(deepPath));
+            const content = await fs.readFile(deepPath, 'utf8');
+            assert.strictEqual(content, 'Deep file content');
+
+            // 清理深层目录
+            await fs.unlink(deepPath);
+            await fs.rmdir(join(testDir, 'deep', 'nested'));
+            await fs.rmdir(join(testDir, 'deep'));
+        });
+
+    });
+
+});