@wonderwhy-er/desktop-commander 0.2.10 → 0.2.11

package/dist/tools/filesystem.js

@@ -768,6 +768,63 @@ export async function moveFile(sourcePath, destinationPath) {
     await fs.rename(validSourcePath, validDestPath);
 }
 export async function searchFiles(rootPath, pattern) {
+    // Use the new search manager for better performance
+    // This provides a temporary compatibility layer until we fully migrate to search sessions
+    const { searchManager } = await import('../search-manager.js');
+    try {
+        const result = await searchManager.startSearch({
+            rootPath,
+            pattern,
+            searchType: 'files',
+            ignoreCase: true,
+            maxResults: 5000, // Higher limit for compatibility
+            earlyTermination: true, // Use early termination for better performance
+        });
+        const sessionId = result.sessionId;
+        // Poll for results until complete
+        let allResults = [];
+        let isComplete = result.isComplete;
+        let startTime = Date.now();
+        // Add initial results
+        for (const searchResult of result.results) {
+            if (searchResult.type === 'file') {
+                allResults.push(searchResult.file);
+            }
+        }
+        while (!isComplete) {
+            await new Promise(resolve => setTimeout(resolve, 100)); // Wait 100ms
+            const results = searchManager.readSearchResults(sessionId);
+            isComplete = results.isComplete;
+            // Add new file paths to results
+            for (const searchResult of results.results) {
+                if (searchResult.file !== '__LAST_READ_MARKER__' && searchResult.type === 'file') {
+                    allResults.push(searchResult.file);
+                }
+            }
+            // Safety check to prevent infinite loops (30 second timeout)
+            if (Date.now() - startTime > 30000) {
+                searchManager.terminateSearch(sessionId);
+                break;
+            }
+        }
+        // Log only the count of found files, not their paths
+        capture('server_search_files_complete', {
+            resultsCount: allResults.length,
+            patternLength: pattern.length,
+            usedRipgrep: true
+        });
+        return allResults;
+    }
+    catch (error) {
+        // Fallback to original Node.js implementation if ripgrep fails
+        capture('server_search_files_ripgrep_fallback', {
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+        return await searchFilesNodeJS(rootPath, pattern);
+    }
+}
+// Keep the original Node.js implementation as fallback
+async function searchFilesNodeJS(rootPath, pattern) {
     const results = [];
     async function search(currentPath) {
         let entries;
@@ -800,7 +857,8 @@ export async function searchFiles(rootPath, pattern) {
         // Log only the count of found files, not their paths
         capture('server_search_files_complete', {
             resultsCount: results.length,
-            patternLength: pattern.length
+            patternLength: pattern.length,
+            usedRipgrep: false
         });
         return results;
     }

package/dist/tools/schemas.d.ts

@@ -109,19 +109,6 @@ export declare const MoveFileArgsSchema: z.ZodObject<{
     source: string;
     destination: string;
 }>;
-export declare const SearchFilesArgsSchema: z.ZodObject<{
-    path: z.ZodString;
-    pattern: z.ZodString;
-    timeoutMs: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    pattern: string;
-    timeoutMs?: number | undefined;
-}, {
-    path: string;
-    pattern: string;
-    timeoutMs?: number | undefined;
-}>;
 export declare const GetFileInfoArgsSchema: z.ZodObject<{
     path: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -129,34 +116,6 @@ 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>;
-    timeoutMs: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    pattern: string;
-    timeoutMs?: number | undefined;
-    filePattern?: string | undefined;
-    ignoreCase?: boolean | undefined;
-    maxResults?: number | undefined;
-    includeHidden?: boolean | undefined;
-    contextLines?: number | undefined;
-}, {
-    path: string;
-    pattern: string;
-    timeoutMs?: number | undefined;
-    filePattern?: string | undefined;
-    ignoreCase?: boolean | undefined;
-    maxResults?: number | undefined;
-    includeHidden?: boolean | undefined;
-    contextLines?: number | undefined;
-}>;
 export declare const EditBlockArgsSchema: z.ZodObject<{
     file_path: z.ZodString;
     old_string: z.ZodString;
@@ -191,3 +150,58 @@ export declare const InteractWithProcessArgsSchema: z.ZodObject<{
 }>;
 export declare const GetUsageStatsArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
 export declare const GiveFeedbackArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const StartSearchArgsSchema: z.ZodObject<{
+    path: z.ZodString;
+    pattern: z.ZodString;
+    searchType: z.ZodDefault<z.ZodEnum<["files", "content"]>>;
+    filePattern: z.ZodOptional<z.ZodString>;
+    ignoreCase: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxResults: z.ZodOptional<z.ZodNumber>;
+    includeHidden: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    contextLines: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+    earlyTermination: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    pattern: string;
+    searchType: "content" | "files";
+    ignoreCase: boolean;
+    includeHidden: boolean;
+    contextLines: number;
+    timeout_ms?: number | undefined;
+    filePattern?: string | undefined;
+    maxResults?: number | undefined;
+    earlyTermination?: boolean | undefined;
+}, {
+    path: string;
+    pattern: string;
+    timeout_ms?: number | undefined;
+    searchType?: "content" | "files" | undefined;
+    filePattern?: string | undefined;
+    ignoreCase?: boolean | undefined;
+    maxResults?: number | undefined;
+    includeHidden?: boolean | undefined;
+    contextLines?: number | undefined;
+    earlyTermination?: boolean | undefined;
+}>;
+export declare const GetMoreSearchResultsArgsSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    length: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    length: number;
+    offset: number;
+    sessionId: string;
+}, {
+    sessionId: string;
+    length?: number | undefined;
+    offset?: number | undefined;
+}>;
+export declare const StopSearchArgsSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+}, {
+    sessionId: string;
+}>;
+export declare const ListSearchesArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;

package/dist/tools/schemas.js

@@ -49,25 +49,9 @@ export const MoveFileArgsSchema = z.object({
     source: z.string(),
     destination: z.string(),
 });
-export const SearchFilesArgsSchema = z.object({
-    path: z.string(),
-    pattern: z.string(),
-    timeoutMs: z.number().optional(),
-});
 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(),
-    timeoutMs: z.number().optional(),
-});
 // Edit tools schema
 export const EditBlockArgsSchema = z.object({
     file_path: z.string(),
@@ -93,3 +77,25 @@ export const GiveFeedbackArgsSchema = z.object({
 // - platform (auto)
 // - client_id (auto)
 });
+// Search schemas (renamed for natural language)
+export const StartSearchArgsSchema = z.object({
+    path: z.string(),
+    pattern: z.string(),
+    searchType: z.enum(['files', 'content']).default('files'),
+    filePattern: z.string().optional(),
+    ignoreCase: z.boolean().optional().default(true),
+    maxResults: z.number().optional(),
+    includeHidden: z.boolean().optional().default(false),
+    contextLines: z.number().optional().default(5),
+    timeout_ms: z.number().optional(), // Match process naming convention
+    earlyTermination: z.boolean().optional(), // Stop search early when exact filename match is found (default: true for files, false for content)
+});
+export const GetMoreSearchResultsArgsSchema = z.object({
+    sessionId: z.string(),
+    offset: z.number().optional().default(0), // Same as file reading
+    length: z.number().optional().default(100), // Same as file reading (but smaller default)
+});
+export const StopSearchArgsSchema = z.object({
+    sessionId: z.string(),
+});
+export const ListSearchesArgsSchema = z.object({});

package/dist/tools/search.js

@@ -27,7 +27,15 @@ export async function searchCode(options) {
         args.push('-C', contextLines.toString());
     }
     if (filePattern) {
-        args.push('-g', filePattern);
+        const patterns = filePattern
+            .split('|')
+            .map(p => p.trim()) // remove surrounding spaces
+            .filter(Boolean); // drop empty tokens
+        // If all patterns were empty, return no results
+        if (patterns.length === 0) {
+            return [];
+        }
+        patterns.forEach(p => args.push('-g', p));
     }
     // Add pattern and path
     args.push(pattern, validPath);
@@ -97,7 +105,21 @@ export async function searchCodeFallback(options) {
     const validPath = await validatePath(rootPath);
     const results = [];
     const regex = new RegExp(pattern, ignoreCase ? 'i' : '');
-    const fileRegex = filePattern ? new RegExp(filePattern) : null;
+    // Handle filePattern similarly to main implementation
+    let fileRegex = null;
+    if (filePattern) {
+        const patterns = filePattern
+            .split('|')
+            .map(p => p.trim())
+            .filter(Boolean);
+        // If all patterns were empty, return no results
+        if (patterns.length === 0) {
+            return [];
+        }
+        // Create a regex that matches any of the patterns
+        const combinedPattern = patterns.map(p => p.replace(/\./g, '\\.').replace(/\*/g, '.*').replace(/\?/g, '.')).join('|');
+        fileRegex = new RegExp(`^(${combinedPattern})$`);
+    }
     async function searchDir(dirPath) {
         if (results.length >= maxResults)
             return;
@@ -163,12 +185,18 @@ export async function searchCodeFallback(options) {
 // Main function that tries ripgrep first, falls back to native implementation
 export async function searchTextInFiles(options) {
     try {
+        // For better performance and consistency, prefer the search session manager
+        // when doing content search, but keep the original direct ripgrep approach as primary
         return await searchCode(options);
     }
     catch (error) {
+        capture('searchTextInFiles_ripgrep_fallback', {
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+        // Use consistent exclusions - remove 'dist' to match ripgrep behavior
         return searchCodeFallback({
             ...options,
-            excludeDirs: ['node_modules', '.git', 'dist']
+            excludeDirs: ['node_modules', '.git']
         });
     }
 }

package/dist/utils/capture.js

@@ -123,16 +123,63 @@ export const captureBase = async (captureURL, event, properties) => {
         if (process.env.MCP_DXT) {
             isDXT = 'true';
         }
-        // Is MCP running in a Docker container
-        let isDocker = 'false';
-        if (process.env.MCP_CLIENT_DOCKER) {
-            isDocker = 'true';
+        // Is MCP running in a container - use robust detection
+        const { getSystemInfo } = await import('./system-info.js');
+        const systemInfo = getSystemInfo();
+        const isContainer = systemInfo.docker.isContainer ? 'true' : 'false';
+        const containerType = systemInfo.docker.containerType || 'none';
+        const orchestrator = systemInfo.docker.orchestrator || 'none';
+        // Add container metadata (with privacy considerations)
+        let containerName = 'none';
+        let containerImage = 'none';
+        if (systemInfo.docker.isContainer && systemInfo.docker.containerEnvironment) {
+            const env = systemInfo.docker.containerEnvironment;
+            // Container name - sanitize to remove potentially sensitive info
+            if (env.containerName) {
+                // Keep only alphanumeric chars, dashes, and underscores
+                // Remove random IDs and UUIDs for privacy
+                containerName = env.containerName
+                    .replace(/[0-9a-f]{8,}/gi, 'ID') // Replace long hex strings with 'ID'
+                    .replace(/[0-9]{8,}/g, 'ID') // Replace long numeric IDs with 'ID'
+                    .substring(0, 50); // Limit length
+            }
+            // Docker image - sanitize registry info for privacy
+            if (env.dockerImage) {
+                // Remove registry URLs and keep just image:tag format
+                containerImage = env.dockerImage
+                    .replace(/^[^/]+\/[^/]+\//, '') // Remove registry.com/namespace/ prefix
+                    .replace(/^[^/]+\//, '') // Remove simple registry.com/ prefix
+                    .replace(/@sha256:.*$/, '') // Remove digest hashes
+                    .substring(0, 100); // Limit length
+            }
+        }
+        // Detect if we're running through Smithery at runtime
+        let runtimeSource = 'unknown';
+        const processArgs = process.argv.join(' ');
+        try {
+            if (processArgs.includes('@smithery/cli') || processArgs.includes('smithery')) {
+                runtimeSource = 'smithery-runtime';
+            }
+            else if (processArgs.includes('npx')) {
+                runtimeSource = 'npx-runtime';
+            }
+            else {
+                runtimeSource = 'direct-runtime';
+            }
+        }
+        catch (error) {
+            // Ignore detection errors
         }
         // Prepare standard properties
         const baseProperties = {
             timestamp: new Date().toISOString(),
             platform: platform(),
-            isDocker,
+            isContainer,
+            containerType,
+            orchestrator,
+            containerName,
+            containerImage,
+            runtimeSource,
             isDXT,
             app_version: VERSION,
             engagement_time_msec: "100"
@@ -169,13 +216,14 @@ export const captureBase = async (captureURL, event, properties) => {
                 data += chunk;
             });
             res.on('end', () => {
-                if (res.statusCode !== 200 && res.statusCode !== 204) {
+                const success = res.statusCode === 200 || res.statusCode === 204;
+                if (!success) {
                     // Optional debug logging
                     // console.debug(`GA tracking error: ${res.statusCode} ${data}`);
                 }
             });
         });
-        req.on('error', () => {
+        req.on('error', (error) => {
             // Silently fail - we don't want analytics issues to break functionality
         });
         // Set timeout to prevent blocking the app
@@ -186,7 +234,7 @@ export const captureBase = async (captureURL, event, properties) => {
         req.write(postData);
         req.end();
     }
-    catch {
+    catch (error) {
         // Silently fail - we don't want analytics issues to break functionality
     }
 };

package/dist/utils/dedent.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Removes common leading whitespace from all lines in a template literal.
+ * This function helps clean up indented template literals used for tool descriptions.
+ *
+ * @param text - The template literal string with potential leading whitespace
+ * @returns The dedented string with leading whitespace removed
+ */
+export declare function dedent(text: string): string;

package/dist/utils/dedent.js

@@ -0,0 +1,38 @@
+/**
+ * Removes common leading whitespace from all lines in a template literal.
+ * This function helps clean up indented template literals used for tool descriptions.
+ *
+ * @param text - The template literal string with potential leading whitespace
+ * @returns The dedented string with leading whitespace removed
+ */
+export function dedent(text) {
+    // Split into lines
+    const lines = text.split('\n');
+    // Remove first and last lines if they're empty
+    if (lines[0] === '')
+        lines.shift();
+    if (lines[lines.length - 1] === '')
+        lines.pop();
+    // If no lines remain, return empty string
+    if (lines.length === 0)
+        return '';
+    // Find the minimum indentation (excluding empty lines)
+    let minIndent = Infinity;
+    for (const line of lines) {
+        if (line.trim() === '')
+            continue; // Skip empty lines
+        const indent = line.match(/^(\s*)/)?.[1]?.length || 0;
+        minIndent = Math.min(minIndent, indent);
+    }
+    // If no indentation found, return as-is
+    if (minIndent === 0 || minIndent === Infinity) {
+        return lines.join('\n');
+    }
+    // Remove the common indentation from all lines
+    const dedentedLines = lines.map(line => {
+        if (line.trim() === '')
+            return ''; // Keep empty lines empty
+        return line.slice(minIndent);
+    });
+    return dedentedLines.join('\n');
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Centralized logging utility for Desktop Commander
+ * Ensures all logging goes through proper channels based on initialization state
+ */
+import type { FilteredStdioServerTransport } from '../custom-stdio.js';
+declare global {
+    var mcpTransport: FilteredStdioServerTransport | undefined;
+}
+export type LogLevel = 'emergency' | 'alert' | 'critical' | 'error' | 'warning' | 'notice' | 'info' | 'debug';
+/**
+ * Log a message using the appropriate method based on MCP initialization state
+ */
+export declare function log(level: LogLevel, message: string, data?: any): void;
+/**
+ * Convenience functions for different log levels
+ */
+export declare const logger: {
+    emergency: (message: string, data?: any) => void;
+    alert: (message: string, data?: any) => void;
+    critical: (message: string, data?: any) => void;
+    error: (message: string, data?: any) => void;
+    warning: (message: string, data?: any) => void;
+    notice: (message: string, data?: any) => void;
+    info: (message: string, data?: any) => void;
+    debug: (message: string, data?: any) => void;
+};
+/**
+ * Log to stderr during early initialization (before MCP is ready)
+ * Use this for critical startup messages that must be visible
+ * NOTE: This should also be JSON-RPC format
+ */
+export declare function logToStderr(level: LogLevel, message: string): void;

package/dist/utils/logger.js

@@ -0,0 +1,72 @@
+/**
+ * Centralized logging utility for Desktop Commander
+ * Ensures all logging goes through proper channels based on initialization state
+ */
+/**
+ * Log a message using the appropriate method based on MCP initialization state
+ */
+export function log(level, message, data) {
+    try {
+        // Check if MCP transport is available
+        if (global.mcpTransport) {
+            // Always use MCP logging (will buffer if not initialized yet)
+            global.mcpTransport.sendLog(level, message, data);
+        }
+        else {
+            // This should rarely happen, but fallback to create a JSON-RPC notification manually
+            const notification = {
+                jsonrpc: "2.0",
+                method: "notifications/message",
+                params: {
+                    level: level,
+                    logger: "desktop-commander",
+                    data: data ? { message, ...data } : message
+                }
+            };
+            process.stdout.write(JSON.stringify(notification) + '\n');
+        }
+    }
+    catch (error) {
+        // Ultimate fallback - but this should be JSON-RPC too
+        const notification = {
+            jsonrpc: "2.0",
+            method: "notifications/message",
+            params: {
+                level: "error",
+                logger: "desktop-commander",
+                data: `[LOG-ERROR] Failed to log message: ${message}`
+            }
+        };
+        process.stdout.write(JSON.stringify(notification) + '\n');
+    }
+}
+/**
+ * Convenience functions for different log levels
+ */
+export const logger = {
+    emergency: (message, data) => log('emergency', message, data),
+    alert: (message, data) => log('alert', message, data),
+    critical: (message, data) => log('critical', message, data),
+    error: (message, data) => log('error', message, data),
+    warning: (message, data) => log('warning', message, data),
+    notice: (message, data) => log('notice', message, data),
+    info: (message, data) => log('info', message, data),
+    debug: (message, data) => log('debug', message, data),
+};
+/**
+ * Log to stderr during early initialization (before MCP is ready)
+ * Use this for critical startup messages that must be visible
+ * NOTE: This should also be JSON-RPC format
+ */
+export function logToStderr(level, message) {
+    const notification = {
+        jsonrpc: "2.0",
+        method: "notifications/message",
+        params: {
+            level: level,
+            logger: "desktop-commander",
+            data: message
+        }
+    };
+    process.stdout.write(JSON.stringify(notification) + '\n');
+}

package/dist/utils/system-info.d.ts

@@ -5,13 +5,19 @@ export interface DockerMount {
     readOnly: boolean;
     description: string;
 }
-export interface DockerInfo {
+export interface ContainerInfo {
+    isContainer: boolean;
+    containerType: 'docker' | 'podman' | 'kubernetes' | 'lxc' | 'systemd-nspawn' | 'other' | null;
+    orchestrator: 'kubernetes' | 'docker-compose' | 'docker-swarm' | 'podman-compose' | null;
     isDocker: boolean;
     mountPoints: DockerMount[];
     containerEnvironment?: {
         dockerImage?: string;
         containerName?: string;
         hostPlatform?: string;
+        kubernetesNamespace?: string;
+        kubernetesPod?: string;
+        kubernetesNode?: string;
     };
 }
 export interface SystemInfo {
@@ -22,7 +28,7 @@ export interface SystemInfo {
     isWindows: boolean;
     isMacOS: boolean;
     isLinux: boolean;
-    docker: DockerInfo;
+    docker: ContainerInfo;
     examplePaths: {
         home: string;
         temp: string;