@wonderwhy-er/desktop-commander 0.2.10 → 0.2.12

package/dist/handlers/search-handlers.js

@@ -0,0 +1,219 @@
+import { searchManager } from '../search-manager.js';
+import { StartSearchArgsSchema, GetMoreSearchResultsArgsSchema, StopSearchArgsSchema } from '../tools/schemas.js';
+import { capture } from '../utils/capture.js';
+/**
+ * Handle start_search command
+ */
+export async function handleStartSearch(args) {
+    const parsed = StartSearchArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Invalid arguments for start_search: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const result = await searchManager.startSearch({
+            rootPath: parsed.data.path,
+            pattern: parsed.data.pattern,
+            searchType: parsed.data.searchType,
+            filePattern: parsed.data.filePattern,
+            ignoreCase: parsed.data.ignoreCase,
+            maxResults: parsed.data.maxResults,
+            includeHidden: parsed.data.includeHidden,
+            contextLines: parsed.data.contextLines,
+            timeout: parsed.data.timeout_ms,
+            earlyTermination: parsed.data.earlyTermination,
+        });
+        const searchTypeText = parsed.data.searchType === 'content' ? 'content search' : 'file search';
+        let output = `Started ${searchTypeText} session: ${result.sessionId}\n`;
+        output += `Pattern: "${parsed.data.pattern}"\n`;
+        output += `Path: ${parsed.data.path}\n`;
+        output += `Status: ${result.isComplete ? 'COMPLETED' : 'RUNNING'}\n`;
+        output += `Runtime: ${Math.round(result.runtime)}ms\n`;
+        output += `Total results: ${result.totalResults}\n\n`;
+        if (result.results.length > 0) {
+            output += "Initial results:\n";
+            for (const searchResult of result.results.slice(0, 10)) {
+                if (searchResult.type === 'content') {
+                    output += `📄 ${searchResult.file}:${searchResult.line} - ${searchResult.match?.substring(0, 100)}${searchResult.match && searchResult.match.length > 100 ? '...' : ''}\n`;
+                }
+                else {
+                    output += `📁 ${searchResult.file}\n`;
+                }
+            }
+            if (result.results.length > 10) {
+                output += `... and ${result.results.length - 10} more results\n`;
+            }
+        }
+        if (result.isComplete) {
+            output += `\n✅ Search completed.`;
+        }
+        else {
+            output += `\n🔄 Search in progress. Use get_more_search_results to get more results.`;
+        }
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('search_session_start_error', { error: errorMessage });
+        return {
+            content: [{ type: "text", text: `Error starting search session: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle get_more_search_results command
+ */
+export async function handleGetMoreSearchResults(args) {
+    const parsed = GetMoreSearchResultsArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Invalid arguments for get_more_search_results: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const results = searchManager.readSearchResults(parsed.data.sessionId, parsed.data.offset, parsed.data.length);
+        // Only return error if we have no results AND there's an actual error
+        // Permission errors should not block returning found results
+        if (results.isError && results.totalResults === 0 && results.error?.trim()) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Search session ${parsed.data.sessionId} encountered an error: ${results.error}`
+                    }],
+                isError: true,
+            };
+        }
+        // Format results for display
+        let output = `Search session: ${parsed.data.sessionId}\n`;
+        output += `Status: ${results.isComplete ? 'COMPLETED' : 'IN PROGRESS'}\n`;
+        output += `Runtime: ${Math.round(results.runtime / 1000)}s\n`;
+        output += `Total results found: ${results.totalResults} (${results.totalMatches} matches)\n`;
+        const offset = parsed.data.offset;
+        if (offset < 0) {
+            // Negative offset - tail behavior
+            output += `Showing last ${results.returnedCount} results\n\n`;
+        }
+        else {
+            // Positive offset - range behavior
+            const startPos = offset;
+            const endPos = startPos + results.returnedCount - 1;
+            output += `Showing results ${startPos}-${endPos}\n\n`;
+        }
+        if (results.results.length === 0) {
+            if (results.isComplete) {
+                output += results.totalResults === 0 ? "No matches found." : "No results in this range.";
+            }
+            else {
+                output += "No results yet, search is still running...";
+            }
+        }
+        else {
+            output += "Results:\n";
+            for (const result of results.results) {
+                if (result.type === 'content') {
+                    output += `📄 ${result.file}:${result.line} - ${result.match?.substring(0, 100)}${result.match && result.match.length > 100 ? '...' : ''}\n`;
+                }
+                else {
+                    output += `📁 ${result.file}\n`;
+                }
+            }
+        }
+        // Add pagination hints
+        if (offset >= 0 && results.hasMoreResults) {
+            const nextOffset = offset + results.returnedCount;
+            output += `\n📖 More results available. Use get_more_search_results with offset: ${nextOffset}`;
+        }
+        if (results.isComplete) {
+            output += `\n✅ Search completed.`;
+        }
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error reading search results: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle stop_search command
+ */
+export async function handleStopSearch(args) {
+    const parsed = StopSearchArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Invalid arguments for stop_search: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const success = searchManager.terminateSearch(parsed.data.sessionId);
+        if (success) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Search session ${parsed.data.sessionId} terminated successfully.`
+                    }],
+            };
+        }
+        else {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Search session ${parsed.data.sessionId} not found or already completed.`
+                    }],
+            };
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error terminating search session: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle list_searches command
+ */
+export async function handleListSearches() {
+    try {
+        const sessions = searchManager.listSearchSessions();
+        if (sessions.length === 0) {
+            return {
+                content: [{ type: "text", text: "No active searches." }],
+            };
+        }
+        let output = `Active Searches (${sessions.length}):\n\n`;
+        for (const session of sessions) {
+            const status = session.isComplete
+                ? (session.isError ? '❌ ERROR' : '✅ COMPLETED')
+                : '🔄 RUNNING';
+            output += `Session: ${session.id}\n`;
+            output += `  Type: ${session.searchType}\n`;
+            output += `  Pattern: "${session.pattern}"\n`;
+            output += `  Status: ${status}\n`;
+            output += `  Runtime: ${Math.round(session.runtime / 1000)}s\n`;
+            output += `  Results: ${session.totalResults}\n\n`;
+        }
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error listing search sessions: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}

package/dist/index.js

@@ -5,6 +5,7 @@ import { configManager } from './config-manager.js';
 import { runSetup } from './npm-scripts/setup.js';
 import { runUninstall } from './npm-scripts/uninstall.js';
 import { capture } from './utils/capture.js';
+import { logToStderr, logger } from './utils/logger.js';
 async function runServer() {
     try {
         // Check if first argument is "setup"
@@ -17,6 +18,19 @@ async function runServer() {
             await runUninstall();
             return;
         }
+        try {
+            logToStderr('info', 'Loading configuration...');
+            await configManager.loadConfig();
+            logToStderr('info', 'Configuration loaded successfully');
+        }
+        catch (configError) {
+            logToStderr('error', `Failed to load configuration: ${configError instanceof Error ? configError.message : String(configError)}`);
+            if (configError instanceof Error && configError.stack) {
+                logToStderr('debug', `Stack trace: ${configError.stack}`);
+            }
+            logToStderr('warning', 'Continuing with in-memory configuration only');
+            // Continue anyway - we'll use an in-memory config
+        }
         const transport = new FilteredStdioServerTransport();
         // Export transport for use throughout the application
         global.mcpTransport = transport;
@@ -25,13 +39,13 @@ async function runServer() {
             const errorMessage = error instanceof Error ? error.message : String(error);
             // If this is a JSON parsing error, log it to stderr but don't crash
             if (errorMessage.includes('JSON') && errorMessage.includes('Unexpected token')) {
-                process.stderr.write(`[desktop-commander] JSON parsing error: ${errorMessage}\n`);
+                logger.error(`JSON parsing error: ${errorMessage}`);
                 return; // Don't exit on JSON parsing errors
             }
             capture('run_server_uncaught_exception', {
                 error: errorMessage
             });
-            process.stderr.write(`[desktop-commander] Uncaught exception: ${errorMessage}\n`);
+            logger.error(`Uncaught exception: ${errorMessage}`);
             process.exit(1);
         });
         // Handle unhandled rejections
@@ -39,40 +53,45 @@ async function runServer() {
             const errorMessage = reason instanceof Error ? reason.message : String(reason);
             // If this is a JSON parsing error, log it to stderr but don't crash
             if (errorMessage.includes('JSON') && errorMessage.includes('Unexpected token')) {
-                process.stderr.write(`[desktop-commander] JSON parsing rejection: ${errorMessage}\n`);
+                logger.error(`JSON parsing rejection: ${errorMessage}`);
                 return; // Don't exit on JSON parsing errors
             }
             capture('run_server_unhandled_rejection', {
                 error: errorMessage
             });
-            process.stderr.write(`[desktop-commander] Unhandled rejection: ${errorMessage}\n`);
+            logger.error(`Unhandled rejection: ${errorMessage}`);
             process.exit(1);
         });
         capture('run_server_start');
-        try {
-            console.error("Loading configuration...");
-            await configManager.loadConfig();
-            console.error("Configuration loaded successfully");
-        }
-        catch (configError) {
-            console.error(`Failed to load configuration: ${configError instanceof Error ? configError.message : String(configError)}`);
-            console.error(configError instanceof Error && configError.stack ? configError.stack : 'No stack trace available');
-            console.error("Continuing with in-memory configuration only");
-            // Continue anyway - we'll use an in-memory config
-        }
-        console.error("Connecting server...");
+        logToStderr('info', 'Connecting server...');
+        // Set up event-driven initialization completion handler
+        server.oninitialized = () => {
+            // This callback is triggered after the client sends the "initialized" notification
+            // At this point, the MCP protocol handshake is fully complete
+            transport.enableNotifications();
+            // Use the transport to send a proper JSON-RPC notification
+            transport.sendLog('info', 'MCP fully initialized, notifications enabled');
+        };
         await server.connect(transport);
-        console.error("Server connected successfully");
+        logToStderr('info', 'Server connected successfully');
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`FATAL ERROR: ${errorMessage}`);
-        console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
-        process.stderr.write(JSON.stringify({
-            type: 'error',
-            timestamp: new Date().toISOString(),
-            message: `Failed to start server: ${errorMessage}`
-        }) + '\n');
+        logger.error(`FATAL ERROR: ${errorMessage}`);
+        if (error instanceof Error && error.stack) {
+            logger.debug(error.stack);
+        }
+        // Send a structured error notification
+        const errorNotification = {
+            jsonrpc: "2.0",
+            method: "notifications/message",
+            params: {
+                level: "error",
+                logger: "desktop-commander",
+                data: `Failed to start server: ${errorMessage} (${new Date().toISOString()})`
+            }
+        };
+        process.stdout.write(JSON.stringify(errorNotification) + '\n');
         capture('run_server_failed_start_error', {
             error: errorMessage
         });

package/dist/search-manager.d.ts

@@ -0,0 +1,107 @@
+import { ChildProcess } from 'child_process';
+export interface SearchResult {
+    file: string;
+    line?: number;
+    match?: string;
+    type: 'file' | 'content';
+}
+export interface SearchSession {
+    id: string;
+    process: ChildProcess;
+    results: SearchResult[];
+    isComplete: boolean;
+    isError: boolean;
+    error?: string;
+    startTime: number;
+    lastReadTime: number;
+    options: SearchSessionOptions;
+    buffer: string;
+    totalMatches: number;
+    totalContextLines: number;
+}
+export interface SearchSessionOptions {
+    rootPath: string;
+    pattern: string;
+    searchType: 'files' | 'content';
+    filePattern?: string;
+    ignoreCase?: boolean;
+    maxResults?: number;
+    includeHidden?: boolean;
+    contextLines?: number;
+    timeout?: number;
+    earlyTermination?: boolean;
+}
+/**
+ * Search Session Manager - handles ripgrep processes like terminal sessions
+ * Supports both file search and content search with progressive results
+ */ export declare class SearchManager {
+    private sessions;
+    private sessionCounter;
+    /**
+     * Start a new search session (like start_process)
+     * Returns immediately with initial state and results
+     */
+    startSearch(options: SearchSessionOptions): Promise<{
+        sessionId: string;
+        isComplete: boolean;
+        isError: boolean;
+        results: SearchResult[];
+        totalResults: number;
+        runtime: number;
+    }>;
+    /**
+     * Read search results with offset-based pagination (like read_file)
+     * Supports both range reading and tail behavior
+     */
+    readSearchResults(sessionId: string, offset?: number, length?: number): {
+        results: SearchResult[];
+        returnedCount: number;
+        totalResults: number;
+        totalMatches: number;
+        isComplete: boolean;
+        isError: boolean;
+        error?: string;
+        hasMoreResults: boolean;
+        runtime: number;
+    };
+    /**
+     * Terminate a search session (like force_terminate)
+     */
+    terminateSearch(sessionId: string): boolean;
+    /**
+     * Get list of active search sessions (like list_sessions)
+     */
+    listSearchSessions(): Array<{
+        id: string;
+        searchType: string;
+        pattern: string;
+        isComplete: boolean;
+        isError: boolean;
+        runtime: number;
+        totalResults: number;
+    }>;
+    /**
+     * Clean up completed sessions older than specified time
+     * Called automatically by cleanup interval
+     */
+    cleanupSessions(maxAge?: number): void;
+    /**
+     * Get total number of active sessions (excluding completed ones)
+     */
+    getActiveSessionCount(): number;
+    /**
+     * Detect if pattern looks like an exact filename
+     * (has file extension and no glob wildcards)
+     */
+    private isExactFilename;
+    /**
+     * Detect if pattern contains glob wildcards
+     */
+    private isGlobPattern;
+    private buildRipgrepArgs;
+    private setupProcessHandlers;
+    private processBufferedOutput;
+    private parseLine;
+}
+export declare const searchManager: SearchManager;
+export declare function stopSearchManagerCleanup(): void;