@wonderwhy-er/desktop-commander 0.1.31 → 0.1.32

package/dist/server.js

@@ -1,13 +1,7 @@
 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 { commandManager } from './command-manager.js';
 import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, BlockCommandArgsSchema, UnblockCommandArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, SearchFilesArgsSchema, GetFileInfoArgsSchema, EditBlockArgsSchema, SearchCodeArgsSchema, } from './tools/schemas.js';
-import { executeCommand, readOutput, forceTerminate, listSessions } from './tools/execute.js';
-import { listProcesses, killProcess } from './tools/process.js';
-import { readFile, readMultipleFiles, writeFile, createDirectory, listDirectory, moveFile, searchFiles, getFileInfo, listAllowedDirectories, } from './tools/filesystem.js';
-import { parseEditBlock, performSearchReplace } from './tools/edit.js';
-import { searchTextInFiles } from './tools/search.js';
 import { VERSION } from './version.js';
 import { capture } from "./utils.js";
 export const server = new Server({
@@ -96,10 +90,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             // Filesystem tools
             {
                 name: "read_file",
-                description: "Read the complete contents of a file from the file system. " +
+                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. " +
-                    "Only works within allowed directories.",
+                    "Recognized image types: PNG, JPEG, GIF, WebP.",
                 inputSchema: zodToJsonSchema(ReadFileArgsSchema),
             },
             {
@@ -142,6 +137,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 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),
             },
@@ -150,6 +146,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 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),
             },
@@ -179,331 +176,61 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         ],
     };
 });
+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);
+        // Using a more structured approach with dedicated handlers
         switch (name) {
             // Terminal tools
-            case "execute_command": {
-                capture('server_execute_command');
-                const parsed = ExecuteCommandArgsSchema.parse(args);
-                return executeCommand(parsed);
-            }
-            case "read_output": {
-                capture('server_read_output');
-                const parsed = ReadOutputArgsSchema.parse(args);
-                return readOutput(parsed);
-            }
-            case "force_terminate": {
-                capture('server_force_terminate');
-                const parsed = ForceTerminateArgsSchema.parse(args);
-                return forceTerminate(parsed);
-            }
+            case "execute_command":
+                return handlers.handleExecuteCommand(args);
+            case "read_output":
+                return handlers.handleReadOutput(args);
+            case "force_terminate":
+                return handlers.handleForceTerminate(args);
             case "list_sessions":
-                capture('server_list_sessions');
-                return listSessions();
+                return handlers.handleListSessions();
+            // Process tools
             case "list_processes":
-                capture('server_list_processes');
-                return listProcesses();
-            case "kill_process": {
-                capture('server_kill_process');
-                const parsed = KillProcessArgsSchema.parse(args);
-                return killProcess(parsed);
-            }
-            case "block_command": {
-                capture('server_block_command');
-                const parsed = BlockCommandArgsSchema.parse(args);
-                const blockResult = await commandManager.blockCommand(parsed.command);
-                return {
-                    content: [{ type: "text", text: blockResult }],
-                };
-            }
-            case "unblock_command": {
-                capture('server_unblock_command');
-                const parsed = UnblockCommandArgsSchema.parse(args);
-                const unblockResult = await commandManager.unblockCommand(parsed.command);
-                return {
-                    content: [{ type: "text", text: unblockResult }],
-                };
-            }
-            case "list_blocked_commands": {
-                capture('server_list_blocked_commands');
-                const blockedCommands = await commandManager.listBlockedCommands();
-                return {
-                    content: [{ type: "text", text: blockedCommands.join('\n') }],
-                };
-            }
+                return 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();
             // Filesystem tools
-            case "edit_block": {
-                capture('server_edit_block');
-                try {
-                    const parsed = EditBlockArgsSchema.parse(args);
-                    const { filePath, searchReplace } = await parseEditBlock(parsed.blockContent);
-                    await performSearchReplace(filePath, searchReplace);
-                    return {
-                        content: [{ type: "text", text: `Successfully applied edit to ${filePath}` }],
-                    };
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    capture('server_' + name + "_error");
-                    return {
-                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
-                    };
-                }
-            }
-            case "read_file": {
-                capture('server_read_file');
-                try {
-                    const parsed = ReadFileArgsSchema.parse(args);
-                    // Explicitly cast the result to FileResult since we're passing true
-                    const fileResult = await readFile(parsed.path, true);
-                    if (fileResult.isImage) {
-                        // For image files, return as an image content type
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Image file: ${parsed.path} (${fileResult.mimeType})\n`
-                                },
-                                {
-                                    type: "image",
-                                    data: fileResult.content,
-                                    mimeType: fileResult.mimeType
-                                }
-                            ],
-                        };
-                    }
-                    else {
-                        // For all other files, return as text
-                        capture('server_' + "read_file_error");
-                        return {
-                            content: [{ type: "text", text: fileResult.content }],
-                        };
-                    }
-                }
-                catch (error) {
-                    capture('server_' + name + "_error");
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    return {
-                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
-                    };
-                }
-            }
-            case "read_multiple_files": {
-                capture('server_read_multiple_files');
-                try {
-                    const parsed = ReadMultipleFilesArgsSchema.parse(args);
-                    const fileResults = await readMultipleFiles(parsed.paths);
-                    // Create a text summary of all files
-                    const textSummary = fileResults.map(result => {
-                        if (result.error) {
-                            return `${result.path}: Error - ${result.error}`;
-                        }
-                        else if (result.mimeType) {
-                            return `${result.path}: ${result.mimeType} ${result.isImage ? '(image)' : '(text)'}`;
-                        }
-                        else {
-                            return `${result.path}: Unknown type`;
-                        }
-                    }).join("\n");
-                    // Create content items for each file
-                    const contentItems = [];
-                    // Add the text summary
-                    contentItems.push({ type: "text", text: textSummary });
-                    // Add each file content
-                    for (const result of fileResults) {
-                        if (!result.error && result.content !== undefined) {
-                            if (result.isImage && result.mimeType) {
-                                // For image files, add an image content item
-                                contentItems.push({
-                                    type: "image",
-                                    data: result.content,
-                                    mimeType: result.mimeType
-                                });
-                            }
-                            else {
-                                // For text files, add a text summary
-                                contentItems.push({
-                                    type: "text",
-                                    text: `\n--- ${result.path} contents: ---\n${result.content}`
-                                });
-                            }
-                        }
-                    }
-                    return { content: contentItems };
-                }
-                catch (error) {
-                    capture('server_' + name + "_error");
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    return {
-                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
-                    };
-                }
-            }
-            case "write_file": {
-                capture('server_write_file');
-                try {
-                    const parsed = WriteFileArgsSchema.parse(args);
-                    await writeFile(parsed.path, parsed.content);
-                    return {
-                        content: [{ type: "text", text: `Successfully wrote to ${parsed.path}` }],
-                    };
-                }
-                catch (error) {
-                    capture('server_' + name + "_error");
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    return {
-                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
-                    };
-                }
-            }
-            case "create_directory": {
-                capture('server_create_directory');
-                try {
-                    const parsed = CreateDirectoryArgsSchema.parse(args);
-                    await createDirectory(parsed.path);
-                    return {
-                        content: [{ type: "text", text: `Successfully created directory ${parsed.path}` }],
-                    };
-                }
-                catch (error) {
-                    capture('server_' + name + "_error");
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    return {
-                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
-                    };
-                }
-            }
-            case "list_directory": {
-                capture('server_list_directory');
-                try {
-                    const parsed = ListDirectoryArgsSchema.parse(args);
-                    const entries = await listDirectory(parsed.path);
-                    return {
-                        content: [{ type: "text", text: entries.join('\n') }],
-                    };
-                }
-                catch (error) {
-                    capture('server_' + name + "_error");
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    return {
-                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
-                    };
-                }
-            }
-            case "move_file": {
-                capture('server_move_file');
-                try {
-                    const parsed = MoveFileArgsSchema.parse(args);
-                    await moveFile(parsed.source, parsed.destination);
-                    return {
-                        content: [{ type: "text", text: `Successfully moved ${parsed.source} to ${parsed.destination}` }],
-                    };
-                }
-                catch (error) {
-                    capture('server_' + name + "_error");
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    return {
-                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
-                    };
-                }
-            }
-            case "search_files": {
-                capture('server_search_files');
-                try {
-                    const parsed = SearchFilesArgsSchema.parse(args);
-                    const results = await searchFiles(parsed.path, parsed.pattern);
-                    return {
-                        content: [{ type: "text", text: results.length > 0 ? results.join('\n') : "No matches found" }],
-                    };
-                }
-                catch (error) {
-                    capture('server_' + name + "_error");
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    return {
-                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
-                    };
-                }
-            }
-            case "search_code": {
-                capture('server_search_code');
-                let results = [];
-                try {
-                    const parsed = SearchCodeArgsSchema.parse(args);
-                    results = await searchTextInFiles({
-                        rootPath: parsed.path,
-                        pattern: parsed.pattern,
-                        filePattern: parsed.filePattern,
-                        ignoreCase: parsed.ignoreCase,
-                        maxResults: parsed.maxResults,
-                        includeHidden: parsed.includeHidden,
-                        contextLines: parsed.contextLines,
-                    });
-                    if (results.length === 0) {
-                        return {
-                            content: [{ type: "text", text: "No matches found" }],
-                        };
-                    }
-                }
-                catch (error) {
-                    capture('server_' + name + "_error");
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    return {
-                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
-                    };
-                }
-                // Format the results in a VS Code-like format
-                let currentFile = "";
-                let formattedResults = "";
-                results.forEach(result => {
-                    if (result.file !== currentFile) {
-                        formattedResults += `\n${result.file}:\n`;
-                        currentFile = result.file;
-                    }
-                    formattedResults += `  ${result.line}: ${result.match}\n`;
-                });
-                return {
-                    content: [{ type: "text", text: formattedResults.trim() }],
-                };
-            }
-            case "get_file_info": {
-                capture('server_get_file_info');
-                try {
-                    const parsed = GetFileInfoArgsSchema.parse(args);
-                    const info = await getFileInfo(parsed.path);
-                    return {
-                        content: [{
-                                type: "text",
-                                text: Object.entries(info)
-                                    .map(([key, value]) => `${key}: ${value}`)
-                                    .join('\n')
-                            }],
-                    };
-                }
-                catch (error) {
-                    capture('server_' + name + "_error");
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    return {
-                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
-                    };
-                }
-            }
-            case "list_allowed_directories": {
-                capture('server_list_allowed_directories');
-                const directories = listAllowedDirectories();
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Allowed directories:\n${directories.join('\n')}`
-                        }],
-                };
-            }
+            case "read_file":
+                return handlers.handleReadFile(args);
+            case "read_multiple_files":
+                return handlers.handleReadMultipleFiles(args);
+            case "write_file":
+                return handlers.handleWriteFile(args);
+            case "create_directory":
+                return handlers.handleCreateDirectory(args);
+            case "list_directory":
+                return handlers.handleListDirectory(args);
+            case "move_file":
+                return handlers.handleMoveFile(args);
+            case "search_files":
+                return handlers.handleSearchFiles(args);
+            case "search_code":
+                return handlers.handleSearchCode(args);
+            case "get_file_info":
+                return handlers.handleGetFileInfo(args);
+            case "list_allowed_directories":
+                return handlers.handleListAllowedDirectories();
+            case "edit_block":
+                return handlers.handleEditBlock(args);
             default:
-                capture('server_unknow_tool', {
-                    name
-                });
+                capture('server_unknown_tool', { name });
                 throw new Error(`Unknown tool: ${name}`);
         }
     }

package/dist/setup-claude-server.js

@@ -15,7 +15,7 @@ try {
     const machineIdModule = await import('node-machine-id');
     
     client = new PostHog(
-        'phc_TFQqTkCwtFGxlwkXDY3gSs7uvJJcJu8GurfXd6mV063',
+        'phc_BW8KJ0cajzj2v8qfMhvDQ4dtFdgHPzeYcMRvRFGvQdH',
         { 
             host: 'https://eu.i.posthog.com',
             flushAt: 1, // send all every time

package/dist/tools/filesystem.d.ts

@@ -13,7 +13,28 @@ export interface FileResult {
     mimeType: string;
     isImage: boolean;
 }
-export declare function readFile(filePath: string, returnMetadata?: boolean): Promise<string | FileResult>;
+/**
+ * Read file content from a URL
+ * @param url URL to fetch content from
+ * @param returnMetadata Whether to return metadata with the content
+ * @returns File content or file result with metadata
+ */
+export declare function readFileFromUrl(url: string, returnMetadata?: boolean): Promise<string | FileResult>;
+/**
+ * Read file content from the local filesystem
+ * @param filePath Path to the file
+ * @param returnMetadata Whether to return metadata with the content
+ * @returns File content or file result with metadata
+ */
+export declare function readFileFromDisk(filePath: string, returnMetadata?: boolean): Promise<string | FileResult>;
+/**
+ * Read a file from either the local filesystem or a URL
+ * @param filePath Path to the file or URL
+ * @param returnMetadata Whether to return metadata with the content
+ * @param isUrl Whether the path is a URL
+ * @returns File content or file result with metadata
+ */
+export declare function readFile(filePath: string, returnMetadata?: boolean, isUrl?: boolean): Promise<string | FileResult>;
 export declare function writeFile(filePath: string, content: string): Promise<void>;
 export interface MultiFileResult {
     path: string;