mcp-prompt-optimizer 1.5.0 → 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,6 +1,6 @@
 {
   "name": "mcp-prompt-optimizer",
-  "version": "1.5.0",
+  "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": {
@@ -23,6 +23,7 @@
     "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",
     "version": "echo 'Updating version...' && npm run test:quick"
@@ -111,7 +112,6 @@
   "files": [
     "index.js",
     "lib/",
-    "tests/",
     "README.md",
     "CHANGELOG.md",
     "CROSS-PLATFORM.md",
@@ -218,7 +218,7 @@
     }
   },
   "backend_alignment": {
-    "version": "production-v2.1.0-bayesian",
+    "version": "production-v2.2.0-stable",
     "api_version": "v1",
     "endpoints_aligned": true,
     "feature_parity": true,

package/tests/README.md

@@ -1,232 +0,0 @@
-# 🧪 MCP Prompt Optimizer Test Suite
-
-Comprehensive testing framework for validating package functionality before NPM publication.
-
-## 📋 Test Overview
-
-### 🚀 Quick Test (`npm run test:quick`)
-**Duration:** ~30 seconds  
-**Purpose:** Rapid validation of core functionality  
-**API Key:** Not required (uses mock mode)
-
-Tests:
-- ✅ Package structure validation
-- ✅ Cross-platform compatibility
-- ✅ MCP server instantiation
-- ✅ API key format validation
-- ✅ AI context detection
-- ✅ Mock optimization generation
-- ✅ Response formatting
-- ✅ Environment variable support
-
-**Use Case:** Quick verification during development
-
-### 🔌 Integration Test (`npm run test:integration`)
-**Duration:** ~60 seconds  
-**Purpose:** Validate API connectivity and real backend integration  
-**API Key:** Optional (falls back to mock mode)
-
-Tests:
-- ✅ Backend connectivity
-- ✅ Real API key validation
-- ✅ Live optimization requests
-- ✅ Quota status retrieval
-- ✅ Template search functionality
-- ✅ Error recovery mechanisms
-- ✅ Network resilience
-
-**Use Case:** Pre-deployment validation with real backend
-
-### 🔬 Comprehensive Test (`npm run test:comprehensive`)
-**Duration:** ~2 minutes  
-**Purpose:** Exhaustive validation of all features and edge cases  
-**API Key:** Optional (extensive mock testing)
-
-Tests:
-- ✅ All quick test features
-- ✅ All integration test features
-- ✅ Command-line interface testing
-- ✅ Network resilience scenarios
-- ✅ Error handling edge cases
-- ✅ Package integrity validation
-- ✅ MCP protocol compliance
-- ✅ Cross-platform script testing
-
-**Use Case:** Full validation before major releases
-
-### 🎯 Test Runner (`npm test` or `npm run test:runner`)
-**Duration:** ~3-4 minutes  
-**Purpose:** Orchestrates all test suites in optimal order  
-**API Key:** Optional (runs all modes)
-
-**Use Case:** Complete pre-publication validation
-
-## 🛠️ Usage Examples
-
-### Basic Testing (No API Key Required)
-```bash
-# Quick validation
-npm run test:quick
-
-# Full test suite in mock mode
-npm test
-```
-
-### Testing with Real API Key
-```bash
-# Set your API key
-export OPTIMIZER_API_KEY=sk-opt-your-actual-key
-
-# Run integration tests
-npm run test:integration
-
-# Run full test suite
-npm test
-```
-
-### Development Mode Testing
-```bash
-# Enable development mode
-export OPTIMIZER_DEV_MODE=true
-export OPTIMIZER_API_KEY=sk-dev-test-key
-
-# Run tests
-npm test
-```
-
-### Custom Backend Testing
-```bash
-# Test against custom backend
-export OPTIMIZER_BACKEND_URL=https://your-backend.com
-export OPTIMIZER_API_KEY=your-key
-
-# Run integration tests
-npm run test:integration
-```
-
-## 📊 Test Output Examples
-
-### ✅ Success Output
-```
-🎉 ALL TESTS PASSED - READY FOR PUBLICATION!
-
-🚀 Recommended publication commands:
-   npm publish
-   git tag v1.4.0
-   git push --tags
-```
-
-### ❌ Failure Output
-```
-❌ SOME TESTS FAILED - FIX ISSUES BEFORE PUBLICATION
-   Run the comprehensive test suite for detailed analysis:
-   node tests/comprehensive-test.js
-```
-
-## 🔧 Test Modes
-
-### Mock Mode (Default)
-- **Trigger:** No API key provided
-- **Behavior:** Uses simulated responses
-- **Tests:** All functionality except live API calls
-- **Advantage:** Fast, no dependencies
-
-### Development Mode
-- **Trigger:** `OPTIMIZER_DEV_MODE=true`
-- **Behavior:** Enhanced logging, extended timeouts
-- **Tests:** All functionality with debug output
-- **Advantage:** Detailed debugging information
-
-### Production Mode
-- **Trigger:** Real API key provided
-- **Behavior:** Tests against live backend
-- **Tests:** Full end-to-end validation
-- **Advantage:** Real-world validation
-
-## 🎯 Pre-Publication Checklist
-
-Run this checklist before publishing to NPM:
-
-1. **Quick Test** ✅
-   ```bash
-   npm run test:quick
-   ```
-
-2. **Integration Test** (if you have API key) ✅
-   ```bash
-   OPTIMIZER_API_KEY=your-key npm run test:integration
-   ```
-
-3. **Full Test Suite** ✅
-   ```bash
-   npm test
-   ```
-
-4. **Manual Verification** ✅
-   - [ ] Version number updated in package.json
-   - [ ] CHANGELOG.md updated
-   - [ ] README.md current
-   - [ ] All files included in `files` array
-
-5. **Publication** 🚀
-   ```bash
-   npm publish
-   git tag v$(node -p "require('./package.json').version")
-   git push --tags
-   ```
-
-## 🚨 Troubleshooting
-
-### Common Issues
-
-**"Tests failed with exit code 1"**
-- Run individual test suites to identify specific failures
-- Check error messages for detailed debugging information
-
-**"Network error during integration tests"**
-- Verify internet connection
-- Check if backend URL is accessible
-- Try running in mock mode first
-
-**"API key validation failed"**
-- Verify API key format: `sk-opt-`, `sk-team-`, `sk-dev-`, or `sk-local-`
-- Check API key permissions and quota
-- Try development mode: `OPTIMIZER_DEV_MODE=true`
-
-**"Cross-platform script issues"**
-- Ensure `cross-env` is installed: `npm install`
-- Use platform-specific commands if needed:
-  - Windows: `npm run dev:windows`
-  - Unix/Mac: `npm run dev:unix`
-
-### Debug Commands
-
-```bash
-# Verbose test output
-DEBUG=* npm test
-
-# Individual test suites
-npm run test:quick
-npm run test:integration  
-npm run test:comprehensive
-
-# Test specific functionality
-node lib/validate-key.js
-node lib/diagnose.js
-```
-
-## 📈 Continuous Integration
-
-For CI/CD pipelines, use:
-
-```yaml
-# GitHub Actions example
-- name: Run tests
-  run: |
-    npm ci
-    npm run test:quick
-  env:
-    OPTIMIZER_DEV_MODE: true
-```
-
-The test suite is designed to work in CI environments without requiring real API keys.