@wonderwhy-er/desktop-commander 0.1.33 → 0.1.35

package/dist/tools/config.d.ts

@@ -1,29 +1,3 @@
-import { z } from 'zod';
-export declare const GetConfigArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-export declare const GetConfigValueArgsSchema: z.ZodObject<{
-    key: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    key: string;
-}, {
-    key: string;
-}>;
-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 UpdateConfigArgsSchema: z.ZodObject<{
-    config: z.ZodRecord<z.ZodString, z.ZodAny>;
-}, "strip", z.ZodTypeAny, {
-    config: Record<string, any>;
-}, {
-    config: Record<string, any>;
-}>;
 /**
  * Get the entire config
  */
@@ -33,22 +7,6 @@ export declare function getConfig(): Promise<{
         text: string;
     }[];
 }>;
-/**
- * Get a specific config value
- */
-export declare function getConfigValue(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError: boolean;
-} | {
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError?: undefined;
-}>;
 /**
  * Set a specific config value
  */
@@ -65,19 +23,3 @@ export declare function setConfigValue(args: unknown): Promise<{
     }[];
     isError?: undefined;
 }>;
-/**
- * Update multiple config values at once
- */
-export declare function updateConfig(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError: boolean;
-} | {
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError?: undefined;
-}>;

package/dist/tools/config.js

@@ -1,17 +1,5 @@
-import { z } from 'zod';
 import { configManager } from '../config-manager.js';
-// Schemas for config operations
-export const GetConfigArgsSchema = z.object({});
-export const GetConfigValueArgsSchema = z.object({
-    key: z.string(),
-});
-export const SetConfigValueArgsSchema = z.object({
-    key: z.string(),
-    value: z.any(),
-});
-export const UpdateConfigArgsSchema = z.object({
-    config: z.record(z.any()),
-});
+import { SetConfigValueArgsSchema } from './schemas.js';
 /**
  * Get the entire config
  */
@@ -39,46 +27,6 @@ export async function getConfig() {
         };
     }
 }
-/**
- * Get a specific config value
- */
-export async function getConfigValue(args) {
-    console.error(`getConfigValue called with args: ${JSON.stringify(args)}`);
-    try {
-        const parsed = GetConfigValueArgsSchema.safeParse(args);
-        if (!parsed.success) {
-            console.error(`Invalid arguments for get_config_value: ${parsed.error}`);
-            return {
-                content: [{
-                        type: "text",
-                        text: `Invalid arguments: ${parsed.error}`
-                    }],
-                isError: true
-            };
-        }
-        const value = await configManager.getValue(parsed.data.key);
-        console.error(`getConfigValue result for key ${parsed.data.key}: ${JSON.stringify(value)}`);
-        return {
-            content: [{
-                    type: "text",
-                    text: value !== undefined
-                        ? `Value for ${parsed.data.key}: ${JSON.stringify(value, null, 2)}`
-                        : `No value found for key: ${parsed.data.key}`
-                }],
-        };
-    }
-    catch (error) {
-        console.error(`Error in getConfigValue: ${error instanceof Error ? error.message : String(error)}`);
-        console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
-        return {
-            content: [{
-                    type: "text",
-                    text: `Error retrieving value: ${error instanceof Error ? error.message : String(error)}`
-                }],
-            isError: true
-        };
-    }
-}
 /**
  * Set a specific config value
  */
@@ -97,12 +45,52 @@ export async function setConfigValue(args) {
             };
         }
         try {
-            await configManager.setValue(parsed.data.key, parsed.data.value);
-            console.error(`setConfigValue: Successfully set ${parsed.data.key} to ${JSON.stringify(parsed.data.value)}`);
+            // Parse string values that should be arrays or objects
+            let valueToStore = parsed.data.value;
+            // If the value is a string that looks like an array or object, try to parse it
+            if (typeof valueToStore === 'string' &&
+                (valueToStore.startsWith('[') || valueToStore.startsWith('{'))) {
+                try {
+                    valueToStore = JSON.parse(valueToStore);
+                    console.error(`Parsed string value to object/array: ${JSON.stringify(valueToStore)}`);
+                }
+                catch (parseError) {
+                    console.error(`Failed to parse string as JSON, using as-is: ${parseError}`);
+                }
+            }
+            // Special handling for known array configuration keys
+            if ((parsed.data.key === 'allowedDirectories' || parsed.data.key === 'blockedCommands') &&
+                !Array.isArray(valueToStore)) {
+                if (typeof valueToStore === 'string') {
+                    try {
+                        valueToStore = JSON.parse(valueToStore);
+                    }
+                    catch (parseError) {
+                        console.error(`Failed to parse string as array for ${parsed.data.key}: ${parseError}`);
+                        // If parsing failed and it's a single value, convert to an array with one item
+                        if (!valueToStore.includes('[')) {
+                            valueToStore = [valueToStore];
+                        }
+                    }
+                }
+                else {
+                    // If not a string or array, convert to an array with one item
+                    valueToStore = [valueToStore];
+                }
+                // Ensure the value is an array after all our conversions
+                if (!Array.isArray(valueToStore)) {
+                    console.error(`Value for ${parsed.data.key} is still not an array, converting to array`);
+                    valueToStore = [String(valueToStore)];
+                }
+            }
+            await configManager.setValue(parsed.data.key, valueToStore);
+            // Get the updated configuration to show the user
+            const updatedConfig = await configManager.getConfig();
+            console.error(`setConfigValue: Successfully set ${parsed.data.key} to ${JSON.stringify(valueToStore)}`);
             return {
                 content: [{
                         type: "text",
-                        text: `Successfully set ${parsed.data.key} to ${JSON.stringify(parsed.data.value, null, 2)}`
+                        text: `Successfully set ${parsed.data.key} to ${JSON.stringify(valueToStore, null, 2)}\n\nUpdated configuration:\n${JSON.stringify(updatedConfig, null, 2)}`
                     }],
             };
         }
@@ -130,54 +118,3 @@ export async function setConfigValue(args) {
         };
     }
 }
-/**
- * Update multiple config values at once
- */
-export async function updateConfig(args) {
-    console.error(`updateConfig called with args: ${JSON.stringify(args)}`);
-    try {
-        const parsed = UpdateConfigArgsSchema.safeParse(args);
-        if (!parsed.success) {
-            console.error(`Invalid arguments for update_config: ${parsed.error}`);
-            return {
-                content: [{
-                        type: "text",
-                        text: `Invalid arguments: ${parsed.error}`
-                    }],
-                isError: true
-            };
-        }
-        try {
-            const updatedConfig = await configManager.updateConfig(parsed.data.config);
-            console.error(`updateConfig result: ${JSON.stringify(updatedConfig, null, 2)}`);
-            return {
-                content: [{
-                        type: "text",
-                        text: `Configuration updated successfully.\nNew configuration:\n${JSON.stringify(updatedConfig, null, 2)}`
-                    }],
-            };
-        }
-        catch (saveError) {
-            console.error(`Error saving updated config: ${saveError.message}`);
-            // Return useful response instead of crashing
-            return {
-                content: [{
-                        type: "text",
-                        text: `Configuration updated in memory but couldn't be saved to disk: ${saveError.message}`
-                    }],
-                isError: true
-            };
-        }
-    }
-    catch (error) {
-        console.error(`Error in updateConfig: ${error instanceof Error ? error.message : String(error)}`);
-        console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
-        return {
-            content: [{
-                    type: "text",
-                    text: `Error updating configuration: ${error instanceof Error ? error.message : String(error)}`
-                }],
-            isError: true
-        };
-    }
-}

package/dist/tools/debug-path.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/debug-path.js

@@ -0,0 +1,44 @@
+// This is a debug script to help understand how ~ expansion works
+import os from 'os';
+import path from 'path';
+function expandHome(filepath) {
+    console.log(`Expanding ${filepath}`);
+    // Handle both '~' alone or '~/' path prefix
+    if (filepath === '~') {
+        const home = os.homedir();
+        console.log(`~ expanded to ${home}`);
+        return home;
+    }
+    else if (filepath.startsWith('~/')) {
+        const joinedPath = path.join(os.homedir(), filepath.slice(2));
+        console.log(`~/ expanded to ${joinedPath}`);
+        return joinedPath;
+    }
+    return filepath;
+}
+console.log(`Home directory: ${os.homedir()}`);
+console.log(`Current working directory: ${process.cwd()}`);
+console.log(`Expanding ~: ${expandHome('~')}`);
+console.log(`Expanding ~/Documents: ${expandHome('~/Documents')}`);
+console.log(`Expanding /tmp: ${expandHome('/tmp')}`);
+// Create lowercase normalized paths for comparison
+function normalizePath(p) {
+    return path.normalize(p).toLowerCase();
+}
+const allowedDir = '~';
+const expandedAllowedDir = expandHome(allowedDir);
+const normalizedAllowedDir = normalizePath(expandedAllowedDir);
+console.log(`Allowed dir: ${allowedDir}`);
+console.log(`Expanded allowed dir: ${expandedAllowedDir}`);
+console.log(`Normalized allowed dir: ${normalizedAllowedDir}`);
+// Example path to check
+const pathToCheck = '~';
+const expandedPathToCheck = expandHome(pathToCheck);
+const normalizedPathToCheck = normalizePath(expandedPathToCheck);
+console.log(`Path to check: ${pathToCheck}`);
+console.log(`Expanded path to check: ${expandedPathToCheck}`);
+console.log(`Normalized path to check: ${normalizedPathToCheck}`);
+// Check if path is allowed
+const isAllowed = normalizedPathToCheck === normalizedAllowedDir ||
+    normalizedPathToCheck.startsWith(normalizedAllowedDir + path.sep);
+console.log(`Is path allowed: ${isAllowed}`);

package/dist/tools/edit.d.ts

@@ -1,10 +1,12 @@
+import { ServerResult } from '../types.js';
 interface SearchReplace {
     search: string;
     replace: string;
 }
-export declare function performSearchReplace(filePath: string, block: SearchReplace): Promise<void>;
+export declare function performSearchReplace(filePath: string, block: SearchReplace): Promise<ServerResult>;
 export declare function parseEditBlock(blockContent: string): Promise<{
     filePath: string;
     searchReplace: SearchReplace;
+    error?: string;
 }>;
 export {};

package/dist/tools/edit.js

@@ -1,19 +1,27 @@
 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);
+    const { content } = await readFile(filePath);
     // Make sure content is a string
-    const contentStr = typeof content === 'string' ? content : content.content;
+    if (typeof content !== 'string') {
+        throw new Error('Wrong content for file ' + filePath);
+    }
+    ;
     // Find first occurrence
-    const searchIndex = contentStr.indexOf(block.search);
+    const searchIndex = content.indexOf(block.search);
     if (searchIndex === -1) {
-        throw new Error(`Search content not found in ${filePath}`);
+        return {
+            content: [{ type: "text", text: `Search content not found in ${filePath}.` }],
+        };
     }
     // Replace content
-    const newContent = contentStr.substring(0, searchIndex) +
+    const newContent = content.substring(0, searchIndex) +
         block.replace +
-        contentStr.substring(searchIndex + block.search.length);
+        content.substring(searchIndex + block.search.length);
     await writeFile(filePath, newContent);
+    return {
+        content: [{ type: "text", text: `Successfully applied edit to ${filePath}` }],
+    };
 }
 export async function parseEditBlock(blockContent) {
     const lines = blockContent.split('\n');
@@ -24,7 +32,11 @@ export async function parseEditBlock(blockContent) {
     const divider = lines.indexOf('=======');
     const replaceEnd = lines.indexOf('>>>>>>> REPLACE');
     if (searchStart === -1 || divider === -1 || replaceEnd === -1) {
-        throw new Error('Invalid edit block format - missing markers');
+        return {
+            filePath: '',
+            searchReplace: { search: '', replace: '' },
+            error: 'Invalid edit block format - missing markers'
+        };
     }
     // Extract search and replace content
     const search = lines.slice(searchStart + 1, divider).join('\n');

package/dist/tools/execute.d.ts

@@ -1,21 +1,7 @@
-export declare function executeCommand(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
-export declare function readOutput(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
-export declare function forceTerminate(args: unknown): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
+import { ServerResult } from '../types.js';
+export declare function executeCommand(args: unknown): Promise<ServerResult>;
+export declare function readOutput(args: unknown): Promise<ServerResult>;
+export declare function forceTerminate(args: unknown): Promise<ServerResult>;
 export declare function listSessions(): Promise<{
     content: {
         type: string;

package/dist/tools/execute.js

@@ -6,7 +6,10 @@ export async function executeCommand(args) {
     const parsed = ExecuteCommandArgsSchema.safeParse(args);
     if (!parsed.success) {
         capture('server_execute_command_failed');
-        throw new Error(`Invalid arguments for execute_command: ${parsed.error}`);
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for execute_command: ${parsed.error}` }],
+            isError: true,
+        };
     }
     try {
         // Extract all commands for analytics while ensuring execution continues even if parsing fails
@@ -21,13 +24,23 @@ export async function executeCommand(args) {
         capture('server_execute_command', {
             command: commandManager.getBaseCommand(parsed.data.command)
         });
-        // Log the error but continue execution
-        console.error('Error during command extraction:', error);
     }
-    if (!commandManager.validateCommand(parsed.data.command)) {
-        throw new Error(`Command not allowed: ${parsed.data.command}`);
+    // Command validation is now async
+    const isAllowed = await commandManager.validateCommand(parsed.data.command);
+    if (!isAllowed) {
+        return {
+            content: [{ type: "text", text: `Error: Command not allowed: ${parsed.data.command}` }],
+            isError: true,
+        };
+    }
+    const result = await terminalManager.executeCommand(parsed.data.command, parsed.data.timeout_ms, parsed.data.shell);
+    // Check for error condition (pid = -1)
+    if (result.pid === -1) {
+        return {
+            content: [{ type: "text", text: result.output }],
+            isError: true,
+        };
     }
-    const result = await terminalManager.executeCommand(parsed.data.command, parsed.data.timeout_ms);
     return {
         content: [{
                 type: "text",
@@ -38,7 +51,10 @@ export async function executeCommand(args) {
 export async function readOutput(args) {
     const parsed = ReadOutputArgsSchema.safeParse(args);
     if (!parsed.success) {
-        throw new Error(`Invalid arguments for read_output: ${parsed.error}`);
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for read_output: ${parsed.error}` }],
+            isError: true,
+        };
     }
     const output = terminalManager.getNewOutput(parsed.data.pid);
     return {
@@ -53,7 +69,10 @@ export async function readOutput(args) {
 export async function forceTerminate(args) {
     const parsed = ForceTerminateArgsSchema.safeParse(args);
     if (!parsed.success) {
-        throw new Error(`Invalid arguments for force_terminate: ${parsed.error}`);
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for force_terminate: ${parsed.error}` }],
+            isError: true,
+        };
     }
     const success = terminalManager.forceTerminate(parsed.data.pid);
     return {

package/dist/tools/filesystem-fixed.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 declare function readFile(filePath: string, returnMetadata?: boolean, isUrl?: boolean): Promise<string | FileResult>;
+export declare function writeFile(filePath: string, content: string): Promise<void>;
+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>;
+export declare function searchFiles(rootPath: string, pattern: string): Promise<string[]>;
+export declare function getFileInfo(filePath: string): Promise<Record<string, any>>;

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