@wonderwhy-er/desktop-commander 0.1.30 → 0.1.32

package/README.md

@@ -7,7 +7,7 @@
 
 [![Discord](https://img.shields.io/badge/Join%20Discord-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/kQ27sNnZr7)
 
-Short version. Two key things. Terminal commands and diff based file editing.
+Short version. Four key things. Terminal commands, diff based file editing, ripgrep based text search in folders, ability to read files from urls 
 
 
 ![Desktop Commander MCP](https://raw.githubusercontent.com/wonderwhy-er/ClaudeComputerCommander/main/header.png)
@@ -63,7 +63,14 @@ npx @wonderwhy-er/desktop-commander@latest setup --debug
 ```
 Restart Claude if running
 
-### Option 2: Installing via Smithery
+### Option 2: Using bash script installer (macOS)
+For macOS users, you can use our automated bash installer which will check your Node.js version, install it if needed, and automatically configure Desktop Commander:
+```
+curl -fsSL https://raw.githubusercontent.com/wonderwhy-er/DesktopCommanderMCP/refs/heads/main/install.sh | bash
+```
+This script handles all dependencies and configuration automatically for a seamless setup experience.
+
+### Option 3: Installing via Smithery
 
 To install Desktop Commander for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@wonderwhy-er/desktop-commander):
 
@@ -71,7 +78,7 @@ To install Desktop Commander for Claude Desktop automatically via [Smithery](htt
 npx -y @smithery/cli install @wonderwhy-er/desktop-commander --client claude
 ```
 
-### Option 3: Add to claude_desktop_config by hand
+### Option 4: Add to claude_desktop_config by hand
 Add this entry to your claude_desktop_config.json:
 
 - On Mac: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
@@ -93,7 +100,7 @@ Add this entry to your claude_desktop_config.json:
 ```
 Restart Claude if running
 
-### Option 4: Checkout locally
+### Option 5: Checkout locally
 1. Clone and build:
 ```bash
 git clone https://github.com/wonderwhy-er/ClaudeComputerCommander.git
@@ -108,6 +115,12 @@ The setup command will:
 - Configure Claude's desktop app
 - Add MCP servers to Claude's config if needed
 
+### Updating Desktop Commander
+
+When installed through npx (Option 1) or Smithery (Option 2), Desktop Commander will automatically update to the latest version whenever you restart Claude. No manual update process is needed.
+
+For manual installations, you can update by running the setup command again.
+
 ## Usage
 
 The server provides these tool categories:
@@ -122,7 +135,7 @@ The server provides these tool categories:
 - `block_command`/`unblock_command`: Manage command blacklist
 
 ### Filesystem Tools
-- `read_file`/`write_file`: File operations
+- `read_file`/`write_file`: Read files from local filesystem or URLs (supports viewing PNG, JPEG, GIF, and WebP images directly in Claude)
 - `create_directory`/`list_directory`: Directory management  
 - `move_file`: Move/rename files
 - `search_files`: Pattern-based file search
@@ -153,6 +166,14 @@ console.log("new message");
 >>>>>>> REPLACE
 ```
 
+### URL Support
+- `read_file` can now fetch content from both local files and URLs
+- Example: `read_file` with `isUrl: true` parameter to read from web resources
+- Handles both text and image content from remote sources
+- Images (local or from URLs) are displayed visually in Claude's interface, not as text
+- Claude can see and analyze the actual image content
+- Default 30-second timeout for URL requests
+
 ## Handling Long-Running Commands
 
 For commands that may take a while:
@@ -208,6 +229,7 @@ This project extends the MCP Filesystem Server to enable:
 Created as part of exploring Claude MCPs: https://youtube.com/live/TlbjFDbl5Us
 
 ## DONE
+- **07-04-2025 Added URL support** - `read_file` command can now fetch content from URLs
 - **28-03-2025 Fixed "Watching /" JSON error** - Implemented custom stdio transport to handle non-JSON messages and prevent server crashes
 - **25-03-2025 Better code search** ([merged](https://github.com/wonderwhy-er/ClaudeDesktopCommander/pull/17)) - Enhanced code exploration with context-aware results
 
@@ -252,7 +274,7 @@ Join our [Discord server](https://discord.gg/kQ27sNnZr7) to get help, share feed
 https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgztdHvDMqTb9jiqnf54AaABAg](https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgztdHvDMqTb9jiqnf54AaABAg
 )
 
-[![Great! I just used Windsurf, bought license a week ago, for upgrading old fullstack socket project and it works many times good or ok but also many times runs away in cascade and have to revert all changes loosing hundereds of cascade tokens. In just a week down to less than 100 tokens and do not want to buy only 300 tokens for 10$. This Claude MCP ,bought claude Pro finally needed but wanted very good reason to also have next to ChatGPT, and now can code as much as I want not worrying about token cost.
+[![Great! I just used Windsurf, bought license a week ago, for upgrading old fullstack socket project and it works many times good or ok but also many times runs away in cascade and have to revert all changes losing hundereds of cascade tokens. In just a week down to less than 100 tokens and do not want to buy only 300 tokens for 10$. This Claude MCP ,bought claude Pro finally needed but wanted very good reason to also have next to ChatGPT, and now can code as much as I want not worrying about token cost.
 Also this is much more than code editing it is much more thank you for great video!](https://raw.githubusercontent.com/wonderwhy-er/ClaudeComputerCommander/main/testemonials/img_2.png)
 https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgyQFTmYLJ4VBwIlmql4AaABAg](https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgyQFTmYLJ4VBwIlmql4AaABAg)
 
@@ -293,6 +315,9 @@ Unlike IDE-focused tools, Claude Desktop Commander provides a solution-centric a
 ### Do I need to pay for API credits?
 No. This tool works with Claude Desktop's standard Pro subscription ($20/month), not with API calls, so you won't incur additional costs beyond the subscription fee.
 
+### Does Desktop Commander automatically update?
+Yes, when installed through npx or Smithery, Desktop Commander automatically updates to the latest version when you restart Claude. No manual update process is needed.
+
 ### What are the most common use cases?
 - Exploring and understanding complex codebases
 - Generating diagrams and documentation

package/dist/handlers/command-handlers.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Handle block_command command
+ */
+export declare function handleBlockCommand(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: boolean;
+    }[];
+}>;
+/**
+ * Handle unblock_command command
+ */
+export declare function handleUnblockCommand(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: boolean;
+    }[];
+}>;
+/**
+ * Handle list_blocked_commands command
+ */
+export declare function handleListBlockedCommands(): {
+    content: {
+        type: string;
+        text: string;
+    }[];
+};

package/dist/handlers/command-handlers.js

@@ -0,0 +1,31 @@
+import { commandManager } from '../command-manager.js';
+import { BlockCommandArgsSchema, UnblockCommandArgsSchema } from '../tools/schemas.js';
+/**
+ * Handle block_command command
+ */
+export async function handleBlockCommand(args) {
+    const parsed = BlockCommandArgsSchema.parse(args);
+    const blockResult = await commandManager.blockCommand(parsed.command);
+    return {
+        content: [{ type: "text", text: blockResult }],
+    };
+}
+/**
+ * Handle unblock_command command
+ */
+export async function handleUnblockCommand(args) {
+    const parsed = UnblockCommandArgsSchema.parse(args);
+    const unblockResult = await commandManager.unblockCommand(parsed.command);
+    return {
+        content: [{ type: "text", text: unblockResult }],
+    };
+}
+/**
+ * Handle list_blocked_commands command
+ */
+export function handleListBlockedCommands() {
+    const blockedCommands = commandManager.listBlockedCommands();
+    return {
+        content: [{ type: "text", text: blockedCommands.join('\n') }],
+    };
+}

package/dist/handlers/edit-search-handlers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Handle edit_block command
+ */
+export declare function handleEditBlock(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+/**
+ * Handle search_code command
+ */
+export declare function handleSearchCode(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/handlers/edit-search-handlers.js

@@ -0,0 +1,72 @@
+import { parseEditBlock, performSearchReplace } from '../tools/edit.js';
+import { searchTextInFiles } from '../tools/search.js';
+import { EditBlockArgsSchema, SearchCodeArgsSchema } from '../tools/schemas.js';
+import { withTimeout } from '../utils.js';
+/**
+ * Handle edit_block command
+ */
+export async function handleEditBlock(args) {
+    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}` }],
+    };
+}
+/**
+ * Handle search_code command
+ */
+export async function handleSearchCode(args) {
+    const parsed = SearchCodeArgsSchema.parse(args);
+    const timeoutMs = parsed.timeoutMs || 30000; // 30 seconds default
+    // Apply timeout at the handler level
+    const searchOperation = async () => {
+        return await searchTextInFiles({
+            rootPath: parsed.path,
+            pattern: parsed.pattern,
+            filePattern: parsed.filePattern,
+            ignoreCase: parsed.ignoreCase,
+            maxResults: parsed.maxResults,
+            includeHidden: parsed.includeHidden,
+            contextLines: parsed.contextLines,
+            // Don't pass timeoutMs down to the implementation
+        });
+    };
+    // Use withTimeout at the handler level
+    const results = await withTimeout(searchOperation(), timeoutMs, 'Code search operation', [] // Empty array as default on timeout
+    );
+    // If timeout occurred, try to terminate the ripgrep process
+    if (results.length === 0 && globalThis.currentSearchProcess) {
+        try {
+            console.log(`Terminating timed out search process (PID: ${globalThis.currentSearchProcess.pid})`);
+            globalThis.currentSearchProcess.kill();
+            delete globalThis.currentSearchProcess;
+        }
+        catch (error) {
+            console.error('Error terminating search process:', error);
+        }
+    }
+    if (results.length === 0) {
+        if (timeoutMs > 0) {
+            return {
+                content: [{ type: "text", text: `No matches found or search timed out after ${timeoutMs}ms.` }],
+            };
+        }
+        return {
+            content: [{ type: "text", text: "No matches found" }],
+        };
+    }
+    // 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() }],
+    };
+}

package/dist/handlers/filesystem-handlers.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Handle read_file command
+ */
+export declare function handleReadFile(args: unknown): Promise<{
+    content: ({
+        type: string;
+        text: string;
+        data?: undefined;
+        mimeType?: undefined;
+    } | {
+        type: string;
+        data: string;
+        mimeType: string;
+        text?: undefined;
+    })[];
+}>;
+/**
+ * Handle read_multiple_files command
+ */
+export declare function handleReadMultipleFiles(args: unknown): Promise<{
+    content: {
+        type: string;
+        text?: string;
+        data?: string;
+        mimeType?: string;
+    }[];
+}>;
+/**
+ * Handle write_file command
+ */
+export declare function handleWriteFile(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+/**
+ * Handle create_directory command
+ */
+export declare function handleCreateDirectory(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+/**
+ * Handle list_directory command
+ */
+export declare function handleListDirectory(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+/**
+ * Handle move_file command
+ */
+export declare function handleMoveFile(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+/**
+ * Handle search_files command
+ */
+export declare function handleSearchFiles(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+/**
+ * Handle get_file_info command
+ */
+export declare function handleGetFileInfo(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+/**
+ * Handle list_allowed_directories command
+ */
+export declare function handleListAllowedDirectories(): {
+    content: {
+        type: string;
+        text: string;
+    }[];
+};

package/dist/handlers/filesystem-handlers.js

@@ -0,0 +1,179 @@
+import { readFile, readMultipleFiles, writeFile, createDirectory, listDirectory, moveFile, searchFiles, getFileInfo, listAllowedDirectories } from '../tools/filesystem.js';
+import { withTimeout } from '../utils.js';
+import { ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, SearchFilesArgsSchema, GetFileInfoArgsSchema } from '../tools/schemas.js';
+/**
+ * Handle read_file command
+ */
+export async function handleReadFile(args) {
+    const HANDLER_TIMEOUT = 60000; // 60 seconds total operation timeout
+    const readFileOperation = async () => {
+        const parsed = ReadFileArgsSchema.parse(args);
+        // Explicitly cast the result to FileResult since we're passing true
+        const fileResult = await readFile(parsed.path, true, parsed.isUrl);
+        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
+            return {
+                content: [{ type: "text", text: fileResult.content }],
+            };
+        }
+    };
+    // Execute with timeout at the handler level
+    return await withTimeout(readFileOperation(), HANDLER_TIMEOUT, 'Read file handler operation', {
+        content: [{ type: "text", text: `Operation timed out after ${HANDLER_TIMEOUT / 1000} seconds. The file might be too large or on a slow/unresponsive storage device.` }],
+    });
+}
+/**
+ * Handle read_multiple_files command
+ */
+export async function handleReadMultipleFiles(args) {
+    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 };
+}
+/**
+ * Handle write_file command
+ */
+export async function handleWriteFile(args) {
+    const parsed = WriteFileArgsSchema.parse(args);
+    await writeFile(parsed.path, parsed.content);
+    return {
+        content: [{ type: "text", text: `Successfully wrote to ${parsed.path}` }],
+    };
+}
+/**
+ * Handle create_directory command
+ */
+export async function handleCreateDirectory(args) {
+    const parsed = CreateDirectoryArgsSchema.parse(args);
+    await createDirectory(parsed.path);
+    return {
+        content: [{ type: "text", text: `Successfully created directory ${parsed.path}` }],
+    };
+}
+/**
+ * Handle list_directory command
+ */
+export async function handleListDirectory(args) {
+    const parsed = ListDirectoryArgsSchema.parse(args);
+    const entries = await listDirectory(parsed.path);
+    return {
+        content: [{ type: "text", text: entries.join('\n') }],
+    };
+}
+/**
+ * Handle move_file command
+ */
+export async function handleMoveFile(args) {
+    const parsed = MoveFileArgsSchema.parse(args);
+    await moveFile(parsed.source, parsed.destination);
+    return {
+        content: [{ type: "text", text: `Successfully moved ${parsed.source} to ${parsed.destination}` }],
+    };
+}
+/**
+ * Handle search_files command
+ */
+export async function handleSearchFiles(args) {
+    const parsed = SearchFilesArgsSchema.parse(args);
+    const timeoutMs = parsed.timeoutMs || 30000; // 30 seconds default
+    // Apply timeout at the handler level
+    const searchOperation = async () => {
+        return await searchFiles(parsed.path, parsed.pattern);
+    };
+    // Use withTimeout at the handler level
+    const results = await withTimeout(searchOperation(), timeoutMs, 'File search operation', [] // Empty array as default on timeout
+    );
+    if (results.length === 0) {
+        // Similar approach as in handleSearchCode
+        if (timeoutMs > 0) {
+            return {
+                content: [{ type: "text", text: `No matches found or search timed out after ${timeoutMs}ms.` }],
+            };
+        }
+        return {
+            content: [{ type: "text", text: "No matches found" }],
+        };
+    }
+    return {
+        content: [{ type: "text", text: results.join('\n') }],
+    };
+}
+/**
+ * Handle get_file_info command
+ */
+export async function handleGetFileInfo(args) {
+    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')
+            }],
+    };
+}
+/**
+ * Handle list_allowed_directories command
+ */
+export function handleListAllowedDirectories() {
+    const directories = listAllowedDirectories();
+    return {
+        content: [{
+                type: "text",
+                text: `Allowed directories:\n${directories.join('\n')}`
+            }],
+    };
+}

package/dist/handlers/index.d.ts

@@ -0,0 +1,5 @@
+export * from './filesystem-handlers.js';
+export * from './terminal-handlers.js';
+export * from './process-handlers.js';
+export * from './command-handlers.js';
+export * from './edit-search-handlers.js';

package/dist/handlers/index.js

@@ -0,0 +1,6 @@
+// Export all handlers from their respective files
+export * from './filesystem-handlers.js';
+export * from './terminal-handlers.js';
+export * from './process-handlers.js';
+export * from './command-handlers.js';
+export * from './edit-search-handlers.js';

package/dist/handlers/process-handlers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Handle list_processes command
+ */
+export declare function handleListProcesses(): Promise<{
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+}>;
+/**
+ * Handle kill_process command
+ */
+export declare function handleKillProcess(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/handlers/process-handlers.js

@@ -0,0 +1,15 @@
+import { listProcesses, killProcess } from '../tools/process.js';
+import { KillProcessArgsSchema } from '../tools/schemas.js';
+/**
+ * Handle list_processes command
+ */
+export async function handleListProcesses() {
+    return listProcesses();
+}
+/**
+ * Handle kill_process command
+ */
+export async function handleKillProcess(args) {
+    const parsed = KillProcessArgsSchema.parse(args);
+    return killProcess(parsed);
+}

package/dist/handlers/terminal-handlers.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Handle execute_command command
+ */
+export declare function handleExecuteCommand(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+/**
+ * Handle read_output command
+ */
+export declare function handleReadOutput(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+/**
+ * Handle force_terminate command
+ */
+export declare function handleForceTerminate(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+/**
+ * Handle list_sessions command
+ */
+export declare function handleListSessions(): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/handlers/terminal-handlers.js

@@ -0,0 +1,29 @@
+import { executeCommand, readOutput, forceTerminate, listSessions } from '../tools/execute.js';
+import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchema } from '../tools/schemas.js';
+/**
+ * Handle execute_command command
+ */
+export async function handleExecuteCommand(args) {
+    const parsed = ExecuteCommandArgsSchema.parse(args);
+    return executeCommand(parsed);
+}
+/**
+ * Handle read_output command
+ */
+export async function handleReadOutput(args) {
+    const parsed = ReadOutputArgsSchema.parse(args);
+    return readOutput(parsed);
+}
+/**
+ * Handle force_terminate command
+ */
+export async function handleForceTerminate(args) {
+    const parsed = ForceTerminateArgsSchema.parse(args);
+    return forceTerminate(parsed);
+}
+/**
+ * Handle list_sessions command
+ */
+export async function handleListSessions() {
+    return listSessions();
+}