@wonderwhy-er/desktop-commander 0.1.18 → 0.1.20

package/README.md

@@ -1,11 +1,31 @@
-# Claude Desktop Commander MCP
+# Desktop Commander MCP
+
 
 [![npm downloads](https://img.shields.io/npm/dw/@wonderwhy-er/desktop-commander)](https://www.npmjs.com/package/@wonderwhy-er/desktop-commander)
 [![smithery badge](https://smithery.ai/badge/@wonderwhy-er/desktop-commander)](https://smithery.ai/server/@wonderwhy-er/desktop-commander)
+[![Buy Me A Coffee](https://img.shields.io/badge/Buy%20Me%20A%20Coffee-support-yellow.svg)](https://www.buymeacoffee.com/wonderwhyer)
 
+[![Discord](https://img.shields.io/badge/Join%20Discord-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/kQ27sNnZr7)
 
 Short version. Two key things. Terminal commands and diff based file editing.
 
+![Desktop Commander MCP](logo.png)
+
+<a href="https://glama.ai/mcp/servers/zempur9oh4">
+  <img width="380" height="200" src="https://glama.ai/mcp/servers/zempur9oh4/badge" alt="Claude Desktop Commander MCP server" />
+</a>
+
+## Table of Contents
+- [Features](#features)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Handling Long-Running Commands](#handling-long-running-commands)
+- [Work in Progress and TODOs](#work-in-progress-and-todos)
+- [Media links](#media)
+- [Testimonials](#testimonials)
+- [Contributing](#contributing)
+- [License](#license)
+
 This is server that allows Claude desktop app to execute long-running terminal commands on your computer and manage processes through Model Context Protocol (MCP) + Built on top of [MCP Filesystem Server](https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem) to provide additional search and replace file editing capabilities .
 
 ## Features
@@ -25,6 +45,7 @@ This is server that allows Claude desktop app to execute long-running terminal c
   - Full file rewrites for major changes
   - Multiple file support
   - Pattern-based replacements
+  - vscode-ripgrep based recursive code or text search in folders
 
 ## Installation
 First, ensure you've downloaded and installed the [Claude Desktop app](https://claude.ai/download) and you have [npm installed](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm).
@@ -95,6 +116,7 @@ The server provides these tool categories:
 - `move_file`: Move/rename files
 - `search_files`: Pattern-based file search
 - `get_file_info`: File metadata
+- `code_search`: Recursive ripgrep based text and code search
 
 ### Edit Tools
 - `edit_block`: Apply surgical text replacements (best for changes <20% of file size)
@@ -140,6 +162,55 @@ This project extends the MCP Filesystem Server to enable:
 
 Created as part of exploring Claude MCPs: https://youtube.com/live/TlbjFDbl5Us
 
+## DONE
+- **25-03-2025 Better code search** ([in progress](https://github.com/wonderwhy-er/ClaudeDesktopCommander/pull/17)) - Enhanced code exploration with context-aware results
+
+## Work in Progress and TODOs
+
+The following features are currently being developed or planned:
+
+- **Better configurations** ([in progress](https://github.com/wonderwhy-er/ClaudeDesktopCommander/pull/16)) - Improved settings for allowed paths, commands and shell environment
+- **Windows environment fixes** ([in progress](https://github.com/wonderwhy-er/ClaudeDesktopCommander/pull/13)) - Resolving issues specific to Windows platforms
+- **Linux improvements** ([in progress](https://github.com/wonderwhy-er/ClaudeDesktopCommander/pull/12)) - Enhancing compatibility with various Linux distributions
+- **Support for WSL** - Windows Subsystem for Linux integration
+- **Support for SSH** - Remote server command execution
+- **Installation troubleshooting guide** - Comprehensive help for setup issues
+
+## Media
+Learn more about this project through these resources:
+
+### Article
+[Claude with MCPs replaced Cursor & Windsurf. How did that happen?](https://wonderwhy-er.medium.com/claude-with-mcps-replaced-cursor-windsurf-how-did-that-happen-c1d1e2795e96) - A detailed exploration of how Claude with Model Context Protocol capabilities is changing developer workflows.
+
+### Video
+[Claude Desktop Commander Video Tutorial](https://www.youtube.com/watch?v=ly3bed99Dy8) - Watch how to set up and use the Commander effectively.
+
+### Community
+Join our [Discord server](https://discord.gg/7cbccwRp) to get help, share feedback, and connect with other users.
+
+## Testimonials
+
+[![It's a life saver! I paid Claude + Cursor currently which I always feel it's kind of duplicated. This solves the problem ultimately. I am so happy. Thanks so much. Plus today Claude has added the web search support. With this MCP + Internet search, it writes the code with the latest updates. It's so good when Cursor doesn't work sometimes or all the fast requests are used.](testemonials/img.png) https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgyyBt6_ShdDX_rIOad4AaABAg
+](https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgyyBt6_ShdDX_rIOad4AaABAg
+)
+
+[![This is the first comment I've ever left on a youtube video, THANK YOU! I've been struggling to update an old Flutter app in Cursor from an old pre null-safety version to a current version and implemented null-safety using Claude 3.7. I got most of the way but had critical BLE errors that I spent days trying to resolve with no luck. I tried Augment Code but it didn't get it either. I implemented your MCP in Claude desktop and was able to compare the old and new codebase fully, accounting for the updates in the code, and fix the issues in a couple of hours. A word of advice to people trying this, be sure to stage changes and commit when appropriate to be able to undo unwanted changes. Amazing!](testemonials/img_1.png)
+https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgztdHvDMqTb9jiqnf54AaABAg](https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgztdHvDMqTb9jiqnf54AaABAg
+)
+
+[![Great! I just used Windsurf, bought license a week ago, for upgrading old fullstack socket project and it works many times good or ok but also many times runs away in cascade and have to revert all changes loosing hundereds of cascade tokens. In just a week down to less than 100 tokens and do not want to buy only 300 tokens for 10$. This Claude MCP ,bought claude Pro finally needed but wanted very good reason to also have next to ChatGPT, and now can code as much as I want not worrying about token cost.
+Also this is much more than code editing it is much more thank you for great video!](testemonials/img_2.png)
+https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgyQFTmYLJ4VBwIlmql4AaABAg](https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgyQFTmYLJ4VBwIlmql4AaABAg)
+
+[![it is a great tool, thank you, I like using it, as it gives claude an ability to do surgical edits, making it more like a human developer.](testemonials/img_3.png)
+https://www.youtube.com/watch?v=ly3bed99Dy8&lc=Ugy4-exy166_Ma7TH-h4AaABAg](https://www.youtube.com/watch?v=ly3bed99Dy8&lc=Ugy4-exy166_Ma7TH-h4AaABAg)
+
+[![You sir are my hero. You've pretty much summed up and described my experiences of late, much better than I could have. Cursor and Windsurf both had me frustrated to the point where I was almost yelling at my computer screen. Out of whimsy, I thought to myself why not just ask Claude directly, and haven't looked back since.
+Claude first to keep my sanity in check, then if necessary, engage with other IDEs, frameworks, etc. I thought I was the only one, glad to see I'm not lol.
+33
+1](testemonials/img_4.png)
+https://medium.com/@pharmx/you-sir-are-my-hero-62cff5836a3e](https://medium.com/@pharmx/you-sir-are-my-hero-62cff5836a3e)
+
 ## Contributing
 
 If you find this project useful, please consider giving it a ⭐ star on GitHub! This helps others discover the project and encourages further development.
@@ -153,6 +224,8 @@ We welcome contributions from the community! Whether you've found a bug, have a
 
 All contributions, big or small, are greatly appreciated!
 
+If you find this tool valuable for your workflow, please consider [supporting the project](https://www.buymeacoffee.com/wonderwhyer).
+
 ## License
 
-MIT
+MIT

package/dist/config-manager.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Interface for the server configuration
+ */
+export interface ServerConfig {
+    blockedCommands?: string[];
+    defaultShell?: string;
+    logLevel?: 'error' | 'warn' | 'info' | 'debug';
+    allowedDirectories?: string[];
+    [key: string]: any;
+}
+/**
+ * Manages reading and writing server configuration
+ */
+export declare class ConfigManager {
+    private config;
+    private initialized;
+    /**
+     * Load configuration from disk
+     */
+    loadConfig(): Promise<ServerConfig>;
+    /**
+     * Save current configuration to disk
+     */
+    saveConfig(): Promise<void>;
+    /**
+     * Get a specific configuration value
+     */
+    getValue<T>(key: string): Promise<T | undefined>;
+    /**
+     * Set a specific configuration value
+     */
+    setValue<T>(key: string, value: T): Promise<void>;
+    /**
+     * Get the entire configuration object
+     */
+    getConfig(): Promise<ServerConfig>;
+    /**
+     * Update multiple configuration values at once
+     */
+    updateConfig(partialConfig: Partial<ServerConfig>): Promise<ServerConfig>;
+}
+export declare const configManager: ConfigManager;

package/dist/config-manager.js

@@ -0,0 +1,242 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { CONFIG_FILE } from './config.js';
+import * as process from 'process';
+/**
+ * Manages reading and writing server configuration
+ */
+export class ConfigManager {
+    constructor() {
+        this.config = {};
+        this.initialized = false;
+    }
+    /**
+     * Load configuration from disk
+     */
+    async loadConfig() {
+        try {
+            console.error(`Loading config from ${CONFIG_FILE}...`);
+            console.error(`Current working directory: ${process.cwd()}`);
+            console.error(`Absolute config path: ${path.resolve(CONFIG_FILE)}`);
+            // Ensure config directory exists
+            const configDir = path.dirname(CONFIG_FILE);
+            try {
+                console.error(`Ensuring config directory exists: ${configDir}`);
+                await fs.mkdir(configDir, { recursive: true });
+                console.error(`Config directory ready: ${configDir}`);
+            }
+            catch (mkdirError) {
+                console.error(`Error creating config directory: ${mkdirError.message}`);
+                // Continue if directory already exists
+                if (mkdirError.code !== 'EEXIST') {
+                    throw mkdirError;
+                }
+            }
+            // Check if the directory exists and is writable
+            try {
+                const dirStats = await fs.stat(configDir);
+                console.error(`Config directory exists: ${dirStats.isDirectory()}`);
+                await fs.access(configDir, fs.constants.W_OK);
+                console.error(`Directory ${configDir} is writable`);
+            }
+            catch (dirError) {
+                console.error(`Config directory check error: ${dirError.message}`);
+            }
+            // Check file permissions
+            try {
+                const fileStats = await fs.stat(CONFIG_FILE).catch(() => null);
+                if (fileStats) {
+                    console.error(`Config file exists, permissions: ${fileStats.mode.toString(8)}`);
+                }
+                else {
+                    console.error('Config file does not exist, will create');
+                }
+            }
+            catch (statError) {
+                console.error(`Error checking file stats: ${statError.message}`);
+            }
+            let configData;
+            try {
+                configData = await fs.readFile(CONFIG_FILE, 'utf-8');
+                console.error(`Config file read successfully, content length: ${configData.length}`);
+            }
+            catch (readError) {
+                console.error(`Error reading config file: ${readError.message}, code: ${readError.code}, stack: ${readError.stack}`);
+                if (readError.code === 'ENOENT') {
+                    console.error('Config file does not exist, will create default');
+                }
+                else {
+                    throw readError;
+                }
+            }
+            if (configData) {
+                try {
+                    this.config = JSON.parse(configData);
+                    console.error(`Config parsed successfully: ${JSON.stringify(this.config, null, 2)}`);
+                }
+                catch (parseError) {
+                    console.error(`Failed to parse config JSON: ${parseError.message}`);
+                    // If file exists but has invalid JSON, use default empty config
+                    this.config = {};
+                }
+            }
+            else {
+                // If file doesn't exist, use default empty config
+                this.config = {};
+            }
+            this.initialized = true;
+            // Create default config file if it doesn't exist
+            if (!configData) {
+                console.error('Creating default config file');
+                await this.saveConfig();
+            }
+        }
+        catch (error) {
+            console.error(`Unexpected error in loadConfig: ${error instanceof Error ? error.message : String(error)}`);
+            console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
+            // Initialize with empty config
+            this.config = {};
+            this.initialized = true; // Mark as initialized even with empty config
+        }
+        return this.config;
+    }
+    /**
+     * Save current configuration to disk
+     */
+    async saveConfig() {
+        try {
+            console.error(`Saving config to ${CONFIG_FILE}...`);
+            console.error(`Current working directory: ${process.cwd()}`);
+            console.error(`Absolute config path: ${path.resolve(CONFIG_FILE)}`);
+            // Always try to create the config directory first
+            const configDir = path.dirname(CONFIG_FILE);
+            try {
+                console.error(`Ensuring config directory exists: ${configDir}`);
+                await fs.mkdir(configDir, { recursive: true });
+                console.error(`Config directory ready: ${configDir}`);
+            }
+            catch (mkdirError) {
+                console.error(`Failed to create directory: ${mkdirError.message}`);
+                if (mkdirError.code !== 'EEXIST') {
+                    throw mkdirError;
+                }
+            }
+            // Check directory permissions
+            try {
+                await fs.access(configDir, fs.constants.W_OK);
+                console.error(`Directory ${configDir} is writable`);
+            }
+            catch (accessError) {
+                console.error(`Directory access error: ${accessError.message}`);
+                throw new Error(`Config directory is not writable: ${accessError.message}`);
+            }
+            const configJson = JSON.stringify(this.config, null, 2);
+            console.error(`Config to save: ${configJson}`);
+            try {
+                // Try to write the file with explicit encoding and permissions
+                await fs.writeFile(CONFIG_FILE, configJson, {
+                    encoding: 'utf-8',
+                    mode: 0o644 // Readable/writable by owner, readable by others
+                });
+                console.error('Config saved successfully');
+            }
+            catch (writeError) {
+                console.error(`Write file error: ${writeError.message}, code: ${writeError.code}, stack: ${writeError.stack}`);
+                throw writeError;
+            }
+        }
+        catch (error) {
+            console.error(`Failed to save configuration: ${error instanceof Error ? error.message : String(error)}`);
+            console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
+            throw new Error(`Failed to save configuration: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get a specific configuration value
+     */
+    async getValue(key) {
+        if (!this.initialized) {
+            console.error(`getValue for key "${key}" - loading config first`);
+            await this.loadConfig();
+        }
+        console.error(`Getting value for key "${key}": ${JSON.stringify(this.config[key])}`);
+        return this.config[key];
+    }
+    /**
+     * Set a specific configuration value
+     */
+    async setValue(key, value) {
+        console.error(`Setting value for key "${key}": ${JSON.stringify(value)}`);
+        if (!this.initialized) {
+            console.error('setValue - loading config first');
+            await this.loadConfig();
+        }
+        this.config[key] = value;
+        await this.saveConfig();
+    }
+    /**
+     * Get the entire configuration object
+     */
+    async getConfig() {
+        if (!this.initialized) {
+            console.error('getConfig - loading config first');
+            await this.loadConfig();
+        }
+        console.error(`Getting full config: ${JSON.stringify(this.config, null, 2)}`);
+        return { ...this.config }; // Return a copy to prevent untracked mutations
+    }
+    /**
+     * Update multiple configuration values at once
+     */
+    async updateConfig(partialConfig) {
+        console.error(`Updating config with: ${JSON.stringify(partialConfig, null, 2)}`);
+        if (!this.initialized) {
+            console.error('updateConfig - loading config first');
+            await this.loadConfig();
+        }
+        this.config = {
+            ...this.config,
+            ...partialConfig
+        };
+        await this.saveConfig();
+        return { ...this.config };
+    }
+}
+// Memory-only version that doesn't try to save to filesystem
+class MemoryConfigManager {
+    constructor() {
+        this.config = {};
+        this.initialized = true;
+    }
+    async loadConfig() {
+        console.error('Using memory-only configuration (no filesystem operations)');
+        return this.config;
+    }
+    async saveConfig() {
+        console.error('Memory-only configuration - changes will not persist after restart');
+        // No-op - we don't save to filesystem
+        return;
+    }
+    async getValue(key) {
+        console.error(`Getting memory value for key "${key}": ${JSON.stringify(this.config[key])}`);
+        return this.config[key];
+    }
+    async setValue(key, value) {
+        console.error(`Setting memory value for key "${key}": ${JSON.stringify(value)}`);
+        this.config[key] = value;
+    }
+    async getConfig() {
+        console.error(`Getting full memory config: ${JSON.stringify(this.config, null, 2)}`);
+        return { ...this.config };
+    }
+    async updateConfig(partialConfig) {
+        console.error(`Updating memory config with: ${JSON.stringify(partialConfig, null, 2)}`);
+        this.config = {
+            ...this.config,
+            ...partialConfig
+        };
+        return { ...this.config };
+    }
+}
+// Export the appropriate manager based on the environment
+export const configManager = new ConfigManager();

package/dist/server.js

@@ -2,11 +2,12 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { commandManager } from './command-manager.js';
-import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, BlockCommandArgsSchema, UnblockCommandArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, SearchFilesArgsSchema, GetFileInfoArgsSchema, EditBlockArgsSchema, } from './tools/schemas.js';
+import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, BlockCommandArgsSchema, UnblockCommandArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, SearchFilesArgsSchema, GetFileInfoArgsSchema, EditBlockArgsSchema, SearchCodeArgsSchema, } from './tools/schemas.js';
 import { executeCommand, readOutput, forceTerminate, listSessions } from './tools/execute.js';
 import { listProcesses, killProcess } from './tools/process.js';
 import { readFile, readMultipleFiles, writeFile, createDirectory, listDirectory, moveFile, searchFiles, getFileInfo, listAllowedDirectories, } from './tools/filesystem.js';
 import { parseEditBlock, performSearchReplace } from './tools/edit.js';
+import { searchTextInFiles } from './tools/search.js';
 import { VERSION } from './version.js';
 export const server = new Server({
     name: "desktop-commander",
@@ -124,6 +125,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     "Only searches within allowed directories.",
                 inputSchema: zodToJsonSchema(SearchFilesArgsSchema),
             },
+            {
+                name: "search_code",
+                description: "Search for text/code patterns within file contents using ripgrep. " +
+                    "Fast and powerful search similar to VS Code search functionality. " +
+                    "Supports regular expressions, file pattern filtering, and context lines. " +
+                    "Only searches within allowed directories.",
+                inputSchema: zodToJsonSchema(SearchCodeArgsSchema),
+            },
             {
                 name: "get_file_info",
                 description: "Retrieve detailed metadata about a file or directory including size, " +
@@ -253,6 +262,36 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [{ type: "text", text: results.length > 0 ? results.join('\n') : "No matches found" }],
                 };
             }
+            case "search_code": {
+                const parsed = SearchCodeArgsSchema.parse(args);
+                const results = await searchTextInFiles({
+                    rootPath: parsed.path,
+                    pattern: parsed.pattern,
+                    filePattern: parsed.filePattern,
+                    ignoreCase: parsed.ignoreCase,
+                    maxResults: parsed.maxResults,
+                    includeHidden: parsed.includeHidden,
+                    contextLines: parsed.contextLines,
+                });
+                if (results.length === 0) {
+                    return {
+                        content: [{ type: "text", text: "No matches found" }],
+                    };
+                }
+                // Format the results in a VS Code-like format
+                let currentFile = "";
+                let formattedResults = "";
+                results.forEach(result => {
+                    if (result.file !== currentFile) {
+                        formattedResults += `\n${result.file}:\n`;
+                        currentFile = result.file;
+                    }
+                    formattedResults += `  ${result.line}: ${result.match}\n`;
+                });
+                return {
+                    content: [{ type: "text", text: formattedResults.trim() }],
+                };
+            }
             case "get_file_info": {
                 const parsed = GetFileInfoArgsSchema.parse(args);
                 const info = await getFileInfo(parsed.path);

package/dist/terminal-manager.d.ts

@@ -1,9 +1,19 @@
 import { CommandExecutionResult, ActiveSession } from './types.js';
+interface CompletedSession {
+    pid: number;
+    output: string;
+    exitCode: number | null;
+    startTime: Date;
+    endTime: Date;
+}
 export declare class TerminalManager {
     private sessions;
+    private completedSessions;
     executeCommand(command: string, timeoutMs?: number): Promise<CommandExecutionResult>;
     getNewOutput(pid: number): string | null;
     forceTerminate(pid: number): boolean;
     listActiveSessions(): ActiveSession[];
+    listCompletedSessions(): CompletedSession[];
 }
 export declare const terminalManager: TerminalManager;
+export {};

package/dist/terminal-manager.js

@@ -3,6 +3,7 @@ import { DEFAULT_COMMAND_TIMEOUT } from './config.js';
 export class TerminalManager {
     constructor() {
         this.sessions = new Map();
+        this.completedSessions = new Map();
     }
     async executeCommand(command, timeoutMs = DEFAULT_COMMAND_TIMEOUT) {
         const process = spawn(command, [], { shell: true });
@@ -38,8 +39,21 @@ export class TerminalManager {
                     isBlocked: true
                 });
             }, timeoutMs);
-            process.on('exit', () => {
+            process.on('exit', (code) => {
                 if (process.pid) {
+                    // Store completed session before removing active session
+                    this.completedSessions.set(process.pid, {
+                        pid: process.pid,
+                        output: output + session.lastOutput, // Combine all output
+                        exitCode: code,
+                        startTime: session.startTime,
+                        endTime: new Date()
+                    });
+                    // Keep only last 100 completed sessions
+                    if (this.completedSessions.size > 100) {
+                        const oldestKey = Array.from(this.completedSessions.keys())[0];
+                        this.completedSessions.delete(oldestKey);
+                    }
                     this.sessions.delete(process.pid);
                 }
                 resolve({
@@ -51,13 +65,21 @@ export class TerminalManager {
         });
     }
     getNewOutput(pid) {
+        // First check active sessions
         const session = this.sessions.get(pid);
-        if (!session) {
-            return null;
+        if (session) {
+            const output = session.lastOutput;
+            session.lastOutput = '';
+            return output;
+        }
+        // Then check completed sessions
+        const completedSession = this.completedSessions.get(pid);
+        if (completedSession) {
+            // Format completion message with exit code and runtime
+            const runtime = (completedSession.endTime.getTime() - completedSession.startTime.getTime()) / 1000;
+            return `Process completed with exit code ${completedSession.exitCode}\nRuntime: ${runtime}s\nFinal output:\n${completedSession.output}`;
         }
-        const output = session.lastOutput;
-        session.lastOutput = '';
-        return output;
+        return null;
     }
     forceTerminate(pid) {
         const session = this.sessions.get(pid);
@@ -86,5 +108,8 @@ export class TerminalManager {
             runtime: now.getTime() - session.startTime.getTime()
         }));
     }
+    listCompletedSessions() {
+        return Array.from(this.completedSessions.values());
+    }
 }
 export const terminalManager = new TerminalManager();

package/dist/tools/config.d.ts

@@ -0,0 +1,83 @@
+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
+ */
+export declare function getConfig(): Promise<{
+    content: {
+        type: string;
+        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
+ */
+export declare function setConfigValue(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+} | {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    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

@@ -0,0 +1,183 @@
+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()),
+});
+/**
+ * Get the entire config
+ */
+export async function getConfig() {
+    console.error('getConfig called');
+    try {
+        const config = await configManager.getConfig();
+        console.error(`getConfig result: ${JSON.stringify(config, null, 2)}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Current configuration:\n${JSON.stringify(config, null, 2)}`
+                }],
+        };
+    }
+    catch (error) {
+        console.error(`Error in getConfig: ${error instanceof Error ? error.message : String(error)}`);
+        console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
+        // Return empty config rather than crashing
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error getting configuration: ${error instanceof Error ? error.message : String(error)}\nUsing empty configuration.`
+                }],
+        };
+    }
+}
+/**
+ * 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
+ */
+export async function setConfigValue(args) {
+    console.error(`setConfigValue called with args: ${JSON.stringify(args)}`);
+    try {
+        const parsed = SetConfigValueArgsSchema.safeParse(args);
+        if (!parsed.success) {
+            console.error(`Invalid arguments for set_config_value: ${parsed.error}`);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Invalid arguments: ${parsed.error}`
+                    }],
+                isError: true
+            };
+        }
+        try {
+            await configManager.setValue(parsed.data.key, parsed.data.value);
+            console.error(`setConfigValue: Successfully set ${parsed.data.key} to ${JSON.stringify(parsed.data.value)}`);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Successfully set ${parsed.data.key} to ${JSON.stringify(parsed.data.value, null, 2)}`
+                    }],
+            };
+        }
+        catch (saveError) {
+            console.error(`Error saving config: ${saveError.message}`);
+            // Continue with in-memory change but report error
+            return {
+                content: [{
+                        type: "text",
+                        text: `Value changed in memory but couldn't be saved to disk: ${saveError.message}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    catch (error) {
+        console.error(`Error in setConfigValue: ${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 setting value: ${error instanceof Error ? error.message : String(error)}`
+                }],
+            isError: true
+        };
+    }
+}
+/**
+ * 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/filesystem.js

@@ -1,11 +1,18 @@
 import fs from "fs/promises";
 import path from "path";
 import os from 'os';
-// Store allowed directories
+// 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
+    os.homedir()   // User's home directory
 ];
+*/
 // Normalize all paths consistently
 function normalizePath(p) {
     return path.normalize(p).toLowerCase();
@@ -18,16 +25,34 @@ function expandHome(filepath) {
 }
 // Security utilities
 export async function validatePath(requestedPath) {
+    // Temporarily allow all paths by just returning the resolved path
+    // TODO: Implement configurable path validation
+    const expandedPath = expandHome(requestedPath);
+    const absolute = path.isAbsolute(expandedPath)
+        ? path.resolve(expandedPath)
+        : path.resolve(process.cwd(), expandedPath);
+    // Try to resolve real path for symlinks, but don't enforce restrictions
+    try {
+        return await fs.realpath(absolute);
+    }
+    catch (error) {
+        // If can't resolve (e.g., file doesn't exist yet), return absolute path
+        return absolute;
+    }
+    /* Original implementation commented out for future reference
     const expandedPath = expandHome(requestedPath);
     const absolute = path.isAbsolute(expandedPath)
         ? path.resolve(expandedPath)
         : path.resolve(process.cwd(), expandedPath);
+        
     const normalizedRequested = normalizePath(absolute);
+
     // Check if path is within allowed directories
     const isAllowed = allowedDirectories.some(dir => normalizedRequested.startsWith(normalizePath(dir)));
     if (!isAllowed) {
         throw new Error(`Access denied - path outside allowed directories: ${absolute}`);
     }
+
     // Handle symlinks by checking their real path
     try {
         const realPath = await fs.realpath(absolute);
@@ -37,8 +62,7 @@ export async function validatePath(requestedPath) {
             throw new Error("Access denied - symlink target outside allowed directories");
         }
         return realPath;
-    }
-    catch (error) {
+    } catch (error) {
         // For new files that don't exist yet, verify parent directory
         const parentDir = path.dirname(absolute);
         try {
@@ -49,11 +73,11 @@ export async function validatePath(requestedPath) {
                 throw new Error("Access denied - parent directory outside allowed directories");
             }
             return absolute;
-        }
-        catch {
+        } catch {
             throw new Error(`Parent directory does not exist: ${parentDir}`);
         }
     }
+    */
 }
 // File operation tools
 export async function readFile(filePath) {
@@ -129,5 +153,5 @@ export async function getFileInfo(filePath) {
     };
 }
 export function listAllowedDirectories() {
-    return allowedDirectories;
+    return ["/ (All paths are currently allowed)"];
 }

package/dist/tools/progress.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare const LongRunningTaskSchema: z.ZodObject<{
+    total_steps: z.ZodDefault<z.ZodNumber>;
+    step_duration: z.ZodDefault<z.ZodNumber>;
+    should_fail: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    total_steps: number;
+    step_duration: number;
+    should_fail: boolean;
+}, {
+    total_steps?: number | undefined;
+    step_duration?: number | undefined;
+    should_fail?: boolean | undefined;
+}>;
+export declare function executeLongRunning(args: unknown, server: any, progressToken?: string): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/progress.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+export const LongRunningTaskSchema = z.object({
+    total_steps: z.number().default(5).describe("Total number of steps to execute"),
+    step_duration: z.number().default(1000).describe("Duration of each step in milliseconds"),
+    should_fail: z.boolean().default(false).describe("Whether the task should fail midway through"),
+});
+export async function executeLongRunning(args, server, progressToken) {
+    const parsed = LongRunningTaskSchema.safeParse(args);
+    if (!parsed.success) {
+        throw new Error(`Invalid arguments for long_running_task: ${parsed.error}`);
+    }
+    const { total_steps, step_duration, should_fail } = parsed.data;
+    try {
+        for (let step = 1; step <= total_steps; step++) {
+            // Simulate work
+            await new Promise(resolve => setTimeout(resolve, step_duration));
+            // Send progress notification if we have a token
+            if (progressToken) {
+                await server.notification({
+                    method: "notifications/progress",
+                    params: {
+                        progress: step,
+                        total: total_steps,
+                        progressToken,
+                        detail: `Completed step ${step} of ${total_steps}${should_fail && step === Math.floor(total_steps / 2)
+                            ? ' (about to fail)'
+                            : ''}`
+                    }
+                });
+            }
+            // If should_fail is true, fail halfway through
+            if (should_fail && step === Math.floor(total_steps / 2)) {
+                throw new Error("Task failed halfway through as requested");
+            }
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Long running task completed successfully after ${total_steps} steps`
+                }]
+        };
+    }
+    catch (error) {
+        // Send error notification if we have a token
+        if (progressToken) {
+            await server.notification({
+                method: "notifications/progress",
+                params: {
+                    progress: Math.floor(total_steps / 2),
+                    total: total_steps,
+                    progressToken,
+                    detail: error instanceof Error ? error.message : 'Unknown error',
+                    error: true
+                }
+            });
+        }
+        throw error;
+    }
+}

package/dist/tools/schemas.d.ts

@@ -110,6 +110,31 @@ export declare const GetFileInfoArgsSchema: z.ZodObject<{
 }, {
     path: string;
 }>;
+export declare const SearchCodeArgsSchema: z.ZodObject<{
+    path: z.ZodString;
+    pattern: z.ZodString;
+    filePattern: z.ZodOptional<z.ZodString>;
+    ignoreCase: z.ZodOptional<z.ZodBoolean>;
+    maxResults: z.ZodOptional<z.ZodNumber>;
+    includeHidden: z.ZodOptional<z.ZodBoolean>;
+    contextLines: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    pattern: string;
+    filePattern?: string | undefined;
+    ignoreCase?: boolean | undefined;
+    maxResults?: number | undefined;
+    includeHidden?: boolean | undefined;
+    contextLines?: number | undefined;
+}, {
+    path: string;
+    pattern: string;
+    filePattern?: string | undefined;
+    ignoreCase?: boolean | undefined;
+    maxResults?: number | undefined;
+    includeHidden?: boolean | undefined;
+    contextLines?: number | undefined;
+}>;
 export declare const EditBlockArgsSchema: z.ZodObject<{
     blockContent: z.ZodString;
 }, "strip", z.ZodTypeAny, {

package/dist/tools/schemas.js

@@ -48,6 +48,16 @@ export const SearchFilesArgsSchema = z.object({
 export const GetFileInfoArgsSchema = z.object({
     path: z.string(),
 });
+// Search tools schema
+export const SearchCodeArgsSchema = z.object({
+    path: z.string(),
+    pattern: z.string(),
+    filePattern: z.string().optional(),
+    ignoreCase: z.boolean().optional(),
+    maxResults: z.number().optional(),
+    includeHidden: z.boolean().optional(),
+    contextLines: z.number().optional(),
+});
 // Edit tools schemas
 export const EditBlockArgsSchema = z.object({
     blockContent: z.string(),

package/dist/tools/search.d.ts

@@ -0,0 +1,32 @@
+export interface SearchResult {
+    file: string;
+    line: number;
+    match: string;
+}
+export declare function searchCode(options: {
+    rootPath: string;
+    pattern: string;
+    filePattern?: string;
+    ignoreCase?: boolean;
+    maxResults?: number;
+    includeHidden?: boolean;
+    contextLines?: number;
+}): Promise<SearchResult[]>;
+export declare function searchCodeFallback(options: {
+    rootPath: string;
+    pattern: string;
+    filePattern?: string;
+    ignoreCase?: boolean;
+    maxResults?: number;
+    excludeDirs?: string[];
+    contextLines?: number;
+}): Promise<SearchResult[]>;
+export declare function searchTextInFiles(options: {
+    rootPath: string;
+    pattern: string;
+    filePattern?: string;
+    ignoreCase?: boolean;
+    maxResults?: number;
+    includeHidden?: boolean;
+    contextLines?: number;
+}): Promise<SearchResult[]>;

package/dist/tools/search.js

@@ -0,0 +1,164 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs/promises';
+import { validatePath } from './filesystem.js';
+import { rgPath } from '@vscode/ripgrep';
+// 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;
+    // Validate path for security
+    const validPath = await validatePath(rootPath);
+    // Build command arguments
+    const args = [
+        '--json', // Output in JSON format for easier parsing
+        '--line-number', // Include line numbers
+    ];
+    if (ignoreCase) {
+        args.push('-i');
+    }
+    if (maxResults) {
+        args.push('-m', maxResults.toString());
+    }
+    if (includeHidden) {
+        args.push('--hidden');
+    }
+    if (contextLines > 0) {
+        args.push('-C', contextLines.toString());
+    }
+    if (filePattern) {
+        args.push('-g', filePattern);
+    }
+    // Add pattern and path
+    args.push(pattern, validPath);
+    // Run ripgrep command
+    return new Promise((resolve, reject) => {
+        const results = [];
+        const rg = spawn(rgPath, args);
+        let stdoutBuffer = '';
+        rg.stdout.on('data', (data) => {
+            stdoutBuffer += data.toString();
+        });
+        rg.stderr.on('data', (data) => {
+            console.error(`ripgrep error: ${data}`);
+        });
+        rg.on('close', (code) => {
+            if (code === 0 || code === 1) {
+                // Process the buffered output
+                const lines = stdoutBuffer.trim().split('\n');
+                for (const line of lines) {
+                    if (!line)
+                        continue;
+                    try {
+                        const result = JSON.parse(line);
+                        if (result.type === 'match') {
+                            result.data.submatches.forEach((submatch) => {
+                                results.push({
+                                    file: result.data.path.text,
+                                    line: result.data.line_number,
+                                    match: submatch.match.text
+                                });
+                            });
+                        }
+                        else if (result.type === 'context' && contextLines > 0) {
+                            results.push({
+                                file: result.data.path.text,
+                                line: result.data.line_number,
+                                match: result.data.lines.text.trim()
+                            });
+                        }
+                    }
+                    catch (e) {
+                        // Skip non-JSON output
+                        console.error('Error parsing ripgrep output:', e);
+                    }
+                }
+                resolve(results);
+            }
+            else {
+                reject(new Error(`ripgrep process exited with code ${code}`));
+            }
+        });
+    });
+}
+// Fallback implementation using Node.js for environments without ripgrep
+export async function searchCodeFallback(options) {
+    const { rootPath, pattern, filePattern, ignoreCase = true, maxResults = 1000, excludeDirs = ['node_modules', '.git'], contextLines = 0 } = options;
+    const validPath = await validatePath(rootPath);
+    const results = [];
+    const regex = new RegExp(pattern, ignoreCase ? 'i' : '');
+    const fileRegex = filePattern ? new RegExp(filePattern) : null;
+    async function searchDir(dirPath) {
+        if (results.length >= maxResults)
+            return;
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (results.length >= maxResults)
+                    break;
+                const fullPath = path.join(dirPath, entry.name);
+                try {
+                    await validatePath(fullPath);
+                    if (entry.isDirectory()) {
+                        if (!excludeDirs.includes(entry.name)) {
+                            await searchDir(fullPath);
+                        }
+                    }
+                    else if (entry.isFile()) {
+                        if (!fileRegex || fileRegex.test(entry.name)) {
+                            const content = await fs.readFile(fullPath, 'utf-8');
+                            const lines = content.split('\n');
+                            for (let i = 0; i < lines.length; i++) {
+                                if (regex.test(lines[i])) {
+                                    // Add the matched line
+                                    results.push({
+                                        file: fullPath,
+                                        line: i + 1,
+                                        match: lines[i].trim()
+                                    });
+                                    // Add context lines
+                                    if (contextLines > 0) {
+                                        const startIdx = Math.max(0, i - contextLines);
+                                        const endIdx = Math.min(lines.length - 1, i + contextLines);
+                                        for (let j = startIdx; j <= endIdx; j++) {
+                                            if (j !== i) { // Skip the match line as it's already added
+                                                results.push({
+                                                    file: fullPath,
+                                                    line: j + 1,
+                                                    match: lines[j].trim()
+                                                });
+                                            }
+                                        }
+                                    }
+                                    if (results.length >= maxResults)
+                                        break;
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    // Skip files/directories we can't access
+                    continue;
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories we can't read
+        }
+    }
+    await searchDir(validPath);
+    return results;
+}
+// Main function that tries ripgrep first, falls back to native implementation
+export async function searchTextInFiles(options) {
+    try {
+        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

@@ -22,3 +22,10 @@ export interface ActiveSession {
     isBlocked: boolean;
     runtime: number;
 }
+export interface CompletedSession {
+    pid: number;
+    output: string;
+    exitCode: number | null;
+    startTime: Date;
+    endTime: Date;
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.1.18";
+export declare const VERSION = "0.1.20";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.1.18';
+export const VERSION = '0.1.20';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "MCP server for terminal operations and file editing",
   "license": "MIT",
   "author": "Eduards Ruzga",
@@ -28,7 +28,8 @@
     "test:watch": "nodemon test/test.js",
     "link:local": "npm run build && npm link",
     "unlink:local": "npm unlink",
-    "inspector": "npx @modelcontextprotocol/inspector dist/index.js"
+    "inspector": "npx @modelcontextprotocol/inspector dist/index.js",
+    "npm-publish": "npm publish"
   },
   "publishConfig": {
     "access": "public"
@@ -54,6 +55,7 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.0.1",
+    "@vscode/ripgrep": "^1.15.9",
     "glob": "^10.3.10",
     "zod": "^3.24.1",
     "zod-to-json-schema": "^3.23.5"