@wonderwhy-er/desktop-commander 0.1.34 → 0.1.36

package/dist/utils/withTimeout.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Executes a promise with a timeout. If the promise doesn't resolve or reject within
+ * the specified timeout, returns the provided default value.
+ *
+ * @param operation The promise to execute
+ * @param timeoutMs Timeout in milliseconds
+ * @param operationName Name of the operation (for logs)
+ * @param defaultValue Value to return if the operation times out
+ * @returns Promise that resolves with the operation result or the default value on timeout
+ */
+export declare function withTimeout<T>(operation: Promise<T>, timeoutMs: number, operationName: string, defaultValue: T): Promise<T>;

package/dist/utils/withTimeout.js

@@ -0,0 +1,52 @@
+/**
+ * Executes a promise with a timeout. If the promise doesn't resolve or reject within
+ * the specified timeout, returns the provided default value.
+ *
+ * @param operation The promise to execute
+ * @param timeoutMs Timeout in milliseconds
+ * @param operationName Name of the operation (for logs)
+ * @param defaultValue Value to return if the operation times out
+ * @returns Promise that resolves with the operation result or the default value on timeout
+ */
+export function withTimeout(operation, timeoutMs, operationName, defaultValue) {
+    // Don't sanitize operation name for logs - only telemetry will sanitize if needed
+    return new Promise((resolve, reject) => {
+        let isCompleted = false;
+        // Set up timeout
+        const timeoutId = setTimeout(() => {
+            if (!isCompleted) {
+                isCompleted = true;
+                if (defaultValue !== null) {
+                    resolve(defaultValue);
+                }
+                else {
+                    // Keep the original operation name in the error message
+                    // Telemetry sanitization happens at the capture level
+                    reject(`__ERROR__: ${operationName} timed out after ${timeoutMs / 1000} seconds`);
+                }
+            }
+        }, timeoutMs);
+        // Execute the operation
+        operation
+            .then(result => {
+            if (!isCompleted) {
+                isCompleted = true;
+                clearTimeout(timeoutId);
+                resolve(result);
+            }
+        })
+            .catch(error => {
+            if (!isCompleted) {
+                isCompleted = true;
+                clearTimeout(timeoutId);
+                if (defaultValue !== null) {
+                    resolve(defaultValue);
+                }
+                else {
+                    // Pass the original error unchanged - sanitization for telemetry happens in capture
+                    reject(error);
+                }
+            }
+        });
+    });
+}

package/dist/utils.d.ts

@@ -1,4 +1,18 @@
-export declare const capture: (event: string, properties?: any) => void;
+/**
+ * Sanitizes error objects to remove potentially sensitive information like file paths
+ * @param error Error object or string to sanitize
+ * @returns An object with sanitized message and optional error code
+ */
+export declare function sanitizeError(error: any): {
+    message: string;
+    code?: string;
+};
+/**
+ * Send an event to Google Analytics
+ * @param event Event name
+ * @param properties Optional event properties
+ */
+export declare const capture: (event: string, properties?: any) => Promise<void>;
 /**
  * Executes a promise with a timeout. If the promise doesn't resolve or reject within
  * the specified timeout, returns the provided default value.

package/dist/utils.js

@@ -1,54 +1,173 @@
 import { platform } from 'os';
+import { randomUUID } from 'crypto';
+import * as https from 'https';
+import { configManager } from './config-manager.js';
 let VERSION = 'unknown';
 try {
     const versionModule = await import('./version.js');
     VERSION = versionModule.VERSION;
 }
 catch {
+    // Continue without version info if not available
 }
-// Set default tracking state
-const isTrackingEnabled = true;
+// 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}`;
+const GA_DEBUG_BASE_URL = `https://www.google-analytics.com/debug/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
+// Will be initialized when needed
 let uniqueUserId = 'unknown';
-let posthog = null;
-// Try to load PostHog without breaking if it's not available
-try {
-    // Dynamic imports to prevent crashing if dependencies aren't available
-    import('posthog-node').then((posthogModule) => {
-        const PostHog = posthogModule.PostHog;
-        import('node-machine-id').then((machineIdModule) => {
-            // Access the default export from the module
-            uniqueUserId = machineIdModule.default.machineIdSync();
-            if (isTrackingEnabled) {
-                posthog = new PostHog('phc_BW8KJ0cajzj2v8qfMhvDQ4dtFdgHPzeYcMRvRFGvQdH', {
-                    host: 'https://eu.i.posthog.com',
-                    flushAt: 3, // send all every time
-                    flushInterval: 5 // send always
-                });
-            }
-        }).catch(() => {
-            // Silently fail - we don't want analytics issues to break functionality
-        });
-    }).catch(() => {
-        // Silently fail - we don't want analytics issues to break functionality
-    });
-}
-catch {
-    //console.log('Analytics module not available - continuing without tracking');
+// Function to get or create a persistent UUID
+async function getOrCreateUUID() {
+    try {
+        // Try to get the UUID from the config
+        let clientId = await configManager.getValue('clientId');
+        // If it doesn't exist, create a new one and save it
+        if (!clientId) {
+            clientId = randomUUID();
+            await configManager.setValue('clientId', clientId);
+        }
+        return clientId;
+    }
+    catch (error) {
+        // Fallback to a random UUID if config operations fail
+        return randomUUID();
+    }
 }
-export const capture = (event, properties) => {
-    if (!posthog || !isTrackingEnabled) {
-        return;
+/**
+ * Sanitizes error objects to remove potentially sensitive information like file paths
+ * @param error Error object or string to sanitize
+ * @returns An object with sanitized message and optional error code
+ */
+export function sanitizeError(error) {
+    let errorMessage = '';
+    let errorCode = undefined;
+    if (error instanceof Error) {
+        // Extract just the error name and message without stack trace
+        errorMessage = error.name + ': ' + error.message;
+        // Extract error code if available (common in Node.js errors)
+        if ('code' in error) {
+            errorCode = error.code;
+        }
     }
+    else if (typeof error === 'string') {
+        errorMessage = error;
+    }
+    else {
+        errorMessage = 'Unknown error';
+    }
+    // Remove any file paths using regex
+    // This pattern matches common path formats including Windows and Unix-style paths
+    errorMessage = errorMessage.replace(/(?:\/|\\)[\w\d_.-\/\\]+/g, '[PATH]');
+    errorMessage = errorMessage.replace(/[A-Za-z]:\\[\w\d_.-\/\\]+/g, '[PATH]');
+    return {
+        message: errorMessage,
+        code: errorCode
+    };
+}
+/**
+ * Send an event to Google Analytics
+ * @param event Event name
+ * @param properties Optional event properties
+ */
+export const capture = async (event, properties) => {
     try {
-        properties = properties || {};
-        properties.timestamp = new Date().toISOString();
-        properties.platform = platform();
-        properties.DCVersion = VERSION;
-        posthog.capture({
-            distinctId: uniqueUserId,
-            event,
-            properties
+        // Check if telemetry is enabled in config (defaults to true if not set)
+        const telemetryEnabled = await configManager.getValue('telemetryEnabled');
+        // If telemetry is explicitly disabled or GA credentials are missing, don't send
+        if (telemetryEnabled === false || !GA_MEASUREMENT_ID || !GA_API_SECRET) {
+            return;
+        }
+        // Get or create the client ID if not already initialized
+        if (uniqueUserId === 'unknown') {
+            uniqueUserId = await getOrCreateUUID();
+        }
+        // Create a deep copy of properties to avoid modifying the original objects
+        // This ensures we don't alter error objects that are also returned to the AI
+        let sanitizedProperties;
+        try {
+            sanitizedProperties = properties ? JSON.parse(JSON.stringify(properties)) : {};
+        }
+        catch (e) {
+            sanitizedProperties = {};
+        }
+        // Sanitize error objects if present
+        if (sanitizedProperties.error) {
+            // Handle different types of error objects
+            if (typeof sanitizedProperties.error === 'object' && sanitizedProperties.error !== null) {
+                const sanitized = sanitizeError(sanitizedProperties.error);
+                sanitizedProperties.error = sanitized.message;
+                if (sanitized.code) {
+                    sanitizedProperties.errorCode = sanitized.code;
+                }
+            }
+            else if (typeof sanitizedProperties.error === 'string') {
+                sanitizedProperties.error = sanitizeError(sanitizedProperties.error).message;
+            }
+        }
+        // Remove any properties that might contain paths
+        const sensitiveKeys = ['path', 'filePath', 'directory', 'file_path', 'sourcePath', 'destinationPath', 'fullPath', 'rootPath'];
+        for (const key of Object.keys(sanitizedProperties)) {
+            const lowerKey = key.toLowerCase();
+            if (sensitiveKeys.some(sensitiveKey => lowerKey.includes(sensitiveKey)) &&
+                lowerKey !== 'fileextension') { // keep fileExtension as it's safe
+                delete sanitizedProperties[key];
+            }
+        }
+        // Prepare standard properties
+        const baseProperties = {
+            timestamp: new Date().toISOString(),
+            platform: platform(),
+            app_version: VERSION,
+            engagement_time_msec: "100"
+        };
+        // Combine with sanitized properties
+        const eventProperties = {
+            ...baseProperties,
+            ...sanitizedProperties
+        };
+        // Prepare GA4 payload
+        const payload = {
+            client_id: uniqueUserId,
+            non_personalized_ads: false,
+            timestamp_micros: Date.now() * 1000,
+            events: [{
+                    name: event,
+                    params: eventProperties
+                }]
+        };
+        // Send data to Google Analytics
+        const postData = JSON.stringify(payload);
+        const options = {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(postData)
+            }
+        };
+        const req = https.request(GA_BASE_URL, options, (res) => {
+            // Response handling (optional)
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                if (res.statusCode !== 200 && res.statusCode !== 204) {
+                    // Optional debug logging
+                    // console.debug(`GA tracking error: ${res.statusCode} ${data}`);
+                }
+            });
+        });
+        req.on('error', () => {
+            // Silently fail - we don't want analytics issues to break functionality
+        });
+        // Set timeout to prevent blocking the app
+        req.setTimeout(3000, () => {
+            req.destroy();
         });
+        // Send data
+        req.write(postData);
+        req.end();
     }
     catch {
         // Silently fail - we don't want analytics issues to break functionality
@@ -65,13 +184,21 @@ export const capture = (event, properties) => {
  * @returns Promise that resolves with the operation result or the default value on timeout
  */
 export function withTimeout(operation, timeoutMs, operationName, defaultValue) {
-    return new Promise((resolve) => {
+    // Don't sanitize operation name for logs - only telemetry will sanitize if needed
+    return new Promise((resolve, reject) => {
         let isCompleted = false;
         // Set up timeout
         const timeoutId = setTimeout(() => {
             if (!isCompleted) {
                 isCompleted = true;
-                resolve(defaultValue);
+                if (defaultValue !== null) {
+                    resolve(defaultValue);
+                }
+                else {
+                    // Keep the original operation name in the error message
+                    // Telemetry sanitization happens at the capture level
+                    reject(`__ERROR__: ${operationName} timed out after ${timeoutMs / 1000} seconds`);
+                }
             }
         }, timeoutMs);
         // Execute the operation
@@ -87,7 +214,13 @@ export function withTimeout(operation, timeoutMs, operationName, defaultValue) {
             if (!isCompleted) {
                 isCompleted = true;
                 clearTimeout(timeoutId);
-                resolve(defaultValue);
+                if (defaultValue !== null) {
+                    resolve(defaultValue);
+                }
+                else {
+                    // Pass the original error unchanged - sanitization for telemetry happens in capture
+                    reject(error);
+                }
             }
         });
     });

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.1.34";
+export declare const VERSION = "0.1.36";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.1.34';
+export const VERSION = '0.1.36';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "description": "MCP server for terminal operations and file editing",
   "license": "MIT",
   "author": "Eduards Ruzga",
@@ -62,9 +62,8 @@
     "@modelcontextprotocol/sdk": "^1.8.0",
     "@vscode/ripgrep": "^1.15.9",
     "cross-fetch": "^4.1.0",
+    "fastest-levenshtein": "^1.0.16",
     "glob": "^10.3.10",
-    "node-machine-id": "^1.1.12",
-    "posthog-node": "^4.11.1",
     "zod": "^3.24.1",
     "zod-to-json-schema": "^3.23.5"
   },