@wonderwhy-er/desktop-commander 0.1.34 → 0.1.36

package/dist/tools/fuzzySearch.js

@@ -0,0 +1,113 @@
+import { distance } from 'fastest-levenshtein';
+import { capture } from '../utils/capture.js';
+/**
+ * Recursively finds the closest match to a query string within text using fuzzy matching
+ * @param text The text to search within
+ * @param query The query string to find
+ * @param start Start index in the text (default: 0)
+ * @param end End index in the text (default: text.length)
+ * @param parentDistance Best distance found so far (default: Infinity)
+ * @returns Object with start and end indices, matched value, and Levenshtein distance
+ */
+export function recursiveFuzzyIndexOf(text, query, start = 0, end = null, parentDistance = Infinity, depth = 0) {
+    // For debugging and performance tracking purposes
+    if (depth === 0) {
+        const startTime = performance.now();
+        const result = recursiveFuzzyIndexOf(text, query, start, end, parentDistance, depth + 1);
+        const executionTime = performance.now() - startTime;
+        // Capture detailed metrics for the recursive search for in-depth analysis
+        capture('fuzzy_search_recursive_metrics', {
+            execution_time_ms: executionTime,
+            text_length: text.length,
+            query_length: query.length,
+            result_distance: result.distance
+        });
+        return result;
+    }
+    if (end === null)
+        end = text.length;
+    // For small text segments, use iterative approach
+    if (end - start <= 2 * query.length) {
+        return iterativeReduction(text, query, start, end, parentDistance);
+    }
+    let midPoint = start + Math.floor((end - start) / 2);
+    let leftEnd = Math.min(end, midPoint + query.length); // Include query length to cover overlaps
+    let rightStart = Math.max(start, midPoint - query.length); // Include query length to cover overlaps
+    // Calculate distance for current segments
+    let leftDistance = distance(text.substring(start, leftEnd), query);
+    let rightDistance = distance(text.substring(rightStart, end), query);
+    let bestDistance = Math.min(leftDistance, parentDistance, rightDistance);
+    // If parent distance is already the best, use iterative approach
+    if (parentDistance === bestDistance) {
+        return iterativeReduction(text, query, start, end, parentDistance);
+    }
+    // Recursively search the better half
+    if (leftDistance < rightDistance) {
+        return recursiveFuzzyIndexOf(text, query, start, leftEnd, bestDistance, depth + 1);
+    }
+    else {
+        return recursiveFuzzyIndexOf(text, query, rightStart, end, bestDistance, depth + 1);
+    }
+}
+/**
+ * Iteratively refines the best match by reducing the search area
+ * @param text The text to search within
+ * @param query The query string to find
+ * @param start Start index in the text
+ * @param end End index in the text
+ * @param parentDistance Best distance found so far
+ * @returns Object with start and end indices, matched value, and Levenshtein distance
+ */
+function iterativeReduction(text, query, start, end, parentDistance) {
+    const startTime = performance.now();
+    let iterations = 0;
+    let bestDistance = parentDistance;
+    let bestStart = start;
+    let bestEnd = end;
+    // Improve start position
+    let nextDistance = distance(text.substring(bestStart + 1, bestEnd), query);
+    while (nextDistance < bestDistance) {
+        bestDistance = nextDistance;
+        bestStart++;
+        const smallerString = text.substring(bestStart + 1, bestEnd);
+        nextDistance = distance(smallerString, query);
+        iterations++;
+    }
+    // Improve end position
+    nextDistance = distance(text.substring(bestStart, bestEnd - 1), query);
+    while (nextDistance < bestDistance) {
+        bestDistance = nextDistance;
+        bestEnd--;
+        const smallerString = text.substring(bestStart, bestEnd - 1);
+        nextDistance = distance(smallerString, query);
+        iterations++;
+    }
+    const executionTime = performance.now() - startTime;
+    // Capture metrics for the iterative refinement phase
+    capture('fuzzy_search_iterative_metrics', {
+        execution_time_ms: executionTime,
+        iterations: iterations,
+        segment_length: end - start,
+        query_length: query.length,
+        final_distance: bestDistance
+    });
+    return {
+        start: bestStart,
+        end: bestEnd,
+        value: text.substring(bestStart, bestEnd),
+        distance: bestDistance
+    };
+}
+/**
+ * Calculates the similarity ratio between two strings
+ * @param a First string
+ * @param b Second string
+ * @returns Similarity ratio (0-1)
+ */
+export function getSimilarityRatio(a, b) {
+    const maxLength = Math.max(a.length, b.length);
+    if (maxLength === 0)
+        return 1; // Both strings are empty
+    const levenshteinDistance = distance(a, b);
+    return 1 - (levenshteinDistance / maxLength);
+}

package/dist/tools/pdf-reader.d.ts

@@ -0,0 +1,13 @@
+import { FileResult } from './filesystem.js';
+export declare enum PDFOutputFormat {
+    TEXT = "text",
+    MARKDOWN = "markdown",
+    HTML = "html"
+}
+/**
+ * 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 declare function readPDFFile(filePath: string, outputFormat?: PDFOutputFormat): Promise<FileResult>;

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

@@ -1,13 +1,28 @@
 import { z } from "zod";
+export declare const GetConfigArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const SetConfigValueArgsSchema: z.ZodObject<{
+    key: z.ZodString;
+    value: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    value?: any;
+}, {
+    key: string;
+    value?: any;
+}>;
+export declare const ListProcessesArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
 export declare const ExecuteCommandArgsSchema: z.ZodObject<{
     command: z.ZodString;
     timeout_ms: z.ZodOptional<z.ZodNumber>;
+    shell: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     command: string;
     timeout_ms?: number | undefined;
+    shell?: string | undefined;
 }, {
     command: string;
     timeout_ms?: number | undefined;
+    shell?: string | undefined;
 }>;
 export declare const ReadOutputArgsSchema: z.ZodObject<{
     pid: z.ZodNumber;
@@ -31,20 +46,6 @@ export declare const KillProcessArgsSchema: z.ZodObject<{
 }, {
     pid: number;
 }>;
-export declare const BlockCommandArgsSchema: z.ZodObject<{
-    command: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    command: string;
-}, {
-    command: string;
-}>;
-export declare const UnblockCommandArgsSchema: z.ZodObject<{
-    command: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    command: string;
-}, {
-    command: string;
-}>;
 export declare const ReadFileArgsSchema: z.ZodObject<{
     path: z.ZodString;
     isUrl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -145,9 +146,18 @@ export declare const SearchCodeArgsSchema: z.ZodObject<{
     contextLines?: number | undefined;
 }>;
 export declare const EditBlockArgsSchema: z.ZodObject<{
-    blockContent: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    blockContent: string;
-}, {
-    blockContent: string;
+    file_path: z.ZodString;
+    old_string: z.ZodString;
+    new_string: z.ZodString;
+    expected_replacements: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    expected_replacements: number;
+}, {
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    expected_replacements?: number | undefined;
 }>;

package/dist/tools/schemas.js

@@ -1,8 +1,18 @@
 import { z } from "zod";
+console.error("Loading schemas.ts");
+// Config tools schemas
+export const GetConfigArgsSchema = z.object({});
+export const SetConfigValueArgsSchema = z.object({
+    key: z.string(),
+    value: z.any(),
+});
+// Empty schemas
+export const ListProcessesArgsSchema = z.object({});
 // Terminal tools schemas
 export const ExecuteCommandArgsSchema = z.object({
     command: z.string(),
     timeout_ms: z.number().optional(),
+    shell: z.string().optional(),
 });
 export const ReadOutputArgsSchema = z.object({
     pid: z.number(),
@@ -14,12 +24,6 @@ export const ListSessionsArgsSchema = z.object({});
 export const KillProcessArgsSchema = z.object({
     pid: z.number(),
 });
-export const BlockCommandArgsSchema = z.object({
-    command: z.string(),
-});
-export const UnblockCommandArgsSchema = z.object({
-    command: z.string(),
-});
 // Filesystem tools schemas
 export const ReadFileArgsSchema = z.object({
     path: z.string(),
@@ -61,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,6 +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/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;
@@ -76,9 +77,10 @@ export async function searchCode(options) {
                             });
                         }
                     }
-                    catch (e) {
-                        // Skip non-JSON output
-                        console.error('Error parsing ripgrep output:', e);
+                    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);
@@ -164,7 +166,6 @@ export async function searchTextInFiles(options) {
         return await searchCode(options);
     }
     catch (error) {
-        console.error('Ripgrep search failed, falling back to native implementation:', error);
         return searchCodeFallback({
             ...options,
             excludeDirs: ['node_modules', '.git', 'dist']

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
+    }
+};