@wonderwhy-er/desktop-commander 0.2.25 → 0.2.26

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,5 +1,6 @@
 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';
 /**
@@ -15,6 +16,13 @@ export async function handleWelcomePageOnboarding() {
     if (!configManager.isFirstRun()) {
         return;
     }
+    // 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 (!featureFlagManager.wasLoadedFromCache()) {
+        logToStderr('debug', 'Waiting for feature flags to load...');
+        await featureFlagManager.waitForFreshFlags();
+    }
     // Check A/B test assignment
     const shouldShow = await hasFeature('showOnboardingPage');
     if (!shouldShow) {

package/dist/version.d.ts

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

package/dist/version.js

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

package/package.json

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