@wonderwhy-er/desktop-commander 0.2.41 → 0.2.42

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/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/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 } 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
@@ -178,9 +203,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 +219,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 +238,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,7 +258,7 @@ 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) => {
@@ -325,16 +354,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 +380,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 +399,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

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

@@ -0,0 +1,13 @@
+export declare const MCP_UI_EXPERIMENT_NAME = "McpUiPreviews";
+export declare const MCP_UI_SHOW_VARIANT = "showMCPUi";
+export declare const MCP_UI_HIDE_VARIANT = "notShowMCPUi";
+export interface McpUiPreviewDecisionDeps {
+    getExistingAssignment: () => Promise<unknown>;
+    isFirstRun: () => boolean;
+    wasLoadedFromCache: () => boolean;
+    waitForFreshFlags: () => Promise<void>;
+    getABTestVariant: (experimentName: string) => Promise<string | null>;
+    capture: (event: string, properties?: Record<string, unknown>) => Promise<unknown> | unknown;
+}
+export declare function resolveMcpUiPreviewDecision(deps: McpUiPreviewDecisionDeps): Promise<boolean>;
+export declare function shouldShowMcpUiPreviews(): Promise<boolean>;

package/dist/utils/mcp-ui-ab-test.js

@@ -0,0 +1,62 @@
+import { configManager } from '../config-manager.js';
+import { getABTestVariant } from './ab-test.js';
+import { capture } from './capture.js';
+import { featureFlagManager } from './feature-flags.js';
+export const MCP_UI_EXPERIMENT_NAME = 'McpUiPreviews';
+export const MCP_UI_SHOW_VARIANT = 'showMCPUi';
+export const MCP_UI_HIDE_VARIANT = 'notShowMCPUi';
+function variantEnablesMcpUi(variant) {
+    if (variant === MCP_UI_HIDE_VARIANT)
+        return false;
+    if (variant === MCP_UI_SHOW_VARIANT)
+        return true;
+    return null;
+}
+export async function resolveMcpUiPreviewDecision(deps) {
+    try {
+        const existingAssignment = await deps.getExistingAssignment();
+        const existingDecision = variantEnablesMcpUi(existingAssignment);
+        if (existingDecision !== null) {
+            if (!deps.wasLoadedFromCache()) {
+                await deps.waitForFreshFlags();
+            }
+            const currentVariant = await deps.getABTestVariant(MCP_UI_EXPERIMENT_NAME);
+            return variantEnablesMcpUi(currentVariant) ?? existingDecision;
+        }
+        if (!deps.isFirstRun()) {
+            return true;
+        }
+        if (!deps.wasLoadedFromCache()) {
+            await deps.waitForFreshFlags();
+        }
+        const variant = await deps.getABTestVariant(MCP_UI_EXPERIMENT_NAME);
+        const decision = variantEnablesMcpUi(variant);
+        if (decision === null) {
+            return true;
+        }
+        try {
+            await deps.capture('server_mcp_ui_ab_decision', {
+                experiment: MCP_UI_EXPERIMENT_NAME,
+                variant,
+                mcp_ui_enabled: decision,
+            });
+        }
+        catch {
+            // Telemetry must not change the assigned product experience.
+        }
+        return decision;
+    }
+    catch {
+        return true;
+    }
+}
+export async function shouldShowMcpUiPreviews() {
+    return resolveMcpUiPreviewDecision({
+        getExistingAssignment: () => configManager.getValue(`abTest_${MCP_UI_EXPERIMENT_NAME}`),
+        isFirstRun: () => configManager.isFirstRun(),
+        wasLoadedFromCache: () => featureFlagManager.wasLoadedFromCache(),
+        waitForFreshFlags: () => featureFlagManager.waitForFreshFlags(),
+        getABTestVariant,
+        capture,
+    });
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.2.41";
+export declare const VERSION = "0.2.42";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.2.41';
+export const VERSION = '0.2.42';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.2.41",
+  "version": "0.2.42",
   "description": "MCP server for terminal operations and file editing",
   "mcpName": "io.github.wonderwhy-er/desktop-commander",
   "license": "MIT",
@@ -41,6 +41,7 @@
     "prepare": "npm run build",
     "clean": "shx rm -rf dist",
     "test": "npm run build && node test/run-all-tests.js",
+    "test:integration": "npm run build && node test/integration/run-all-integration-tests.js",
     "test:debug": "node --inspect test/run-all-tests.js",
     "validate:tools": "npm run build && node scripts/validate-tools-sync.js",
     "link:local": "npm run build && npm link",