@wonderwhy-er/desktop-commander 0.2.3 → 0.2.4

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();

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

@@ -0,0 +1,65 @@
+/**
+ * Production-Ready Startup Detection Module
+ *
+ * This module provides a lightweight, production-ready way to detect
+ * how a Node.js application was started. Perfect for logging, analytics,
+ * or conditional behavior based on startup method.
+ */
+export interface StartupInfo {
+    method: 'npm-run' | 'npx' | 'docker' | 'node-direct' | 'ci-cd' | 'smithery' | 'unknown';
+    confidence: number;
+    details: {
+        npmScript?: string;
+        ciPlatform?: string;
+        dockerContainer?: boolean;
+        smitheryClient?: string;
+        smitheryConnection?: string;
+        smitherySession?: string;
+        evidence: string[];
+    };
+    environment: 'development' | 'production' | 'ci' | 'container' | 'smithery' | 'unknown';
+}
+export declare class StartupDetector {
+    private static instance;
+    private _startupInfo;
+    private constructor();
+    static getInstance(): StartupDetector;
+    /**
+     * Get startup information (cached after first call)
+     */
+    getStartupInfo(): StartupInfo;
+    /**
+     * Force re-detection (useful for testing)
+     */
+    forceRedetect(): StartupInfo;
+    private detectStartupMethod;
+    private detectNpmRun;
+    private detectNpx;
+    private detectDocker;
+    private detectCiCd;
+    private detectDirectNode;
+    private detectSmithery;
+    private detectEnvironment;
+    /**
+     * Get a simple string representation of how the app was started
+     */
+    getStartupMethodString(): string;
+    /**
+     * Check if running in a specific environment
+     */
+    isEnvironment(env: StartupInfo['environment']): boolean;
+    /**
+     * Check if running via a specific method
+     */
+    isMethod(method: StartupInfo['method']): boolean;
+}
+export declare const startupDetector: StartupDetector;
+export declare const getStartupInfo: () => StartupInfo;
+export declare const getStartupMethod: () => string;
+export declare const isProduction: () => boolean;
+export declare const isDevelopment: () => boolean;
+export declare const isDocker: () => boolean;
+export declare const isCi: () => boolean;
+export declare const isSmithery: () => boolean;
+export declare const getSmitheryClient: () => string | undefined;
+export declare const getSmitheryConnection: () => string | undefined;