mcp-prompt-optimizer 1.4.2 → 2.2.3

package/lib/api-key-manager.js

@@ -15,7 +15,7 @@ const packageJson = require('../package.json');
 class CloudApiKeyManager {
     constructor(apiKey, options = {}) {
         this.apiKey = apiKey;
-        this.backendUrl = options.backendUrl || process.env.OPTIMIZER_BACKEND_URL || 'https://p01--project-optimizer--fvrdk8m9k9j.code.run';
+        this.backendUrl = options.backendUrl || process.env.OPTIMIZER_BACKEND_URL || 'https://p01--project-optimizer--fvmrdk8m9k9j.code.run';
         this.cacheFile = path.join(os.homedir(), '.mcp-cloud-api-cache.json');
         this.healthFile = path.join(os.homedir(), '.mcp-cloud-health.json');
         this.cacheExpiry = options.cacheExpiry || 24 * 60 * 60 * 1000; // 24 hours
@@ -196,8 +196,7 @@ class CloudApiKeyManager {
 
         this.log(`API key format valid: ${formatCheck.keyType}`);
 
-        // Step 2: Development mode handling
-        if (this.developmentMode || formatCheck.keyType === 'development' || formatCheck.keyType === 'testing') {
+        if (this.developmentMode || formatCheck.keyType === 'testing') {
             this.log('Development/testing mode detected, using mock validation', 'warn');
             const mockValidation = this.generateMockValidation(formatCheck.keyType);
             await this.cacheValidation(mockValidation);
@@ -290,99 +289,23 @@ class CloudApiKeyManager {
 
     // ✅ FIXED: Correct API endpoint URL
     async validateWithBackend() {
-        return new Promise((resolve, reject) => {
-            const url = `${this.backendUrl}/api/v1/mcp/validate-key`;
-            
-            const options = {
-                method: 'GET',
-                headers: {
-                    'x-api-key': this.apiKey,
-                    'Content-Type': 'application/json',
-                    'User-Agent': `mcp-prompt-optimizer/${packageJson.version}`,
-                    'Accept': 'application/json',
-                    'Connection': 'close' // Ensure connection cleanup
-                },
-                timeout: this.requestTimeout
-            };
-
-            this.log(`Making request to: ${url}`);
-            this.log(`Using API key: ${this.apiKey.substring(0, 16)}...`);
-
-            const client = this.backendUrl.startsWith('https://') ? https : http;
-            const req = client.request(url, options, (res) => {
-                let data = '';
-                
-                res.on('data', (chunk) => {
-                    data += chunk;
-                });
-                
-                res.on('end', () => {
-                    this.log(`Response status: ${res.statusCode}`);
-                    
-                    try {
-                        if (res.statusCode === 200) {
-                            const validation = JSON.parse(data);
-                            this.log(`Validation successful: ${JSON.stringify(validation, null, 2)}`);
-                            resolve(validation);
-                        } else if (res.statusCode === 401) {
-                            reject(new Error('Invalid API key or unauthorized access'));
-                        } else if (res.statusCode === 403) {
-                            reject(new Error('API key expired or quota exceeded'));
-                        } else if (res.statusCode === 429) {
-                            reject(new Error('Rate limit exceeded. Please try again later.'));
-                        } else if (res.statusCode === 500) {
-                            reject(new Error('Backend server error. Please try again later.'));
-                        } else if (res.statusCode === 503) {
-                            reject(new Error('Backend service temporarily unavailable. Please try again later.'));
-                        } else {
-                            let errorMessage;
-                            try {
-                                const error = JSON.parse(data);
-                                errorMessage = error.detail || error.message || `HTTP ${res.statusCode}`;
-                            } catch {
-                                errorMessage = `HTTP ${res.statusCode}: ${data}`;
-                            }
-                            reject(new Error(errorMessage));
-                        }
-                    } catch (parseError) {
-                        this.log(`Parse error: ${parseError.message}`, 'error');
-                        this.log(`Raw response: ${data}`, 'error');
-                        reject(new Error(`Invalid response format: ${parseError.message}`));
-                    }
-                });
-            });
-
-            req.on('error', (error) => {
-                this.log(`Network error: ${error.message}`, 'error');
-                
-                // Enhanced error classification
-                if (error.code === 'ENOTFOUND') {
-                    reject(new Error(`DNS resolution failed: Cannot resolve ${this.backendUrl.replace(/^https?:\/\//, '')}`));
-                } else if (error.code === 'ECONNREFUSED') {
-                    reject(new Error(`Connection refused: Backend server may be down`));
-                } else if (error.code === 'ETIMEDOUT') {
-                    reject(new Error(`Connection timeout: Backend server is not responding`));
-                } else if (error.code === 'ECONNRESET') {
-                    reject(new Error(`Connection reset: Network instability detected`));
-                } else {
-                    reject(new Error(`Network error: ${error.message}`));
-                }
-            });
-
-            req.on('timeout', () => {
-                req.destroy();
-                reject(new Error('Request timeout - backend may be unavailable'));
-            });
-
-            req.setTimeout(this.requestTimeout);
-            req.end();
-        });
+        const endpoint = '/api/v1/api-keys/validate';
+        const method = 'POST';
+        
+        try {
+            const validation = await this._makeBackendRequest(endpoint, null, method);
+            this.log(`Validation successful: ${JSON.stringify(validation, null, 2)}`);
+            return validation;
+        } catch (error) {
+            this.log(`Backend validation request failed: ${error.message}`, 'error');
+            throw error;
+        }
     }
 
     // ✅ FIXED: Correct API endpoint URL
     async getQuotaStatus() {
         try {
-            const url = `${this.backendUrl}/api/v1/mcp/quota-status`;
+            const url = `${this.backendUrl}/api/v1/api-keys/quota-status`;
             
             const options = {
                 method: 'GET',
@@ -462,38 +385,7 @@ class CloudApiKeyManager {
         }
     }
 
-    // Enhanced quota status checking
-    async checkQuotaStatus(validation) {
-        const quota = validation.quota || {};
-        
-        if (quota.unlimited) {
-            return { allowed: true, unlimited: true };
-        }
 
-        const quotaUsed = quota.used || 0;
-        const quotaLimit = quota.limit || 5000;
-        const quotaRemaining = quota.remaining || (quotaLimit - quotaUsed);
-
-        if (quotaUsed >= quotaLimit) {
-            const tier = validation.tier || 'explorer';
-            const upgradeMessage = tier === 'explorer' 
-                ? 'Upgrade to Creator ($25.99/mo) for 18,000 optimizations: https://promptoptimizer-blog.vercel.app/pricing'
-                : 'Quota will reset on your next billing cycle.';
-            
-            throw new Error(
-                `Monthly quota exceeded (${quotaUsed}/${quotaLimit}). ${upgradeMessage}`
-            );
-        }
-
-        return {
-            allowed: true,
-            unlimited: false,
-            used: quotaUsed,
-            limit: quotaLimit,
-            remaining: quotaRemaining,
-            usage_percentage: (quotaUsed / quotaLimit) * 100
-        };
-    }
 
     // Enhanced caching with metadata
     async cacheValidation(validation) {
@@ -593,13 +485,10 @@ class CloudApiKeyManager {
             // Step 1: Validate API key
             const validation = await this.validateApiKey();
             
-            // Step 2: Check quota (skip for development/mock modes)
-            let quotaStatus;
-            if (validation.mock_mode || validation.fallback_mode || validation.offline_mode) {
-                quotaStatus = validation.quota || { allowed: true, unlimited: true };
-            } else {
-                quotaStatus = await this.checkQuotaStatus(validation);
-            }
+            // Step 2: Get comprehensive quota status
+            const info = await this.getApiKeyInfo();
+            let quotaStatus = info.quota;
+            validation = info; // Use info as the main validation object for consistency
             
             // Step 3: Log success
             const mode = validation.mock_mode ? '(mock)' : 
@@ -633,24 +522,57 @@ class CloudApiKeyManager {
 
     // Enhanced API key info with mode detection
     async getApiKeyInfo() {
+        const formatCheck = this.validateApiKeyFormat(this.apiKey);
+        if (this.developmentMode || formatCheck.keyType === 'development' || formatCheck.keyType === 'testing') {
+            this.log('Development/testing mode detected for getApiKeyInfo, returning mock data.', 'warn');
+            return {
+                tier: 'testing',
+                features: {
+                    optimization: true,
+                    template_search: true,
+                    template_auto_save: true,
+                    optimization_insights: true,
+                    bayesian_optimization: true,
+                    agui_features: true
+                },
+                quota: {
+                    unlimited: false,
+                    used: Math.floor(Math.random() * 100),
+                    limit: 1000,
+                    remaining: 1000 - Math.floor(Math.random() * 100)
+                },
+                isValid: true,
+                keyType: formatCheck.keyType,
+                mode: {
+                    mock: true,
+                    fallback: false,
+                    offline: false,
+                    development: this.developmentMode
+                }
+            };
+        }
+
         try {
-            const validation = await this.validateApiKey();
-            const quotaStatus = await this.checkQuotaStatus(validation);
+            // Directly call the new quota-status endpoint
+            const quotaStatusResponse = await this._makeBackendRequest('/api/v1/api-keys/quota-status', null, 'GET');
             
+            // The backend /mcp/quota-status endpoint returns a comprehensive object
+            // that includes tier, quota details, and features.
             return {
-                tier: validation.tier,
-                features: validation.features || {},
-                quota: quotaStatus,
+                tier: quotaStatusResponse.tier,
+                features: quotaStatusResponse.features_available || {},
+                quota: quotaStatusResponse.quota,
                 isValid: true,
-                keyType: validation.api_key_type || this.validateApiKeyFormat(this.apiKey).keyType,
+                keyType: quotaStatusResponse.account_type || this.validateApiKeyFormat(this.apiKey).keyType,
                 mode: {
-                    mock: validation.mock_mode || false,
-                    fallback: validation.fallback_mode || false,
-                    offline: validation.offline_mode || false,
+                    mock: false, // This endpoint doesn't return mock status
+                    fallback: false,
+                    offline: false,
                     development: this.developmentMode
                 }
             };
         } catch (error) {
+            this.log(`Error getting API key info: ${error.message}`, 'error');
             return {
                 tier: null,
                 features: {},
@@ -692,6 +614,137 @@ class CloudApiKeyManager {
         if (!this.apiKey) return 'No key';
         return `${this.apiKey.substring(0, 8)}...${this.apiKey.slice(-4)}`;
     }
+
+    async getDiagnosticInfo() {
+        const diagnosticInfo = {
+            apiKey: this.apiKey ? this.formatKeyForDisplay() : 'Not set',
+            backendUrl: this.backendUrl,
+            cacheFile: this.cacheFile,
+            healthFile: this.healthFile,
+            cacheExpiry: this.cacheExpiry,
+            fallbackCacheExpiry: this.fallbackCacheExpiry,
+            offlineMode: this.offlineMode,
+            developmentMode: this.developmentMode,
+            maxRetries: this.maxRetries,
+            requestTimeout: this.requestTimeout,
+            nodeEnv: process.env.NODE_ENV || 'not set',
+            packageVersion: packageJson.version,
+            networkHealth: { ...this.networkHealth },
+            cache: {},
+            keyFormat: this.validateApiKeyFormat(this.apiKey),
+            backendConnectivity: { status: 'unknown', error: null, responseTime: null }
+        };
+
+        // Get cache status
+        try {
+            const cached = await this.getCachedValidation();
+            if (cached) {
+                diagnosticInfo.cache.exists = true;
+                diagnosticInfo.cache.expired = this.isCacheExpired(cached);
+                diagnosticInfo.cache.fallbackExpired = this.isFallbackCacheExpired(cached);
+                diagnosticInfo.cache.age = Math.round((Date.now() - cached.timestamp) / 1000 / 60);
+                diagnosticInfo.cache.backendUrl = cached.backendUrl;
+                diagnosticInfo.cache.packageVersion = cached.packageVersion;
+            } else {
+                diagnosticInfo.cache.exists = false;
+            }
+        } catch (error) {
+            diagnosticInfo.cache.error = error.message;
+            diagnosticInfo.cache.exists = false;
+        }
+
+        // Check backend connectivity
+        if (this.apiKey) { // Only check if API key is present
+            try {
+                const startTime = Date.now();
+                await this.validateWithBackend(); // This will attempt to connect to the backend
+                const responseTime = Date.now() - startTime;
+                diagnosticInfo.backendConnectivity.status = 'success';
+                diagnosticInfo.backendConnectivity.responseTime = responseTime;
+            } catch (error) {
+                diagnosticInfo.backendConnectivity.status = 'failed';
+                diagnosticInfo.backendConnectivity.error = error.message;
+            }
+        } else {
+            diagnosticInfo.backendConnectivity.status = 'skipped';
+            diagnosticInfo.backendConnectivity.error = 'No API key provided for connectivity check.';
+        }
+
+        return diagnosticInfo;
+    }
+
+    async _makeBackendRequest(endpoint, data, method = 'POST') {
+        return new Promise((resolve, reject) => {
+            const url = `${this.backendUrl}${endpoint}`;
+            
+            const options = {
+                method: method,
+                headers: {
+                    'x-api-key': this.apiKey,
+                    'Content-Type': 'application/json',
+                    'User-Agent': `mcp-prompt-optimizer/${packageJson.version}`,
+                    'Accept': 'application/json',
+                    'Connection': 'close'
+                },
+                timeout: this.requestTimeout
+            };
+
+            const client = this.backendUrl.startsWith('https://') ? https : http;
+            const req = client.request(url, options, (res) => {
+                let responseData = '';
+                
+                res.on('data', (chunk) => {
+                    responseData += chunk;
+                });
+                
+                res.on('end', () => {
+                    try {
+                        if (res.statusCode >= 200 && res.statusCode < 300) {
+                            const parsed = JSON.parse(responseData);
+                            resolve(parsed);
+                        } else {
+                            let errorMessage;
+                            try {
+                                const error = JSON.parse(responseData);
+                                errorMessage = error.detail || error.message || `HTTP ${res.statusCode}`;
+                            } catch {
+                                errorMessage = `HTTP ${res.statusCode}: ${responseData}`;
+                            }
+                            reject(new Error(errorMessage));
+                        }
+                    } catch (parseError) {
+                        reject(new Error(`Invalid response format: ${parseError.message}`));
+                    }
+                });
+            });
+
+            req.on('error', (error) => {
+                if (error.code === 'ENOTFOUND') {
+                    reject(new Error(`DNS resolution failed: Cannot resolve ${this.backendUrl.replace(/^https?:\/\//, '')}`));
+                } else if (error.code === 'ECONNREFUSED') {
+                    reject(new Error(`Connection refused: Backend server may be down`));
+                } else if (error.code === 'ETIMEDOUT') {
+                    reject(new Error(`Connection timeout: Backend server is not responding`));
+                } else if (error.code === 'ECONNRESET') {
+                    reject(new Error(`Connection reset: Network instability detected`));
+                } else {
+                    reject(new Error(`Network error: ${error.message}`));
+                }
+            });
+
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error('Request timeout - backend may be unavailable'));
+            });
+
+            req.setTimeout(this.requestTimeout);
+            
+            if (method !== 'GET' && data) {
+                req.write(JSON.stringify(data));
+            }
+            req.end();
+        });
+    }
 }
 
 module.exports = CloudApiKeyManager;

package/lib/check-status.js

@@ -10,7 +10,7 @@ async function checkStatus() {
         if (!apiKey) {
             console.error('❌ No API key found');
             console.log('\n📝 Set your API key to check status:');
-            console.log('   export OPTIMIZER_API_KEY=sk-opt-your-key-here');
+            console.log('   export OPTIMIZER_API_KEY=sk-local-your-key-here'); // Aligned with free tier/development
             if (developmentMode) {
                 console.log('\n🧪 Development Mode Options:');
                 console.log('   export OPTIMIZER_API_KEY=sk-dev-test-key');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mcp-prompt-optimizer",
-  "version": "1.4.2",
-  "description": "Professional cloud-based MCP server for AI-powered prompt optimization with intelligent context detection, template auto-save, optimization insights, personal model configuration via WebUI, team collaboration, enterprise-grade features, production resilience, and startup validation. Universal compatibility with Claude Desktop, Cursor, Windsurf, and 17+ MCP clients.",
+  "version": "2.2.3",
+  "description": "Professional cloud-based MCP server for AI-powered prompt optimization with intelligent context detection, Bayesian optimization, AG-UI real-time optimization, template auto-save, optimization insights, personal model configuration via WebUI, team collaboration, enterprise-grade features, production resilience, and startup validation. Universal compatibility with Claude Desktop, Cursor, Windsurf, and 17+ MCP clients.",
   "main": "index.js",
   "bin": {
     "mcp-prompt-optimizer": "index.js"
@@ -23,8 +23,10 @@
     "test:integration": "node tests/integration-test.js",
     "test:comprehensive": "node tests/comprehensive-test.js",
     "test:runner": "node tests/test-runner.js",
+    "test:simple": "node tests/simple-test.js",
     "pretest": "npm run health-check",
-    "prepublishOnly": "npm run test:quick"
+    "prepublishOnly": "npm run test:quick",
+    "version": "echo 'Updating version...' && npm run test:quick"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.15.1",
@@ -85,7 +87,17 @@
     "windows",
     "macos",
     "linux",
-    "arm64"
+    "arm64",
+    "bayesian-optimization",
+    "ag-ui-real-time",
+    "streaming-optimization",
+    "websocket-support",
+    "performance-optimization",
+    "advanced-analytics",
+    "intelligent-context",
+    "ai-aware-rules",
+    "parameter-tuning",
+    "optimization-strategies"
   ],
   "author": "Prompt Optimizer Team <support@promptoptimizer.help>",
   "license": "SEE LICENSE IN LICENSE",
@@ -100,7 +112,6 @@
   "files": [
     "index.js",
     "lib/",
-    "tests/",
     "README.md",
     "CHANGELOG.md",
     "CROSS-PLATFORM.md",
@@ -161,9 +172,73 @@
         "description": "Enable development mode (true/false)",
         "required": false,
         "default": "false"
+      },
+      {
+        "name": "ENABLE_BAYESIAN_OPTIMIZATION",
+        "description": "Enable Bayesian optimization features (true/false)",
+        "required": false,
+        "default": "true"
+      },
+      {
+        "name": "ENABLE_AGUI_FEATURES",
+        "description": "Enable AG-UI real-time optimization features (true/false)",
+        "required": false,
+        "default": "true"
       }
     ]
   },
+  "features": {
+    "core": {
+      "ai_context_detection": true,
+      "template_management": true,
+      "optimization_insights": true,
+      "quota_management": true,
+      "multi_tier_support": true,
+      "error_handling": true,
+      "caching": true,
+      "fallback_modes": true
+    },
+    "advanced": {
+      "bayesian_optimization": true,
+      "ag_ui_real_time": true,
+      "streaming_optimization": true,
+      "intelligent_routing": true,
+      "performance_analytics": true,
+      "ai_aware_rules": true,
+      "context_aware_templates": true,
+      "parameter_tuning": true
+    },
+    "enterprise": {
+      "team_collaboration": true,
+      "advanced_analytics": true,
+      "custom_models": true,
+      "priority_support": true,
+      "sla_guarantees": true,
+      "dedicated_resources": true
+    }
+  },
+  "backend_alignment": {
+    "version": "production-v2.2.0-stable",
+    "api_version": "v1",
+    "endpoints_aligned": true,
+    "feature_parity": true,
+    "bayesian_support": true,
+    "agui_support": true,
+    "last_sync": "2025-09-25T00:00:00Z"
+  },
+  "release_notes": {
+    "v1.5.0": {
+      "major_features": [
+        "Bayesian optimization with parameter tuning",
+        "AG-UI real-time optimization capabilities",
+        "Enhanced AI context detection with weighted scoring",
+        "Advanced template search with AI-aware filtering"
+      ],
+      "breaking_changes": [],
+      "migration_guide": "All existing functionality remains compatible. New features are opt-in via environment variables.",
+      "backend_compatibility": "Fully aligned with FastAPI Backend v2.1.0-bayesian"
+    }
+  },
   "support": {
     "email": "support@promptoptimizer.help",
     "documentation": "https://promptoptimizer-blog.vercel.app/docs",