@wonderwhy-er/desktop-commander 0.1.34 → 0.1.36

package/dist/sandbox/mac-sandbox.js

@@ -0,0 +1,174 @@
+import { spawn } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+/**
+ * Generate a temporary sandbox profile for macOS that restricts access to allowed directories
+ * @param allowedDirectories Array of directories that should be accessible
+ * @returns Path to the generated sandbox profile file
+ */
+export async function generateSandboxProfile(allowedDirectories) {
+    // Create a temporary directory for the sandbox profile
+    const tempDir = path.join(os.tmpdir(), 'claude-server-sandbox');
+    // Ensure temp directory exists
+    try {
+        // Check if directory exists first
+        try {
+            await fs.access(tempDir);
+            console.log(`Temp directory exists: ${tempDir}`);
+        }
+        catch {
+            // Directory doesn't exist, create it
+            console.log(`Creating temp directory: ${tempDir}`);
+            await fs.mkdir(tempDir, { recursive: true });
+            console.log(`Temp directory created: ${tempDir}`);
+        }
+    }
+    catch (error) {
+        console.error('Error creating temp directory for sandbox:', error);
+        throw new Error(`Failed to create sandbox temp directory: ${error}`);
+    }
+    // Create the sandbox profile content - based on our tests, we need a simpler approach
+    // that just allows by default and then adds specific permissions for allowed directories
+    // Use a more restrictive approach - deny all file access, then explicitly allow only what we need
+    let profileContent = `(version 1)
+(debug deny)
+(allow default)
+(deny file-read* file-write*)
+`;
+    // Add explicit permissions for allowed directories
+    for (const dir of allowedDirectories) {
+        // Ensure path is absolute
+        const absPath = path.resolve(dir);
+        profileContent += `(allow file-read* file-write* (subpath "${absPath}"))\n`;
+    }
+    // Add system paths needed for basic command execution
+    profileContent += `
+(allow file-read* (subpath "/usr"))
+(allow file-read* (subpath "/bin"))
+(allow file-read* (subpath "/sbin"))
+(allow file-read* (subpath "/Library"))
+(allow file-read* (subpath "/System"))
+(allow file-read* (subpath "/tmp"))
+(allow file-read* (subpath "/dev"))
+(allow file-read* (subpath "/etc"))
+(allow file-read* (subpath "${os.homedir()}/.zshrc"))
+(allow file-read* (subpath "${os.homedir()}/.bash_profile"))
+(allow file-read* (subpath "${os.homedir()}/.bashrc"))
+(allow process-exec)
+(allow process-fork)
+(allow mach-lookup)
+(allow network-outbound)
+(allow system-socket)
+(allow sysctl-read)
+`;
+    // Add comment for debugging
+    profileContent += `\n; Allowed directories: ${allowedDirectories.join(', ')}\n`;
+    // Write the profile to a temporary file
+    const profilePath = path.join(tempDir, 'sandbox-profile.sb');
+    try {
+        // Write the profile with verbose logging
+        console.log(`Writing sandbox profile to: ${profilePath}`);
+        await fs.writeFile(profilePath, profileContent, 'utf-8');
+        // Verify the file was created
+        await fs.access(profilePath);
+        console.log(`Sandbox profile created successfully`);
+        // Log the profile content for debugging
+        console.log(`Sandbox profile content:\n${profileContent}`);
+        return profilePath;
+    }
+    catch (error) {
+        console.error(`Error creating sandbox profile at ${profilePath}:`, error);
+        throw new Error(`Failed to create sandbox profile: ${error}`);
+    }
+}
+/**
+ * Execute a command in a macOS sandbox with access restricted to allowed directories
+ * @param command Command to execute
+ * @param allowedDirectories Array of allowed directory paths
+ * @param options Additional execution options
+ * @returns Promise resolving to the execution result
+ */
+export async function executeSandboxedCommand(command, allowedDirectories, timeoutMs = 30000) {
+    try {
+        // Generate the sandbox profile
+        const profilePath = await generateSandboxProfile(allowedDirectories);
+        // Create a wrapper script that will perform additional path checks
+        // This is a belt-and-suspenders approach since our tests show the sandbox
+        // doesn't perfectly restrict access to only allowed directories
+        const wrapperScriptPath = path.join(os.tmpdir(), `claude-sandbox-wrapper-${Date.now()}.sh`);
+        // Generate a script that does additional path validation
+        // This will extract file paths from the command and verify they're in allowed directories
+        const wrapperScript = `#!/bin/sh
+# Wrapper script for sandboxed execution
+# Only allows access to specific directories: ${allowedDirectories.join(', ')}
+
+# The actual command to run
+COMMAND="${command.replace(/"/g, '\\"')}"
+
+# Run the command in sandbox
+sandbox-exec -f "${profilePath}" /bin/sh -c "$COMMAND"
+EXIT_CODE=$?
+
+# Return the exit code from the sandbox
+exit $EXIT_CODE
+`;
+        // Write the wrapper script
+        await fs.writeFile(wrapperScriptPath, wrapperScript, { mode: 0o755 });
+        // Log what we're doing
+        console.log(`Executing sandboxed command via wrapper script`);
+        console.log(`Command: ${command}`);
+        console.log(`Allowed directories: ${allowedDirectories.join(', ')}`);
+        // Execute the wrapper script
+        const process = spawn(wrapperScriptPath, []);
+        let output = '';
+        let isBlocked = false;
+        // Set up timeout
+        const timeoutId = setTimeout(() => {
+            isBlocked = true;
+        }, timeoutMs);
+        // Handle output
+        process.stdout.on('data', (data) => {
+            const text = data.toString();
+            console.log(`Sandbox stdout: ${text}`);
+            output += text;
+        });
+        process.stderr.on('data', (data) => {
+            const text = data.toString();
+            console.log(`Sandbox stderr: ${text}`);
+            output += text;
+        });
+        // Return a promise that resolves when the process exits
+        return new Promise((resolve) => {
+            process.on('exit', (code) => {
+                clearTimeout(timeoutId);
+                console.log(`Sandbox process exited with code: ${code}`);
+                // Clean up the temporary files
+                Promise.all([
+                    fs.unlink(profilePath).catch(err => {
+                        console.error('Error removing temporary sandbox profile:', err);
+                    }),
+                    fs.unlink(wrapperScriptPath).catch(err => {
+                        console.error('Error removing temporary wrapper script:', err);
+                    })
+                ]).finally(() => {
+                    resolve({
+                        output,
+                        exitCode: code,
+                        isBlocked,
+                        pid: process.pid || -1
+                    });
+                });
+            });
+        });
+    }
+    catch (error) {
+        console.error('Error in sandbox execution:', error);
+        return {
+            output: `Sandbox execution error: ${error instanceof Error ? error.message : String(error)}`,
+            exitCode: 1,
+            isBlocked: false,
+            pid: -1
+        };
+    }
+}

package/dist/server.js

@@ -1,9 +1,13 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListPromptsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, BlockCommandArgsSchema, UnblockCommandArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, SearchFilesArgsSchema, GetFileInfoArgsSchema, EditBlockArgsSchema, SearchCodeArgsSchema, } from './tools/schemas.js';
+// Shared constants for tool descriptions
+const PATH_GUIDANCE = `IMPORTANT: Always use absolute paths (starting with '/' or drive letter like 'C:\\') for reliability. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.`;
+import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, SearchFilesArgsSchema, GetFileInfoArgsSchema, SearchCodeArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, EditBlockArgsSchema, } from './tools/schemas.js';
+import { getConfig, setConfigValue } from './tools/config.js';
 import { VERSION } from './version.js';
-import { capture } from "./utils.js";
+import { capture } from "./utils/capture.js";
+console.error("Loading server.ts");
 export const server = new Server({
     name: "desktop-commander",
     version: VERSION,
@@ -28,207 +32,208 @@ server.setRequestHandler(ListPromptsRequestSchema, async () => {
         prompts: [],
     };
 });
+console.error("Setting up request handlers...");
 server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-        tools: [
-            // Terminal tools
-            {
-                name: "execute_command",
-                description: "Execute a terminal command with timeout. Command will continue running in background if it doesn't complete within timeout.",
-                inputSchema: zodToJsonSchema(ExecuteCommandArgsSchema),
-            },
-            {
-                name: "read_output",
-                description: "Read new output from a running terminal session.",
-                inputSchema: zodToJsonSchema(ReadOutputArgsSchema),
-            },
-            {
-                name: "force_terminate",
-                description: "Force terminate a running terminal session.",
-                inputSchema: zodToJsonSchema(ForceTerminateArgsSchema),
-            },
-            {
-                name: "list_sessions",
-                description: "List all active terminal sessions.",
-                inputSchema: zodToJsonSchema(ListSessionsArgsSchema),
-            },
-            {
-                name: "list_processes",
-                description: "List all running processes. Returns process information including PID, " +
-                    "command name, CPU usage, and memory usage.",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
-                    required: [],
-                },
-            },
-            {
-                name: "kill_process",
-                description: "Terminate a running process by PID. Use with caution as this will " +
-                    "forcefully terminate the specified process.",
-                inputSchema: zodToJsonSchema(KillProcessArgsSchema),
-            },
-            {
-                name: "block_command",
-                description: "Add a command to the blacklist. Once blocked, the command cannot be executed until unblocked.",
-                inputSchema: zodToJsonSchema(BlockCommandArgsSchema),
-            },
-            {
-                name: "unblock_command",
-                description: "Remove a command from the blacklist. Once unblocked, the command can be executed normally.",
-                inputSchema: zodToJsonSchema(UnblockCommandArgsSchema),
-            },
-            {
-                name: "list_blocked_commands",
-                description: "List all currently blocked commands.",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
-                    required: [],
-                },
-            },
-            // Filesystem tools
-            {
-                name: "read_file",
-                description: "Read the complete contents of a file from the file system or a URL. " +
-                    "When reading from the file system, only works within allowed directories. " +
-                    "Can fetch content from URLs when isUrl parameter is set to true. " +
-                    "Handles text files normally and image files are returned as viewable images. " +
-                    "Recognized image types: PNG, JPEG, GIF, WebP.",
-                inputSchema: zodToJsonSchema(ReadFileArgsSchema),
-            },
-            {
-                name: "read_multiple_files",
-                description: "Read the contents of multiple files simultaneously. " +
-                    "Each file's content is returned with its path as a reference. " +
-                    "Handles text files normally and renders images as viewable content. " +
-                    "Recognized image types: PNG, JPEG, GIF, WebP. " +
-                    "Failed reads for individual files won't stop the entire operation. " +
-                    "Only works within allowed directories.",
-                inputSchema: zodToJsonSchema(ReadMultipleFilesArgsSchema),
-            },
-            {
-                name: "write_file",
-                description: "Completely replace file contents. Best for large changes (>20% of file) or when edit_block fails. " +
-                    "Use with caution as it will overwrite existing files. Only works within allowed directories.",
-                inputSchema: zodToJsonSchema(WriteFileArgsSchema),
-            },
-            {
-                name: "create_directory",
-                description: "Create a new directory or ensure a directory exists. Can create multiple " +
-                    "nested directories in one operation. Only works within allowed directories.",
-                inputSchema: zodToJsonSchema(CreateDirectoryArgsSchema),
-            },
-            {
-                name: "list_directory",
-                description: "Get a detailed listing of all files and directories in a specified path. " +
-                    "Results distinguish between files and directories with [FILE] and [DIR] prefixes. " +
-                    "Only works within allowed directories.",
-                inputSchema: zodToJsonSchema(ListDirectoryArgsSchema),
-            },
-            {
-                name: "move_file",
-                description: "Move or rename files and directories. Can move files between directories " +
-                    "and rename them in a single operation. Both source and destination must be " +
-                    "within allowed directories.",
-                inputSchema: zodToJsonSchema(MoveFileArgsSchema),
-            },
-            {
-                name: "search_files",
-                description: "Finds files by name using a case-insensitive substring matching. " +
-                    "Searches through all subdirectories from the starting path. " +
-                    "Has a default timeout of 30 seconds which can be customized using the timeoutMs parameter. " +
-                    "Only searches within allowed directories.",
-                inputSchema: zodToJsonSchema(SearchFilesArgsSchema),
-            },
-            {
-                name: "search_code",
-                description: "Search for text/code patterns within file contents using ripgrep. " +
-                    "Fast and powerful search similar to VS Code search functionality. " +
-                    "Supports regular expressions, file pattern filtering, and context lines. " +
-                    "Has a default timeout of 30 seconds which can be customized. " +
-                    "Only searches within allowed directories.",
-                inputSchema: zodToJsonSchema(SearchCodeArgsSchema),
-            },
-            {
-                name: "get_file_info",
-                description: "Retrieve detailed metadata about a file or directory including size, " +
-                    "creation time, last modified time, permissions, and type. " +
-                    "Only works within allowed directories.",
-                inputSchema: zodToJsonSchema(GetFileInfoArgsSchema),
-            },
-            {
-                name: "list_allowed_directories",
-                description: "Returns the list of directories that this server is allowed to access.",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
-                    required: [],
-                },
-            },
-            {
-                name: "edit_block",
-                description: "Apply surgical text replacements to files. Best for small changes (<20% of file size). " +
-                    "Call repeatedly to change multiple blocks. Will verify changes after application. " +
-                    "Format:\nfilepath\n<<<<<<< SEARCH\ncontent to find\n=======\nnew content\n>>>>>>> REPLACE",
-                inputSchema: zodToJsonSchema(EditBlockArgsSchema),
-            },
-        ],
-    };
+    try {
+        console.error("Generating tools list...");
+        return {
+            tools: [
+                // Configuration tools
+                {
+                    name: "get_config",
+                    description: "Get the complete server configuration as JSON. Config includes fields for: blockedCommands (array of blocked shell commands), defaultShell (shell to use for commands), allowedDirectories (paths the server can access).",
+                    inputSchema: zodToJsonSchema(GetConfigArgsSchema),
+                },
+                {
+                    name: "set_config_value",
+                    description: "Set a specific configuration value by key. WARNING: Should be used in a separate chat from file operations and command execution to prevent security issues. Config keys include: blockedCommands (array), defaultShell (string), allowedDirectories (array of paths). IMPORTANT: Setting allowedDirectories to an empty array ([]) allows full access to the entire file system, regardless of the operating system.",
+                    inputSchema: zodToJsonSchema(SetConfigValueArgsSchema),
+                },
+                // Filesystem tools
+                {
+                    name: "read_file",
+                    description: `Read the complete contents of a file from the file system or a URL. Prefer this over 'execute_command' with cat/type for viewing files. When reading from the file system, only works within allowed directories. Can fetch content from URLs when isUrl parameter is set to true. Handles text files normally and image files are returned as viewable images. Recognized image types: PNG, JPEG, GIF, WebP. ${PATH_GUIDANCE}`,
+                    inputSchema: zodToJsonSchema(ReadFileArgsSchema),
+                },
+                {
+                    name: "read_multiple_files",
+                    description: `Read the contents of multiple files simultaneously. Each file's content is returned with its path as a reference. Handles text files normally and renders images as viewable content. Recognized image types: PNG, JPEG, GIF, WebP. Failed reads for individual files won't stop the entire operation. Only works within allowed directories. ${PATH_GUIDANCE}`,
+                    inputSchema: zodToJsonSchema(ReadMultipleFilesArgsSchema),
+                },
+                {
+                    name: "write_file",
+                    description: `Completely replace file contents. Best for large changes (>20% of file) or when edit_block fails. Use with caution as it will overwrite existing files. Only works within allowed directories. ${PATH_GUIDANCE}`,
+                    inputSchema: zodToJsonSchema(WriteFileArgsSchema),
+                },
+                {
+                    name: "create_directory",
+                    description: `Create a new directory or ensure a directory exists. Can create multiple nested directories in one operation. Only works within allowed directories. ${PATH_GUIDANCE}`,
+                    inputSchema: zodToJsonSchema(CreateDirectoryArgsSchema),
+                },
+                {
+                    name: "list_directory",
+                    description: `Get a detailed listing of all files and directories in a specified path. Use this instead of 'execute_command' with ls/dir commands. Results distinguish between files and directories with [FILE] and [DIR] prefixes. Only works within allowed directories. ${PATH_GUIDANCE}`,
+                    inputSchema: zodToJsonSchema(ListDirectoryArgsSchema),
+                },
+                {
+                    name: "move_file",
+                    description: `Move or rename files and directories. 
+                        Can move files between directories and rename them in a single operation. 
+                        Both source and destination must be within allowed directories. ${PATH_GUIDANCE}`,
+                    inputSchema: zodToJsonSchema(MoveFileArgsSchema),
+                },
+                {
+                    name: "search_files",
+                    description: `Finds files by name using a case-insensitive substring matching. 
+                        Use this instead of 'execute_command' with find/dir/ls for locating files.
+                        Searches through all subdirectories from the starting path. 
+                        Has a default timeout of 30 seconds which can be customized using the timeoutMs parameter. 
+                        Only searches within allowed directories. ${PATH_GUIDANCE}`,
+                    inputSchema: zodToJsonSchema(SearchFilesArgsSchema),
+                },
+                {
+                    name: "search_code",
+                    description: `Search for text/code patterns within file contents using ripgrep. 
+                        Use this instead of 'execute_command' with grep/find for searching code content.
+                        Fast and powerful search similar to VS Code search functionality. 
+                        Supports regular expressions, file pattern filtering, and context lines. 
+                        Has a default timeout of 30 seconds which can be customized. 
+                        Only searches within allowed directories. 
+                        ${PATH_GUIDANCE}`,
+                    inputSchema: zodToJsonSchema(SearchCodeArgsSchema),
+                },
+                {
+                    name: "get_file_info",
+                    description: `Retrieve detailed metadata about a file or directory including size, creation time, last modified time, 
+                        permissions, and type. 
+                        Only works within allowed directories. ${PATH_GUIDANCE}`,
+                    inputSchema: zodToJsonSchema(GetFileInfoArgsSchema),
+                },
+                // Note: list_allowed_directories removed - use get_config to check allowedDirectories
+                // Text editing tools
+                {
+                    name: "edit_block",
+                    description: `Apply surgical text replacements to files. 
+                        BEST PRACTICE: Make multiple small, focused edits rather than one large edit. 
+                        Each edit_block call should change only what needs to be changed - include just enough context to uniquely identify the text being modified. 
+                        Takes file_path, old_string (text to replace), new_string (replacement text), and optional expected_replacements parameter. 
+                        By default, replaces only ONE occurrence of the search text. 
+                        To replace multiple occurrences, provide the expected_replacements parameter with the exact number of matches expected. 
+                        UNIQUENESS REQUIREMENT: When expected_replacements=1 (default), include the minimal amount of context necessary (typically 1-3 lines) before and after the change point, with exact whitespace and indentation. 
+                        When editing multiple sections, make separate edit_block calls for each distinct change rather than one large replacement. 
+                        When a close but non-exact match is found, a character-level diff is shown in the format: common_prefix{-removed-}{+added+}common_suffix to help you identify what's different. 
+                        ${PATH_GUIDANCE}`,
+                    inputSchema: zodToJsonSchema(EditBlockArgsSchema),
+                },
+                // Terminal tools
+                {
+                    name: "execute_command",
+                    description: `Execute a terminal command with timeout. 
+                        Command will continue running in background if it doesn't complete within timeout. 
+                        NOTE: For file operations, prefer specialized tools like read_file, search_code, list_directory instead of cat, grep, or ls commands.
+                        ${PATH_GUIDANCE}`,
+                    inputSchema: zodToJsonSchema(ExecuteCommandArgsSchema),
+                },
+                {
+                    name: "read_output",
+                    description: "Read new output from a running terminal session.",
+                    inputSchema: zodToJsonSchema(ReadOutputArgsSchema),
+                },
+                {
+                    name: "force_terminate",
+                    description: "Force terminate a running terminal session.",
+                    inputSchema: zodToJsonSchema(ForceTerminateArgsSchema),
+                },
+                {
+                    name: "list_sessions",
+                    description: "List all active terminal sessions.",
+                    inputSchema: zodToJsonSchema(ListSessionsArgsSchema),
+                },
+                {
+                    name: "list_processes",
+                    description: "List all running processes. Returns process information including PID, command name, CPU usage, and memory usage.",
+                    inputSchema: zodToJsonSchema(ListProcessesArgsSchema),
+                },
+                {
+                    name: "kill_process",
+                    description: "Terminate a running process by PID. Use with caution as this will forcefully terminate the specified process.",
+                    inputSchema: zodToJsonSchema(KillProcessArgsSchema),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error in list_tools request handler:", error);
+        throw error;
+    }
 });
 import * as handlers from './handlers/index.js';
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         const { name, arguments: args } = request.params;
-        capture('server_call_tool');
-        // Add a single dynamic capture for the specific tool
-        capture('server_' + name);
+        capture('server_call_tool', {
+            name
+        });
         // Using a more structured approach with dedicated handlers
         switch (name) {
+            // Config tools
+            case "get_config":
+                try {
+                    return await getConfig();
+                }
+                catch (error) {
+                    capture('server_request_error', { message: `Error in get_config handler: ${error}` });
+                    return {
+                        content: [{ type: "text", text: `Error: Failed to get configuration` }],
+                        isError: true,
+                    };
+                }
+            case "set_config_value":
+                try {
+                    return await setConfigValue(args);
+                }
+                catch (error) {
+                    capture('server_request_error', { message: `Error in set_config_value handler: ${error}` });
+                    return {
+                        content: [{ type: "text", text: `Error: Failed to set configuration value` }],
+                        isError: true,
+                    };
+                }
             // Terminal tools
             case "execute_command":
-                return handlers.handleExecuteCommand(args);
+                return await handlers.handleExecuteCommand(args);
             case "read_output":
-                return handlers.handleReadOutput(args);
+                return await handlers.handleReadOutput(args);
             case "force_terminate":
-                return handlers.handleForceTerminate(args);
+                return await handlers.handleForceTerminate(args);
             case "list_sessions":
-                return handlers.handleListSessions();
+                return await handlers.handleListSessions();
             // Process tools
             case "list_processes":
-                return handlers.handleListProcesses();
+                return await handlers.handleListProcesses();
             case "kill_process":
-                return handlers.handleKillProcess(args);
-            // Command management tools
-            case "block_command":
-                return handlers.handleBlockCommand(args);
-            case "unblock_command":
-                return handlers.handleUnblockCommand(args);
-            case "list_blocked_commands":
-                return handlers.handleListBlockedCommands();
+                return await handlers.handleKillProcess(args);
             // Filesystem tools
             case "read_file":
-                return handlers.handleReadFile(args);
+                return await handlers.handleReadFile(args);
             case "read_multiple_files":
-                return handlers.handleReadMultipleFiles(args);
+                return await handlers.handleReadMultipleFiles(args);
             case "write_file":
-                return handlers.handleWriteFile(args);
+                return await handlers.handleWriteFile(args);
             case "create_directory":
-                return handlers.handleCreateDirectory(args);
+                return await handlers.handleCreateDirectory(args);
             case "list_directory":
-                return handlers.handleListDirectory(args);
+                return await handlers.handleListDirectory(args);
             case "move_file":
-                return handlers.handleMoveFile(args);
+                return await handlers.handleMoveFile(args);
             case "search_files":
-                return handlers.handleSearchFiles(args);
+                return await handlers.handleSearchFiles(args);
             case "search_code":
-                return handlers.handleSearchCode(args);
+                return await handlers.handleSearchCode(args);
             case "get_file_info":
-                return handlers.handleGetFileInfo(args);
-            case "list_allowed_directories":
-                return handlers.handleListAllowedDirectories();
+                return await handlers.handleGetFileInfo(args);
             case "edit_block":
-                return handlers.handleEditBlock(args);
+                return await handlers.handleEditBlock(args);
             default:
                 capture('server_unknown_tool', { name });
                 return {