@wonderwhy-er/desktop-commander 0.2.2 → 0.2.4

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/process-detection.d.ts

@@ -0,0 +1,23 @@
+/**
+ * REPL and Process State Detection Utilities
+ * Detects when processes are waiting for input vs finished vs running
+ */
+export interface ProcessState {
+    isWaitingForInput: boolean;
+    isFinished: boolean;
+    isRunning: boolean;
+    detectedPrompt?: string;
+    lastOutput: string;
+}
+/**
+ * Analyze process output to determine current state
+ */
+export declare function analyzeProcessState(output: string, pid?: number): ProcessState;
+/**
+ * Clean output by removing prompts and input echoes
+ */
+export declare function cleanProcessOutput(output: string, inputSent?: string): string;
+/**
+ * Format process state for user display
+ */
+export declare function formatProcessStateMessage(state: ProcessState, pid: number): string;

package/dist/utils/process-detection.js

@@ -0,0 +1,150 @@
+/**
+ * REPL and Process State Detection Utilities
+ * Detects when processes are waiting for input vs finished vs running
+ */
+// Common REPL prompt patterns
+const REPL_PROMPTS = {
+    python: ['>>> ', '... '],
+    node: ['> ', '... '],
+    r: ['> ', '+ '],
+    julia: ['julia> ', '       '], // julia continuation is spaces
+    shell: ['$ ', '# ', '% ', 'bash-', 'zsh-'],
+    mysql: ['mysql> ', '    -> '],
+    postgres: ['=# ', '-# '],
+    redis: ['redis> '],
+    mongo: ['> ', '... ']
+};
+// Error patterns that indicate completion (even with errors)
+const ERROR_COMPLETION_PATTERNS = [
+    /Error:/i,
+    /Exception:/i,
+    /Traceback/i,
+    /SyntaxError/i,
+    /NameError/i,
+    /TypeError/i,
+    /ValueError/i,
+    /ReferenceError/i,
+    /Uncaught/i,
+    /at Object\./i, // Node.js stack traces
+    /^\s*\^/m // Syntax error indicators
+];
+// Process completion indicators
+const COMPLETION_INDICATORS = [
+    /Process finished/i,
+    /Command completed/i,
+    /\[Process completed\]/i,
+    /Program terminated/i,
+    /Exit code:/i
+];
+/**
+ * Analyze process output to determine current state
+ */
+export function analyzeProcessState(output, pid) {
+    if (!output || output.trim().length === 0) {
+        return {
+            isWaitingForInput: false,
+            isFinished: false,
+            isRunning: true,
+            lastOutput: output
+        };
+    }
+    const lines = output.split('\n');
+    const lastLine = lines[lines.length - 1] || '';
+    const lastFewLines = lines.slice(-3).join('\n');
+    // Check for REPL prompts (waiting for input)
+    const allPrompts = Object.values(REPL_PROMPTS).flat();
+    const detectedPrompt = allPrompts.find(prompt => lastLine.endsWith(prompt) || lastLine.includes(prompt));
+    if (detectedPrompt) {
+        return {
+            isWaitingForInput: true,
+            isFinished: false,
+            isRunning: true,
+            detectedPrompt,
+            lastOutput: output
+        };
+    }
+    // Check for completion indicators
+    const hasCompletionIndicator = COMPLETION_INDICATORS.some(pattern => pattern.test(output));
+    if (hasCompletionIndicator) {
+        return {
+            isWaitingForInput: false,
+            isFinished: true,
+            isRunning: false,
+            lastOutput: output
+        };
+    }
+    // Check for error completion (errors usually end with prompts, but let's be thorough)
+    const hasErrorCompletion = ERROR_COMPLETION_PATTERNS.some(pattern => pattern.test(lastFewLines));
+    if (hasErrorCompletion) {
+        // Errors can indicate completion, but check if followed by prompt
+        if (detectedPrompt) {
+            return {
+                isWaitingForInput: true,
+                isFinished: false,
+                isRunning: true,
+                detectedPrompt,
+                lastOutput: output
+            };
+        }
+        else {
+            return {
+                isWaitingForInput: false,
+                isFinished: true,
+                isRunning: false,
+                lastOutput: output
+            };
+        }
+    }
+    // Default: process is running, not clearly waiting or finished
+    return {
+        isWaitingForInput: false,
+        isFinished: false,
+        isRunning: true,
+        lastOutput: output
+    };
+}
+/**
+ * Clean output by removing prompts and input echoes
+ */
+export function cleanProcessOutput(output, inputSent) {
+    let cleaned = output;
+    // Remove input echo if provided
+    if (inputSent) {
+        const inputLines = inputSent.split('\n');
+        inputLines.forEach(line => {
+            if (line.trim()) {
+                cleaned = cleaned.replace(new RegExp(`^${escapeRegExp(line.trim())}\\s*\n?`, 'm'), '');
+            }
+        });
+    }
+    // Remove common prompt patterns from output
+    cleaned = cleaned.replace(/^>>>\s*/gm, ''); // Python >>>
+    cleaned = cleaned.replace(/^>\s*/gm, ''); // Node.js/Shell >
+    cleaned = cleaned.replace(/^\.{3}\s*/gm, ''); // Python ...
+    cleaned = cleaned.replace(/^\+\s*/gm, ''); // R +
+    // Remove trailing prompts
+    cleaned = cleaned.replace(/\n>>>\s*$/, '');
+    cleaned = cleaned.replace(/\n>\s*$/, '');
+    cleaned = cleaned.replace(/\n\+\s*$/, '');
+    return cleaned.trim();
+}
+/**
+ * Escape special regex characters
+ */
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Format process state for user display
+ */
+export function formatProcessStateMessage(state, pid) {
+    if (state.isWaitingForInput) {
+        return `Process ${pid} is waiting for input${state.detectedPrompt ? ` (detected: "${state.detectedPrompt.trim()}")` : ''}`;
+    }
+    else if (state.isFinished) {
+        return `Process ${pid} has finished execution`;
+    }
+    else {
+        return `Process ${pid} is running`;
+    }
+}

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;

package/dist/utils/smithery-detector.js

@@ -0,0 +1,292 @@
+/**
+ * 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.
+ */
+import { platform } from 'os';
+export class SmitheryDetector {
+    constructor() {
+        this._detectionInfo = null;
+    }
+    static getInstance() {
+        if (!SmitheryDetector.instance) {
+            SmitheryDetector.instance = new SmitheryDetector();
+        }
+        return SmitheryDetector.instance;
+    }
+    /**
+     * Get Smithery detection information (cached after first call)
+     */
+    getSmitheryInfo() {
+        if (!this._detectionInfo) {
+            this._detectionInfo = this.detectSmithery();
+        }
+        return this._detectionInfo;
+    }
+    /**
+     * Force re-detection (useful for testing)
+     */
+    forceRedetect() {
+        this._detectionInfo = this.detectSmithery();
+        return this._detectionInfo;
+    }
+    detectSmithery() {
+        const result = {
+            isSmithery: false,
+            confidence: 0,
+            evidence: [],
+            details: {}
+        };
+        // Method 1: Check for Smithery-specific environment variables
+        this.checkSmitheryEnvironmentVars(result);
+        // Method 2: Check process arguments for Smithery patterns
+        this.checkProcessArguments(result);
+        // Method 3: Check parent process for Smithery CLI
+        this.checkParentProcess(result);
+        // Method 4: Check for Smithery runtime environment patterns
+        this.checkRuntimeEnvironment(result);
+        // Method 5: Check for analytics/session indicators
+        this.checkAnalyticsIndicators(result);
+        // Method 6: Check for MCP SDK transport patterns
+        this.checkTransportPatterns(result);
+        // Method 7: Check stdio patterns
+        this.checkStdioPatterns(result);
+        // Set final determination
+        result.isSmithery = result.confidence >= 30;
+        return result;
+    }
+    /**
+     * Check for Smithery-specific environment variables
+     */
+    checkSmitheryEnvironmentVars(result) {
+        const smitheryEnvVars = [
+            'SMITHERY_SESSION_ID',
+            'SMITHERY_API_KEY',
+            'SMITHERY_CLIENT',
+            'SMITHERY_PROFILE',
+            'SMITHERY_ANALYTICS',
+            'SMITHERY_RUNTIME',
+            'REGISTRY_ENDPOINT',
+            'ANALYTICS_ENDPOINT'
+        ];
+        for (const envVar of smitheryEnvVars) {
+            if (process.env[envVar]) {
+                result.confidence += 40;
+                result.evidence.push(`Smithery environment variable: ${envVar}`);
+                // Extract specific details
+                switch (envVar) {
+                    case 'SMITHERY_SESSION_ID':
+                        result.details.sessionId = process.env[envVar];
+                        break;
+                    case 'SMITHERY_CLIENT':
+                        result.details.clientType = process.env[envVar];
+                        break;
+                    case 'SMITHERY_PROFILE':
+                        result.details.profile = process.env[envVar];
+                        break;
+                    case 'SMITHERY_ANALYTICS':
+                        result.details.analyticsEnabled = process.env[envVar] === 'true';
+                        break;
+                    case 'SMITHERY_RUNTIME':
+                        result.details.runtimeEnvironment = process.env[envVar];
+                        break;
+                }
+            }
+        }
+        // Check for Smithery endpoints
+        if (process.env.REGISTRY_ENDPOINT?.includes('smithery')) {
+            result.confidence += 30;
+            result.evidence.push('Smithery registry endpoint detected');
+        }
+        if (process.env.ANALYTICS_ENDPOINT?.includes('smithery')) {
+            result.confidence += 25;
+            result.evidence.push('Smithery analytics endpoint detected');
+        }
+    }
+    /**
+     * Check process arguments for Smithery patterns
+     */
+    checkProcessArguments(result) {
+        const args = process.argv.join(' ');
+        // Check for common Smithery CLI patterns
+        const smitheryPatterns = [
+            /smithery[\s\/\\]cli/i,
+            /@smithery[\s\/\\]cli/i,
+            /npx.*@smithery/i,
+            /smithery.*run/i,
+            /smithery.*install/i
+        ];
+        for (const pattern of smitheryPatterns) {
+            if (pattern.test(args)) {
+                result.confidence += 35;
+                result.evidence.push(`Smithery CLI pattern in arguments: ${pattern.source}`);
+            }
+        }
+        // Check for typical Smithery command structure
+        if (args.includes('--config') && args.includes('--client')) {
+            result.confidence += 20;
+            result.evidence.push('Smithery-style CLI arguments detected');
+        }
+    }
+    /**
+     * Check parent process for Smithery CLI
+     */
+    checkParentProcess(result) {
+        try {
+            if (platform() === 'darwin' || platform() === 'linux') {
+                const { execSync } = require('child_process');
+                const ppid = process.ppid;
+                if (ppid) {
+                    // Get parent process command line
+                    const parentCmd = execSync(`ps -p ${ppid} -o command=`, {
+                        encoding: 'utf8',
+                        timeout: 1000
+                    }).trim();
+                    if (parentCmd.includes('smithery') || parentCmd.includes('@smithery/cli')) {
+                        result.confidence += 50;
+                        result.evidence.push(`Parent process is Smithery CLI: ${parentCmd}`);
+                    }
+                    if (parentCmd.includes('node') && parentCmd.includes('npx')) {
+                        result.confidence += 15;
+                        result.evidence.push('Parent process shows npx execution pattern');
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Ignore errors, parent process detection is best-effort
+        }
+    }
+    /**
+     * Check for Smithery runtime environment patterns
+     */
+    checkRuntimeEnvironment(result) {
+        // Check working directory for Smithery artifacts
+        const cwd = process.cwd();
+        if (cwd.includes('.smithery') || cwd.includes('smithery-cli')) {
+            result.confidence += 25;
+            result.evidence.push('Working directory indicates Smithery environment');
+        }
+        // Check for typical Smithery PATH modifications
+        const path = process.env.PATH || '';
+        if (path.includes('smithery') || path.includes('.smithery')) {
+            result.confidence += 20;
+            result.evidence.push('PATH contains Smithery directories');
+        }
+        // Check for Smithery-injected NODE_OPTIONS or similar
+        if (process.env.NODE_OPTIONS?.includes('smithery')) {
+            result.confidence += 30;
+            result.evidence.push('NODE_OPTIONS indicates Smithery runtime');
+        }
+    }
+    /**
+     * Check for analytics and session indicators
+     */
+    checkAnalyticsIndicators(result) {
+        // Check for UUID v7 pattern in environment (Smithery uses uuidv7 for sessions)
+        const envVars = Object.keys(process.env);
+        for (const key of envVars) {
+            const value = process.env[key] || '';
+            // UUID v7 pattern: 8-4-4-4-12 hex characters starting with timestamp
+            if (/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) {
+                result.confidence += 25;
+                result.evidence.push(`UUID v7 session ID pattern detected: ${key}`);
+                result.details.sessionId = value;
+            }
+        }
+        // Check for Smithery analytics patterns
+        if (process.env.SMITHERY_ANALYTICS_CONSENT) {
+            result.confidence += 20;
+            result.evidence.push('Smithery analytics consent setting detected');
+        }
+    }
+    /**
+     * Check for MCP transport patterns that indicate Smithery
+     */
+    checkTransportPatterns(result) {
+        // Check for environment variables that suggest MCP transport through Smithery
+        if (process.env.MCP_TRANSPORT_TYPE) {
+            result.confidence += 15;
+            result.evidence.push('MCP transport type specification detected');
+            result.details.connectionType = process.env.MCP_TRANSPORT_TYPE;
+        }
+        // Check for Smithery's specific transport configurations
+        if (process.env.SMITHERY_CONNECTION_TYPE) {
+            result.confidence += 35;
+            result.evidence.push('Smithery connection type detected');
+            result.details.connectionType = process.env.SMITHERY_CONNECTION_TYPE;
+        }
+        // Check for server qualification patterns
+        if (process.env.SMITHERY_QUALIFIED_NAME || process.env.MCP_SERVER_NAME) {
+            result.confidence += 30;
+            result.evidence.push('MCP server qualification detected');
+            result.details.qualifiedName = process.env.SMITHERY_QUALIFIED_NAME || process.env.MCP_SERVER_NAME;
+        }
+    }
+    /**
+     * Check stdio patterns that suggest Smithery proxying
+     */
+    checkStdioPatterns(result) {
+        // Check if stdin/stdout are being piped in a way consistent with Smithery
+        if (!process.stdin.isTTY && !process.stdout.isTTY) {
+            result.confidence += 10;
+            result.evidence.push('Non-TTY stdio suggests proxied execution');
+        }
+        // Check for JSON-RPC message patterns in environment
+        if (process.env.MCP_JSONRPC_VERSION) {
+            result.confidence += 15;
+            result.evidence.push('JSON-RPC version specification detected');
+        }
+        // Check for Smithery's specific stdio handling
+        if (process.env.SMITHERY_STDIO_BUFFER_SIZE || process.env.SMITHERY_MESSAGE_TIMEOUT) {
+            result.confidence += 25;
+            result.evidence.push('Smithery stdio configuration detected');
+        }
+    }
+    /**
+     * Check if running through Smithery (convenience method)
+     */
+    isSmithery() {
+        return this.getSmitheryInfo().isSmithery;
+    }
+    /**
+     * Get the client type if running through Smithery
+     */
+    getClientType() {
+        return this.getSmitheryInfo().details.clientType;
+    }
+    /**
+     * Get the connection type if running through Smithery
+     */
+    getConnectionType() {
+        return this.getSmitheryInfo().details.connectionType;
+    }
+    /**
+     * Get analytics status if running through Smithery
+     */
+    isAnalyticsEnabled() {
+        return this.getSmitheryInfo().details.analyticsEnabled;
+    }
+    /**
+     * Get session ID if running through Smithery
+     */
+    getSessionId() {
+        return this.getSmitheryInfo().details.sessionId;
+    }
+    /**
+     * Get server qualified name if running through Smithery
+     */
+    getQualifiedName() {
+        return this.getSmitheryInfo().details.qualifiedName;
+    }
+}
+// Singleton instance
+export const smitheryDetector = SmitheryDetector.getInstance();
+// Convenience functions
+export const getSmitheryInfo = () => smitheryDetector.getSmitheryInfo();
+export const isSmithery = () => smitheryDetector.isSmithery();
+export const getSmitheryClientType = () => smitheryDetector.getClientType();
+export const getSmitheryConnectionType = () => smitheryDetector.getConnectionType();
+export const getSmitherySessionId = () => smitheryDetector.getSessionId();
+export const isSmitheryAnalyticsEnabled = () => smitheryDetector.isAnalyticsEnabled();