@wonderwhy-er/desktop-commander 0.1.29 → 0.1.31

package/README.md

@@ -108,6 +108,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 +128,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`: File operations (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
@@ -252,7 +258,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 +299,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/server.js

@@ -97,14 +97,17 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             {
                 name: "read_file",
                 description: "Read the complete contents of a file from the file system. " +
-                    "Reads UTF-8 text and provides detailed error messages " +
-                    "if the file cannot be read. Only works within allowed directories.",
+                    "Handles text files normally and image files are returned as viewable images. " +
+                    "Recognized image types: PNG, JPEG, GIF, WebP. " +
+                    "Only works within allowed directories.",
                 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),
@@ -244,6 +247,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : String(error);
+                    capture('server_' + name + "_error");
                     return {
                         content: [{ type: "text", text: `Error: ${errorMessage}` }],
                     };
@@ -253,12 +257,34 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 capture('server_read_file');
                 try {
                     const parsed = ReadFileArgsSchema.parse(args);
-                    const content = await readFile(parsed.path);
-                    return {
-                        content: [{ type: "text", text: content }],
-                    };
+                    // 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}` }],
@@ -269,12 +295,47 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 capture('server_read_multiple_files');
                 try {
                     const parsed = ReadMultipleFilesArgsSchema.parse(args);
-                    const results = await readMultipleFiles(parsed.paths);
-                    return {
-                        content: [{ type: "text", text: results.join("\n---\n") }],
-                    };
+                    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}` }],
@@ -291,6 +352,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     };
                 }
                 catch (error) {
+                    capture('server_' + name + "_error");
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     return {
                         content: [{ type: "text", text: `Error: ${errorMessage}` }],
@@ -307,6 +369,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     };
                 }
                 catch (error) {
+                    capture('server_' + name + "_error");
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     return {
                         content: [{ type: "text", text: `Error: ${errorMessage}` }],
@@ -323,6 +386,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     };
                 }
                 catch (error) {
+                    capture('server_' + name + "_error");
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     return {
                         content: [{ type: "text", text: `Error: ${errorMessage}` }],
@@ -339,6 +403,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     };
                 }
                 catch (error) {
+                    capture('server_' + name + "_error");
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     return {
                         content: [{ type: "text", text: `Error: ${errorMessage}` }],
@@ -355,6 +420,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     };
                 }
                 catch (error) {
+                    capture('server_' + name + "_error");
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     return {
                         content: [{ type: "text", text: `Error: ${errorMessage}` }],
@@ -382,6 +448,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     }
                 }
                 catch (error) {
+                    capture('server_' + name + "_error");
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     return {
                         content: [{ type: "text", text: `Error: ${errorMessage}` }],
@@ -416,6 +483,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     };
                 }
                 catch (error) {
+                    capture('server_' + name + "_error");
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     return {
                         content: [{ type: "text", text: `Error: ${errorMessage}` }],

package/dist/setup-claude-server.js

@@ -46,6 +46,15 @@ async function getNpmVersion() {
   }
 }
 
+const getVersion = async () => {
+    try {
+        const packageJson = await import('./package.json', { assert: { type: 'json' } });
+        return packageJson.default.version;
+    } catch {
+        return 'unknown'
+    }
+};
+
 // Function to detect shell environment
 function detectShell() {
   // Check for Windows shells
@@ -115,7 +124,7 @@ async function getTrackingProperties(additionalProps = {}) {
   }
   
   const context = getExecutionContext();
-  
+  const version = await getVersion();
   return {
     platform: platform(),
     nodeVersion: nodeVersion,
@@ -123,6 +132,7 @@ async function getTrackingProperties(additionalProps = {}) {
     executionContext: context.runMethod,
     isCI: context.isCI,
     shell: context.shell,
+    DCVersion: version,
     timestamp: new Date().toISOString(),
     ...additionalProps
   };

package/dist/tools/edit.js

@@ -1,15 +1,18 @@
 import { readFile, writeFile } from './filesystem.js';
 export async function performSearchReplace(filePath, block) {
+    // Read file as plain string (don't pass true to get just the string)
     const content = await readFile(filePath);
+    // Make sure content is a string
+    const contentStr = typeof content === 'string' ? content : content.content;
     // Find first occurrence
-    const searchIndex = content.indexOf(block.search);
+    const searchIndex = contentStr.indexOf(block.search);
     if (searchIndex === -1) {
         throw new Error(`Search content not found in ${filePath}`);
     }
     // Replace content
-    const newContent = content.substring(0, searchIndex) +
+    const newContent = contentStr.substring(0, searchIndex) +
         block.replace +
-        content.substring(searchIndex + block.search.length);
+        contentStr.substring(searchIndex + block.search.length);
     await writeFile(filePath, newContent);
 }
 export async function parseEditBlock(blockContent) {

package/dist/tools/filesystem.d.ts

@@ -1,7 +1,28 @@
+/**
+ * Validates a path to ensure it can be accessed or created.
+ * For existing paths, returns the real path (resolving symlinks).
+ * For non-existent paths, validates parent directories to ensure they exist.
+ *
+ * @param requestedPath The path to validate
+ * @returns Promise<string> The validated path
+ * @throws Error if the path or its parent directories don't exist
+ */
 export declare function validatePath(requestedPath: string): Promise<string>;
-export declare function readFile(filePath: string): Promise<string>;
+export interface FileResult {
+    content: string;
+    mimeType: string;
+    isImage: boolean;
+}
+export declare function readFile(filePath: string, returnMetadata?: boolean): Promise<string | FileResult>;
 export declare function writeFile(filePath: string, content: string): Promise<void>;
-export declare function readMultipleFiles(paths: string[]): Promise<string[]>;
+export interface MultiFileResult {
+    path: string;
+    content?: string;
+    mimeType?: string;
+    isImage?: boolean;
+    error?: string;
+}
+export declare function readMultipleFiles(paths: string[]): Promise<MultiFileResult[]>;
 export declare function createDirectory(dirPath: string): Promise<void>;
 export declare function listDirectory(dirPath: string): Promise<string[]>;
 export declare function moveFile(sourcePath: string, destinationPath: string): Promise<void>;

package/dist/tools/filesystem.js

@@ -23,10 +23,40 @@ function expandHome(filepath) {
     }
     return filepath;
 }
-// Security utilities
+/**
+ * Recursively validates parent directories until it finds a valid one
+ * This function handles the case where we need to create nested directories
+ * and we need to check if any of the parent directories exist
+ *
+ * @param directoryPath The path to validate
+ * @returns Promise<boolean> True if a valid parent directory was found
+ */
+async function validateParentDirectories(directoryPath) {
+    const parentDir = path.dirname(directoryPath);
+    // Base case: we've reached the root or the same directory (shouldn't happen normally)
+    if (parentDir === directoryPath || parentDir === path.dirname(parentDir)) {
+        return false;
+    }
+    try {
+        // Check if the parent directory exists
+        await fs.realpath(parentDir);
+        return true;
+    }
+    catch {
+        // Parent doesn't exist, recursively check its parent
+        return validateParentDirectories(parentDir);
+    }
+}
+/**
+ * Validates a path to ensure it can be accessed or created.
+ * For existing paths, returns the real path (resolving symlinks).
+ * For non-existent paths, validates parent directories to ensure they exist.
+ *
+ * @param requestedPath The path to validate
+ * @returns Promise<string> The validated path
+ * @throws Error if the path or its parent directories don't exist
+ */
 export async function validatePath(requestedPath) {
-    // Temporarily allow all paths by just returning the resolved path
-    // TODO: Implement configurable path validation
     // Expand home directory if present
     const expandedPath = expandHome(requestedPath);
     // Convert to absolute path
@@ -40,53 +70,59 @@ export async function validatePath(requestedPath) {
         return await fs.realpath(absolute);
     }
     catch (error) {
-        // return path if it's not exist. This will be used for folder creation and many other file operations
+        // Path doesn't exist - validate parent directories
+        if (await validateParentDirectories(absolute)) {
+            // Return the path if a valid parent exists
+            // This will be used for folder creation and many other file operations
+            return absolute;
+        }
+        // If no valid parent directory was found, still return the absolute path
+        // to maintain compatibility with upstream behavior, but log a warning
+        console.warn(`Warning: Parent directory does not exist: ${path.dirname(absolute)}`);
         return absolute;
     }
-    /* Original implementation commented out for future reference
-    const expandedPath = expandHome(requestedPath);
-    const absolute = path.isAbsolute(expandedPath)
-        ? path.resolve(expandedPath)
-        : path.resolve(process.cwd(), expandedPath);
-        
-    const normalizedRequested = normalizePath(absolute);
-
-    // Check if path is within allowed directories
-    const isAllowed = allowedDirectories.some(dir => normalizedRequested.startsWith(normalizePath(dir)));
-    if (!isAllowed) {
-        throw new Error(`Access denied - path outside allowed directories: ${absolute}`);
-    }
-
-    // Handle symlinks by checking their real path
-    try {
-        const realPath = await fs.realpath(absolute);
-        const normalizedReal = normalizePath(realPath);
-        const isRealPathAllowed = allowedDirectories.some(dir => normalizedReal.startsWith(normalizePath(dir)));
-        if (!isRealPathAllowed) {
-            throw new Error("Access denied - symlink target outside allowed directories");
+}
+export async function readFile(filePath, returnMetadata) {
+    const validPath = await validatePath(filePath);
+    // Import the MIME type utilities
+    const { getMimeType, isImageFile } = await import('./mime-types.js');
+    // Detect the MIME type based on file extension
+    const mimeType = getMimeType(validPath);
+    const isImage = isImageFile(mimeType);
+    if (isImage) {
+        // For image files, read as Buffer and convert to base64
+        const buffer = await fs.readFile(validPath);
+        const content = buffer.toString('base64');
+        if (returnMetadata === true) {
+            return { content, mimeType, isImage };
+        }
+        else {
+            return content;
         }
-        return realPath;
-    } catch (error) {
-        // For new files that don't exist yet, verify parent directory
-        const parentDir = path.dirname(absolute);
+    }
+    else {
+        // For all other files, try to read as UTF-8 text
         try {
-            const realParentPath = await fs.realpath(parentDir);
-            const normalizedParent = normalizePath(realParentPath);
-            const isParentAllowed = allowedDirectories.some(dir => normalizedParent.startsWith(normalizePath(dir)));
-            if (!isParentAllowed) {
-                throw new Error("Access denied - parent directory outside allowed directories");
+            const content = await fs.readFile(validPath, "utf-8");
+            if (returnMetadata === true) {
+                return { content, mimeType, isImage };
+            }
+            else {
+                return content;
+            }
+        }
+        catch (error) {
+            // If UTF-8 reading fails, treat as binary and return base64 but still as text
+            const buffer = await fs.readFile(validPath);
+            const content = `Binary file content (base64 encoded):\n${buffer.toString('base64')}`;
+            if (returnMetadata === true) {
+                return { content, mimeType: 'text/plain', isImage: false };
+            }
+            else {
+                return content;
             }
-            return absolute;
-        } catch {
-            throw new Error(`Parent directory does not exist: ${parentDir}`);
         }
     }
-    */
-}
-// File operation tools
-export async function readFile(filePath) {
-    const validPath = await validatePath(filePath);
-    return fs.readFile(validPath, "utf-8");
 }
 export async function writeFile(filePath, content) {
     const validPath = await validatePath(filePath);
@@ -96,12 +132,20 @@ export async function readMultipleFiles(paths) {
     return Promise.all(paths.map(async (filePath) => {
         try {
             const validPath = await validatePath(filePath);
-            const content = await fs.readFile(validPath, "utf-8");
-            return `${filePath}:\n${content}\n`;
+            const fileResult = await readFile(validPath, true);
+            return {
+                path: filePath,
+                content: typeof fileResult === 'string' ? fileResult : fileResult.content,
+                mimeType: typeof fileResult === 'string' ? "text/plain" : fileResult.mimeType,
+                isImage: typeof fileResult === 'string' ? false : fileResult.isImage
+            };
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            return `${filePath}: Error - ${errorMessage}`;
+            return {
+                path: filePath,
+                error: errorMessage
+            };
         }
     }));
 }

package/dist/tools/mime-types.d.ts

@@ -0,0 +1,2 @@
+export declare function getMimeType(filePath: string): string;
+export declare function isImageFile(mimeType: string): boolean;

package/dist/tools/mime-types.js

@@ -0,0 +1,21 @@
+// Simple MIME type detection based on file extension
+export function getMimeType(filePath) {
+    const extension = filePath.toLowerCase().split('.').pop() || '';
+    // Image types - only the formats we can display
+    const imageTypes = {
+        'png': 'image/png',
+        'jpg': 'image/jpeg',
+        'jpeg': 'image/jpeg',
+        'gif': 'image/gif',
+        'webp': 'image/webp'
+    };
+    // Check if the file is an image
+    if (extension in imageTypes) {
+        return imageTypes[extension];
+    }
+    // Default to text/plain for all other files
+    return 'text/plain';
+}
+export function isImageFile(mimeType) {
+    return mimeType.startsWith('image/');
+}

package/dist/utils.js

@@ -1,4 +1,11 @@
 import { platform } from 'os';
+let VERSION = 'unknown';
+try {
+    const versionModule = await import('./version.js');
+    VERSION = versionModule.VERSION;
+}
+catch {
+}
 // Set default tracking state
 const isTrackingEnabled = true;
 let uniqueUserId = 'unknown';
@@ -25,7 +32,7 @@ try {
         // Silently fail - we don't want analytics issues to break functionality
     });
 }
-catch (error) {
+catch {
     //console.log('Analytics module not available - continuing without tracking');
 }
 export const capture = (event, properties) => {
@@ -36,14 +43,14 @@ export const capture = (event, properties) => {
         properties = properties || {};
         properties.timestamp = new Date().toISOString();
         properties.platform = platform();
+        properties.DCVersion = VERSION;
         posthog.capture({
             distinctId: uniqueUserId,
             event,
             properties
         });
     }
-    catch (error) {
+    catch {
         // Silently fail - we don't want analytics issues to break functionality
-        console.error('Analytics tracking failed:', error);
     }
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.1.29";
+export declare const VERSION = "0.1.31";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.1.29';
+export const VERSION = '0.1.31';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "description": "MCP server for terminal operations and file editing",
   "license": "MIT",
   "author": "Eduards Ruzga",
@@ -31,8 +31,7 @@
     "setup": "npm install && npm run build && node setup-claude-server.js",
     "setup:debug": "npm install && npm run build && node setup-claude-server.js --debug",
     "prepare": "npm run build",
-    "test": "node test/test.js",
-    "test:watch": "nodemon test/test.js",
+    "test": "node test/run-all-tests.js",
     "link:local": "npm run build && npm link",
     "unlink:local": "npm unlink",
     "inspector": "npx @modelcontextprotocol/inspector dist/index.js"