@wonderwhy-er/desktop-commander 0.1.30 → 0.1.32

package/dist/tools/filesystem.js

@@ -1,6 +1,8 @@
 import fs from "fs/promises";
 import path from "path";
 import os from 'os';
+import fetch from 'cross-fetch';
+import { withTimeout } from '../utils.js';
 // Store allowed directories - temporarily allowing all paths
 // TODO: Make this configurable through a configuration file
 const allowedDirectories = [
@@ -23,70 +25,219 @@ function expandHome(filepath) {
     }
     return filepath;
 }
-// Security utilities
-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
-    const absolute = path.isAbsolute(expandedPath)
-        ? path.resolve(expandedPath)
-        : path.resolve(process.cwd(), expandedPath);
-    // Check if path exists
+/**
+ * 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 {
-        const stats = await fs.stat(absolute);
-        // If path exists, resolve any symlinks
-        return await fs.realpath(absolute);
+        // Check if the parent directory exists
+        await fs.realpath(parentDir);
+        return true;
     }
-    catch (error) {
-        // Path doesn't exist, throw an error
-        throw new Error(`Path does not exist: ${absolute}`);
+    catch {
+        // Parent doesn't exist, recursively check its parent
+        return validateParentDirectories(parentDir);
     }
-    /* 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}`);
+}
+/**
+ * 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) {
+    const PATH_VALIDATION_TIMEOUT = 10000; // 10 seconds timeout
+    const validationOperation = async () => {
+        // Expand home directory if present
+        const expandedPath = expandHome(requestedPath);
+        // Convert to absolute path
+        const absolute = path.isAbsolute(expandedPath)
+            ? path.resolve(expandedPath)
+            : path.resolve(process.cwd(), expandedPath);
+        // Check if path exists
+        try {
+            const stats = await fs.stat(absolute);
+            // If path exists, resolve any symlinks
+            return await fs.realpath(absolute);
+        }
+        catch (error) {
+            // 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 found, return the absolute path anyway
+            return absolute;
+        }
+    };
+    // Execute with timeout
+    const result = await withTimeout(validationOperation(), PATH_VALIDATION_TIMEOUT, `Path validation for ${requestedPath}`, null);
+    if (result === null) {
+        throw new Error(`Path validation timed out after ${PATH_VALIDATION_TIMEOUT / 1000} seconds for: ${requestedPath}`);
     }
-
-    // Handle symlinks by checking their real path
+    return result;
+}
+/**
+ * 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 async function readFileFromUrl(url, returnMetadata) {
+    // Import the MIME type utilities
+    const { isImageFile } = await import('./mime-types.js');
+    // Set up fetch with timeout
+    const FETCH_TIMEOUT_MS = 30000;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
     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");
+        const response = await fetch(url, {
+            signal: controller.signal
+        });
+        // Clear the timeout since fetch completed
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            throw new Error(`HTTP error! Status: ${response.status}`);
         }
-        return realPath;
-    } catch (error) {
-        // For new files that don't exist yet, verify parent directory
-        const parentDir = path.dirname(absolute);
-        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");
+        // Get MIME type from Content-Type header
+        const contentType = response.headers.get('content-type') || 'text/plain';
+        const isImage = isImageFile(contentType);
+        if (isImage) {
+            // For images, convert to base64
+            const buffer = await response.arrayBuffer();
+            const content = Buffer.from(buffer).toString('base64');
+            if (returnMetadata === true) {
+                return { content, mimeType: contentType, isImage };
             }
-            return absolute;
-        } catch {
-            throw new Error(`Parent directory does not exist: ${parentDir}`);
+            else {
+                return content;
+            }
+        }
+        else {
+            // For text content
+            const content = await response.text();
+            if (returnMetadata === true) {
+                return { content, mimeType: contentType, isImage };
+            }
+            else {
+                return content;
+            }
+        }
+    }
+    catch (error) {
+        // Clear the timeout to prevent memory leaks
+        clearTimeout(timeoutId);
+        // Improve error message for timeout/abort cases
+        if (error instanceof DOMException && error.name === 'AbortError') {
+            throw new Error(`URL fetch timed out after ${FETCH_TIMEOUT_MS}ms: ${url}`);
         }
+        throw new Error(`Failed to fetch URL: ${error instanceof Error ? error.message : String(error)}`);
     }
-    */
 }
-// File operation tools
-export async function readFile(filePath) {
+/**
+ * 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 async function readFileFromDisk(filePath, returnMetadata) {
+    // Import the MIME type utilities
+    const { getMimeType, isImageFile } = await import('./mime-types.js');
     const validPath = await validatePath(filePath);
-    return fs.readFile(validPath, "utf-8");
+    // Check file size before attempting to read
+    try {
+        const stats = await fs.stat(validPath);
+        const MAX_SIZE = 100 * 1024; // 100KB limit
+        if (stats.size > MAX_SIZE) {
+            const message = `File too large (${(stats.size / 1024).toFixed(2)}KB > ${MAX_SIZE / 1024}KB limit)`;
+            if (returnMetadata) {
+                return {
+                    content: message,
+                    mimeType: 'text/plain',
+                    isImage: false
+                };
+            }
+            else {
+                return message;
+            }
+        }
+    }
+    catch (error) {
+        // If we can't stat the file, continue anyway and let the read operation handle errors
+        console.error(`Failed to stat file ${validPath}:`, error);
+    }
+    // Detect the MIME type based on file extension
+    const mimeType = getMimeType(validPath);
+    const isImage = isImageFile(mimeType);
+    const FILE_READ_TIMEOUT = 30000; // 30 seconds timeout for file operations
+    // Use withTimeout to handle potential hangs
+    const readOperation = async () => {
+        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;
+            }
+        }
+        else {
+            // For all other files, try to read as UTF-8 text
+            try {
+                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;
+                }
+            }
+        }
+    };
+    // Execute with timeout
+    const result = await withTimeout(readOperation(), FILE_READ_TIMEOUT, `Read file operation for ${filePath}`, returnMetadata ?
+        { content: `Operation timed out after ${FILE_READ_TIMEOUT / 1000} seconds`, mimeType: 'text/plain', isImage: false } :
+        `Operation timed out after ${FILE_READ_TIMEOUT / 1000} seconds`);
+    return result;
+}
+/**
+ * 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 async function readFile(filePath, returnMetadata, isUrl) {
+    return isUrl
+        ? readFileFromUrl(filePath, returnMetadata)
+        : readFileFromDisk(filePath, returnMetadata);
 }
 export async function writeFile(filePath, content) {
     const validPath = await validatePath(filePath);
@@ -96,12 +247,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.js

@@ -1,20 +1,14 @@
 // Simple MIME type detection based on file extension
 export function getMimeType(filePath) {
     const extension = filePath.toLowerCase().split('.').pop() || '';
-    // Image types
+    // Image types - only the formats we can display
     const imageTypes = {
         'png': 'image/png',
         'jpg': 'image/jpeg',
         'jpeg': 'image/jpeg',
         'gif': 'image/gif',
-        'bmp': 'image/bmp',
-        'svg': 'image/svg+xml',
-        'webp': 'image/webp',
-        'ico': 'image/x-icon',
-        'tif': 'image/tiff',
-        'tiff': 'image/tiff',
+        'webp': 'image/webp'
     };
-    // Text types - consider everything else as text for simplicity
     // Check if the file is an image
     if (extension in imageTypes) {
         return imageTypes[extension];

package/dist/tools/schemas.d.ts

@@ -47,10 +47,13 @@ export declare const UnblockCommandArgsSchema: z.ZodObject<{
 }>;
 export declare const ReadFileArgsSchema: z.ZodObject<{
     path: z.ZodString;
+    isUrl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
     path: string;
+    isUrl: boolean;
 }, {
     path: string;
+    isUrl?: boolean | undefined;
 }>;
 export declare const ReadMultipleFilesArgsSchema: z.ZodObject<{
     paths: z.ZodArray<z.ZodString, "many">;
@@ -96,12 +99,15 @@ export declare const MoveFileArgsSchema: z.ZodObject<{
 export declare const SearchFilesArgsSchema: z.ZodObject<{
     path: z.ZodString;
     pattern: z.ZodString;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     path: string;
     pattern: string;
+    timeoutMs?: number | undefined;
 }, {
     path: string;
     pattern: string;
+    timeoutMs?: number | undefined;
 }>;
 export declare const GetFileInfoArgsSchema: z.ZodObject<{
     path: z.ZodString;
@@ -118,9 +124,11 @@ export declare const SearchCodeArgsSchema: z.ZodObject<{
     maxResults: z.ZodOptional<z.ZodNumber>;
     includeHidden: z.ZodOptional<z.ZodBoolean>;
     contextLines: z.ZodOptional<z.ZodNumber>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     path: string;
     pattern: string;
+    timeoutMs?: number | undefined;
     filePattern?: string | undefined;
     ignoreCase?: boolean | undefined;
     maxResults?: number | undefined;
@@ -129,6 +137,7 @@ export declare const SearchCodeArgsSchema: z.ZodObject<{
 }, {
     path: string;
     pattern: string;
+    timeoutMs?: number | undefined;
     filePattern?: string | undefined;
     ignoreCase?: boolean | undefined;
     maxResults?: number | undefined;

package/dist/tools/schemas.js

@@ -23,6 +23,7 @@ export const UnblockCommandArgsSchema = z.object({
 // Filesystem tools schemas
 export const ReadFileArgsSchema = z.object({
     path: z.string(),
+    isUrl: z.boolean().optional().default(false),
 });
 export const ReadMultipleFilesArgsSchema = z.object({
     paths: z.array(z.string()),
@@ -44,6 +45,7 @@ export const MoveFileArgsSchema = z.object({
 export const SearchFilesArgsSchema = z.object({
     path: z.string(),
     pattern: z.string(),
+    timeoutMs: z.number().optional(),
 });
 export const GetFileInfoArgsSchema = z.object({
     path: z.string(),
@@ -57,6 +59,7 @@ export const SearchCodeArgsSchema = z.object({
     maxResults: z.number().optional(),
     includeHidden: z.boolean().optional(),
     contextLines: z.number().optional(),
+    timeoutMs: z.number().optional(),
 });
 // Edit tools schemas
 export const EditBlockArgsSchema = z.object({

package/dist/tools/search.js

@@ -35,6 +35,11 @@ export async function searchCode(options) {
         const results = [];
         const rg = spawn(rgPath, args);
         let stdoutBuffer = '';
+        // Store a reference to the child process for potential termination
+        const childProcess = rg;
+        // Store in a process list - this could be expanded to a global registry
+        // of running search processes if needed for management
+        globalThis.currentSearchProcess = childProcess;
         rg.stdout.on('data', (data) => {
             stdoutBuffer += data.toString();
         });
@@ -42,6 +47,10 @@ export async function searchCode(options) {
             console.error(`ripgrep error: ${data}`);
         });
         rg.on('close', (code) => {
+            // Clean up the global reference
+            if (globalThis.currentSearchProcess === childProcess) {
+                delete globalThis.currentSearchProcess;
+            }
             if (code === 0 || code === 1) {
                 // Process the buffered output
                 const lines = stdoutBuffer.trim().split('\n');

package/dist/utils.d.ts

@@ -1 +1,12 @@
 export declare const capture: (event: string, properties?: any) => void;
+/**
+ * Executes a promise with a timeout. If the promise doesn't resolve or reject within
+ * the specified timeout, returns the provided default value.
+ *
+ * @param operation The promise to execute
+ * @param timeoutMs Timeout in milliseconds
+ * @param operationName Name of the operation (for logs)
+ * @param defaultValue Value to return if the operation times out
+ * @returns Promise that resolves with the operation result or the default value on timeout
+ */
+export declare function withTimeout<T>(operation: Promise<T>, timeoutMs: number, operationName: string, defaultValue: T): Promise<T>;

package/dist/utils.js

@@ -19,7 +19,7 @@ try {
             // Access the default export from the module
             uniqueUserId = machineIdModule.default.machineIdSync();
             if (isTrackingEnabled) {
-                posthog = new PostHog('phc_TFQqTkCwtFGxlwkXDY3gSs7uvJJcJu8GurfXd6mV063', {
+                posthog = new PostHog('phc_BW8KJ0cajzj2v8qfMhvDQ4dtFdgHPzeYcMRvRFGvQdH', {
                     host: 'https://eu.i.posthog.com',
                     flushAt: 3, // send all every time
                     flushInterval: 5 // send always
@@ -54,3 +54,41 @@ export const capture = (event, properties) => {
         // Silently fail - we don't want analytics issues to break functionality
     }
 };
+/**
+ * Executes a promise with a timeout. If the promise doesn't resolve or reject within
+ * the specified timeout, returns the provided default value.
+ *
+ * @param operation The promise to execute
+ * @param timeoutMs Timeout in milliseconds
+ * @param operationName Name of the operation (for logs)
+ * @param defaultValue Value to return if the operation times out
+ * @returns Promise that resolves with the operation result or the default value on timeout
+ */
+export function withTimeout(operation, timeoutMs, operationName, defaultValue) {
+    return new Promise((resolve) => {
+        let isCompleted = false;
+        // Set up timeout
+        const timeoutId = setTimeout(() => {
+            if (!isCompleted) {
+                isCompleted = true;
+                resolve(defaultValue);
+            }
+        }, timeoutMs);
+        // Execute the operation
+        operation
+            .then(result => {
+            if (!isCompleted) {
+                isCompleted = true;
+                clearTimeout(timeoutId);
+                resolve(result);
+            }
+        })
+            .catch(error => {
+            if (!isCompleted) {
+                isCompleted = true;
+                clearTimeout(timeoutId);
+                resolve(defaultValue);
+            }
+        });
+    });
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.1.30";
+export declare const VERSION = "0.1.32";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.1.30';
+export const VERSION = '0.1.32';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "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"
@@ -62,6 +61,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.8.0",
     "@vscode/ripgrep": "^1.15.9",
+    "cross-fetch": "^4.1.0",
     "glob": "^10.3.10",
     "node-machine-id": "^1.1.12",
     "posthog-node": "^4.11.1",
@@ -70,6 +70,7 @@
   },
   "devDependencies": {
     "@types/node": "^20.17.24",
+    "nexe": "^5.0.0-beta.4",
     "nodemon": "^3.0.2",
     "shx": "^0.3.4",
     "typescript": "^5.3.3"