@wonderwhy-er/desktop-commander 0.1.35 → 0.1.37

package/dist/tools/pdf-reader.js

@@ -0,0 +1,214 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { capture } from '../utils.js';
+// Direct imports
+import pdfParse from 'pdf-parse';
+import TurndownService from 'turndown';
+// PDF output formats
+export var PDFOutputFormat;
+(function (PDFOutputFormat) {
+    PDFOutputFormat["TEXT"] = "text";
+    PDFOutputFormat["MARKDOWN"] = "markdown";
+    PDFOutputFormat["HTML"] = "html";
+})(PDFOutputFormat || (PDFOutputFormat = {}));
+/**
+ * Reads a PDF file and returns its content in the specified format
+ * @param filePath Path to the PDF file
+ * @param outputFormat Desired output format (text, markdown, or html)
+ * @returns FileResult object with the parsed content
+ */
+export async function readPDFFile(filePath, outputFormat = PDFOutputFormat.TEXT) {
+    try {
+        // Read the PDF file as a buffer
+        const dataBuffer = await fs.readFile(filePath);
+        // Parse the PDF 
+        const pdfData = await pdfParse(dataBuffer);
+        // Extract the raw text
+        const rawText = pdfData.text;
+        let content;
+        let mimeType;
+        // Convert to the requested format
+        switch (outputFormat) {
+            case PDFOutputFormat.HTML:
+                // Convert to simple HTML (using paragraphs for line breaks)
+                content = convertPDFToHTML(rawText, pdfData, filePath);
+                mimeType = 'text/html';
+                break;
+            case PDFOutputFormat.MARKDOWN:
+                try {
+                    // First convert to HTML, then to Markdown
+                    const htmlContent = convertPDFToHTML(rawText, pdfData, filePath);
+                    const turndownService = new TurndownService({
+                        headingStyle: 'atx',
+                        codeBlockStyle: 'fenced',
+                        emDelimiter: '*'
+                    });
+                    content = turndownService.turndown(htmlContent);
+                    mimeType = 'text/markdown';
+                }
+                catch (error) {
+                    capture('server_turndown_error', {
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                    // Fallback to basic markdown conversion if turndown has an issue
+                    content = convertPDFToBasicMarkdown(rawText, pdfData, filePath);
+                    mimeType = 'text/markdown';
+                }
+                break;
+                // First convert to HTML, then to Markdown
+                const htmlContent = convertPDFToHTML(rawText, pdfData, filePath);
+                const turndownService = new TurndownService({
+                    headingStyle: 'atx',
+                    codeBlockStyle: 'fenced',
+                    emDelimiter: '*'
+                });
+                content = turndownService.turndown(htmlContent);
+                mimeType = 'text/markdown';
+                break;
+            case PDFOutputFormat.TEXT:
+            default:
+                // Format as readable text
+                content = formatPDFText(rawText, pdfData, filePath);
+                mimeType = 'text/plain';
+                break;
+        }
+        return {
+            content,
+            mimeType,
+            isImage: false
+        };
+    }
+    catch (error) {
+        capture('server_pdf_read_error', {
+            error: error instanceof Error ? error.name : 'Unknown',
+            errorMessage: error instanceof Error ? error.message : String(error)
+        });
+        throw new Error(`Failed to read PDF file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Format PDF text to make it more readable as plain text
+ * @param text Raw text from PDF
+ * @param pdfData PDF data
+ * @param filePath Original file path (for filename)
+ * @returns Formatted text
+ */
+function formatPDFText(text, pdfData, filePath) {
+    const fileName = path.basename(filePath);
+    let output = `Document: ${fileName}\n`;
+    output += `Pages: ${pdfData.numpages}\n\n`;
+    // Add PDF metadata if available
+    if (pdfData.info) {
+        if (pdfData.info.Title)
+            output += `Title: ${pdfData.info.Title}\n`;
+        if (pdfData.info.Author)
+            output += `Author: ${pdfData.info.Author}\n`;
+        if (pdfData.info.Subject)
+            output += `Subject: ${pdfData.info.Subject}\n`;
+        if (pdfData.info.Keywords)
+            output += `Keywords: ${pdfData.info.Keywords}\n`;
+        if (pdfData.info.CreationDate)
+            output += `Creation Date: ${pdfData.info.CreationDate}\n`;
+        output += '\n';
+    }
+    // Format the actual text content
+    // Split by double line breaks to identify paragraphs
+    const paragraphs = text.split(/\n\s*\n/);
+    output += paragraphs.join('\n\n');
+    return output;
+}
+/**
+ * Convert PDF text to basic markdown format without using turndown
+ * @param text Raw text from PDF
+ * @param pdfData PDF data
+ * @param filePath Original file path (for filename)
+ * @returns Markdown text
+ */
+function convertPDFToBasicMarkdown(text, pdfData, filePath) {
+    const fileName = path.basename(filePath);
+    let output = `# ${fileName}\n\n`;
+    // Add PDF metadata if available
+    if (pdfData.info) {
+        if (pdfData.info.Title)
+            output += `**Title:** ${pdfData.info.Title}\n\n`;
+        if (pdfData.info.Author)
+            output += `**Author:** ${pdfData.info.Author}\n\n`;
+        if (pdfData.info.Subject)
+            output += `**Subject:** ${pdfData.info.Subject}\n\n`;
+    }
+    // Split by double line breaks to identify paragraphs
+    const paragraphs = text.split(/\n\s*\n/);
+    // Process each paragraph
+    paragraphs.forEach(paragraph => {
+        const trimmed = paragraph.trim();
+        if (trimmed) {
+            // Check if this looks like a heading (shorter, ends without punctuation)
+            if (trimmed.length < 80 && !trimmed.match(/[.,:;?!]$/)) {
+                output += `## ${trimmed}\n\n`;
+            }
+            else {
+                output += `${trimmed}\n\n`;
+            }
+        }
+    });
+    return output;
+}
+/**
+ * Convert PDF text to a simple HTML representation
+ * @param text Raw text from PDF
+ * @param pdfData PDF data
+ * @param filePath Original file path (for filename)
+ * @returns HTML string
+ */
+function convertPDFToHTML(text, pdfData, filePath) {
+    // This is a basic conversion that preserves paragraphs
+    const fileName = path.basename(filePath);
+    const title = pdfData.info && pdfData.info.Title ? pdfData.info.Title : fileName;
+    // Split by double line breaks to identify paragraphs
+    const paragraphs = text.split(/\n\s*\n/);
+    // Build HTML structure
+    let html = `<!DOCTYPE html>
+<html>
+<head>
+  <title>${title}</title>
+  <style>
+    body { font-family: Arial, sans-serif; line-height: 1.6; max-width: 800px; margin: 0 auto; padding: 20px; }
+    h1 { border-bottom: 1px solid #eee; padding-bottom: 10px; }
+    h2 { margin-top: 24px; }
+    pre { background-color: #f5f5f5; padding: 15px; border-radius: 5px; overflow-x: auto; }
+    .metadata { color: #666; font-size: 0.9em; margin-bottom: 24px; }
+  </style>
+</head>
+<body>
+  <h1>${title}</h1>
+`;
+    // Add metadata if available
+    if (pdfData.info) {
+        html += '  <div class="metadata">\n';
+        if (pdfData.info.Author)
+            html += `    <p><strong>Author:</strong> ${pdfData.info.Author}</p>\n`;
+        if (pdfData.info.Subject)
+            html += `    <p><strong>Subject:</strong> ${pdfData.info.Subject}</p>\n`;
+        if (pdfData.info.Keywords)
+            html += `    <p><strong>Keywords:</strong> ${pdfData.info.Keywords}</p>\n`;
+        if (pdfData.numpages)
+            html += `    <p><strong>Pages:</strong> ${pdfData.numpages}</p>\n`;
+        html += '  </div>\n';
+    }
+    // Add paragraphs
+    paragraphs.forEach(paragraph => {
+        const trimmed = paragraph.trim();
+        if (trimmed) {
+            // Check if this looks like a heading (shorter, ends without punctuation)
+            if (trimmed.length < 100 && !trimmed.match(/[.,:;?!]$/)) {
+                html += `  <h2>${trimmed}</h2>\n`;
+            }
+            else {
+                html += `  <p>${trimmed}</p>\n`;
+            }
+        }
+    });
+    html += `</body>
+</html>`;
+    return html;
+}

package/dist/tools/schemas.d.ts

@@ -146,9 +146,18 @@ export declare const SearchCodeArgsSchema: z.ZodObject<{
     contextLines?: number | undefined;
 }>;
 export declare const EditBlockArgsSchema: z.ZodObject<{
-    blockContent: z.ZodString;
+    file_path: z.ZodString;
+    old_string: z.ZodString;
+    new_string: z.ZodString;
+    expected_replacements: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
-    blockContent: string;
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    expected_replacements: number;
 }, {
-    blockContent: string;
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    expected_replacements?: number | undefined;
 }>;

package/dist/tools/schemas.js

@@ -65,7 +65,10 @@ export const SearchCodeArgsSchema = z.object({
     contextLines: z.number().optional(),
     timeoutMs: z.number().optional(),
 });
-// Edit tools schemas
+// Edit tools schema
 export const EditBlockArgsSchema = z.object({
-    blockContent: z.string(),
+    file_path: z.string(),
+    old_string: z.string(),
+    new_string: z.string(),
+    expected_replacements: z.number().optional().default(1),
 });

package/dist/tools/search.js

@@ -3,7 +3,7 @@ import path from 'path';
 import fs from 'fs/promises';
 import { validatePath } from './filesystem.js';
 import { rgPath } from '@vscode/ripgrep';
-import { capture } from "../utils.js";
+import { capture } from "../utils/capture.js";
 // Function to search file contents using ripgrep
 export async function searchCode(options) {
     const { rootPath, pattern, filePattern, ignoreCase = true, maxResults = 1000, includeHidden = false, contextLines = 0 } = options;
@@ -77,9 +77,10 @@ export async function searchCode(options) {
                             });
                         }
                     }
-                    catch (e) {
-                        capture('server_request_error', { error: 'Error parsing ripgrep output:' + e });
-                        console.error();
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        capture('server_request_error', { error: `Error parsing ripgrep output: ${errorMessage}` });
+                        console.error(`Error parsing ripgrep output: ${errorMessage}`);
                     }
                 }
                 resolve(results);

package/dist/utils/capture.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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>;

package/dist/utils/capture.js

@@ -0,0 +1,175 @@
+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
+}
+// 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';
+// 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();
+    }
+}
+/**
+ * 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 {
+        // 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
+    }
+};

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,9 +1,18 @@
+/**
+ * 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) => void;
+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.