@wonderwhy-er/desktop-commander 0.2.8 → 0.2.9

package/dist/uninstall-claude-server.js

@@ -0,0 +1,753 @@
+import { homedir, platform } from 'os';
+import fs from 'fs/promises';
+import path from 'path';
+import { join } from 'path';
+import { readFileSync, writeFileSync, existsSync, appendFileSync, mkdirSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { exec } from "node:child_process";
+import { version as nodeVersion } from 'process';
+import * as https from 'https';
+import { randomUUID } from 'crypto';
+
+// Google Analytics configuration
+const GA_MEASUREMENT_ID = 'G-NGGDNL0K4L'; // Replace with your GA4 Measurement ID
+const GA_API_SECRET = '5M0mC--2S_6t94m8WrI60A';   // Replace with your GA4 API Secret
+const GA_BASE_URL = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
+
+// Read clientId and telemetry settings from existing config
+let uniqueUserId = 'unknown';
+let telemetryEnabled = false; // Default to disabled for privacy
+
+async function getConfigSettings() {
+    try {
+        const USER_HOME = homedir();
+        const CONFIG_DIR = path.join(USER_HOME, '.claude-server-commander');
+        const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+        
+        if (existsSync(CONFIG_FILE)) {
+            const configData = readFileSync(CONFIG_FILE, 'utf8');
+            const config = JSON.parse(configData);
+            
+            return {
+                clientId: config.clientId || randomUUID(),
+                telemetryEnabled: config.telemetryEnabled === true // Explicit check for true
+            };
+        }
+        
+        // Fallback: generate new ID and default telemetry to false if config doesn't exist
+        return {
+            clientId: `unknown-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`,
+            telemetryEnabled: false
+        };
+    } catch (error) {
+        // Final fallback
+        return {
+            clientId: `random-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`,
+            telemetryEnabled: false
+        };
+    }
+}
+
+// Uninstall tracking
+let uninstallSteps = [];
+let uninstallStartTime = Date.now();
+
+// Fix for Windows ESM path resolution
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Setup logging
+const LOG_FILE = join(__dirname, 'setup.log');
+
+function logToFile(message, isError = false) {
+    const timestamp = new Date().toISOString();
+    const logMessage = `${timestamp} - ${isError ? 'ERROR: ' : ''}${message}\n`;
+    try {
+        appendFileSync(LOG_FILE, logMessage);
+        const jsonOutput = {
+            type: isError ? 'error' : 'info',
+            timestamp,
+            message
+        };
+        process.stdout.write(`${message}\n`);
+    } catch (err) {
+        process.stderr.write(`${JSON.stringify({
+            type: 'error',
+            timestamp: new Date().toISOString(),
+            message: `Failed to write to log file: ${err.message}`
+        })}\n`);
+    }
+}
+
+// Function to get npm version
+async function getNpmVersion() {
+    try {
+        return new Promise((resolve, reject) => {
+            exec('npm --version', (error, stdout, stderr) => {
+                if (error) {
+                    resolve('unknown');
+                    return;
+                }
+                resolve(stdout.trim());
+            });
+        });
+    } catch (error) {
+        return 'unknown';
+    }
+}
+
+// Get Desktop Commander version
+const getVersion = async () => {
+    try {
+        if (process.env.npm_package_version) {
+            return process.env.npm_package_version;
+        }
+        
+        const versionPath = join(__dirname, 'version.js');
+        if (existsSync(versionPath)) {
+            const { VERSION } = await import(versionPath);
+            return VERSION;
+        }
+
+        const packageJsonPath = join(__dirname, 'package.json');
+        if (existsSync(packageJsonPath)) {
+            const packageJsonContent = readFileSync(packageJsonPath, 'utf8');
+            const packageJson = JSON.parse(packageJsonContent);
+            if (packageJson.version) {
+                return packageJson.version;
+            }
+        }
+        
+        return 'unknown';
+    } catch (error) {
+        return 'unknown';
+    }
+};
+// Function to detect shell environment
+function detectShell() {
+    if (process.platform === 'win32') {
+        if (process.env.TERM_PROGRAM === 'vscode') return 'vscode-terminal';
+        if (process.env.WT_SESSION) return 'windows-terminal';
+        if (process.env.SHELL?.includes('bash')) return 'git-bash';
+        if (process.env.TERM?.includes('xterm')) return 'xterm-on-windows';
+        if (process.env.ComSpec?.toLowerCase().includes('powershell')) return 'powershell';
+        if (process.env.PROMPT) return 'cmd';
+
+        if (process.env.WSL_DISTRO_NAME || process.env.WSLENV) {
+            return `wsl-${process.env.WSL_DISTRO_NAME || 'unknown'}`;
+        }
+
+        return 'windows-unknown';
+    }
+
+    if (process.env.SHELL) {
+        const shellPath = process.env.SHELL.toLowerCase();
+        if (shellPath.includes('bash')) return 'bash';
+        if (shellPath.includes('zsh')) return 'zsh';
+        if (shellPath.includes('fish')) return 'fish';
+        if (shellPath.includes('ksh')) return 'ksh';
+        if (shellPath.includes('csh')) return 'csh';
+        if (shellPath.includes('dash')) return 'dash';
+        return `other-unix-${shellPath.split('/').pop()}`;
+    }
+
+    if (process.env.TERM_PROGRAM) {
+        return process.env.TERM_PROGRAM.toLowerCase();
+    }
+
+    return 'unknown-shell';
+}
+
+// Function to determine execution context
+function getExecutionContext() {
+    const isNpx = process.env.npm_lifecycle_event === 'npx' ||
+                  process.env.npm_execpath?.includes('npx') ||
+                  process.env._?.includes('npx') ||
+                  import.meta.url.includes('node_modules');
+
+    const isGlobal = process.env.npm_config_global === 'true' ||
+                     process.argv[1]?.includes('node_modules/.bin');
+
+    const isNpmScript = !!process.env.npm_lifecycle_script;
+
+    return {
+        runMethod: isNpx ? 'npx' : (isGlobal ? 'global' : (isNpmScript ? 'npm_script' : 'direct')),
+        isCI: !!process.env.CI || !!process.env.GITHUB_ACTIONS || !!process.env.TRAVIS || !!process.env.CIRCLECI,
+        shell: detectShell()
+    };
+}
+// Enhanced tracking properties
+let npmVersionCache = null;
+
+async function getTrackingProperties(additionalProps = {}) {
+    const propertiesStep = addUninstallStep('get_tracking_properties');
+    try {
+        if (npmVersionCache === null) {
+            npmVersionCache = await getNpmVersion();
+        }
+
+        const context = getExecutionContext();
+        const version = await getVersion();
+
+        updateUninstallStep(propertiesStep, 'completed');
+        return {
+            platform: platform(),
+            node_version: nodeVersion,
+            npm_version: npmVersionCache,
+            execution_context: context.runMethod,
+            is_ci: context.isCI,
+            shell: context.shell,
+            app_version: version,
+            engagement_time_msec: "100",
+            ...additionalProps
+        };
+    } catch (error) {
+        updateUninstallStep(propertiesStep, 'failed', error);
+        return {
+            platform: platform(),
+            node_version: nodeVersion,
+            error: error.message,
+            ...additionalProps
+        };
+    }
+}
+// Enhanced tracking function with retries
+async function trackEvent(eventName, additionalProps = {}) {
+    const trackingStep = addUninstallStep(`track_event_${eventName}`);
+
+    // Check if telemetry is disabled
+    if (!telemetryEnabled) {
+        updateUninstallStep(trackingStep, 'skipped_telemetry_disabled');
+        return true; // Return success since this is expected behavior
+    }
+
+    if (!GA_MEASUREMENT_ID || !GA_API_SECRET) {
+        updateUninstallStep(trackingStep, 'skipped', new Error('GA not configured'));
+        return;
+    }
+
+    const maxRetries = 2;
+    let attempt = 0;
+    let lastError = null;
+
+    while (attempt <= maxRetries) {
+        try {
+            attempt++;
+
+            const eventProperties = await getTrackingProperties(additionalProps);
+
+            const payload = {
+                client_id: uniqueUserId,
+                non_personalized_ads: false,
+                timestamp_micros: Date.now() * 1000,
+                events: [{
+                    name: eventName,
+                    params: eventProperties
+                }]
+            };
+
+            const postData = JSON.stringify(payload);
+            
+            const options = {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(postData)
+                }
+            };
+
+            const result = 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);
+                    reject(error);
+                });
+
+                req.on('response', (res) => {
+                    clearTimeout(timeoutId);
+                    let data = '';
+
+                    res.on('data', (chunk) => {
+                        data += chunk;
+                    });
+
+                    res.on('error', (error) => {
+                        reject(error);
+                    });
+
+                    res.on('end', () => {
+                        if (res.statusCode >= 200 && res.statusCode < 300) {
+                            resolve({ success: true, data });
+                        } else {
+                            reject(new Error(`HTTP error ${res.statusCode}: ${data}`));
+                        }
+                    });
+                });
+
+                req.write(postData);
+                req.end();
+            });
+
+            updateUninstallStep(trackingStep, 'completed');
+            return result;
+
+        } catch (error) {
+            lastError = error;
+            if (attempt <= maxRetries) {
+                await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+            }
+        }
+    }
+
+    updateUninstallStep(trackingStep, 'failed', lastError);
+    return false;
+}
+// Ensure tracking completes before process exits
+async function ensureTrackingCompleted(eventName, additionalProps = {}, timeoutMs = 6000) {
+    return new Promise(async (resolve) => {
+        const timeoutId = setTimeout(() => {
+            resolve(false);
+        }, timeoutMs);
+
+        try {
+            await trackEvent(eventName, additionalProps);
+            clearTimeout(timeoutId);
+            resolve(true);
+        } catch (error) {
+            clearTimeout(timeoutId);
+            resolve(false);
+        }
+    });
+}
+
+// Setup global error handlers (will be initialized after config is loaded)
+let errorHandlersInitialized = false;
+
+function initializeErrorHandlers() {
+    if (errorHandlersInitialized) return;
+    
+    process.on('uncaughtException', async (error) => {
+        if (telemetryEnabled) {
+            await trackEvent('uninstall_uncaught_exception', { error: error.message });
+        }
+        setTimeout(() => {
+            process.exit(1);
+        }, 1000);
+    });
+
+    process.on('unhandledRejection', async (reason, promise) => {
+        if (telemetryEnabled) {
+            await trackEvent('uninstall_unhandled_rejection', { error: String(reason) });
+        }
+        setTimeout(() => {
+            process.exit(1);
+        }, 1000);
+    });
+
+    errorHandlersInitialized = true;
+}
+
+// Track when the process is about to exit
+let isExiting = false;
+process.on('exit', () => {
+    if (!isExiting) {
+        isExiting = true;
+    }
+});
+
+// Determine OS and set appropriate config path
+const os = platform();
+const isWindows = os === 'win32';
+let claudeConfigPath;
+
+switch (os) {
+    case 'win32':
+        claudeConfigPath = join(process.env.APPDATA, 'Claude', 'claude_desktop_config.json');
+        break;
+    case 'darwin':
+        claudeConfigPath = join(homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+        break;
+    case 'linux':
+        claudeConfigPath = join(homedir(), '.config', 'Claude', 'claude_desktop_config.json');
+        break;
+    default:
+        claudeConfigPath = join(homedir(), '.claude_desktop_config.json');
+}
+// Step tracking functions
+function addUninstallStep(step, status = 'started', error = null) {
+    const timestamp = Date.now();
+    uninstallSteps.push({
+        step,
+        status,
+        timestamp,
+        timeFromStart: timestamp - uninstallStartTime,
+        error: error ? error.message || String(error) : null
+    });
+    return uninstallSteps.length - 1;
+}
+
+function updateUninstallStep(index, status, error = null) {
+    if (uninstallSteps[index]) {
+        const timestamp = Date.now();
+        uninstallSteps[index].status = status;
+        uninstallSteps[index].completionTime = timestamp;
+        uninstallSteps[index].timeFromStart = timestamp - uninstallStartTime;
+        if (error) {
+            uninstallSteps[index].error = error.message || String(error);
+        }
+    }
+}
+
+async function execAsync(command) {
+    const execStep = addUninstallStep(`exec_${command.substring(0, 20)}...`);
+    return new Promise((resolve, reject) => {
+        const actualCommand = isWindows
+            ? `cmd.exe /c ${command}`
+            : command;
+
+        exec(actualCommand, { timeout: 10000 }, (error, stdout, stderr) => {
+            if (error) {
+                updateUninstallStep(execStep, 'failed', error);
+                reject(error);
+                return;
+            }
+            updateUninstallStep(execStep, 'completed');
+            resolve({ stdout, stderr });
+        });
+    });
+}
+// Backup configuration before removal
+async function createConfigBackup(configPath) {
+    const backupStep = addUninstallStep('create_config_backup');
+    try {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupPath = `${configPath}.backup.${timestamp}`;
+        
+        if (existsSync(configPath)) {
+            const configData = readFileSync(configPath, 'utf8');
+            writeFileSync(backupPath, configData, 'utf8');
+            updateUninstallStep(backupStep, 'completed');
+            logToFile(`Configuration backup created: ${backupPath}`);
+            await trackEvent('uninstall_backup_created');
+            return backupPath;
+        } else {
+            updateUninstallStep(backupStep, 'no_config_file');
+            return null;
+        }
+    } catch (error) {
+        updateUninstallStep(backupStep, 'failed', error);
+        await trackEvent('uninstall_backup_failed', { error: error.message });
+        logToFile(`Failed to create backup: ${error.message}`, true);
+        return null;
+    }
+}
+
+// Restore configuration from backup
+async function restoreFromBackup(backupPath) {
+    if (!backupPath || !existsSync(backupPath)) {
+        return false;
+    }
+
+    try {
+        const backupData = readFileSync(backupPath, 'utf8');
+        writeFileSync(claudeConfigPath, backupData, 'utf8');
+        logToFile(`Configuration restored from backup: ${backupPath}`);
+        await trackEvent('uninstall_backup_restored');
+        return true;
+    } catch (error) {
+        logToFile(`Failed to restore from backup: ${error.message}`, true);
+        await trackEvent('uninstall_backup_restore_failed', { error: error.message });
+        return false;
+    }
+}
+
+async function restartClaude() {
+    const restartStep = addUninstallStep('restart_claude');
+    try {
+        const platform = process.platform;
+        logToFile('Attempting to restart Claude...');
+        await trackEvent('uninstall_restart_claude_attempt');
+
+        // Try to kill Claude process first
+        const killStep = addUninstallStep('kill_claude_process');
+        try {
+            switch (platform) {
+                case "win32":
+                    await execAsync(`taskkill /F /IM "Claude.exe"`);
+                    break;
+                case "darwin":
+                    await execAsync(`killall "Claude"`);
+                    break;
+                case "linux":
+                    await execAsync(`pkill -f "claude"`);
+                    break;
+            }
+            updateUninstallStep(killStep, 'completed');
+            logToFile("Claude process terminated successfully");
+            await trackEvent('uninstall_kill_claude_success');
+        } catch (killError) {
+            updateUninstallStep(killStep, 'no_process_found', killError);
+            logToFile("Claude process not found or already terminated");
+            await trackEvent('uninstall_kill_claude_not_needed');
+        }
+
+        // Wait a bit to ensure process termination
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+
+        // Try to start Claude
+        const startStep = addUninstallStep('start_claude_process');
+        try {
+            if (platform === "win32") {
+                logToFile("Windows: Claude restart skipped - please restart Claude manually");
+                updateUninstallStep(startStep, 'skipped');
+                await trackEvent('uninstall_start_claude_skipped');
+            } else if (platform === "darwin") {
+                await execAsync(`open -a "Claude"`);
+                updateUninstallStep(startStep, 'completed');
+                logToFile("✅ Claude has been restarted automatically!");
+                await trackEvent('uninstall_start_claude_success');
+            } else if (platform === "linux") {
+                await execAsync(`claude`);
+                updateUninstallStep(startStep, 'completed');
+                logToFile("✅ Claude has been restarted automatically!");
+                await trackEvent('uninstall_start_claude_success');
+            } else {
+                logToFile('To complete uninstallation, restart Claude if it\'s currently running');
+                updateUninstallStep(startStep, 'manual_required');
+            }
+            
+            updateUninstallStep(restartStep, 'completed');
+            await trackEvent('uninstall_restart_claude_success');
+        } catch (startError) {
+            updateUninstallStep(startStep, 'failed', startError);
+            await trackEvent('uninstall_start_claude_error', {
+                error: startError.message
+            });
+            logToFile(`Could not automatically restart Claude: ${startError.message}. Please restart it manually.`);
+        }
+    } catch (error) {
+        updateUninstallStep(restartStep, 'failed', error);
+        await trackEvent('uninstall_restart_claude_error', { error: error.message });
+        logToFile(`Failed to restart Claude: ${error.message}. Please restart it manually.`, true);
+    }
+}
+async function removeDesktopCommanderConfig() {
+    const configStep = addUninstallStep('remove_mcp_config');
+    let backupPath = null;
+    
+    try {
+        // Check if config file exists
+        if (!existsSync(claudeConfigPath)) {
+            updateUninstallStep(configStep, 'no_config_file');
+            logToFile(`Claude config file not found at: ${claudeConfigPath}`);
+            logToFile('✅ Desktop Commander was not configured or already removed.');
+            await trackEvent('uninstall_config_not_found');
+            return true;
+        }
+
+        // Create backup before making changes
+        backupPath = await createConfigBackup(claudeConfigPath);
+
+        // Read existing config
+        let config;
+        const readStep = addUninstallStep('read_config_file');
+        try {
+            const configData = readFileSync(claudeConfigPath, 'utf8');
+            config = JSON.parse(configData);
+            updateUninstallStep(readStep, 'completed');
+        } catch (readError) {
+            updateUninstallStep(readStep, 'failed', readError);
+            await trackEvent('uninstall_config_read_error', { error: readError.message });
+            throw new Error(`Failed to read config file: ${readError.message}`);
+        }
+
+        // Check if mcpServers exists
+        if (!config.mcpServers) {
+            updateUninstallStep(configStep, 'no_mcp_servers');
+            logToFile('No MCP servers configured in Claude.');
+            logToFile('✅ Desktop Commander was not configured or already removed.');
+            await trackEvent('uninstall_no_mcp_servers');
+            return true;
+        }
+        // Track what we're removing
+        const serversToRemove = [];
+        
+        if (config.mcpServers["desktop-commander"]) {
+            serversToRemove.push("desktop-commander");
+        }
+
+        if (serversToRemove.length === 0) {
+            updateUninstallStep(configStep, 'not_found');
+            logToFile('Desktop Commander MCP server not found in configuration.');
+            logToFile('✅ Desktop Commander was not configured or already removed.');
+            await trackEvent('uninstall_server_not_found');
+            return true;
+        }
+
+        // Remove the server configurations
+        const removeStep = addUninstallStep('remove_server_configs');
+        try {
+            serversToRemove.forEach(serverName => {
+                delete config.mcpServers[serverName];
+                logToFile(`Removed "${serverName}" from Claude configuration`);
+            });
+
+            updateUninstallStep(removeStep, 'completed');
+            await trackEvent('uninstall_servers_removed');
+        } catch (removeError) {
+            updateUninstallStep(removeStep, 'failed', removeError);
+            await trackEvent('uninstall_servers_remove_error', { error: removeError.message });
+            throw new Error(`Failed to remove server configs: ${removeError.message}`);
+        }        // Write the updated config back
+        const writeStep = addUninstallStep('write_updated_config');
+        try {
+            writeFileSync(claudeConfigPath, JSON.stringify(config, null, 2), 'utf8');
+            updateUninstallStep(writeStep, 'completed');
+            updateUninstallStep(configStep, 'completed');
+            logToFile('✅ Desktop Commander successfully removed from Claude configuration');
+            logToFile(`Configuration updated at: ${claudeConfigPath}`);
+            await trackEvent('uninstall_config_updated');
+        } catch (writeError) {
+            updateUninstallStep(writeStep, 'failed', writeError);
+            await trackEvent('uninstall_config_write_error', { error: writeError.message });
+            
+            // Try to restore from backup
+            if (backupPath) {
+                logToFile('Attempting to restore configuration from backup...');
+                const restored = await restoreFromBackup(backupPath);
+                if (restored) {
+                    throw new Error(`Failed to write updated config, but backup was restored: ${writeError.message}`);
+                } else {
+                    throw new Error(`Failed to write updated config and backup restoration failed: ${writeError.message}`);
+                }
+            } else {
+                throw new Error(`Failed to write updated config: ${writeError.message}`);
+            }
+        }
+
+        return true;
+    } catch (error) {
+        updateUninstallStep(configStep, 'failed', error);
+        await trackEvent('uninstall_config_error', { error: error.message });
+        logToFile(`Error removing Desktop Commander configuration: ${error.message}`, true);
+        
+        // Try to restore from backup if we have one
+        if (backupPath) {
+            logToFile('Attempting to restore configuration from backup...');
+            await restoreFromBackup(backupPath);
+        }
+        
+        return false;
+    }
+}
+// Main uninstall function
+export default async function uninstall() {
+    // Initialize clientId and telemetry settings from existing config
+    const configSettings = await getConfigSettings();
+    uniqueUserId = configSettings.clientId;
+    telemetryEnabled = configSettings.telemetryEnabled;
+    
+    // Initialize error handlers now that telemetry setting is known
+    initializeErrorHandlers();
+    
+    // Log telemetry status for transparency
+    if (!telemetryEnabled) {
+        logToFile('Telemetry disabled - no analytics will be sent');
+    }
+    
+    // Initial tracking (only if telemetry enabled)
+    await ensureTrackingCompleted('uninstall_start');
+
+    const mainStep = addUninstallStep('main_uninstall');
+
+    try {
+        logToFile('Starting Desktop Commander uninstallation...');
+        
+        // Remove the server configuration from Claude
+        const configRemoved = await removeDesktopCommanderConfig();
+        
+        if (configRemoved) {
+            // Try to restart Claude
+            // await restartClaude();
+            
+            updateUninstallStep(mainStep, 'completed');
+            
+            const appVersion = await getVersion();
+            logToFile(`\n✅ Desktop Commander has been successfully uninstalled!`);
+            logToFile('The MCP server has been removed from Claude\'s configuration.');
+
+            logToFile('\nIf you want to reinstall later, you can run:');
+            logToFile('npx @wonderwhy-er/desktop-commander@latest setup');
+
+            logToFile('\n🎁 We\'re sorry to see you leaving, we’d love to understand your decision not to use Desktop Commander.')
+            logToFile('In return for a brief 30-minute call, we’ll send you a $20 Amazon gift card as a thank-you.');
+            logToFile('To get a gift card, please fill out this form:');
+            logToFile(' https://tally.so/r/w8lyRo');
+
+
+            logToFile('\nThank you for using Desktop Commander! 👋\n');
+            
+            // Send final tracking event
+            await ensureTrackingCompleted('uninstall_complete');
+            
+            return true;        
+        } else {
+            updateUninstallStep(mainStep, 'failed_config_removal');
+            
+            logToFile('\n❌ Uninstallation completed with errors.');
+            logToFile('You may need to manually remove Desktop Commander from Claude\'s configuration.');
+            logToFile(`Configuration file location: ${claudeConfigPath}\n`);
+
+            logToFile('\n🎁 We\'re sorry to see you leaving, we\'d love to understand your decision not to use Desktop Commander.')
+            logToFile('In return for a brief 30-minute call, we\'ll send you a $20 Amazon gift card as a thank-you.');
+            logToFile('To get a gift card, please fill out this form:');
+            logToFile(' https://tally.so/r/w8lyRo');
+            
+            await ensureTrackingCompleted('uninstall_partial_failure');
+            
+            return false;
+        }
+    } catch (error) {
+        updateUninstallStep(mainStep, 'fatal_error', error);
+        
+        await ensureTrackingCompleted('uninstall_fatal_error', {
+            error: error.message,
+            error_stack: error.stack,
+            last_successful_step: uninstallSteps.filter(s => s.status === 'completed').pop()?.step || 'none'
+        });
+        
+        logToFile(`Fatal error during uninstallation: ${error.message}`, true);
+        logToFile('\n❌ Uninstallation failed.');
+        logToFile('You may need to manually remove Desktop Commander from Claude\'s configuration.');
+        logToFile(`Configuration file location: ${claudeConfigPath}\n`);
+
+        logToFile('\n🎁 We\'re sorry to see you leaving, we\'d love to understand your decision not to use Desktop Commander.')
+        logToFile('In return for a brief 30-minute call, we\'ll send you a $20 Amazon gift card as a thank-you.');
+        logToFile('To get a gift card, please fill out this form:');
+        logToFile('https://tally.so/r/w8lyRo');
+        return false;
+    }
+}
+
+// Allow direct execution
+if (process.argv.length >= 2 && process.argv[1] === fileURLToPath(import.meta.url)) {
+    uninstall().then(success => {
+        if (!success) {
+            process.exit(1);
+        }
+    }).catch(async error => {
+        await ensureTrackingCompleted('uninstall_execution_error', {
+            error: error.message,
+            error_stack: error.stack
+        });
+        logToFile(`Fatal error: ${error}`, true);
+        process.exit(1);
+    });
+}