@wonderwhy-er/desktop-commander 0.2.25 → 0.2.27

package/dist/config-manager.d.ts

@@ -62,6 +62,10 @@ declare class ConfigManager {
      * Check if this is the first run (config file was just created)
      */
     isFirstRun(): boolean;
+    /**
+     * Get or create a persistent client ID for analytics and A/B tests
+     */
+    getOrCreateClientId(): Promise<string>;
 }
 export declare const configManager: ConfigManager;
 export {};

package/dist/config-manager.js

@@ -193,6 +193,18 @@ class ConfigManager {
     isFirstRun() {
         return this._isFirstRun;
     }
+    /**
+     * Get or create a persistent client ID for analytics and A/B tests
+     */
+    async getOrCreateClientId() {
+        let clientId = await this.getValue('clientId');
+        if (!clientId) {
+            const { randomUUID } = await import('crypto');
+            clientId = randomUUID();
+            await this.setValue('clientId', clientId);
+        }
+        return clientId;
+    }
 }
 // Export singleton instance
 export const configManager = new ConfigManager();

package/dist/utils/ab-test.js

@@ -28,7 +28,7 @@ async function getVariant(experimentName) {
         return existing;
     }
     // New assignment based on clientId
-    const clientId = await configManager.getValue('clientId') || '';
+    const clientId = await configManager.getOrCreateClientId();
     const hash = hashCode(clientId + experimentName);
     const variantIndex = hash % experiment.variants.length;
     const variant = experiment.variants[variantIndex];

package/dist/utils/capture.js

@@ -1,5 +1,4 @@
 import { platform } from 'os';
-import { randomUUID } from 'crypto';
 import * as https from 'https';
 import { configManager } from '../config-manager.js';
 import { currentClient } from '../server.js';
@@ -13,23 +12,6 @@ catch {
 }
 // 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
@@ -76,7 +58,7 @@ export const captureBase = async (captureURL, event, properties) => {
         }
         // Get or create the client ID if not already initialized
         if (uniqueUserId === 'unknown') {
-            uniqueUserId = await getOrCreateUUID();
+            uniqueUserId = await configManager.getOrCreateClientId();
         }
         // Get current client information for all events
         let clientContext = {};

package/dist/utils/feature-flags.d.ts

@@ -5,6 +5,9 @@ declare class FeatureFlagManager {
     private cacheMaxAge;
     private flagUrl;
     private refreshInterval;
+    private freshFetchPromise;
+    private resolveFreshFetch;
+    private loadedFromCache;
     constructor();
     /**
      * Initialize - load from cache and start background refresh
@@ -22,6 +25,16 @@ declare class FeatureFlagManager {
      * Manually refresh flags immediately (for testing)
      */
     refresh(): Promise<boolean>;
+    /**
+     * Check if flags were loaded from cache (vs fresh fetch)
+     */
+    wasLoadedFromCache(): boolean;
+    /**
+     * Wait for fresh flags to be fetched from network.
+     * Use this when you need to ensure flags are loaded before making decisions
+     * (e.g., A/B test assignments for new users who don't have a cache yet)
+     */
+    waitForFreshFlags(): Promise<void>;
     /**
      * Load flags from local cache
      */

package/dist/utils/feature-flags.js

@@ -9,11 +9,19 @@ class FeatureFlagManager {
         this.lastFetch = 0;
         this.cacheMaxAge = 30 * 60 * 1000;
         this.refreshInterval = null;
+        // Track fresh fetch status for A/B tests that need network flags
+        this.freshFetchPromise = null;
+        this.resolveFreshFetch = null;
+        this.loadedFromCache = false;
         const configDir = path.dirname(CONFIG_FILE);
         this.cachePath = path.join(configDir, 'feature-flags.json');
         // Use production flags
         this.flagUrl = process.env.DC_FLAG_URL ||
             'https://desktopcommander.app/flags/v1/production.json';
+        // Set up promise for waiting on fresh fetch
+        this.freshFetchPromise = new Promise((resolve) => {
+            this.resolveFreshFetch = resolve;
+        });
     }
     /**
      * Initialize - load from cache and start background refresh
@@ -23,8 +31,17 @@ class FeatureFlagManager {
             // Load from cache immediately (non-blocking)
             await this.loadFromCache();
             // Fetch in background (don't block startup)
-            this.fetchFlags().catch(err => {
+            this.fetchFlags().then(() => {
+                // Signal that fresh flags are now available
+                if (this.resolveFreshFetch) {
+                    this.resolveFreshFetch();
+                }
+            }).catch(err => {
                 logger.debug('Initial flag fetch failed:', err.message);
+                // Still resolve the promise so waiters don't hang forever
+                if (this.resolveFreshFetch) {
+                    this.resolveFreshFetch();
+                }
             });
             // Start periodic refresh every 5 minutes
             this.refreshInterval = setInterval(() => {
@@ -66,6 +83,22 @@ class FeatureFlagManager {
             return false;
         }
     }
+    /**
+     * Check if flags were loaded from cache (vs fresh fetch)
+     */
+    wasLoadedFromCache() {
+        return this.loadedFromCache;
+    }
+    /**
+     * Wait for fresh flags to be fetched from network.
+     * Use this when you need to ensure flags are loaded before making decisions
+     * (e.g., A/B test assignments for new users who don't have a cache yet)
+     */
+    async waitForFreshFlags() {
+        if (this.freshFetchPromise) {
+            await this.freshFetchPromise;
+        }
+    }
     /**
      * Load flags from local cache
      */
@@ -73,6 +106,7 @@ class FeatureFlagManager {
         try {
             if (!existsSync(this.cachePath)) {
                 logger.debug('No feature flag cache found');
+                this.loadedFromCache = false;
                 return;
             }
             const data = await fs.readFile(this.cachePath, 'utf8');
@@ -80,11 +114,13 @@ class FeatureFlagManager {
             if (config.flags) {
                 this.flags = config.flags;
                 this.lastFetch = Date.now();
+                this.loadedFromCache = true;
                 logger.debug(`Loaded ${Object.keys(this.flags).length} feature flags from cache`);
             }
         }
         catch (error) {
             logger.warning('Failed to load feature flags from cache:', error);
+            this.loadedFromCache = false;
         }
     }
     /**

package/dist/utils/welcome-onboarding.js

@@ -1,7 +1,9 @@
 import { configManager } from '../config-manager.js';
 import { hasFeature } from './ab-test.js';
+import { featureFlagManager } from './feature-flags.js';
 import { openWelcomePage } from './open-browser.js';
 import { logToStderr } from './logger.js';
+import { capture } from './capture.js';
 /**
  * Handle welcome page display for new users (A/B test controlled)
  *
@@ -15,8 +17,22 @@ export async function handleWelcomePageOnboarding() {
     if (!configManager.isFirstRun()) {
         return;
     }
+    // Track that we have a first-run user attempting onboarding
+    const loadedFromCache = featureFlagManager.wasLoadedFromCache();
+    // For new users, we need to wait for feature flags to load from network
+    // since they won't have a cache file yet. Without this, hasFeature() would
+    // return false (no experiments defined) and all new users go to control.
+    if (!loadedFromCache) {
+        logToStderr('debug', 'Waiting for feature flags to load...');
+        await featureFlagManager.waitForFreshFlags();
+    }
     // Check A/B test assignment
     const shouldShow = await hasFeature('showOnboardingPage');
+    // Track the A/B decision
+    capture('server_welcome_page_ab_decision', {
+        variant: shouldShow ? 'treatment' : 'control',
+        loaded_from_cache: loadedFromCache
+    });
     if (!shouldShow) {
         logToStderr('debug', 'Welcome page skipped (A/B: noOnboardingPage)');
         return;
@@ -29,9 +45,11 @@ export async function handleWelcomePageOnboarding() {
     try {
         await openWelcomePage();
         await configManager.setValue('sawOnboardingPage', true);
+        capture('server_welcome_page_opened', { success: true });
         logToStderr('info', 'Welcome page opened');
     }
     catch (e) {
+        capture('server_welcome_page_opened', { success: false, error: e instanceof Error ? e.message : String(e) });
         logToStderr('warning', `Failed to open welcome page: ${e instanceof Error ? e.message : e}`);
     }
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.2.25";
+export declare const VERSION = "0.2.27";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.2.25';
+export const VERSION = '0.2.27';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.2.25",
+  "version": "0.2.27",
   "description": "MCP server for terminal operations and file editing",
   "mcpName": "io.github.wonderwhy-er/desktop-commander",
   "license": "MIT",