ai-cli-mcp 2.1.0 → 2.3.0

package/src/server.ts

@@ -16,7 +16,7 @@ import * as path from 'path';
 import { parseCodexOutput, parseClaudeOutput, parseGeminiOutput } from './parsers.js';
 
 // Server version - update this when releasing new versions
-const SERVER_VERSION = "2.1.0";
+const SERVER_VERSION = "2.2.0";
 
 // Model alias mappings for user-friendly model names
 const MODEL_ALIASES: Record<string, string> = {
@@ -47,6 +47,13 @@ interface ClaudeProcess {
   exitCode?: number;
 }
 
+// Type definition for list_processes return value
+interface ProcessListItem {
+  pid: number;                                // プロセスID
+  agent: 'claude' | 'codex' | 'gemini';      // エージェントタイプ
+  status: 'running' | 'completed' | 'failed'; // プロセスの状態
+}
+
 // Global process manager
 const processManager = new Map<number, ClaudeProcess>();
 
@@ -332,7 +339,7 @@ export class ClaudeCodeServer {
 **IMPORTANT**: This tool now returns immediately with a PID. Use other tools to check status and get results.
 
 **Supported models**:
-"sonnet", "opus", "haiku", "gpt-5-low", "gpt-5-medium", "gpt-5-high", "gemini-2.5-pro", "gemini-2.5-flash"
+"sonnet", "opus", "haiku", "gpt-5-low", "gpt-5-medium", "gpt-5-high", "gemini-2.5-pro", "gemini-2.5-flash", "gemini-3-pro-preview"
 
 **Prompt input**: You must provide EITHER prompt (string) OR prompt_file (file path), but not both.
 
@@ -360,11 +367,11 @@ export class ClaudeCodeServer {
               },
               model: {
                 type: 'string',
-                description: 'The model to use: "sonnet", "opus", "haiku", "gpt-5-low", "gpt-5-medium", "gpt-5-high", "gemini-2.5-pro", "gemini-2.5-flash".',
+                description: 'The model to use: "sonnet", "opus", "haiku", "gpt-5-low", "gpt-5-medium", "gpt-5-high", "gemini-2.5-pro", "gemini-2.5-flash", "gemini-3-pro-preview".',
               },
               session_id: {
                 type: 'string',
-                description: 'Optional session ID to resume a previous session. Supported for: haiku, sonnet, opus.',
+                description: 'Optional session ID to resume a previous session. Supported for: haiku, sonnet, opus, gemini-2.5-pro, gemini-2.5-flash, gemini-3-pro-preview.',
               },
             },
             required: ['workFolder'],
@@ -372,7 +379,7 @@ export class ClaudeCodeServer {
         },
         {
           name: 'list_processes',
-          description: 'List all running and completed AI agent processes with their status, PID, and basic info.',
+          description: 'List all running and completed AI agent processes. Returns a simple list with PID, agent type, and status for each process.',
           inputSchema: {
             type: 'object',
             properties: {},
@@ -392,6 +399,25 @@ export class ClaudeCodeServer {
             required: ['pid'],
           },
         },
+        {
+          name: 'wait',
+          description: 'Wait for multiple AI agent processes to complete and return their results. Blocks until all specified PIDs finish or timeout occurs.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              pids: {
+                type: 'array',
+                items: { type: 'number' },
+                description: 'List of process IDs to wait for (returned by the run tool).',
+              },
+              timeout: {
+                type: 'number',
+                description: 'Optional: Maximum time to wait in seconds. Defaults to 180 (3 minutes).',
+              },
+            },
+            required: ['pids'],
+          },
+        },
         {
           name: 'kill_process',
           description: 'Terminate a running AI agent process by PID.',
@@ -405,6 +431,14 @@ export class ClaudeCodeServer {
             },
             required: ['pid'],
           },
+        },
+        {
+          name: 'cleanup_processes',
+          description: 'Remove all completed and failed processes from the process list to free up memory.',
+          inputSchema: {
+            type: 'object',
+            properties: {},
+          },
         }
       ],
     }));
@@ -425,8 +459,12 @@ export class ClaudeCodeServer {
           return this.handleListProcesses();
         case 'get_result':
           return this.handleGetResult(toolArguments);
+        case 'wait':
+          return this.handleWait(toolArguments);
         case 'kill_process':
           return this.handleKillProcess(toolArguments);
+        case 'cleanup_processes':
+          return this.handleCleanupProcesses();
         default:
           throw new McpError(ErrorCode.MethodNotFound, `Tool ${toolName} not found`);
       }
@@ -525,6 +563,11 @@ export class ClaudeCodeServer {
       cliPath = this.geminiCliPath;
       processArgs = ['-y', '--output-format', 'json'];
 
+      // Add session_id if provided
+      if (toolArguments.session_id && typeof toolArguments.session_id === 'string') {
+        processArgs.push('-r', toolArguments.session_id);
+      }
+
       // Add model if specified
       if (toolArguments.model) {
         processArgs.push('--model', toolArguments.model);
@@ -628,32 +671,15 @@ export class ClaudeCodeServer {
    * Handle list_processes tool
    */
   private async handleListProcesses(): Promise<ServerResult> {
-    const processes: any[] = [];
-    
+    const processes: ProcessListItem[] = [];
+
     for (const [pid, process] of processManager.entries()) {
-      const processInfo: any = {
+      const processInfo: ProcessListItem = {
         pid,
         agent: process.toolType,
-        status: process.status,
-        startTime: process.startTime,
-        prompt: process.prompt.substring(0, 100) + (process.prompt.length > 100 ? '...' : ''),
-        workFolder: process.workFolder,
-        model: process.model,
-        exitCode: process.exitCode
+        status: process.status
       };
 
-      // Try to extract session_id from JSON output if available
-      if (process.stdout) {
-        try {
-          const claudeOutput = JSON.parse(process.stdout);
-          if (claudeOutput.session_id) {
-            processInfo.session_id = claudeOutput.session_id;
-          }
-        } catch (e) {
-          // Ignore parsing errors
-        }
-      }
-
       processes.push(processInfo);
     }
 
@@ -666,14 +692,9 @@ export class ClaudeCodeServer {
   }
 
   /**
-   * Handle get_result tool
+   * Helper to get process result object
    */
-  private async handleGetResult(toolArguments: any): Promise<ServerResult> {
-    if (!toolArguments.pid || typeof toolArguments.pid !== 'number') {
-      throw new McpError(ErrorCode.InvalidParams, 'Missing or invalid required parameter: pid');
-    }
-
-    const pid = toolArguments.pid;
+  private getProcessResultHelper(pid: number): any {
     const process = processManager.get(pid);
 
     if (!process) {
@@ -707,8 +728,8 @@ export class ClaudeCodeServer {
     // If we have valid output from agent, include it
     if (agentOutput) {
       response.agentOutput = agentOutput;
-      // Extract session_id if available (Claude only)
-      if (process.toolType === 'claude' && agentOutput.session_id) {
+      // Extract session_id if available (Claude and Gemini)
+      if ((process.toolType === 'claude' || process.toolType === 'gemini') && agentOutput.session_id) {
         response.session_id = agentOutput.session_id;
       }
     } else {
@@ -716,6 +737,20 @@ export class ClaudeCodeServer {
       response.stdout = process.stdout;
       response.stderr = process.stderr;
     }
+    
+    return response;
+  }
+
+  /**
+   * Handle get_result tool
+   */
+  private async handleGetResult(toolArguments: any): Promise<ServerResult> {
+    if (!toolArguments.pid || typeof toolArguments.pid !== 'number') {
+      throw new McpError(ErrorCode.InvalidParams, 'Missing or invalid required parameter: pid');
+    }
+
+    const pid = toolArguments.pid;
+    const response = this.getProcessResultHelper(pid);
 
     return {
       content: [{
@@ -725,9 +760,70 @@ export class ClaudeCodeServer {
     };
   }
 
+  /**
+   * Handle wait tool
+   */
+  private async handleWait(toolArguments: any): Promise<ServerResult> {
+    if (!toolArguments.pids || !Array.isArray(toolArguments.pids) || toolArguments.pids.length === 0) {
+      throw new McpError(ErrorCode.InvalidParams, 'Missing or invalid required parameter: pids (must be a non-empty array of numbers)');
+    }
+
+    const pids: number[] = toolArguments.pids;
+    // Default timeout: 3 minutes (180 seconds)
+    const timeoutSeconds = typeof toolArguments.timeout === 'number' ? toolArguments.timeout : 180;
+    const timeoutMs = timeoutSeconds * 1000;
+
+    // Validate all PIDs exist first
+    for (const pid of pids) {
+      if (!processManager.has(pid)) {
+        throw new McpError(ErrorCode.InvalidParams, `Process with PID ${pid} not found`);
+      }
+    }
+
+    // Create promises for each process
+    const waitPromises = pids.map(pid => {
+      const processEntry = processManager.get(pid)!;
+      
+      if (processEntry.status !== 'running') {
+        return Promise.resolve();
+      }
+
+      return new Promise<void>((resolve) => {
+        processEntry.process.once('close', () => {
+          resolve();
+        });
+      });
+    });
+
+    // Create a timeout promise
+    const timeoutPromise = new Promise<void>((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Timed out after ${timeoutSeconds} seconds waiting for processes`));
+      }, timeoutMs);
+    });
+
+    try {
+      // Wait for all processes to finish or timeout
+      await Promise.race([Promise.all(waitPromises), timeoutPromise]);
+    } catch (error: any) {
+      throw new McpError(ErrorCode.InternalError, error.message);
+    }
+
+    // Collect results
+    const results = pids.map(pid => this.getProcessResultHelper(pid));
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify(results, null, 2)
+      }]
+    };
+  }
+
   /**
    * Handle kill_process tool
    */
+
   private async handleKillProcess(toolArguments: any): Promise<ServerResult> {
     if (!toolArguments.pid || typeof toolArguments.pid !== 'number') {
       throw new McpError(ErrorCode.InvalidParams, 'Missing or invalid required parameter: pid');
@@ -773,6 +869,32 @@ export class ClaudeCodeServer {
     }
   }
 
+  /**
+   * Handle cleanup_processes tool
+   */
+  private async handleCleanupProcesses(): Promise<ServerResult> {
+    const removedPids: number[] = [];
+
+    // Iterate through all processes and collect PIDs to remove
+    for (const [pid, process] of processManager.entries()) {
+      if (process.status === 'completed' || process.status === 'failed') {
+        removedPids.push(pid);
+        processManager.delete(pid);
+      }
+    }
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          removed: removedPids.length,
+          removedPids,
+          message: `Cleaned up ${removedPids.length} finished process(es)`
+        }, null, 2)
+      }]
+    };
+  }
+
   /**
    * Start the MCP server
    */
@@ -796,4 +918,4 @@ export class ClaudeCodeServer {
 
 // Create and run the server if this is the main module
 const server = new ClaudeCodeServer();
-server.run().catch(console.error);
+server.run().catch(console.error);

package/dist/__tests__/e2e.test.js

@@ -1,238 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
-import { mkdtempSync, rmSync, readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { MCPTestClient } from './utils/mcp-client.js';
-import { getSharedMock, cleanupSharedMock } from './utils/persistent-mock.js';
-describe('Claude Code MCP E2E Tests', () => {
-    let client;
-    let testDir;
-    const serverPath = 'dist/server.js';
-    beforeEach(async () => {
-        // Ensure mock exists
-        await getSharedMock();
-        // Create a temporary directory for test files
-        testDir = mkdtempSync(join(tmpdir(), 'claude-code-test-'));
-        // Initialize MCP client with debug mode and custom binary name using absolute path
-        client = new MCPTestClient(serverPath, {
-            MCP_CLAUDE_DEBUG: 'true',
-            CLAUDE_CLI_NAME: '/tmp/claude-code-test-mock/claudeMocked',
-        });
-        await client.connect();
-    });
-    afterEach(async () => {
-        // Disconnect client
-        await client.disconnect();
-        // Clean up test directory
-        rmSync(testDir, { recursive: true, force: true });
-    });
-    afterAll(async () => {
-        // Only cleanup mock at the very end
-        await cleanupSharedMock();
-    });
-    describe('Tool Registration', () => {
-        it('should register claude_code tool', async () => {
-            const tools = await client.listTools();
-            expect(tools).toHaveLength(4);
-            const claudeCodeTool = tools.find((t) => t.name === 'claude_code');
-            expect(claudeCodeTool).toEqual({
-                name: 'claude_code',
-                description: expect.stringContaining('Claude Code Agent'),
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        prompt: {
-                            type: 'string',
-                            description: expect.stringContaining('Either this or prompt_file is required'),
-                        },
-                        prompt_file: {
-                            type: 'string',
-                            description: expect.stringContaining('Path to a file containing the prompt'),
-                        },
-                        workFolder: {
-                            type: 'string',
-                            description: expect.stringContaining('working directory'),
-                        },
-                        model: {
-                            type: 'string',
-                            description: expect.stringContaining('Claude model'),
-                        },
-                        session_id: {
-                            type: 'string',
-                            description: expect.stringContaining('session ID'),
-                        },
-                    },
-                    required: ['workFolder'],
-                },
-            });
-            // Verify other tools exist
-            expect(tools.some((t) => t.name === 'list_claude_processes')).toBe(true);
-            expect(tools.some((t) => t.name === 'get_claude_result')).toBe(true);
-            expect(tools.some((t) => t.name === 'kill_claude_process')).toBe(true);
-        });
-    });
-    describe('Basic Operations', () => {
-        it('should execute a simple prompt', async () => {
-            const response = await client.callTool('claude_code', {
-                prompt: 'create a file called test.txt with content "Hello World"',
-                workFolder: testDir,
-            });
-            expect(response).toEqual([{
-                    type: 'text',
-                    text: expect.stringContaining('successfully'),
-                }]);
-        });
-        it('should handle process management correctly', async () => {
-            // claude_code now returns a PID immediately
-            const response = await client.callTool('claude_code', {
-                prompt: 'error',
-                workFolder: testDir,
-            });
-            expect(response).toEqual([{
-                    type: 'text',
-                    text: expect.stringContaining('pid'),
-                }]);
-            // Extract PID from response
-            const responseText = response[0].text;
-            const pidMatch = responseText.match(/"pid":\s*(\d+)/);
-            expect(pidMatch).toBeTruthy();
-        });
-        it('should reject missing workFolder', async () => {
-            await expect(client.callTool('claude_code', {
-                prompt: 'List files in current directory',
-            })).rejects.toThrow(/workFolder/i);
-        });
-    });
-    describe('Working Directory Handling', () => {
-        it('should respect custom working directory', async () => {
-            const response = await client.callTool('claude_code', {
-                prompt: 'Show current working directory',
-                workFolder: testDir,
-            });
-            expect(response).toBeTruthy();
-        });
-        it('should reject non-existent working directory', async () => {
-            const nonExistentDir = join(testDir, 'non-existent');
-            await expect(client.callTool('claude_code', {
-                prompt: 'Test prompt',
-                workFolder: nonExistentDir,
-            })).rejects.toThrow(/does not exist/i);
-        });
-    });
-    describe('Timeout Handling', () => {
-        it('should respect timeout settings', async () => {
-            // This would require modifying the mock to simulate a long-running command
-            // Since we're testing locally, we'll skip the actual timeout test
-            expect(true).toBe(true);
-        });
-    });
-    describe('Model Alias Handling', () => {
-        it('should resolve haiku alias when calling claude_code', async () => {
-            const response = await client.callTool('claude_code', {
-                prompt: 'Test with haiku model',
-                workFolder: testDir,
-                model: 'haiku'
-            });
-            expect(response).toEqual([{
-                    type: 'text',
-                    text: expect.stringContaining('pid'),
-                }]);
-            // Extract PID from response
-            const responseText = response[0].text;
-            const pidMatch = responseText.match(/"pid":\s*(\d+)/);
-            expect(pidMatch).toBeTruthy();
-            // Get the PID and check the process
-            const pid = parseInt(pidMatch[1]);
-            const processes = await client.callTool('list_claude_processes', {});
-            const processesText = processes[0].text;
-            const processData = JSON.parse(processesText);
-            // Find our process
-            const ourProcess = processData.find((p) => p.pid === pid);
-            expect(ourProcess).toBeTruthy();
-            // Verify that the model was set correctly
-            expect(ourProcess.model).toBe('haiku');
-        });
-        it('should pass non-alias model names unchanged', async () => {
-            const response = await client.callTool('claude_code', {
-                prompt: 'Test with sonnet model',
-                workFolder: testDir,
-                model: 'sonnet'
-            });
-            expect(response).toEqual([{
-                    type: 'text',
-                    text: expect.stringContaining('pid'),
-                }]);
-            // Extract PID
-            const responseText = response[0].text;
-            const pidMatch = responseText.match(/"pid":\s*(\d+)/);
-            const pid = parseInt(pidMatch[1]);
-            // Check the process
-            const processes = await client.callTool('list_claude_processes', {});
-            const processesText = processes[0].text;
-            const processData = JSON.parse(processesText);
-            // Find our process
-            const ourProcess = processData.find((p) => p.pid === pid);
-            expect(ourProcess).toBeTruthy();
-            // The model should be unchanged
-            expect(ourProcess.model).toBe('sonnet');
-        });
-        it('should work without specifying a model', async () => {
-            const response = await client.callTool('claude_code', {
-                prompt: 'Test without model parameter',
-                workFolder: testDir
-            });
-            expect(response).toEqual([{
-                    type: 'text',
-                    text: expect.stringContaining('pid'),
-                }]);
-        });
-    });
-    describe('Debug Mode', () => {
-        it('should log debug information when enabled', async () => {
-            // Debug logs go to stderr, which we capture in the client
-            const response = await client.callTool('claude_code', {
-                prompt: 'Debug test prompt',
-                workFolder: testDir,
-            });
-            expect(response).toBeTruthy();
-        });
-    });
-});
-describe('Integration Tests (Local Only)', () => {
-    let client;
-    let testDir;
-    beforeEach(async () => {
-        testDir = mkdtempSync(join(tmpdir(), 'claude-code-integration-'));
-        // Initialize client without mocks for real Claude testing
-        client = new MCPTestClient('dist/server.js', {
-            MCP_CLAUDE_DEBUG: 'true',
-        });
-    });
-    afterEach(async () => {
-        if (client) {
-            await client.disconnect();
-        }
-        rmSync(testDir, { recursive: true, force: true });
-    });
-    // These tests will only run locally when Claude is available
-    it.skip('should create a file with real Claude CLI', async () => {
-        await client.connect();
-        const response = await client.callTool('claude_code', {
-            prompt: 'Create a file called hello.txt with content "Hello from Claude"',
-            workFolder: testDir,
-        });
-        const filePath = join(testDir, 'hello.txt');
-        expect(existsSync(filePath)).toBe(true);
-        expect(readFileSync(filePath, 'utf-8')).toContain('Hello from Claude');
-    });
-    it.skip('should handle git operations with real Claude CLI', async () => {
-        await client.connect();
-        // Initialize git repo
-        const response = await client.callTool('claude_code', {
-            prompt: 'Initialize a git repository and create a README.md file',
-            workFolder: testDir,
-        });
-        expect(existsSync(join(testDir, '.git'))).toBe(true);
-        expect(existsSync(join(testDir, 'README.md'))).toBe(true);
-    });
-});

package/dist/__tests__/edge-cases.test.js

@@ -1,135 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { MCPTestClient } from './utils/mcp-client.js';
-import { getSharedMock, cleanupSharedMock } from './utils/persistent-mock.js';
-describe('Claude Code Edge Cases', () => {
-    let client;
-    let testDir;
-    const serverPath = 'dist/server.js';
-    beforeEach(async () => {
-        // Ensure mock exists
-        await getSharedMock();
-        // Create test directory
-        testDir = mkdtempSync(join(tmpdir(), 'claude-code-edge-'));
-        // Initialize client with custom binary name using absolute path
-        client = new MCPTestClient(serverPath, {
-            MCP_CLAUDE_DEBUG: 'true',
-            CLAUDE_CLI_NAME: '/tmp/claude-code-test-mock/claudeMocked',
-        });
-        await client.connect();
-    });
-    afterEach(async () => {
-        await client.disconnect();
-        rmSync(testDir, { recursive: true, force: true });
-    });
-    afterAll(async () => {
-        // Cleanup mock only at the end
-        await cleanupSharedMock();
-    });
-    describe('Input Validation', () => {
-        it('should reject missing prompt', async () => {
-            await expect(client.callTool('claude_code', {
-                workFolder: testDir,
-            })).rejects.toThrow(/prompt/i);
-        });
-        it('should reject invalid prompt type', async () => {
-            await expect(client.callTool('claude_code', {
-                prompt: 123, // Should be string
-                workFolder: testDir,
-            })).rejects.toThrow();
-        });
-        it('should reject invalid workFolder type', async () => {
-            await expect(client.callTool('claude_code', {
-                prompt: 'Test prompt',
-                workFolder: 123, // Should be string
-            })).rejects.toThrow(/workFolder/i);
-        });
-        it('should reject empty prompt', async () => {
-            await expect(client.callTool('claude_code', {
-                prompt: '',
-                workFolder: testDir,
-            })).rejects.toThrow(/prompt/i);
-        });
-    });
-    describe('Special Characters', () => {
-        it.skip('should handle prompts with quotes', async () => {
-            // Skipping: This test fails in CI when mock is not found at expected path
-            const response = await client.callTool('claude_code', {
-                prompt: 'Create a file with content "Hello \\"World\\""',
-                workFolder: testDir,
-            });
-            expect(response).toBeTruthy();
-        });
-        it('should handle prompts with newlines', async () => {
-            const response = await client.callTool('claude_code', {
-                prompt: 'Create a file with content:\\nLine 1\\nLine 2',
-                workFolder: testDir,
-            });
-            expect(response).toBeTruthy();
-        });
-        it('should handle prompts with shell special characters', async () => {
-            const response = await client.callTool('claude_code', {
-                prompt: 'Create a file named test$file.txt',
-                workFolder: testDir,
-            });
-            expect(response).toBeTruthy();
-        });
-    });
-    describe('Error Recovery', () => {
-        it('should handle Claude CLI not found gracefully', async () => {
-            // Create a client with a different binary name that doesn't exist
-            const errorClient = new MCPTestClient(serverPath, {
-                MCP_CLAUDE_DEBUG: 'true',
-                CLAUDE_CLI_NAME: 'non-existent-claude',
-            });
-            await errorClient.connect();
-            await expect(errorClient.callTool('claude_code', {
-                prompt: 'Test prompt',
-                workFolder: testDir,
-            })).rejects.toThrow();
-            await errorClient.disconnect();
-        });
-        it('should handle permission denied errors', async () => {
-            const restrictedDir = '/root/restricted';
-            // Non-existent directories now throw an error
-            await expect(client.callTool('claude_code', {
-                prompt: 'Test prompt',
-                workFolder: restrictedDir,
-            })).rejects.toThrow(/does not exist/i);
-        });
-    });
-    describe('Concurrent Requests', () => {
-        it('should handle multiple simultaneous requests', async () => {
-            const promises = Array(5).fill(null).map((_, i) => client.callTool('claude_code', {
-                prompt: `Create file test${i}.txt`,
-                workFolder: testDir,
-            }));
-            const results = await Promise.allSettled(promises);
-            const successful = results.filter(r => r.status === 'fulfilled');
-            expect(successful.length).toBeGreaterThan(0);
-        });
-    });
-    describe('Large Prompts', () => {
-        it('should handle very long prompts', async () => {
-            const longPrompt = 'Create a file with content: ' + 'x'.repeat(10000);
-            const response = await client.callTool('claude_code', {
-                prompt: longPrompt,
-                workFolder: testDir,
-            });
-            expect(response).toBeTruthy();
-        });
-    });
-    describe('Path Traversal', () => {
-        it('should prevent path traversal attacks', async () => {
-            const maliciousPath = join(testDir, '..', '..', 'etc', 'passwd');
-            // Server resolves paths and checks existence
-            // The path /etc/passwd may exist but be a file, not a directory
-            await expect(client.callTool('claude_code', {
-                prompt: 'Read file',
-                workFolder: maliciousPath,
-            })).rejects.toThrow(/(does not exist|ENOTDIR)/i);
-        });
-    });
-});