@wonderwhy-er/desktop-commander 0.1.34 → 0.1.36

package/dist/tools/filesystem-fixed.js

@@ -0,0 +1,176 @@
+if (returnMetadata === true) {
+    return { content, mimeType, isImage };
+}
+else {
+    return content;
+}
+try { }
+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) {
+    // Expand home directory in filePath before validation
+    const expandedFilePath = expandHome(filePath);
+    const validPath = await validatePath(expandedFilePath);
+    // Check if the path validation returned an error
+    if (validPath.startsWith('__ERROR__:')) {
+        throw new Error(validPath.substring('__ERROR__:'.length).trim());
+    }
+    await fs.writeFile(validPath, content, "utf-8");
+}
+export async function readMultipleFiles(paths) {
+    return Promise.all(paths.map(async (filePath) => {
+        try {
+            // Expand home directory in filePath before validation
+            const expandedFilePath = expandHome(filePath);
+            const validPath = await validatePath(expandedFilePath);
+            // Check if the path validation returned an error
+            if (validPath.startsWith('__ERROR__:')) {
+                return {
+                    path: filePath,
+                    error: validPath.substring('__ERROR__:'.length).trim()
+                };
+            }
+            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 {
+                path: filePath,
+                error: errorMessage
+            };
+        }
+    }));
+}
+export async function createDirectory(dirPath) {
+    // Expand home directory in dirPath before validation
+    const expandedDirPath = expandHome(dirPath);
+    const validPath = await validatePath(expandedDirPath);
+    // Check if the path validation returned an error
+    if (validPath.startsWith('__ERROR__:')) {
+        throw new Error(validPath.substring('__ERROR__:'.length).trim());
+    }
+    await fs.mkdir(validPath, { recursive: true });
+}
+export async function listDirectory(dirPath) {
+    console.log(`List directory called with: ${dirPath}`);
+    // Handle tilde expansion directly here as well
+    const expandedDirPath = expandHome(dirPath);
+    console.log(`Expanded dir path: ${expandedDirPath}`);
+    const validPath = await validatePath(expandedDirPath);
+    console.log(`Valid path: ${validPath}`);
+    // Check if the path starts with an error indicator
+    if (validPath.startsWith('__ERROR__:')) {
+        console.error(`Path validation error: ${validPath}`);
+        return [`Error: ${validPath.substring('__ERROR__:'.length).trim()}`];
+    }
+    try {
+        const entries = await fs.readdir(validPath, { withFileTypes: true });
+        return entries.map((entry) => `${entry.isDirectory() ? "[DIR]" : "[FILE]"} ${entry.name}`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`Error reading directory: ${errorMessage}`);
+        return [`Error reading directory: ${errorMessage}`];
+    }
+}
+export async function moveFile(sourcePath, destinationPath) {
+    // Expand home directory in both paths before validation
+    const expandedSourcePath = expandHome(sourcePath);
+    const expandedDestPath = expandHome(destinationPath);
+    const validSourcePath = await validatePath(expandedSourcePath);
+    const validDestPath = await validatePath(expandedDestPath);
+    // Check if either path validation returned an error
+    if (validSourcePath.startsWith('__ERROR__:')) {
+        throw new Error(validSourcePath.substring('__ERROR__:'.length).trim());
+    }
+    if (validDestPath.startsWith('__ERROR__:')) {
+        throw new Error(validDestPath.substring('__ERROR__:'.length).trim());
+    }
+    await fs.rename(validSourcePath, validDestPath);
+}
+export async function searchFiles(rootPath, pattern) {
+    const results = [];
+    async function search(currentPath) {
+        const entries = await fs.readdir(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentPath, entry.name);
+            try {
+                // No need to expand home directory here as we're generating full paths
+                // from the already validated rootPath
+                await validatePath(fullPath);
+                if (entry.name.toLowerCase().includes(pattern.toLowerCase())) {
+                    results.push(fullPath);
+                }
+                if (entry.isDirectory()) {
+                    await search(fullPath);
+                }
+            }
+            catch (error) {
+                continue;
+            }
+        }
+    }
+    // Expand home directory in rootPath before validation
+    const expandedRootPath = expandHome(rootPath);
+    const validPath = await validatePath(expandedRootPath);
+    // Check if the path validation returned an error
+    if (validPath.startsWith('__ERROR__:')) {
+        throw new Error(validPath.substring('__ERROR__:'.length).trim());
+    }
+    await search(validPath);
+    return results;
+}
+export async function getFileInfo(filePath) {
+    // Expand home directory in filePath before validation
+    const expandedFilePath = expandHome(filePath);
+    const validPath = await validatePath(expandedFilePath);
+    // Check if the path validation returned an error
+    if (validPath.startsWith('__ERROR__:')) {
+        throw new Error(validPath.substring('__ERROR__:'.length).trim());
+    }
+    const stats = await fs.stat(validPath);
+    return {
+        size: stats.size,
+        created: stats.birthtime,
+        modified: stats.mtime,
+        accessed: stats.atime,
+        isDirectory: stats.isDirectory(),
+        isFile: stats.isFile(),
+        permissions: stats.mode.toString(8).slice(-3),
+    };
+}
+// This function has been replaced with configManager.getConfig()
+// Use get_config tool to retrieve allowedDirectories

package/dist/tools/filesystem.d.ts

@@ -5,7 +5,7 @@
  *
  * @param requestedPath The path to validate
  * @returns Promise<string> The validated path
- * @throws Error if the path or its parent directories don't exist
+ * @throws Error if the path or its parent directories don't exist or if the path is not allowed
  */
 export declare function validatePath(requestedPath: string): Promise<string>;
 export interface FileResult {
@@ -16,17 +16,16 @@ export interface 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>;
+export declare function readFileFromUrl(url: string): Promise<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>;
+export declare function readFileFromDisk(filePath: string): Promise<FileResult>;
 /**
  * Read a file from either the local filesystem or a URL
  * @param filePath Path to the file or URL
@@ -34,7 +33,7 @@ export declare function readFileFromDisk(filePath: string, returnMetadata?: bool
  * @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 readFile(filePath: string, isUrl?: boolean): Promise<FileResult>;
 export declare function writeFile(filePath: string, content: string): Promise<void>;
 export interface MultiFileResult {
     path: string;
@@ -49,4 +48,3 @@ export declare function listDirectory(dirPath: string): Promise<string[]>;
 export declare function moveFile(sourcePath: string, destinationPath: string): Promise<void>;
 export declare function searchFiles(rootPath: string, pattern: string): Promise<string[]>;
 export declare function getFileInfo(filePath: string): Promise<Record<string, any>>;
-export declare function listAllowedDirectories(): string[];

package/dist/tools/filesystem.js

@@ -2,22 +2,36 @@ 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 = [
-    "/" // Root directory - effectively allows all paths
-];
-// Original implementation commented out for future reference
-/*
-const allowedDirectories: string[] = [
-    process.cwd(), // Current working directory
-    os.homedir()   // User's home directory
-];
-*/
+import { capture } from '../utils/capture.js';
+import { withTimeout } from '../utils/withTimeout.js';
+import { configManager } from '../config-manager.js';
+// Initialize allowed directories from configuration
+async function getAllowedDirs() {
+    try {
+        let allowedDirectories;
+        const config = await configManager.getConfig();
+        if (config.allowedDirectories && Array.isArray(config.allowedDirectories)) {
+            allowedDirectories = config.allowedDirectories;
+        }
+        else {
+            // Fall back to default directories if not configured
+            allowedDirectories = [
+                os.homedir() // User's home directory
+            ];
+            // Update config with default
+            await configManager.setValue('allowedDirectories', allowedDirectories);
+        }
+        return allowedDirectories;
+    }
+    catch (error) {
+        console.error('Failed to initialize allowed directories:', error);
+        // Keep the default permissive path
+    }
+    return [];
+}
 // Normalize all paths consistently
 function normalizePath(p) {
-    return path.normalize(p).toLowerCase();
+    return path.normalize(expandHome(p)).toLowerCase();
 }
 function expandHome(filepath) {
     if (filepath.startsWith('~/') || filepath === '~') {
@@ -49,6 +63,47 @@ async function validateParentDirectories(directoryPath) {
         return validateParentDirectories(parentDir);
     }
 }
+/**
+ * Checks if a path is within any of the allowed directories
+ *
+ * @param pathToCheck Path to check
+ * @returns boolean True if path is allowed
+ */
+async function isPathAllowed(pathToCheck) {
+    // If root directory is allowed, all paths are allowed
+    const allowedDirectories = await getAllowedDirs();
+    if (allowedDirectories.includes('/') || allowedDirectories.length === 0) {
+        return true;
+    }
+    let normalizedPathToCheck = normalizePath(pathToCheck);
+    if (normalizedPathToCheck.slice(-1) === path.sep) {
+        normalizedPathToCheck = normalizedPathToCheck.slice(0, -1);
+    }
+    // Check if the path is within any allowed directory
+    const isAllowed = allowedDirectories.some(allowedDir => {
+        let normalizedAllowedDir = normalizePath(allowedDir);
+        if (normalizedAllowedDir.slice(-1) === path.sep) {
+            normalizedAllowedDir = normalizedAllowedDir.slice(0, -1);
+        }
+        // Check if path is exactly the allowed directory
+        if (normalizedPathToCheck === normalizedAllowedDir) {
+            return true;
+        }
+        // Check if path is a subdirectory of the allowed directory
+        // Make sure to add a separator to prevent partial directory name matches
+        // e.g. /home/user vs /home/username
+        const subdirCheck = normalizedPathToCheck.startsWith(normalizedAllowedDir + path.sep);
+        if (subdirCheck) {
+            return true;
+        }
+        // If allowed directory is the root (C:\ on Windows), allow access to the entire drive
+        if (normalizedAllowedDir === 'c:' && process.platform === 'win32') {
+            return normalizedPathToCheck.startsWith('c:');
+        }
+        return false;
+    });
+    return isAllowed;
+}
 /**
  * Validates a path to ensure it can be accessed or created.
  * For existing paths, returns the real path (resolving symlinks).
@@ -56,7 +111,7 @@ async function validateParentDirectories(directoryPath) {
  *
  * @param requestedPath The path to validate
  * @returns Promise<string> The validated path
- * @throws Error if the path or its parent directories don't exist
+ * @throws Error if the path or its parent directories don't exist or if the path is not allowed
  */
 export async function validatePath(requestedPath) {
     const PATH_VALIDATION_TIMEOUT = 10000; // 10 seconds timeout
@@ -67,6 +122,14 @@ export async function validatePath(requestedPath) {
         const absolute = path.isAbsolute(expandedPath)
             ? path.resolve(expandedPath)
             : path.resolve(process.cwd(), expandedPath);
+        // Check if path is allowed
+        if (!(await isPathAllowed(absolute))) {
+            capture('server_path_validation_error', {
+                error: 'Path not allowed',
+                allowedDirsCount: (await getAllowedDirs()).length
+            });
+            throw new Error(`Path not allowed: ${requestedPath}. Must be within one of these directories: ${(await getAllowedDirs()).join(', ')}`);
+        }
         // Check if path exists
         try {
             const stats = await fs.stat(absolute);
@@ -85,20 +148,23 @@ export async function validatePath(requestedPath) {
         }
     };
     // Execute with timeout
-    const result = await withTimeout(validationOperation(), PATH_VALIDATION_TIMEOUT, `Path validation for ${requestedPath}`, null);
+    const result = await withTimeout(validationOperation(), PATH_VALIDATION_TIMEOUT, `Path validation operation`, // Generic name for telemetry
+    null);
     if (result === null) {
-        // Return a path with an error indicator instead of throwing
-        return `__ERROR__: Path validation timed out after ${PATH_VALIDATION_TIMEOUT / 1000} seconds for: ${requestedPath}`;
+        // Keep original path in error for AI but a generic message for telemetry
+        capture('server_path_validation_timeout', {
+            timeoutMs: PATH_VALIDATION_TIMEOUT
+        });
+        throw new Error(`Path validation failed for path: ${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) {
+export async function readFileFromUrl(url) {
     // Import the MIME type utilities
     const { isImageFile } = await import('./mime-types.js');
     // Set up fetch with timeout
@@ -121,22 +187,12 @@ export async function readFileFromUrl(url, returnMetadata) {
             // 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;
-            }
+            return { content, mimeType: contentType, isImage };
         }
         else {
             // For text content
             const content = await response.text();
-            if (returnMetadata === true) {
-                return { content, mimeType: contentType, isImage };
-            }
-            else {
-                return content;
-            }
+            return { content, mimeType: contentType, isImage };
         }
     }
     catch (error) {
@@ -146,16 +202,7 @@ export async function readFileFromUrl(url, returnMetadata) {
         const errorMessage = error instanceof DOMException && error.name === 'AbortError'
             ? `URL fetch timed out after ${FETCH_TIMEOUT_MS}ms: ${url}`
             : `Failed to fetch URL: ${error instanceof Error ? error.message : String(error)}`;
-        if (returnMetadata === true) {
-            return {
-                content: `Error: ${errorMessage}`,
-                mimeType: 'text/plain',
-                isImage: false
-            };
-        }
-        else {
-            return `Error: ${errorMessage}`;
-        }
+        throw new Error(errorMessage);
     }
 }
 /**
@@ -164,31 +211,35 @@ export async function readFileFromUrl(url, returnMetadata) {
  * @param returnMetadata Whether to return metadata with the content
  * @returns File content or file result with metadata
  */
-export async function readFileFromDisk(filePath, returnMetadata) {
+export async function readFileFromDisk(filePath) {
     // Import the MIME type utilities
     const { getMimeType, isImageFile } = await import('./mime-types.js');
     const validPath = await validatePath(filePath);
+    // Get file extension for telemetry using path module consistently
+    const fileExtension = path.extname(validPath).toLowerCase();
     // 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;
-            }
+            // Capture file extension in telemetry without capturing the file path
+            capture('server_read_file_large', { fileExtension: fileExtension });
+            return {
+                content: message,
+                mimeType: 'text/plain',
+                isImage: false
+            };
         }
+        // Capture file extension in telemetry without capturing the file path
+        capture('server_read_file', { fileExtension: fileExtension });
     }
     catch (error) {
+        console.error('error catch ' + error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_read_file_error', { error: errorMessage, fileExtension: fileExtension });
         // If we can't stat the file, continue anyway and let the read operation handle errors
-        console.error(`Failed to stat file ${validPath}:`, error);
+        //console.error(`Failed to stat file ${validPath}:`, error);
     }
     // Detect the MIME type based on file extension
     const mimeType = getMimeType(validPath);
@@ -200,41 +251,28 @@ export async function readFileFromDisk(filePath, returnMetadata) {
             // 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 { content, mimeType, isImage };
         }
         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;
-                }
+                return { content, mimeType, isImage };
             }
             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 { content, mimeType: 'text/plain', isImage: false };
             }
         }
     };
     // 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`);
+    const result = await withTimeout(readOperation(), FILE_READ_TIMEOUT, `Read file operation for ${filePath}`, null);
+    if (result == null) {
+        // Handles the impossible case where withTimeout resolves to null instead of throwing
+        throw new Error('Failed to read the file');
+    }
     return result;
 }
 /**
@@ -244,20 +282,24 @@ export async function readFileFromDisk(filePath, returnMetadata) {
  * @param isUrl Whether the path is a URL
  * @returns File content or file result with metadata
  */
-export async function readFile(filePath, returnMetadata, isUrl) {
+export async function readFile(filePath, isUrl) {
     return isUrl
-        ? readFileFromUrl(filePath, returnMetadata)
-        : readFileFromDisk(filePath, returnMetadata);
+        ? readFileFromUrl(filePath)
+        : readFileFromDisk(filePath);
 }
 export async function writeFile(filePath, content) {
     const validPath = await validatePath(filePath);
+    // Get file extension for telemetry
+    const fileExtension = path.extname(validPath).toLowerCase();
+    // Capture file extension in telemetry without capturing the file path
+    capture('server_write_file', { fileExtension: fileExtension });
     await fs.writeFile(validPath, content, "utf-8");
 }
 export async function readMultipleFiles(paths) {
     return Promise.all(paths.map(async (filePath) => {
         try {
             const validPath = await validatePath(filePath);
-            const fileResult = await readFile(validPath, true);
+            const fileResult = await readFile(validPath);
             return {
                 path: filePath,
                 content: typeof fileResult === 'string' ? fileResult : fileResult.content,
@@ -291,7 +333,19 @@ export async function moveFile(sourcePath, destinationPath) {
 export async function searchFiles(rootPath, pattern) {
     const results = [];
     async function search(currentPath) {
-        const entries = await fs.readdir(currentPath, { withFileTypes: true });
+        let entries;
+        try {
+            entries = await fs.readdir(currentPath, { withFileTypes: true });
+        }
+        catch (error) {
+            // Only sanitize for telemetry, not for the returned error
+            capture('server_search_files_error', {
+                errorType: error instanceof Error ? error.name : 'Unknown',
+                errorMessage: 'Error reading directory',
+                isReadDirError: true
+            });
+            return; // Skip this directory on error
+        }
         for (const entry of entries) {
             const fullPath = path.join(currentPath, entry.name);
             try {
@@ -308,10 +362,27 @@ export async function searchFiles(rootPath, pattern) {
             }
         }
     }
-    // if path not exist, it will throw an error
-    const validPath = await validatePath(rootPath);
-    await search(validPath);
-    return results;
+    try {
+        // Validate root path before starting search
+        const validPath = await validatePath(rootPath);
+        await search(validPath);
+        // Log only the count of found files, not their paths
+        capture('server_search_files_complete', {
+            resultsCount: results.length,
+            patternLength: pattern.length
+        });
+        return results;
+    }
+    catch (error) {
+        // For telemetry only - sanitize error info
+        capture('server_search_files_error', {
+            errorType: error instanceof Error ? error.name : 'Unknown',
+            errorMessage: 'Error with root path',
+            isRootPathError: true
+        });
+        // Re-throw the original error for the caller
+        throw error;
+    }
 }
 export async function getFileInfo(filePath) {
     const validPath = await validatePath(filePath);
@@ -326,6 +397,5 @@ export async function getFileInfo(filePath) {
         permissions: stats.mode.toString(8).slice(-3),
     };
 }
-export function listAllowedDirectories() {
-    return ["/ (All paths are currently allowed)"];
-}
+// This function has been replaced with configManager.getConfig()
+// Use get_config tool to retrieve allowedDirectories

package/dist/tools/fuzzySearch.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Recursively finds the closest match to a query string within text using fuzzy matching
+ * @param text The text to search within
+ * @param query The query string to find
+ * @param start Start index in the text (default: 0)
+ * @param end End index in the text (default: text.length)
+ * @param parentDistance Best distance found so far (default: Infinity)
+ * @returns Object with start and end indices, matched value, and Levenshtein distance
+ */
+export declare function recursiveFuzzyIndexOf(text: string, query: string, start?: number, end?: number | null, parentDistance?: number, depth?: number): {
+    start: number;
+    end: number;
+    value: string;
+    distance: number;
+};
+/**
+ * Calculates the similarity ratio between two strings
+ * @param a First string
+ * @param b Second string
+ * @returns Similarity ratio (0-1)
+ */
+export declare function getSimilarityRatio(a: string, b: string): number;