@wonderwhy-er/desktop-commander 0.2.41 → 0.2.43

package/dist/ui/file-preview/src/app.js

@@ -11,7 +11,7 @@ import { attachDirectoryHandlers } from './directory-controller.js';
 import { buildDocumentLayout } from './document-layout.js';
 import { getDocumentFullscreenAvailability, parseReadRange, stripReadStatusLine } from './document-workspace.js';
 import { getFileTypeCapabilities, renderPayloadBody } from './file-type-handlers.js';
-import { buildOpenInEditorCommand, buildOpenInFolderCommand, detectDefaultMarkdownEditor, renderMarkdownEditorAppIcon } from './host/external-actions.js';
+import { buildOpenInEditorCommand, buildOpenInFolderCommand, renderMarkdownEditorAppIcon } from './host/external-actions.js';
 import { attachSelectionContext } from './host/selection-context.js';
 import { createMarkdownController } from './markdown/controller.js';
 import { createConflictDialogController, renderConflictDialogMarkup, } from './markdown/conflict-dialog.js';
@@ -40,7 +40,9 @@ let inlinePayloadBeforeFullscreen;
 let directoryBackPayload;
 let selectionAbortController = null;
 const markdownEditorAppCache = new Map();
-const markdownEditorAppPending = new Set();
+function getTelemetryToolName(payload) {
+    return typeof payload?.sourceTool === 'string' ? payload.sourceTool : 'read_file';
+}
 async function callToolIfReady(name, args) {
     return rpcCallTool ? rpcCallTool(name, args) : undefined;
 }
@@ -147,7 +149,10 @@ async function readAndResolvePayload(payload, onReady) {
     try {
         const freshPayload = await markdownController.readPayload(payload.filePath);
         if (freshPayload) {
-            onReady(freshPayload);
+            onReady({
+                ...freshPayload,
+                sourceTool: payload.sourceTool ?? freshPayload.sourceTool,
+            });
             if (freshPayload.fileType === 'markdown') {
                 void markdownController.refreshFromDisk(freshPayload);
             }
@@ -212,21 +217,15 @@ export function renderApp(container, payload, htmlMode = 'rendered', expandedSta
     const canGoFullscreen = !isFullscreen && getDocumentFullscreenAvailability({
         availableDisplayModes: getAvailableDisplayModes(),
     }).canFullscreen;
+    if (payload.fileType === 'markdown' && payload.defaultEditorName) {
+        markdownEditorAppCache.set(payload.filePath, {
+            appName: payload.defaultEditorName,
+            appPath: payload.defaultEditorPath,
+        });
+    }
     const defaultMarkdownEditor = payload.fileType === 'markdown'
         ? markdownEditorAppCache.get(payload.filePath)
         : undefined;
-    if (payload.fileType === 'markdown' && !defaultMarkdownEditor) {
-        void detectDefaultMarkdownEditor({
-            filePath: payload.filePath,
-            editorAppCache: markdownEditorAppCache,
-            editorAppPending: markdownEditorAppPending,
-            callTool: callToolIfReady,
-            extractToolText,
-            onDetected: () => {
-                rerenderCurrent?.();
-            },
-        });
-    }
     const layout = buildDocumentLayout({
         payload,
         body,
@@ -415,9 +414,12 @@ export function bootstrapApp() {
         const result = await app.requestDisplayMode({ mode });
         return typeof result.mode === 'string' ? result.mode : null;
     };
-    trackUiEvent = createUiEventTracker((name, args) => app.callServerTool({ name, arguments: args }), {
+    const filePreviewUiEvent = createUiEventTracker((name, args) => app.callServerTool({ name, arguments: args }), {
         component: 'file_preview',
-        baseParams: { tool_name: 'read_file' },
+    });
+    trackUiEvent = (event, params = {}) => filePreviewUiEvent(event, {
+        tool_name: getTelemetryToolName(currentPayload ?? hostPayload),
+        ...params,
     });
     app.ontoolinput = (params) => {
         const requestedPath = typeof params.arguments?.path === 'string' ? params.arguments.path : undefined;

package/dist/ui/file-preview/src/directory-controller.js

@@ -146,7 +146,7 @@ export function attachDirectoryHandlers(options) {
             loadMoreBtn.querySelector('.dir-warning-text').textContent = 'Loading…';
             loadMoreBtn.disabled = true;
             try {
-                const result = await options.callTool?.('list_directory', { path: loadPath, depth: 1 });
+                const result = await options.callTool?.('list_directory', { path: loadPath, depth: 1, origin: 'ui' });
                 const text = extractToolText(result) ?? '';
                 if (text) {
                     const parsed = parseDirectoryEntries(text);
@@ -194,7 +194,7 @@ export function attachDirectoryHandlers(options) {
             if (chevron)
                 chevron.textContent = '⏳';
             try {
-                const result = await options.callTool?.('list_directory', { path: fullPath, depth: 2 });
+                const result = await options.callTool?.('list_directory', { path: fullPath, depth: 2, origin: 'ui' });
                 const text = extractToolText(result) ?? '';
                 if (text) {
                     target.dataset.loaded = 'true';
@@ -222,7 +222,7 @@ export function attachDirectoryHandlers(options) {
         if (target.classList.contains('dir-row-file')) {
             target.classList.add('dir-loading');
             try {
-                const result = await options.callTool?.('read_file', { path: fullPath });
+                const result = await options.callTool?.('read_file', { path: fullPath, origin: 'ui' });
                 if (!result || typeof result !== 'object' || result === null) {
                     return;
                 }

package/dist/ui/file-preview/src/file-type-handlers.js

@@ -16,13 +16,13 @@ function renderImageBody(payload) {
             html: '<div class="panel-content source-content"></div>',
         };
     }
-    if (!payload.imageData || payload.imageData.trim().length === 0) {
+    if (!payload.content || payload.content.trim().length === 0) {
         return {
             notice: 'Preview is unavailable because image data is missing.',
             html: '<div class="panel-content source-content"></div>',
         };
     }
-    const src = `data:${mimeType};base64,${payload.imageData}`;
+    const src = `data:${mimeType};base64,${payload.content}`;
     return {
         html: `<div class="panel-content image-content"><div class="image-preview"><img src="${escapeHtml(src)}" alt="${escapeHtml(payload.fileName)}" loading="eager" decoding="async"></div></div>`,
     };

package/dist/ui/file-preview/src/host/external-actions.d.ts

@@ -5,15 +5,4 @@ export declare function buildOpenInEditorCommand(filePath: string, isLikelyUrl:
     appName: string;
     appPath?: string;
 }>): string | undefined;
-export declare function detectDefaultMarkdownEditor(options: {
-    filePath: string;
-    editorAppCache: Map<string, {
-        appName: string;
-        appPath?: string;
-    }>;
-    editorAppPending: Set<string>;
-    callTool?: (name: string, args: Record<string, unknown>) => Promise<unknown | undefined>;
-    extractToolText: (value: unknown) => string | undefined;
-    onDetected?: () => void;
-}): Promise<void>;
 export declare function renderMarkdownEditorAppIcon(): string;

package/dist/ui/file-preview/src/host/external-actions.js

@@ -50,45 +50,6 @@ export function buildOpenInEditorCommand(filePath, isLikelyUrl, editorAppCache)
     }
     return `xdg-open ${shellQuote(trimmedPath)}`;
 }
-export async function detectDefaultMarkdownEditor(options) {
-    const trimmedPath = options.filePath.trim();
-    if (!trimmedPath || options.editorAppCache.has(trimmedPath) || options.editorAppPending.has(trimmedPath)) {
-        return;
-    }
-    const userAgent = navigator.userAgent.toLowerCase();
-    if (!userAgent.includes('mac')) {
-        return;
-    }
-    options.editorAppPending.add(trimmedPath);
-    try {
-        const detectCommand = `osascript -e ${shellQuote(`set appAlias to default application of (info for POSIX file "${trimmedPath.replace(/"/g, '\\"')}")
-return (name of (info for appAlias)) & linefeed & POSIX path of appAlias`)}`;
-        const detectResult = await options.callTool?.('start_process', {
-            command: detectCommand,
-            timeout_ms: 12000,
-        });
-        const text = options.extractToolText(detectResult) ?? '';
-        if (!text || text.toLowerCase().includes('error') || text.toLowerCase().includes('execution')) {
-            return;
-        }
-        const lines = text.split('\n').map((line) => line.trim()).filter(Boolean);
-        const appName = lines[lines.length - 2]?.replace(/\.app$/i, '') ?? '';
-        const appPath = lines[lines.length - 1] ?? '';
-        if (appName && appPath.startsWith('/')) {
-            options.editorAppCache.set(trimmedPath, {
-                appName,
-                appPath,
-            });
-            options.onDetected?.();
-        }
-    }
-    catch {
-        // Fall back to generic editor label.
-    }
-    finally {
-        options.editorAppPending.delete(trimmedPath);
-    }
-}
 export function renderMarkdownEditorAppIcon() {
     return '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M12 20h9"/><path d="M16.5 3.5a2.1 2.1 0 1 1 3 3L7 19l-4 1 1-4Z"/></svg>';
 }

package/dist/ui/file-preview/src/markdown/controller.js

@@ -281,6 +281,7 @@ export function createMarkdownController(dependencies) {
         const rawResult = await dependencies.callTool?.('read_file', {
             path: filePath,
             ...(typeof length === 'number' ? { offset: offset ?? 0, length } : {}),
+            origin: 'ui',
         });
         return { rawResult, payload: extractRenderPayload(rawResult) ?? null };
     }
@@ -360,7 +361,7 @@ export function createMarkdownController(dependencies) {
         const markers = new Set(['[DIR] .git', '[DIR] .obsidian', '[FILE] package.json', '[FILE] pnpm-workspace.yaml', '[FILE] turbo.json']);
         for (const ancestor of ancestors) {
             try {
-                const result = await dependencies.callTool?.('list_directory', { path: ancestor, depth: 1 });
+                const result = await dependencies.callTool?.('list_directory', { path: ancestor, depth: 1, origin: 'ui' });
                 const text = extractToolText(result) ?? '';
                 const entries = splitListingLines(text);
                 if (entries.some((entry) => markers.has(entry))) {
@@ -681,6 +682,7 @@ export function createMarkdownController(dependencies) {
                         old_string: block.old_string,
                         new_string: block.new_string,
                         expected_replacements: 1,
+                        origin: 'ui',
                     });
                     assertSuccessfulEditBlockResult(editResult);
                     appliedCount++;

package/dist/ui/file-preview/src/panel-actions.js

@@ -144,8 +144,8 @@ export function attachPanelActions(options) {
         });
         try {
             const readArgs = direction === 'before'
-                ? { path: options.payload.filePath, offset: 0, length: range.fromLine - 1 }
-                : { path: options.payload.filePath, offset: range.toLine };
+                ? { path: options.payload.filePath, offset: 0, length: range.fromLine - 1, origin: 'ui' }
+                : { path: options.payload.filePath, offset: range.toLine, origin: 'ui' };
             const result = await options.callTool?.('read_file', readArgs);
             const newText = extractToolText(result);
             if (newText && typeof newText === 'string') {

package/dist/uninstall-claude-server.js

@@ -10,10 +10,9 @@ 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}`;
+// Telemetry proxy configuration
+const TELEMETRY_PROXY_URL = 'https://telemetry.desktopcommander.app/mp/collect';
+const TELEMETRY_PROXY_FALLBACK_URL = 'https://dc-telemetry-proxy-83847352264.europe-west1.run.app/mp/collect';
 
 // Read clientId and telemetry settings from existing config
 let uniqueUserId = 'unknown';
@@ -222,11 +221,6 @@ async function trackEvent(eventName, additionalProps = {}) {
         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;
@@ -257,43 +251,8 @@ async function trackEvent(eventName, additionalProps = {}) {
                 }
             };
 
-            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();
-            });
+            const result = await postTelemetryPayload(postData, options);
+            if (!result.success) throw new Error('Telemetry proxy request failed');
 
             updateUninstallStep(trackingStep, 'completed');
             return result;
@@ -309,6 +268,54 @@ async function trackEvent(eventName, additionalProps = {}) {
     updateUninstallStep(trackingStep, 'failed', lastError);
     return false;
 }
+
+async function postTelemetryPayload(postData, options) {
+    for (const endpoint of [TELEMETRY_PROXY_URL, TELEMETRY_PROXY_FALLBACK_URL]) {
+        const result = await new Promise((resolve) => {
+            let settled = false;
+            let timeoutId;
+            const finish = (result) => {
+                if (settled) return;
+                settled = true;
+                clearTimeout(timeoutId);
+                resolve(result);
+            };
+            const req = https.request(endpoint, options);
+
+            timeoutId = setTimeout(() => {
+                req.destroy();
+                finish({ success: false, data: '' });
+            }, 5000);
+
+            req.on('error', () => {
+                finish({ success: false, data: '' });
+            });
+
+            req.on('response', (res) => {
+                let data = '';
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+                res.on('error', () => {
+                    finish({ success: false, data: '' });
+                });
+                res.on('end', () => {
+                    finish({ success: res.statusCode >= 200 && res.statusCode < 300, data });
+                });
+                res.on('close', () => {
+                    finish({ success: false, data: '' });
+                });
+            });
+
+            req.write(postData);
+            req.end();
+        });
+
+        if (result.success) return result;
+    }
+
+    return { success: false, data: '' };
+}
 // Ensure tracking completes before process exits
 async function ensureTrackingCompleted(eventName, additionalProps = {}, timeoutMs = 6000) {
     return new Promise(async (resolve) => {
@@ -750,4 +757,4 @@ if (process.argv.length >= 2 && process.argv[1] === fileURLToPath(import.meta.ur
         logToFile(`Fatal error: ${error}`, true);
         process.exit(1);
     });
-}
+}

package/dist/utils/ab-test.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Get the exact assigned variant for a named experiment.
+ */
+export declare function getABTestVariant(experimentName: string): Promise<string | null>;
 /**
  * Check if a feature (variant name) is enabled for current user
  */

package/dist/utils/ab-test.js

@@ -57,6 +57,12 @@ async function getVariant(experimentName) {
     variantCache[experimentName] = variant;
     return variant;
 }
+/**
+ * Get the exact assigned variant for a named experiment.
+ */
+export async function getABTestVariant(experimentName) {
+    return getVariant(experimentName);
+}
 /**
  * Check if a feature (variant name) is enabled for current user
  */

package/dist/utils/capture.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Hard kill-switch for telemetry via environment variable.
+ *
+ * Independent of the persisted `telemetryEnabled` config so that tests, CI and
+ * one-off runs can suppress all analytics without mutating the user's config.
+ * Set DESKTOP_COMMANDER_DISABLE_TELEMETRY to 1/true/yes/on to disable.
+ */
+export declare function isTelemetryDisabledByEnv(): boolean;
 /**
  * Sanitizes error objects to remove potentially sensitive information like file paths
  * @param error Error object or string to sanitize
@@ -8,13 +16,13 @@ export declare function sanitizeError(error: any): {
     code?: string;
 };
 /**
- * Send an event to Google Analytics
+ * Send an event to telemetry
  * @param event Event name
  * @param properties Optional event properties
  */
 export declare const captureBase: (captureURL: string, event: string, properties?: any) => Promise<void>;
-export declare const capture_call_tool: (event: string, properties?: any) => Promise<void>;
 export declare const capture: (event: string, properties?: any) => Promise<void>;
+export declare const capture_call_tool: (event: string, properties?: any) => Promise<void>;
 export declare const capture_ui_event: (event: string, properties?: any) => Promise<void>;
 /**
  * Wrapper for capture() that automatically adds remote flag for remote-device telemetry

package/dist/utils/capture.js

@@ -1,7 +1,7 @@
 import { platform } from 'os';
 import * as https from 'https';
 import { configManager, isTelemetryDisabledValue } from '../config-manager.js';
-import { currentClient } from '../server.js';
+import { currentClient, currentCallIsRemote, currentRemoteClient } from '../server.js';
 let VERSION = 'unknown';
 try {
     const versionModule = await import('../version.js');
@@ -13,8 +13,26 @@ 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';
+// TODO: Move proxy endpoints, auth header setup, request retry/fallback, and
+// transport code into a dedicated telemetry utility once this migration lands.
+// TODO(security): bearer token was removed, so this endpoint is now unauthenticated.
+// Confirm the proxy enforces rate limiting / payload validation server-side,
+// otherwise anyone can POST arbitrary events straight into BigQuery ingestion.
+const TELEMETRY_PROXY_URL = 'https://telemetry.desktopcommander.app/mp/collect';
+const TELEMETRY_PROXY_FALLBACK_URL = 'https://dc-telemetry-proxy-83847352264.europe-west1.run.app/mp/collect';
+/**
+ * Hard kill-switch for telemetry via environment variable.
+ *
+ * Independent of the persisted `telemetryEnabled` config so that tests, CI and
+ * one-off runs can suppress all analytics without mutating the user's config.
+ * Set DESKTOP_COMMANDER_DISABLE_TELEMETRY to 1/true/yes/on to disable.
+ */
+export function isTelemetryDisabledByEnv() {
+    const raw = process.env.DESKTOP_COMMANDER_DISABLE_TELEMETRY;
+    if (!raw)
+        return false;
+    return ['1', 'true', 'yes', 'on'].includes(raw.trim().toLowerCase());
+}
 /**
  * Sanitizes error objects to remove potentially sensitive information like file paths
  * @param error Error object or string to sanitize
@@ -47,12 +65,19 @@ export function sanitizeError(error) {
     };
 }
 /**
- * Send an event to Google Analytics
+ * Send an event to telemetry
  * @param event Event name
  * @param properties Optional event properties
  */
+// TODO(cleanup): captureBase is now dead code — no caller remains after the GA
+// removal (only referenced in a comment). It still carries the full GA4-flavored
+// send path. Remove it, or repurpose it as the shared proxy transport.
 export const captureBase = async (captureURL, event, properties) => {
     try {
+        // Env kill-switch takes precedence over config (tests/CI).
+        if (isTelemetryDisabledByEnv()) {
+            return;
+        }
         // 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
@@ -64,11 +89,14 @@ export const captureBase = async (captureURL, event, properties) => {
             uniqueUserId = await configManager.getOrCreateClientId();
         }
         // Get current client information for all events
+        // For remote calls, attribute to the originating remote client (carried on
+        // the tool call) instead of the device's local currentClient.
+        const effectiveClient = currentCallIsRemote && currentRemoteClient ? currentRemoteClient : currentClient;
         let clientContext = {};
-        if (currentClient) {
+        if (effectiveClient) {
             clientContext = {
-                client_name: currentClient.name,
-                client_version: currentClient.version,
+                client_name: effectiveClient.name,
+                client_version: effectiveClient.version,
             };
         }
         // Track if user saw onboarding page
@@ -178,9 +206,13 @@ export const captureBase = async (captureURL, event, properties) => {
         const eventProperties = {
             ...baseProperties,
             ...clientContext,
+            // Attribute events to the remote path when the in-flight tool call
+            // came from a remote device. Placed before sanitizedProperties so an
+            // explicit `remote` passed by the caller (e.g. captureRemote) wins.
+            ...(currentCallIsRemote ? { remote: String(true) } : {}),
             ...sanitizedProperties
         };
-        // Prepare GA4 payload
+        // Prepare telemetry payload
         const payload = {
             client_id: uniqueUserId,
             non_personalized_ads: false,
@@ -190,7 +222,7 @@ export const captureBase = async (captureURL, event, properties) => {
                     params: eventProperties
                 }]
         };
-        // Send data to Google Analytics
+        // Send data to telemetry endpoint
         const postData = JSON.stringify(payload);
         const options = {
             method: 'POST',
@@ -209,7 +241,7 @@ export const captureBase = async (captureURL, event, properties) => {
                 const success = res.statusCode === 200 || res.statusCode === 204;
                 if (!success) {
                     // Optional debug logging
-                    // console.debug(`GA tracking error: ${res.statusCode} ${data}`);
+                    // console.debug(`Telemetry tracking error: ${res.statusCode} ${data}`);
                 }
             });
         });
@@ -229,18 +261,21 @@ export const captureBase = async (captureURL, event, properties) => {
     }
 };
 /**
- * Build the standard event properties used by both GA4 and the telemetry proxy.
+ * Build the standard event properties used by the telemetry proxy.
  * Extracted from captureBase so both paths get identical data.
  */
 const buildEventProperties = async (properties) => {
     if (uniqueUserId === 'unknown') {
         uniqueUserId = await configManager.getOrCreateClientId();
     }
+    // For remote calls, attribute to the originating remote client (carried on
+    // the tool call) instead of the device's local currentClient.
+    const effectiveClient = currentCallIsRemote && currentRemoteClient ? currentRemoteClient : currentClient;
     let clientContext = {};
-    if (currentClient) {
+    if (effectiveClient) {
         clientContext = {
-            client_name: currentClient.name,
-            client_version: currentClient.version,
+            client_name: effectiveClient.name,
+            client_version: effectiveClient.version,
         };
     }
     const sawOnboardingPage = await configManager.getValue('sawOnboardingPage');
@@ -325,16 +360,21 @@ const buildEventProperties = async (properties) => {
         app_version: VERSION,
         engagement_time_msec: "100",
         ...clientContext,
+        // Attribute events to the remote path when the in-flight tool call
+        // came from a remote device. Placed before sanitizedProperties so an
+        // explicit `remote` passed by the caller (e.g. captureRemote) wins.
+        ...(currentCallIsRemote ? { remote: String(true) } : {}),
         ...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.
+ * Uses the custom domain first and retries the generated Cloud Run URL on failure.
  */
 const sendToTelemetryProxy = async (event, eventProperties) => {
     try {
+        if (isTelemetryDisabledByEnv())
+            return;
         const telemetryEnabled = await configManager.getValue('telemetryEnabled');
         if (isTelemetryDisabledValue(telemetryEnabled))
             return;
@@ -346,7 +386,18 @@ const sendToTelemetryProxy = async (event, eventProperties) => {
                     params: eventProperties
                 }]
         });
-        const url = new URL(TELEMETRY_PROXY_URL);
+        const sent = await postTelemetryPayload(TELEMETRY_PROXY_URL, payload);
+        if (!sent) {
+            await postTelemetryPayload(TELEMETRY_PROXY_FALLBACK_URL, payload);
+        }
+    }
+    catch {
+        // Silent fail — telemetry should never break functionality
+    }
+};
+const postTelemetryPayload = async (endpoint, payload) => {
+    return await new Promise((resolve) => {
+        const url = new URL(endpoint);
         const options = {
             hostname: url.hostname,
             port: 443,
@@ -354,59 +405,40 @@ const sendToTelemetryProxy = async (event, eventProperties) => {
             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
+            res.resume();
+            res.on('end', () => resolve(res.statusCode !== undefined && res.statusCode >= 200 && res.statusCode < 300));
+        });
+        req.on('error', () => resolve(false));
+        req.setTimeout(3000, () => {
+            req.destroy();
+            resolve(false);
         });
-        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) => {
-    // 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?.tool_name ?? 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)
-    ]);
+    });
 };
+// TODO(behavior): capture() is now fire-and-forget — every `await capture(...)`
+// call site resolves before the network send completes. Fine for the long-running
+// MCP server, but events fired right before process exit (e.g. opt-out, feedback)
+// can be silently dropped. If we need delivery guarantees on short-lived paths,
+// expose an awaitable variant or flush-before-exit hook.
 export const capture = async (event, properties) => {
-    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}`;
-    // 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';
-    const GA_API_SECRET = 'BeK3uyAOQ6-TK6wnaDG2Ww';
-    const GA_BASE_URL = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
-    return await captureBase(GA_BASE_URL, event, properties);
+    void (async () => {
+        try {
+            const eventProperties = await buildEventProperties(properties);
+            await sendToTelemetryProxy(event, eventProperties);
+        }
+        catch {
+            // Silent fail — telemetry should never break functionality
+        }
+    })();
 };
+export const capture_call_tool = capture;
+export const capture_ui_event = capture;
 /**
  * Wrapper for capture() that automatically adds remote flag for remote-device telemetry
  * Also adds additional privacy filtering to remove sensitive identity information