@wonderwhy-er/desktop-commander 0.2.3 → 0.2.5

package/dist/index-with-startup-detection.js

@@ -0,0 +1,180 @@
+/**
+ * Example integration of startup detection in your server.ts file
+ * This shows how to add startup detection to your existing server
+ */
+import { FilteredStdioServerTransport } from './custom-stdio.js';
+import { server } from './server.js';
+import { configManager } from './config-manager.js';
+import { getStartupInfo, getStartupMethod, isProduction, isDevelopment, isDocker, isCi } from './utils/startup-detector.js';
+import { capture } from './utils/capture.js';
+import { join, dirname } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { platform } from 'os';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const isWindows = platform() === 'win32';
+function createFileURL(filePath) {
+    if (isWindows) {
+        const normalizedPath = filePath.replace(/\\/g, '/');
+        if (normalizedPath.startsWith('/')) {
+            return new URL(`file://${normalizedPath}`);
+        }
+        else {
+            return new URL(`file:///${normalizedPath}`);
+        }
+    }
+    else {
+        return pathToFileURL(filePath);
+    }
+}
+async function runSetup() {
+    try {
+        const setupScriptPath = join(__dirname, 'setup-claude-server.js');
+        const setupScriptUrl = createFileURL(setupScriptPath);
+        const { default: setupModule } = await import(setupScriptUrl.href);
+        if (typeof setupModule === 'function') {
+            await setupModule();
+        }
+    }
+    catch (error) {
+        console.error('Error running setup:', error);
+        process.exit(1);
+    }
+}
+async function runServer() {
+    try {
+        // Check if first argument is "setup"
+        if (process.argv[2] === 'setup') {
+            await runSetup();
+            return;
+        }
+        // ============ NEW: Startup Detection Integration ============
+        const startupInfo = getStartupInfo();
+        const startupMethod = getStartupMethod();
+        // Log startup information
+        console.error(`🚀 Desktop Commander starting via: ${startupMethod}`);
+        console.error(`📍 Environment: ${startupInfo.environment}`);
+        console.error(`🔍 Detection confidence: ${startupInfo.confidence}%`);
+        if (startupInfo.details.evidence.length > 0) {
+            console.error(`📝 Evidence: ${startupInfo.details.evidence.join(', ')}`);
+        }
+        // Conditional behavior based on startup method
+        if (isProduction()) {
+            console.error('🏭 Production mode: Enhanced error handling enabled');
+            // Enable production-specific features
+            process.on('uncaughtException', (error) => {
+                console.error('[PRODUCTION] Uncaught exception:', error);
+                // More robust error handling in production
+                process.exit(1);
+            });
+        }
+        else if (isDevelopment()) {
+            console.error('🛠️  Development mode: Debug features enabled');
+            // Enable development-specific features
+        }
+        if (isDocker()) {
+            console.error('🐳 Docker environment detected');
+            // Docker-specific configuration
+        }
+        if (isCi()) {
+            console.error('🤖 CI/CD environment detected');
+            // CI-specific behavior (minimal logging, etc.)
+        }
+        // Log startup analytics
+        capture('desktop_commander_startup', {
+            startup_method: startupInfo.method,
+            environment: startupInfo.environment,
+            confidence: startupInfo.confidence,
+            npm_script: startupInfo.details.npmScript || null,
+            ci_platform: startupInfo.details.ciPlatform || null,
+            docker_container: startupInfo.details.dockerContainer || false
+        });
+        // Adjust logging verbosity based on environment
+        const logLevel = isProduction() ? 'error' :
+            isDevelopment() ? 'debug' :
+                isCi() ? 'warn' : 'info';
+        console.error(`📊 Log level set to: ${logLevel}`);
+        // ========================================================
+        const transport = new FilteredStdioServerTransport();
+        // Enhanced error handling with startup context
+        process.on('uncaughtException', async (error) => {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes('JSON') && errorMessage.includes('Unexpected token')) {
+                process.stderr.write(`[desktop-commander] JSON parsing error: ${errorMessage}\n`);
+                return;
+            }
+            // Include startup context in error capture
+            capture('run_server_uncaught_exception', {
+                error: errorMessage,
+                startup_method: startupInfo.method,
+                environment: startupInfo.environment
+            });
+            process.stderr.write(`[desktop-commander] Uncaught exception: ${errorMessage}\n`);
+            process.exit(1);
+        });
+        process.on('unhandledRejection', async (reason) => {
+            const errorMessage = reason instanceof Error ? reason.message : String(reason);
+            if (errorMessage.includes('JSON') && errorMessage.includes('Unexpected token')) {
+                process.stderr.write(`[desktop-commander] JSON parsing rejection: ${errorMessage}\n`);
+                return;
+            }
+            capture('run_server_unhandled_rejection', {
+                error: errorMessage,
+                startup_method: startupInfo.method,
+                environment: startupInfo.environment
+            });
+            process.stderr.write(`[desktop-commander] Unhandled rejection: ${errorMessage}\n`);
+            process.exit(1);
+        });
+        capture('run_server_start', {
+            startup_method: startupInfo.method,
+            environment: startupInfo.environment
+        });
+        try {
+            console.error("Loading configuration...");
+            await configManager.loadConfig();
+            console.error("Configuration loaded successfully");
+        }
+        catch (configError) {
+            console.error(`Failed to load configuration: ${configError instanceof Error ? configError.message : String(configError)}`);
+            console.error(configError instanceof Error && configError.stack ? configError.stack : 'No stack trace available');
+            console.error("Continuing with in-memory configuration only");
+        }
+        console.error("Connecting server...");
+        await server.connect(transport);
+        console.error("✅ Server connected successfully");
+        console.error(`🎯 Running in ${startupInfo.environment} environment via ${startupMethod}`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`FATAL ERROR: ${errorMessage}`);
+        console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
+        process.stderr.write(JSON.stringify({
+            type: 'error',
+            timestamp: new Date().toISOString(),
+            message: `Failed to start server: ${errorMessage}`,
+            startup_method: getStartupInfo().method
+        }) + '\n');
+        capture('run_server_failed_start_error', {
+            error: errorMessage,
+            startup_method: getStartupInfo().method
+        });
+        process.exit(1);
+    }
+}
+runServer().catch(async (error) => {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`RUNTIME ERROR: ${errorMessage}`);
+    console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
+    process.stderr.write(JSON.stringify({
+        type: 'error',
+        timestamp: new Date().toISOString(),
+        message: `Fatal error running server: ${errorMessage}`,
+        startup_method: getStartupInfo().method
+    }) + '\n');
+    capture('run_server_fatal_error', {
+        error: errorMessage,
+        startup_method: getStartupInfo().method
+    });
+    process.exit(1);
+});

package/dist/index.js

@@ -51,6 +51,8 @@ async function runServer() {
             return;
         }
         const transport = new FilteredStdioServerTransport();
+        // Export transport for use throughout the application
+        global.mcpTransport = transport;
         // Handle uncaught exceptions
         process.on('uncaughtException', async (error) => {
             const errorMessage = error instanceof Error ? error.message : String(error);

package/dist/server.d.ts

@@ -22,3 +22,8 @@ export declare const server: Server<{
         [x: string]: unknown;
     } | undefined;
 }>;
+declare let currentClient: {
+    name: string;
+    version: string;
+};
+export { currentClient };