@wonderwhy-er/desktop-commander 0.2.36 → 0.2.38

package/dist/ui/shared/ui-event-tracker.js

@@ -0,0 +1,27 @@
+function normalizeUiEventParams(params) {
+    const normalized = {};
+    if (!params) {
+        return normalized;
+    }
+    for (const [key, value] of Object.entries(params)) {
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || value === null) {
+            normalized[key] = value;
+        }
+    }
+    return normalized;
+}
+export function createUiEventTracker(callTool, options) {
+    const baseParams = options.baseParams ?? {};
+    return (event, params = {}) => {
+        void callTool('track_ui_event', {
+            event,
+            component: options.component,
+            params: {
+                ...baseParams,
+                ...normalizeUiEventParams(params),
+            },
+        }).catch(() => {
+            // UI analytics should never block UI interactions.
+        });
+    };
+}

package/dist/utils/capture.js

@@ -1,6 +1,6 @@
 import { platform } from 'os';
 import * as https from 'https';
-import { configManager } from '../config-manager.js';
+import { configManager, isTelemetryDisabledValue } from '../config-manager.js';
 import { currentClient } from '../server.js';
 let VERSION = 'unknown';
 try {
@@ -12,6 +12,9 @@ catch {
 }
 // Will be initialized when needed
 let uniqueUserId = 'unknown';
+// --- Telemetry Proxy (direct BigQuery ingestion) ---
+const TELEMETRY_PROXY_URL = 'https://dc-telemetry-proxy-83847352264.europe-west1.run.app/mp/collect';
+const TELEMETRY_PROXY_TOKEN = 'Od44UB_fTrVfGPGRPLr5QdVgFhuKdiGaBmvazTdxVdQ';
 /**
  * Sanitizes error objects to remove potentially sensitive information like file paths
  * @param error Error object or string to sanitize
@@ -53,7 +56,7 @@ export const captureBase = async (captureURL, 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 || !captureURL) {
+        if (isTelemetryDisabledValue(telemetryEnabled) || !captureURL) {
             return;
         }
         // Get or create the client ID if not already initialized
@@ -225,19 +228,178 @@ export const captureBase = async (captureURL, event, properties) => {
         // Silently fail - we don't want analytics issues to break functionality
     }
 };
+/**
+ * Build the standard event properties used by both GA4 and the telemetry proxy.
+ * Extracted from captureBase so both paths get identical data.
+ */
+const buildEventProperties = async (properties) => {
+    if (uniqueUserId === 'unknown') {
+        uniqueUserId = await configManager.getOrCreateClientId();
+    }
+    let clientContext = {};
+    if (currentClient) {
+        clientContext = {
+            client_name: currentClient.name,
+            client_version: currentClient.version,
+        };
+    }
+    const sawOnboardingPage = await configManager.getValue('sawOnboardingPage');
+    if (sawOnboardingPage !== undefined) {
+        clientContext.saw_onboarding_page = sawOnboardingPage;
+    }
+    let sanitizedProperties;
+    try {
+        sanitizedProperties = properties ? JSON.parse(JSON.stringify(properties)) : {};
+    }
+    catch {
+        sanitizedProperties = {};
+    }
+    if (sanitizedProperties.error) {
+        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;
+        }
+    }
+    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(sk => lowerKey.includes(sk)) && lowerKey !== 'fileextension') {
+            delete sanitizedProperties[key];
+        }
+    }
+    let isDXT = 'false';
+    if (process.env.MCP_DXT)
+        isDXT = 'true';
+    const { getSystemInfo } = await import('./system-info.js');
+    const systemInfo = getSystemInfo();
+    const isContainer = systemInfo.docker.isContainer ? 'true' : 'false';
+    const containerType = systemInfo.docker.containerType || 'none';
+    const orchestrator = systemInfo.docker.orchestrator || 'none';
+    let containerName = 'none';
+    let containerImage = 'none';
+    if (systemInfo.docker.isContainer && systemInfo.docker.containerEnvironment) {
+        const env = systemInfo.docker.containerEnvironment;
+        if (env.containerName) {
+            containerName = env.containerName
+                .replace(/[0-9a-f]{8,}/gi, 'ID')
+                .replace(/[0-9]{8,}/g, 'ID')
+                .substring(0, 50);
+        }
+        if (env.dockerImage) {
+            containerImage = env.dockerImage
+                .replace(/^[^/]+\/[^/]+\//, '')
+                .replace(/^[^/]+\//, '')
+                .replace(/@sha256:.*$/, '')
+                .substring(0, 100);
+        }
+    }
+    let runtimeSource = 'unknown';
+    try {
+        const processArgs = process.argv.join(' ');
+        if (processArgs.includes('@smithery/cli') || processArgs.includes('smithery')) {
+            runtimeSource = 'smithery-runtime';
+        }
+        else if (processArgs.includes('npx')) {
+            runtimeSource = 'npx-runtime';
+        }
+        else {
+            runtimeSource = 'direct-runtime';
+        }
+    }
+    catch { }
+    return {
+        timestamp: new Date().toISOString(),
+        platform: platform(),
+        isContainer,
+        containerType,
+        orchestrator,
+        containerName,
+        containerImage,
+        runtimeSource,
+        isDXT,
+        app_version: VERSION,
+        engagement_time_msec: "100",
+        ...clientContext,
+        ...sanitizedProperties,
+    };
+};
+/**
+ * Send event to the telemetry proxy (direct BigQuery ingestion).
+ * Runs in parallel with GA4 — used for high-volume events to avoid
+ * the 1M/day GA4 BigQuery export limit.
+ */
+const sendToTelemetryProxy = async (event, eventProperties) => {
+    try {
+        const telemetryEnabled = await configManager.getValue('telemetryEnabled');
+        if (isTelemetryDisabledValue(telemetryEnabled))
+            return;
+        const payload = JSON.stringify({
+            client_id: uniqueUserId,
+            timestamp_micros: Date.now() * 1000,
+            events: [{
+                    name: event,
+                    params: eventProperties
+                }]
+        });
+        const url = new URL(TELEMETRY_PROXY_URL);
+        const options = {
+            hostname: url.hostname,
+            port: 443,
+            path: url.pathname,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${TELEMETRY_PROXY_TOKEN}`,
+                'Content-Length': Buffer.byteLength(payload)
+            }
+        };
+        const req = https.request(options, (res) => {
+            res.resume(); // drain response
+        });
+        req.on('error', () => { }); // silent fail
+        req.setTimeout(3000, () => req.destroy());
+        req.write(payload);
+        req.end();
+    }
+    catch {
+        // Silent fail — telemetry should never break functionality
+    }
+};
 export const capture_call_tool = async (event, properties) => {
-    const GA_MEASUREMENT_ID = 'G-8L163XZ1CE'; // Replace with your GA4 Measurement ID
-    const GA_API_SECRET = 'hNxh4TK2TnSy4oLZn4RwTA'; // 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}`;
-    return await captureBase(GA_BASE_URL, event, properties);
+    // Old property (G-8L163XZ1CE) — keeps lower-volume tool events
+    const GA_OLD_ID = 'G-8L163XZ1CE';
+    const GA_OLD_SECRET = 'hNxh4TK2TnSy4oLZn4RwTA';
+    const GA_OLD_URL = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_OLD_ID}&api_secret=${GA_OLD_SECRET}`;
+    // New property (dc_high_volume) — receives highest-volume tool events to avoid 1M/day BQ export limit
+    const GA_NEW_ID = 'G-ZDF1M5403Z';
+    const GA_NEW_SECRET = 'cUEilpa0SpWfc2UjblDtKQ';
+    const GA_NEW_URL = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_NEW_ID}&api_secret=${GA_NEW_SECRET}`;
+    // Route highest-volume tools to new property, rest to old
+    const HIGH_VOLUME_TOOLS = ['start_process', 'track_ui_event'];
+    const toolName = properties?.name;
+    const gaUrl = HIGH_VOLUME_TOOLS.includes(toolName) ? GA_NEW_URL : GA_OLD_URL;
+    // Build properties once, send to GA4 + telemetry proxy in parallel
+    const eventProperties = await buildEventProperties(properties);
+    await Promise.all([
+        captureBase(gaUrl, event, properties), // GA4 (routed by tool name)
+        sendToTelemetryProxy(event, eventProperties), // direct BigQuery (all events)
+    ]);
 };
 export const capture = async (event, properties) => {
-    const GA_MEASUREMENT_ID = 'G-F3GK01G39Y'; // Replace with your GA4 Measurement ID
-    const GA_API_SECRET = 'SqdcIAweSQS1RQErURMdEA'; // Replace with your GA4 API Secret
+    const GA_MEASUREMENT_ID = 'G-F3GK01G39Y';
+    const GA_API_SECRET = 'SqdcIAweSQS1RQErURMdEA';
     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}`;
-    return await captureBase(GA_BASE_URL, event, properties);
+    // Build properties once, send to both GA4 and telemetry proxy in parallel
+    const eventProperties = await buildEventProperties(properties);
+    await Promise.all([
+        captureBase(GA_BASE_URL, event, properties), // existing GA4
+        sendToTelemetryProxy(event, eventProperties), // new: direct BigQuery
+    ]);
 };
 export const capture_ui_event = async (event, properties) => {
     const GA_MEASUREMENT_ID = 'G-MPFSWEGQ0T';

package/dist/utils/files/base.d.ts

@@ -102,6 +102,8 @@ export interface FileMetadata {
     title?: string;
     totalPages?: number;
     pages?: PdfPageItem[];
+    /** For DOCX files */
+    isDocx?: boolean;
     /** Error information if operation failed */
     error?: boolean;
     errorMessage?: string;
@@ -161,7 +163,7 @@ export interface FileInfo {
     /** File permissions (octal string) */
     permissions: string;
     /** File type classification */
-    fileType: 'text' | 'excel' | 'image' | 'binary';
+    fileType: 'text' | 'excel' | 'image' | 'binary' | 'docx';
     /** Type-specific metadata */
     metadata?: FileMetadata;
 }

package/dist/utils/files/docx.d.ts

@@ -1,34 +1,47 @@
 /**
  * DOCX File Handler
- * Implements FileHandler interface for DOCX documents
- * Handles reading, writing, and modifying DOCX files while preserving formatting
+ *
+ * Approach: expose DOCX as filtered/raw XML through existing read_file + edit_block.
+ *
+ * READ (default): Returns a text-bearing outline — skips shapes, drawings, SVG noise.
+ *   Shows paragraphs with text, tables with cell content, style info, and image refs.
+ *   Each element shows its raw XML tag context so Claude can target it for editing.
+ *
+ * READ (with offset/length): Returns raw pretty-printed XML with line pagination,
+ *   so Claude can drill into specific sections when the outline isn't enough.
+ *
+ * EDIT (old_string/new_string): Find/replace on the pretty-printed XML, then
+ *   compact and repack into valid DOCX. Works exactly like text file editing.
+ *
+ * Round-trip: DOCX → unzip → pretty-print → [outline or raw] → edit → compact → repack
  */
 import { FileHandler, FileResult, FileInfo, ReadOptions, EditResult } from './base.js';
-/**
- * File handler for DOCX documents
- * Extracts text and metadata, supports paragraph-based pagination
- */
 export declare class DocxFileHandler implements FileHandler {
     private readonly extensions;
-    /**
-     * Check if this handler can handle the given file
-     */
     canHandle(path: string): boolean;
     /**
-     * Read DOCX content - returns body XML for LLM modification
+     * Read DOCX content.
+     *
+     * Default (offset=0, no explicit length or default length): returns outline
+     * With offset/length: returns raw pretty-printed XML with line pagination
      */
     read(path: string, options?: ReadOptions): Promise<FileResult>;
     /**
-     * Write DOCX - NOT SUPPORTED via write_file
-     * Use write_docx tool instead to preserve styles
+     * Write/create a DOCX file.
+     * Content is plain text — each line becomes a paragraph.
+     * Lines starting with # become headings (# = Heading1, ## = Heading2, etc.)
      */
     write(path: string, content: any, mode?: 'rewrite' | 'append'): Promise<void>;
     /**
-     * Edit DOCX by applying modifications
+     * Edit DOCX via find/replace on pretty-printed XML.
+     *
+     * Works on the same representation that read() returns when using offset/length,
+     * so XML fragments copied from read output work as search strings.
+     * After editing, XML is compacted and repacked into the DOCX.
      */
-    editRange(path: string, range: string, content: any, options?: Record<string, any>): Promise<EditResult>;
+    editRange(path: string, _range: string, content: any, options?: Record<string, any>): Promise<EditResult>;
     /**
-     * Get DOCX file information
+     * Get DOCX file info
      */
     getInfo(path: string): Promise<FileInfo>;
 }