@wonderwhy-er/desktop-commander 0.2.9 → 0.2.11

package/dist/track-installation.js

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+
+/**
+ * Installation Source Tracking Script
+ * Runs during npm install to detect how Desktop Commander was installed
+ * 
+ * Debug logging can be enabled with:
+ * - DEBUG=desktop-commander npm install
+ * - DEBUG=* npm install  
+ * - NODE_ENV=development npm install
+ * - DC_DEBUG=true npm install
+ */
+
+import { randomUUID } from 'crypto';
+import * as https from 'https';
+import { platform } from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// Get current file directory
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Debug logging utility - configurable via environment variables
+const DEBUG_ENABLED = process.env.DEBUG === 'desktop-commander' || 
+                      process.env.DEBUG === '*' || 
+                      process.env.NODE_ENV === 'development' ||
+                      process.env.DC_DEBUG === 'true';
+
+const debug = (...args) => {
+    if (DEBUG_ENABLED) {
+        console.log('[Desktop Commander Debug]', ...args);
+    }
+};
+
+const log = (...args) => {
+    // Always show important messages, but prefix differently for debug vs production
+    if (DEBUG_ENABLED) {
+        console.log('[Desktop Commander]', ...args);
+    }
+};
+
+/**
+ * Get the client ID from the Desktop Commander config file, or generate a new one
+ */
+async function getClientId() {
+    try {
+        const { homedir } = await import('os');
+        const { join } = await import('path');
+        const fs = await import('fs');
+        
+        const USER_HOME = homedir();
+        const CONFIG_DIR = join(USER_HOME, '.claude-server-commander');
+        const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+        
+        // Try to read existing config
+        if (fs.existsSync(CONFIG_FILE)) {
+            const configData = fs.readFileSync(CONFIG_FILE, 'utf8');
+            const config = JSON.parse(configData);
+            if (config.clientId) {
+                debug(`Using existing clientId from config: ${config.clientId.substring(0, 8)}...`);
+                return config.clientId;
+            }
+        }
+        
+        debug('No existing clientId found, generating new one');
+        // Fallback to random UUID if config doesn't exist or lacks clientId
+        return randomUUID();
+    } catch (error) {
+        debug(`Error reading config file: ${error.message}, using random UUID`);
+        // If anything goes wrong, fall back to random UUID
+        return randomUUID();
+    }
+}
+
+// Google Analytics configuration (same as setup script)
+const GA_MEASUREMENT_ID = 'G-NGGDNL0K4L';
+const GA_API_SECRET = '5M0mC--2S_6t94m8WrI60A';
+const GA_BASE_URL = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
+
+/**
+ * Detect installation source from environment and process context
+ */
+async function detectInstallationSource() {
+    // Check npm environment variables for clues
+    const npmConfigUserAgent = process.env.npm_config_user_agent || '';
+    const npmExecpath = process.env.npm_execpath || '';
+    const npmCommand = process.env.npm_command || '';
+    const npmLifecycleEvent = process.env.npm_lifecycle_event || '';
+    
+    // Check process arguments and parent commands
+    const processArgs = process.argv.join(' ');
+    const processTitle = process.title || '';
+
+    debug('Installation source detection...');
+    debug(`npm_config_user_agent: ${npmConfigUserAgent}`);
+    debug(`npm_execpath: ${npmExecpath}`);
+    debug(`npm_command: ${npmCommand}`);
+    debug(`npm_lifecycle_event: ${npmLifecycleEvent}`);
+    debug(`process.argv: ${processArgs}`);
+    debug(`process.title: ${processTitle}`);
+    
+    // Try to get parent process information
+    let parentProcessInfo = null;
+    try {
+        const { execSync } = await import('child_process');
+        const ppid = process.ppid;
+        if (ppid && process.platform !== 'win32') {
+            // Get parent process command line on Unix systems
+            const parentCmd = execSync(`ps -p ${ppid} -o command=`, { encoding: 'utf8' }).trim();
+            parentProcessInfo = parentCmd;
+            debug(`parent process: ${parentCmd}`);
+        }
+    } catch (error) {
+        debug(`Could not get parent process info: ${error.message}`);
+    }
+    
+    // Smithery detection - look for smithery in the process chain
+    const smitheryIndicators = [
+        npmConfigUserAgent.includes('smithery'),
+        npmExecpath.includes('smithery'),
+        processArgs.includes('smithery'),
+        processArgs.includes('@smithery/cli'),
+        processTitle.includes('smithery'),
+        parentProcessInfo && parentProcessInfo.includes('smithery'),
+        parentProcessInfo && parentProcessInfo.includes('@smithery/cli')
+    ];
+    
+    if (smitheryIndicators.some(indicator => indicator)) {
+        return {
+            source: 'smithery',
+            details: {
+                detection_method: 'process_chain',
+                user_agent: npmConfigUserAgent,
+                exec_path: npmExecpath,
+                command: npmCommand,
+                parent_process: parentProcessInfo || 'unknown',
+                process_args: processArgs
+            }
+        };
+    }
+    
+    // Direct NPX usage
+    if (npmCommand === 'exec' || processArgs.includes('npx')) {
+        return {
+            source: 'npx-direct',
+            details: {
+                user_agent: npmConfigUserAgent,
+                command: npmCommand,
+                lifecycle_event: npmLifecycleEvent
+            }
+        };
+    }
+    
+    // Regular npm install
+    if (npmCommand === 'install' || npmLifecycleEvent === 'postinstall') {
+        return {
+            source: 'npm-install',
+            details: {
+                user_agent: npmConfigUserAgent,
+                command: npmCommand,
+                lifecycle_event: npmLifecycleEvent
+            }
+        };
+    }
+    
+    // GitHub Codespaces
+    if (process.env.CODESPACES) {
+        return {
+            source: 'github-codespaces',
+            details: {
+                codespace: process.env.CODESPACE_NAME || 'unknown'
+            }
+        };
+    }
+    
+    // VS Code
+    if (process.env.VSCODE_PID || process.env.TERM_PROGRAM === 'vscode') {
+        return {
+            source: 'vscode',
+            details: {
+                term_program: process.env.TERM_PROGRAM,
+                vscode_pid: process.env.VSCODE_PID
+            }
+        };
+    }
+    
+    // GitPod
+    if (process.env.GITPOD_WORKSPACE_ID) {
+        return {
+            source: 'gitpod',
+            details: {
+                workspace_id: process.env.GITPOD_WORKSPACE_ID.substring(0, 8) + '...' // Truncate for privacy
+            }
+        };
+    }
+    
+    // CI/CD environments
+    if (process.env.CI) {
+        if (process.env.GITHUB_ACTIONS) {
+            return {
+                source: 'github-actions',
+                details: {
+                    repository: process.env.GITHUB_REPOSITORY,
+                    workflow: process.env.GITHUB_WORKFLOW
+                }
+            };
+        }
+        if (process.env.GITLAB_CI) {
+            return {
+                source: 'gitlab-ci',
+                details: {
+                    project: process.env.CI_PROJECT_NAME
+                }
+            };
+        }
+        if (process.env.JENKINS_URL) {
+            return {
+                source: 'jenkins',
+                details: {
+                    job: process.env.JOB_NAME
+                }
+            };
+        }
+        return {
+            source: 'ci-cd-other',
+            details: {
+                ci_env: 'unknown'
+            }
+        };
+    }
+    
+    // Docker detection
+    if (process.env.DOCKER_CONTAINER) {
+        return {
+            source: 'docker',
+            details: {
+                container_id: process.env.HOSTNAME?.substring(0, 8) + '...' || 'unknown'
+            }
+        };
+    }
+    
+    // Check for .dockerenv file (need to use fs import)
+    try {
+        const fs = await import('fs');
+        if (fs.existsSync('/.dockerenv')) {
+            return {
+                source: 'docker',
+                details: {
+                    container_id: process.env.HOSTNAME?.substring(0, 8) + '...' || 'unknown'
+                }
+            };
+        }
+    } catch (error) {
+        // Ignore fs errors
+    }
+    
+    // Default fallback
+    return {
+        source: 'unknown',
+        details: {
+            user_agent: npmConfigUserAgent || 'none',
+            command: npmCommand || 'none',
+            lifecycle: npmLifecycleEvent || 'none'
+        }
+    };
+}
+
+/**
+ * Send installation tracking to analytics
+ */
+async function trackInstallation(installationData) {
+    if (!GA_MEASUREMENT_ID || !GA_API_SECRET) {
+        debug('Analytics not configured, skipping tracking');
+        return;
+    }
+
+    try {
+        const uniqueUserId = await getClientId();
+        log("user id", uniqueUserId)
+        // Prepare GA4 payload
+        const payload = {
+            client_id: uniqueUserId,
+            non_personalized_ads: false,
+            timestamp_micros: Date.now() * 1000,
+            events: [{
+                name: 'package_installed',
+                params: {
+                    timestamp: new Date().toISOString(),
+                    platform: platform(),
+                    installation_source: installationData.source,
+                    installation_details: JSON.stringify(installationData.details),
+                    package_name: '@wonderwhy-er/desktop-commander',
+                    install_method: 'npm-lifecycle',
+                    node_version: process.version,
+                    npm_version: process.env.npm_version || 'unknown'
+                }
+            }]
+        };
+
+        const postData = JSON.stringify(payload);
+        
+        const options = {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(postData)
+            }
+        };
+
+        await new Promise((resolve, reject) => {
+            const req = https.request(GA_BASE_URL, options);
+            
+            const timeoutId = setTimeout(() => {
+                req.destroy();
+                reject(new Error('Request timeout'));
+            }, 5000);
+
+            req.on('error', (error) => {
+                clearTimeout(timeoutId);
+                debug(`Analytics error: ${error.message}`);
+                resolve(); // Don't fail installation on analytics error
+            });
+
+            req.on('response', (res) => {
+                clearTimeout(timeoutId);
+                // Consume the response data to complete the request
+                res.on('data', () => {}); // Ignore response data
+                res.on('end', () => {
+                    log(`Installation tracked: ${installationData.source}`);
+                    resolve();
+                });
+            });
+
+            req.write(postData);
+            req.end();
+        });
+
+    } catch (error) {
+        debug(`Failed to track installation: ${error.message}`);
+        // Don't fail the installation process
+    }
+}
+
+/**
+ * Main execution
+ */
+async function main() {
+    try {
+        log('Package installation detected');
+        
+        const installationData = await detectInstallationSource();
+        log(`Installation source: ${installationData.source}`);
+        
+        await trackInstallation(installationData);
+        
+    } catch (error) {
+        debug(`Installation tracking error: ${error.message}`);
+        // Don't fail the installation
+    }
+}
+
+// Only run if this script is executed directly (not imported)
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main();
+}
+
+export { detectInstallationSource, trackInstallation };

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;