@wonderwhy-er/desktop-commander 0.1.33 → 0.1.35

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,35 @@ 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, withTimeout } from '../utils.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 +62,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 +110,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 +121,10 @@ 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))) {
+            throw (`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);
@@ -87,17 +145,17 @@ export async function validatePath(requestedPath) {
     // 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 a path with an error indicator instead of throwing
+        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
@@ -120,32 +178,22 @@ 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) {
         // 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)}`);
+        // Return error information instead of throwing
+        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)}`;
+        throw new Error(errorMessage);
     }
 }
 /**
@@ -154,7 +202,7 @@ 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);
@@ -164,21 +212,18 @@ export async function readFileFromDisk(filePath, returnMetadata) {
         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;
-            }
+            return {
+                content: message,
+                mimeType: 'text/plain',
+                isImage: false
+            };
         }
     }
     catch (error) {
+        console.error('error catch ' + error);
+        capture('server_read_file_error', { error: 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);
+        //console.error(`Failed to stat file ${validPath}:`, error);
     }
     // Detect the MIME type based on file extension
     const mimeType = getMimeType(validPath);
@@ -190,41 +235,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;
 }
 /**
@@ -234,10 +266,10 @@ 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);
@@ -247,7 +279,7 @@ 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,
@@ -316,6 +348,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/process.d.ts

@@ -1,12 +1,3 @@
-export declare function listProcesses(): Promise<{
-    content: Array<{
-        type: string;
-        text: string;
-    }>;
-}>;
-export declare function killProcess(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+import { ServerResult } from '../types.js';
+export declare function listProcesses(): Promise<ServerResult>;
+export declare function killProcess(args: unknown): Promise<ServerResult>;

package/dist/tools/process.js

@@ -27,13 +27,19 @@ export async function listProcesses() {
         };
     }
     catch (error) {
-        throw new Error('Failed to list processes');
+        return {
+            content: [{ type: "text", text: `Error: Failed to list processes: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true,
+        };
     }
 }
 export async function killProcess(args) {
     const parsed = KillProcessArgsSchema.safeParse(args);
     if (!parsed.success) {
-        throw new Error(`Invalid arguments for kill_process: ${parsed.error}`);
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for kill_process: ${parsed.error}` }],
+            isError: true,
+        };
     }
     try {
         process.kill(parsed.data.pid);
@@ -42,6 +48,9 @@ export async function killProcess(args) {
         };
     }
     catch (error) {
-        throw new Error(`Failed to kill process: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            content: [{ type: "text", text: `Error: Failed to kill process: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true,
+        };
     }
 }

package/dist/tools/schemas.d.ts

@@ -1,13 +1,28 @@
 import { z } from "zod";
+export declare const GetConfigArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const SetConfigValueArgsSchema: z.ZodObject<{
+    key: z.ZodString;
+    value: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    value?: any;
+}, {
+    key: string;
+    value?: any;
+}>;
+export declare const ListProcessesArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
 export declare const ExecuteCommandArgsSchema: z.ZodObject<{
     command: z.ZodString;
     timeout_ms: z.ZodOptional<z.ZodNumber>;
+    shell: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     command: string;
     timeout_ms?: number | undefined;
+    shell?: string | undefined;
 }, {
     command: string;
     timeout_ms?: number | undefined;
+    shell?: string | undefined;
 }>;
 export declare const ReadOutputArgsSchema: z.ZodObject<{
     pid: z.ZodNumber;
@@ -31,20 +46,6 @@ export declare const KillProcessArgsSchema: z.ZodObject<{
 }, {
     pid: number;
 }>;
-export declare const BlockCommandArgsSchema: z.ZodObject<{
-    command: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    command: string;
-}, {
-    command: string;
-}>;
-export declare const UnblockCommandArgsSchema: z.ZodObject<{
-    command: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    command: string;
-}, {
-    command: string;
-}>;
 export declare const ReadFileArgsSchema: z.ZodObject<{
     path: z.ZodString;
     isUrl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;

package/dist/tools/schemas.js

@@ -1,8 +1,18 @@
 import { z } from "zod";
+console.error("Loading schemas.ts");
+// Config tools schemas
+export const GetConfigArgsSchema = z.object({});
+export const SetConfigValueArgsSchema = z.object({
+    key: z.string(),
+    value: z.any(),
+});
+// Empty schemas
+export const ListProcessesArgsSchema = z.object({});
 // Terminal tools schemas
 export const ExecuteCommandArgsSchema = z.object({
     command: z.string(),
     timeout_ms: z.number().optional(),
+    shell: z.string().optional(),
 });
 export const ReadOutputArgsSchema = z.object({
     pid: z.number(),
@@ -14,12 +24,6 @@ export const ListSessionsArgsSchema = z.object({});
 export const KillProcessArgsSchema = z.object({
     pid: z.number(),
 });
-export const BlockCommandArgsSchema = z.object({
-    command: z.string(),
-});
-export const UnblockCommandArgsSchema = z.object({
-    command: z.string(),
-});
 // Filesystem tools schemas
 export const ReadFileArgsSchema = z.object({
     path: z.string(),

package/dist/tools/search.js

@@ -3,6 +3,7 @@ import path from 'path';
 import fs from 'fs/promises';
 import { validatePath } from './filesystem.js';
 import { rgPath } from '@vscode/ripgrep';
+import { capture } from "../utils.js";
 // Function to search file contents using ripgrep
 export async function searchCode(options) {
     const { rootPath, pattern, filePattern, ignoreCase = true, maxResults = 1000, includeHidden = false, contextLines = 0 } = options;
@@ -77,8 +78,8 @@ export async function searchCode(options) {
                         }
                     }
                     catch (e) {
-                        // Skip non-JSON output
-                        console.error('Error parsing ripgrep output:', e);
+                        capture('server_request_error', { error: 'Error parsing ripgrep output:' + e });
+                        console.error();
                     }
                 }
                 resolve(results);
@@ -164,7 +165,6 @@ export async function searchTextInFiles(options) {
         return await searchCode(options);
     }
     catch (error) {
-        console.error('Ripgrep search failed, falling back to native implementation:', error);
         return searchCodeFallback({
             ...options,
             excludeDirs: ['node_modules', '.git', 'dist']

package/dist/types.d.ts

@@ -29,3 +29,15 @@ export interface CompletedSession {
     startTime: Date;
     endTime: Date;
 }
+export interface ServerResponseContent {
+    type: string;
+    text?: string;
+    data?: string;
+    mimeType?: string;
+}
+export interface ServerResult {
+    content: ServerResponseContent[];
+    isError?: boolean;
+    _meta?: Record<string, unknown>;
+}
+export type ToolHandler<T = unknown> = (args: T) => Promise<ServerResult>;

package/dist/utils.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Send an event to Google Analytics
+ * @param event Event name
+ * @param properties Optional event properties
+ */
 export declare const capture: (event: string, properties?: any) => void;
 /**
  * Executes a promise with a timeout. If the promise doesn't resolve or reject within