@wonderwhy-er/desktop-commander 0.1.31 → 0.1.33

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 = [
@@ -57,53 +59,137 @@ async function validateParentDirectories(directoryPath) {
  * @throws Error if the path or its parent directories don't exist
  */
 export async function validatePath(requestedPath) {
-    // 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
+    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}`);
+    }
+    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 stats = await fs.stat(absolute);
-        // If path exists, resolve any symlinks
-        return await fs.realpath(absolute);
+        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}`);
+        }
+        // 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 };
+            }
+            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) {
-        // 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;
+        // 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}`);
         }
-        // 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;
+        throw new Error(`Failed to fetch URL: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-export async function readFile(filePath, returnMetadata) {
-    const validPath = await validatePath(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);
+    // 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);
-    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");
+    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 };
             }
@@ -111,18 +197,47 @@ export async function readFile(filePath, returnMetadata) {
                 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 {
+            // 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;
+                }
             }
-            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);

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.31";
+export declare const VERSION = "0.1.33";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "description": "MCP server for terminal operations and file editing",
   "license": "MIT",
   "author": "Eduards Ruzga",
@@ -61,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",