@wonderwhy-er/desktop-commander 0.2.3 → 0.2.4

package/dist/tools/improved-process-tools.js

@@ -3,7 +3,8 @@ import { commandManager } from '../command-manager.js';
 import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema } from './schemas.js';
 import { capture } from "../utils/capture.js";
 import { analyzeProcessState, cleanProcessOutput, formatProcessStateMessage } from '../utils/process-detection.js';
-import { getSystemInfo } from '../utils/system-info.js';
+import * as os from 'os';
+import { configManager } from '../config-manager.js';
 /**
  * Start a new process (renamed from execute_command)
  * Includes early detection of process waiting for input
@@ -36,7 +37,26 @@ export async function startProcess(args) {
             isError: true,
         };
     }
-    const result = await terminalManager.executeCommand(parsed.data.command, parsed.data.timeout_ms, parsed.data.shell);
+    let shellUsed = parsed.data.shell;
+    if (!shellUsed) {
+        const config = await configManager.getConfig();
+        if (config.defaultShell) {
+            shellUsed = config.defaultShell;
+        }
+        else {
+            const isWindows = os.platform() === 'win32';
+            if (isWindows && process.env.COMSPEC) {
+                shellUsed = process.env.COMSPEC;
+            }
+            else if (!isWindows && process.env.SHELL) {
+                shellUsed = process.env.SHELL;
+            }
+            else {
+                shellUsed = isWindows ? 'cmd.exe' : '/bin/sh';
+            }
+        }
+    }
+    const result = await terminalManager.executeCommand(parsed.data.command, parsed.data.timeout_ms, shellUsed);
     if (result.pid === -1) {
         return {
             content: [{ type: "text", text: result.output }],
@@ -45,9 +65,6 @@ export async function startProcess(args) {
     }
     // Analyze the process state to detect if it's waiting for input
     const processState = analyzeProcessState(result.output, result.pid);
-    // Get system info for shell information
-    const systemInfo = getSystemInfo();
-    const shellUsed = parsed.data.shell || systemInfo.defaultShell;
     let statusMessage = '';
     if (processState.isWaitingForInput) {
         statusMessage = `\n🔄 ${formatProcessStateMessage(processState, result.pid)}`;
@@ -93,19 +110,27 @@ export async function readProcessOutput(args) {
         const outputPromise = new Promise((resolve) => {
             const initialOutput = terminalManager.getNewOutput(pid);
             if (initialOutput && initialOutput.length > 0) {
+                // Immediate check on existing output
+                const state = analyzeProcessState(initialOutput, pid);
+                if (state.isWaitingForInput) {
+                    earlyExit = true;
+                    processState = state;
+                }
                 resolve(initialOutput);
                 return;
             }
             let resolved = false;
             let interval = null;
             let timeout = null;
+            // Quick prompt patterns for immediate detection
+            const quickPromptPatterns = />>>\s*$|>\s*$|\$\s*$|#\s*$/;
             const cleanup = () => {
                 if (interval)
                     clearInterval(interval);
                 if (timeout)
                     clearTimeout(timeout);
             };
-            const resolveOnce = (value, isTimeout = false) => {
+            let resolveOnce = (value, isTimeout = false) => {
                 if (resolved)
                     return;
                 resolved = true;
@@ -113,6 +138,43 @@ export async function readProcessOutput(args) {
                 timeoutReached = isTimeout;
                 resolve(value);
             };
+            // Monitor for new output with immediate detection
+            const session = terminalManager.getSession(pid);
+            if (session && session.process && session.process.stdout && session.process.stderr) {
+                const immediateDetector = (data) => {
+                    const text = data.toString();
+                    // Immediate check for obvious prompts
+                    if (quickPromptPatterns.test(text)) {
+                        const newOutput = terminalManager.getNewOutput(pid) || text;
+                        const state = analyzeProcessState(output + newOutput, pid);
+                        if (state.isWaitingForInput) {
+                            earlyExit = true;
+                            processState = state;
+                            resolveOnce(newOutput);
+                            return;
+                        }
+                    }
+                };
+                session.process.stdout.on('data', immediateDetector);
+                session.process.stderr.on('data', immediateDetector);
+                // Cleanup immediate detectors when done
+                const originalResolveOnce = resolveOnce;
+                const cleanupDetectors = () => {
+                    if (session.process.stdout) {
+                        session.process.stdout.removeListener('data', immediateDetector);
+                    }
+                    if (session.process.stderr) {
+                        session.process.stderr.removeListener('data', immediateDetector);
+                    }
+                };
+                // Override resolveOnce to include cleanup
+                const resolveOnceWithCleanup = (value, isTimeout = false) => {
+                    cleanupDetectors();
+                    originalResolveOnce(value, isTimeout);
+                };
+                // Replace the local resolveOnce reference
+                resolveOnce = resolveOnceWithCleanup;
+            }
             interval = setInterval(() => {
                 const newOutput = terminalManager.getNewOutput(pid);
                 if (newOutput && newOutput.length > 0) {
@@ -209,32 +271,100 @@ export async function interactWithProcess(args) {
                     }],
             };
         }
-        // Smart waiting with process state detection
+        // Smart waiting with immediate and periodic detection
         let output = "";
-        let attempts = 0;
-        const maxAttempts = Math.ceil(timeout_ms / 200);
         let processState;
-        while (attempts < maxAttempts) {
-            await new Promise(resolve => setTimeout(resolve, 200));
-            const newOutput = terminalManager.getNewOutput(pid);
-            if (newOutput && newOutput.length > 0) {
-                output += newOutput;
-                // Analyze current state
-                processState = analyzeProcessState(output, pid);
-                // Exit early if we detect the process is waiting for input
-                if (processState.isWaitingForInput) {
-                    break;
-                }
-                // Also exit if process finished
-                if (processState.isFinished) {
-                    break;
+        let earlyExit = false;
+        // Quick prompt patterns for immediate detection
+        const quickPromptPatterns = />>>\s*$|>\s*$|\$\s*$|#\s*$/;
+        const waitForResponse = () => {
+            return new Promise((resolve) => {
+                let resolved = false;
+                let attempts = 0;
+                const maxAttempts = Math.ceil(timeout_ms / 200);
+                let interval = null;
+                let resolveOnce = () => {
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    if (interval)
+                        clearInterval(interval);
+                    resolve();
+                };
+                // Set up immediate detection on the process streams
+                const session = terminalManager.getSession(pid);
+                if (session && session.process && session.process.stdout && session.process.stderr) {
+                    const immediateDetector = (data) => {
+                        const text = data.toString();
+                        // Immediate check for obvious prompts
+                        if (quickPromptPatterns.test(text)) {
+                            // Get the latest output and analyze
+                            setTimeout(() => {
+                                const newOutput = terminalManager.getNewOutput(pid);
+                                if (newOutput) {
+                                    output += newOutput;
+                                    const state = analyzeProcessState(output, pid);
+                                    if (state.isWaitingForInput) {
+                                        processState = state;
+                                        earlyExit = true;
+                                        resolveOnce();
+                                    }
+                                }
+                            }, 50); // Small delay to ensure output is captured
+                        }
+                    };
+                    session.process.stdout.on('data', immediateDetector);
+                    session.process.stderr.on('data', immediateDetector);
+                    // Cleanup when done
+                    const cleanupDetectors = () => {
+                        if (session.process.stdout) {
+                            session.process.stdout.removeListener('data', immediateDetector);
+                        }
+                        if (session.process.stderr) {
+                            session.process.stderr.removeListener('data', immediateDetector);
+                        }
+                    };
+                    // Override resolveOnce to include cleanup
+                    const originalResolveOnce = resolveOnce;
+                    const resolveOnceWithCleanup = () => {
+                        cleanupDetectors();
+                        originalResolveOnce();
+                    };
+                    // Replace the local resolveOnce reference
+                    resolveOnce = resolveOnceWithCleanup;
                 }
-            }
-            attempts++;
-        }
+                // Periodic check as fallback
+                interval = setInterval(() => {
+                    if (resolved)
+                        return;
+                    const newOutput = terminalManager.getNewOutput(pid);
+                    if (newOutput && newOutput.length > 0) {
+                        output += newOutput;
+                        // Analyze current state
+                        processState = analyzeProcessState(output, pid);
+                        // Exit early if we detect the process is waiting for input
+                        if (processState.isWaitingForInput) {
+                            earlyExit = true;
+                            resolveOnce();
+                            return;
+                        }
+                        // Also exit if process finished
+                        if (processState.isFinished) {
+                            resolveOnce();
+                            return;
+                        }
+                    }
+                    attempts++;
+                    if (attempts >= maxAttempts) {
+                        resolveOnce();
+                    }
+                }, 200);
+            });
+        };
+        await waitForResponse();
         // Clean and format output
         const cleanOutput = cleanProcessOutput(output, input);
-        const timeoutReached = attempts >= maxAttempts;
+        const timeoutReached = !earlyExit && !processState?.isFinished && !processState?.isWaitingForInput;
         // Determine final state
         if (!processState) {
             processState = analyzeProcessState(output, pid);
@@ -253,14 +383,25 @@ export async function interactWithProcess(args) {
             return {
                 content: [{
                         type: "text",
-                        text: `✅ Input executed in process ${pid}.\n(No output produced)${statusMessage}`
+                        text: `✅ Input executed in process ${pid}.\n📭 (No output produced)${statusMessage}`
                     }],
             };
         }
+        // Format response with better structure and consistent emojis
+        let responseText = `✅ Input executed in process ${pid}`;
+        if (cleanOutput && cleanOutput.trim().length > 0) {
+            responseText += `:\n\n📤 Output:\n${cleanOutput}`;
+        }
+        else {
+            responseText += `.\n📭 (No output produced)`;
+        }
+        if (statusMessage) {
+            responseText += `\n\n${statusMessage}`;
+        }
         return {
             content: [{
                     type: "text",
-                    text: `✅ Input executed in process ${pid}:\n\n${cleanOutput}${statusMessage}`
+                    text: responseText
                 }],
         };
     }

package/dist/tools/schemas.d.ts

@@ -11,7 +11,7 @@ export declare const SetConfigValueArgsSchema: z.ZodObject<{
     value?: any;
 }>;
 export declare const ListProcessesArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-export declare const ExecuteCommandArgsSchema: z.ZodObject<{
+export declare const StartProcessArgsSchema: z.ZodObject<{
     command: z.ZodString;
     timeout_ms: z.ZodNumber;
     shell: z.ZodOptional<z.ZodString>;
@@ -24,7 +24,7 @@ export declare const ExecuteCommandArgsSchema: z.ZodObject<{
     timeout_ms: number;
     shell?: string | undefined;
 }>;
-export declare const ReadOutputArgsSchema: z.ZodObject<{
+export declare const ReadProcessOutputArgsSchema: z.ZodObject<{
     pid: z.ZodNumber;
     timeout_ms: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
@@ -173,3 +173,21 @@ export declare const EditBlockArgsSchema: z.ZodObject<{
     new_string: string;
     expected_replacements?: number | undefined;
 }>;
+export declare const InteractWithProcessArgsSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+    input: z.ZodString;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+    wait_for_prompt: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    pid: number;
+    input: string;
+    timeout_ms?: number | undefined;
+    wait_for_prompt?: boolean | undefined;
+}, {
+    pid: number;
+    input: string;
+    timeout_ms?: number | undefined;
+    wait_for_prompt?: boolean | undefined;
+}>;
+export declare const GetUsageStatsArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const GiveFeedbackArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;

package/dist/tools/schemas.js

@@ -8,12 +8,12 @@ export const SetConfigValueArgsSchema = z.object({
 // Empty schemas
 export const ListProcessesArgsSchema = z.object({});
 // Terminal tools schemas
-export const ExecuteCommandArgsSchema = z.object({
+export const StartProcessArgsSchema = z.object({
     command: z.string(),
     timeout_ms: z.number(),
     shell: z.string().optional(),
 });
-export const ReadOutputArgsSchema = z.object({
+export const ReadProcessOutputArgsSchema = z.object({
     pid: z.number(),
     timeout_ms: z.number().optional(),
 });
@@ -75,3 +75,21 @@ export const EditBlockArgsSchema = z.object({
     new_string: z.string(),
     expected_replacements: z.number().optional().default(1),
 });
+// Send input to process schema
+export const InteractWithProcessArgsSchema = z.object({
+    pid: z.number(),
+    input: z.string(),
+    timeout_ms: z.number().optional(),
+    wait_for_prompt: z.boolean().optional(),
+});
+// Usage stats schema
+export const GetUsageStatsArgsSchema = z.object({});
+// Feedback tool schema - no pre-filled parameters, all user input
+export const GiveFeedbackArgsSchema = z.object({
+// No parameters needed - form will be filled manually by user
+// Only auto-filled hidden fields remain:
+// - tool_call_count (auto)
+// - days_using (auto) 
+// - platform (auto)
+// - client_id (auto)
+});

package/dist/tools/usage.d.ts

@@ -0,0 +1,5 @@
+import { ServerResult } from '../types.js';
+/**
+ * Get usage statistics for debugging and analysis
+ */
+export declare function getUsageStats(): Promise<ServerResult>;

package/dist/tools/usage.js

@@ -0,0 +1,24 @@
+import { usageTracker } from '../utils/usageTracker.js';
+/**
+ * Get usage statistics for debugging and analysis
+ */
+export async function getUsageStats() {
+    try {
+        const summary = await usageTracker.getUsageSummary();
+        return {
+            content: [{
+                    type: "text",
+                    text: summary
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error retrieving usage stats: ${error instanceof Error ? error.message : String(error)}`
+                }],
+            isError: true
+        };
+    }
+}

package/dist/utils/capture.js

@@ -77,6 +77,15 @@ export const captureBase = async (captureURL, event, properties) => {
         if (uniqueUserId === 'unknown') {
             uniqueUserId = await getOrCreateUUID();
         }
+        // Get current client information for all events
+        const currentClient = configManager.getCurrentClientInfo();
+        let clientContext = {};
+        if (currentClient) {
+            clientContext = {
+                client_name: currentClient.name,
+                client_version: currentClient.version,
+            };
+        }
         // Create a deep copy of properties to avoid modifying the original objects
         // This ensures we don't alter error objects that are also returned to the AI
         let sanitizedProperties;
@@ -109,16 +118,29 @@ export const captureBase = async (captureURL, event, properties) => {
                 delete sanitizedProperties[key];
             }
         }
+        // Is MCP installed with DXT
+        let isDXT = 'false';
+        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';
+        }
         // Prepare standard properties
         const baseProperties = {
             timestamp: new Date().toISOString(),
             platform: platform(),
+            isDocker,
+            isDXT,
             app_version: VERSION,
             engagement_time_msec: "100"
         };
-        // Combine with sanitized properties
+        // Combine with sanitized properties and client context
         const eventProperties = {
             ...baseProperties,
+            ...clientContext,
             ...sanitizedProperties
         };
         // Prepare GA4 payload

package/dist/utils/early-logger.d.ts

@@ -0,0 +1,4 @@
+export declare function setTransportInstance(transport: any): void;
+export declare function logError(message: string, data?: any): void;
+export declare function logInfo(message: string, data?: any): void;
+export declare function logWarning(message: string, data?: any): void;

package/dist/utils/early-logger.js

@@ -0,0 +1,35 @@
+// Early logger that can work before FilteredStdioServerTransport is ready
+let transportInstance = null;
+export function setTransportInstance(transport) {
+    transportInstance = transport;
+}
+export function logError(message, data) {
+    if (transportInstance && transportInstance.sendLog) {
+        // Use transport's structured logging
+        transportInstance.sendLog("error", message, data);
+    }
+    else {
+        // Fallback to console.error which will be intercepted later
+        console.error(message);
+    }
+}
+export function logInfo(message, data) {
+    if (transportInstance && transportInstance.sendLog) {
+        // Use transport's structured logging
+        transportInstance.sendLog("info", message, data);
+    }
+    else {
+        // Fallback to console.log which will be intercepted later
+        console.log(message);
+    }
+}
+export function logWarning(message, data) {
+    if (transportInstance && transportInstance.sendLog) {
+        // Use transport's structured logging
+        transportInstance.sendLog("warning", message, data);
+    }
+    else {
+        // Fallback to console.warn which will be intercepted later
+        console.warn(message);
+    }
+}

package/dist/utils/mcp-logger.d.ts

@@ -0,0 +1,30 @@
+import '../types.js';
+export type LogLevel = "emergency" | "alert" | "critical" | "error" | "warning" | "notice" | "info" | "debug";
+/**
+ * MCP-compatible logger that sends log messages via JSON-RPC notifications
+ * Falls back to stderr if transport is not available
+ */
+export declare class McpLogger {
+    private component;
+    constructor(component?: string);
+    private logMessage;
+    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;
+    warn(message: string, data?: any): void;
+    logInfo(message: string, data?: any): void;
+    toolCall(toolName: string, args: any, result?: any, error?: Error): void;
+}
+export declare const logger: McpLogger;
+export declare const mcpConsole: {
+    log: (message: string, data?: any) => void;
+    info: (message: string, data?: any) => void;
+    warn: (message: string, data?: any) => void;
+    error: (message: string, data?: any) => void;
+    debug: (message: string, data?: any) => void;
+};

package/dist/utils/mcp-logger.js

@@ -0,0 +1,59 @@
+// src/utils/mcp-logger.ts
+import '../types.js'; // Import for global types
+/**
+ * MCP-compatible logger that sends log messages via JSON-RPC notifications
+ * Falls back to stderr if transport is not available
+ */
+export class McpLogger {
+    constructor(component = 'desktop-commander') {
+        this.component = component;
+    }
+    logMessage(level, message, data) {
+        if (global.mcpTransport?.sendLog) {
+            // Send via MCP JSON-RPC notification
+            global.mcpTransport.sendLog(level, `[${this.component}] ${message}`, data);
+        }
+        else {
+            // Fallback to stderr
+            const timestamp = new Date().toISOString();
+            const dataStr = data ? ` - ${JSON.stringify(data)}` : '';
+            process.stderr.write(`${timestamp} [${level.toUpperCase()}] [${this.component}] ${message}${dataStr}\n`);
+        }
+    }
+    emergency(message, data) { this.logMessage('emergency', message, data); }
+    alert(message, data) { this.logMessage('alert', message, data); }
+    critical(message, data) { this.logMessage('critical', message, data); }
+    error(message, data) { this.logMessage('error', message, data); }
+    warning(message, data) { this.logMessage('warning', message, data); }
+    notice(message, data) { this.logMessage('notice', message, data); }
+    info(message, data) { this.logMessage('info', message, data); }
+    debug(message, data) { this.logMessage('debug', message, data); }
+    // Convenience methods
+    warn(message, data) { this.warning(message, data); }
+    logInfo(message, data) { this.info(message, data); }
+    // Tool execution logging
+    toolCall(toolName, args, result, error) {
+        const logData = {
+            tool: toolName,
+            args,
+            ...(result && { result }),
+            ...(error && { error: error.message, stack: error.stack })
+        };
+        if (error) {
+            this.error(`Tool ${toolName} failed`, logData);
+        }
+        else {
+            this.debug(`Tool ${toolName} executed`, logData);
+        }
+    }
+}
+// Create a global logger instance
+export const logger = new McpLogger('desktop-commander');
+// Create convenience functions that mimic console methods
+export const mcpConsole = {
+    log: (message, data) => logger.info(message, data),
+    info: (message, data) => logger.info(message, data),
+    warn: (message, data) => logger.warning(message, data),
+    error: (message, data) => logger.error(message, data),
+    debug: (message, data) => logger.debug(message, data),
+};

package/dist/utils/smithery-detector.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Smithery CLI Detection Module
+ *
+ * Detects when a Node.js MCP server is being run through Smithery CLI
+ * which acts as a proxy/wrapper around MCP servers.
+ */
+export interface SmitheryDetectionInfo {
+    isSmithery: boolean;
+    confidence: number;
+    evidence: string[];
+    details: {
+        sessionId?: string;
+        analyticsEnabled?: boolean;
+        clientType?: string;
+        connectionType?: 'stdio' | 'http' | 'streamable-http';
+        qualifiedName?: string;
+        profile?: string;
+        runtimeEnvironment?: string;
+    };
+}
+export declare class SmitheryDetector {
+    private static instance;
+    private _detectionInfo;
+    private constructor();
+    static getInstance(): SmitheryDetector;
+    /**
+     * Get Smithery detection information (cached after first call)
+     */
+    getSmitheryInfo(): SmitheryDetectionInfo;
+    /**
+     * Force re-detection (useful for testing)
+     */
+    forceRedetect(): SmitheryDetectionInfo;
+    private detectSmithery;
+    /**
+     * Check for Smithery-specific environment variables
+     */
+    private checkSmitheryEnvironmentVars;
+    /**
+     * Check process arguments for Smithery patterns
+     */
+    private checkProcessArguments;
+    /**
+     * Check parent process for Smithery CLI
+     */
+    private checkParentProcess;
+    /**
+     * Check for Smithery runtime environment patterns
+     */
+    private checkRuntimeEnvironment;
+    /**
+     * Check for analytics and session indicators
+     */
+    private checkAnalyticsIndicators;
+    /**
+     * Check for MCP transport patterns that indicate Smithery
+     */
+    private checkTransportPatterns;
+    /**
+     * Check stdio patterns that suggest Smithery proxying
+     */
+    private checkStdioPatterns;
+    /**
+     * Check if running through Smithery (convenience method)
+     */
+    isSmithery(): boolean;
+    /**
+     * Get the client type if running through Smithery
+     */
+    getClientType(): string | undefined;
+    /**
+     * Get the connection type if running through Smithery
+     */
+    getConnectionType(): string | undefined;
+    /**
+     * Get analytics status if running through Smithery
+     */
+    isAnalyticsEnabled(): boolean | undefined;
+    /**
+     * Get session ID if running through Smithery
+     */
+    getSessionId(): string | undefined;
+    /**
+     * Get server qualified name if running through Smithery
+     */
+    getQualifiedName(): string | undefined;
+}
+export declare const smitheryDetector: SmitheryDetector;
+export declare const getSmitheryInfo: () => SmitheryDetectionInfo;
+export declare const isSmithery: () => boolean;
+export declare const getSmitheryClientType: () => string | undefined;
+export declare const getSmitheryConnectionType: () => string | undefined;
+export declare const getSmitherySessionId: () => string | undefined;
+export declare const isSmitheryAnalyticsEnabled: () => boolean | undefined;