vibecodingmachine-core 2026.1.3-2209 → 2026.1.22-1441

package/src/ide-integration/provider-manager.cjs

@@ -23,7 +23,7 @@ class ProviderManager {
       if (fs.existsSync(this.rateLimitFile)) {
         const data = fs.readFileSync(this.rateLimitFile, 'utf8');
         const limits = JSON.parse(data);
-        
+
         // Auto-cleanup expired rate limits
         const now = Date.now();
         let cleaned = false;
@@ -33,12 +33,12 @@ class ProviderManager {
             cleaned = true;
           }
         }
-        
+
         // Save cleaned data if any expired limits were removed
         if (cleaned) {
           this.saveRateLimitsInternal(limits);
         }
-        
+
         return limits;
       }
     } catch (err) {
@@ -46,7 +46,7 @@ class ProviderManager {
     }
     return {};
   }
-  
+
   /**
    * Internal save without reload (to prevent infinite loop during cleanup)
    */
@@ -86,33 +86,107 @@ class ProviderManager {
    *   "Session limit reached ∙ resets 12pm" -> ms until 12pm today/tomorrow
    */
   parseRateLimitDuration(errorMessage) {
+    // Gemini / Google AI style: "You can resume using this model at 1/12/2026, 4:07:27 PM"
+    // Also seen as: "resume using this model at <date>, <time>"
+    const resumeAtMatch = errorMessage.match(/resume\s+(?:using\s+this\s+model\s+)?at\s+(\d{1,2}\/\d{1,2}\/\d{4})\s*,?\s*(\d{1,2}:\d{2}(?::\d{2})?)\s*(am|pm)/i);
+    if (resumeAtMatch) {
+      try {
+        const datePart = resumeAtMatch[1];
+        const timePart = resumeAtMatch[2];
+        const meridiem = resumeAtMatch[3];
+        const parsed = new Date(`${datePart}, ${timePart} ${meridiem.toUpperCase()}`);
+        if (!Number.isNaN(parsed.getTime())) {
+          const ms = parsed.getTime() - Date.now();
+          return ms > 0 ? ms : 0;
+        }
+      } catch (_) { }
+    }
+
+    // Check for "resets [Month] [Day] at [Time]" format (e.g. "Spending cap reached resets Jan 17 at 12pm")
+    const dateMatch = errorMessage.match(/resets\s+([a-zA-Z]+)\s+(\d{1,2})\s+at\s+(\d{1,2}(?::\d{2})?)\s*(am|pm)?/i);
+    if (dateMatch) {
+      try {
+        const monthStr = dateMatch[1]; // Jan, February, etc.
+        const day = parseInt(dateMatch[2]);
+        const timeStr = dateMatch[3];
+        const meridiem = dateMatch[4] ? dateMatch[4].toLowerCase() : null;
+
+        // Parse time
+        let [hours, minutes] = timeStr.split(':').map(n => parseInt(n));
+        if (!minutes || Number.isNaN(minutes)) minutes = 0;
+
+        if (meridiem === 'pm' && hours !== 12) hours += 12;
+        if (meridiem === 'am' && hours === 12) hours = 0;
+
+        // Parse month
+        const months = {
+          jan: 0, january: 0,
+          feb: 1, february: 1,
+          mar: 2, march: 2,
+          apr: 3, april: 3,
+          may: 4,
+          jun: 5, june: 5,
+          jul: 6, july: 6,
+          aug: 7, august: 7,
+          sep: 8, sept: 8, september: 8,
+          oct: 9, october: 9,
+          nov: 10, november: 10,
+          dec: 11, december: 11
+        };
+
+        const monthIndex = months[monthStr.toLowerCase().substring(0, 3)] ?? months[monthStr.toLowerCase()];
+
+        if (monthIndex !== undefined) {
+          const currentYear = new Date().getFullYear();
+          let parsed = new Date(currentYear, monthIndex, day, hours, minutes);
+          const now = Date.now();
+
+          // Logic to handle year crossing (reset in Jan, currently Dec)
+          if (parsed.getTime() < now) {
+            if (!Number.isNaN(parsed.getTime())) {
+              if (parsed.getTime() < now) {
+                const nextYearDate = new Date(parsed);
+                nextYearDate.setFullYear(nextYearDate.getFullYear() + 1);
+                if (nextYearDate.getTime() > now) {
+                  parsed = nextYearDate;
+                }
+              }
+            }
+          }
+
+          const ms = parsed.getTime() - now;
+          return ms > 0 ? ms : 0;
+        }
+      } catch (_) { }
+    }
+
     // Check for Claude Code session limit format: "Session limit reached ∙ resets 12pm"
     const sessionMatch = errorMessage.match(/resets?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i);
     if (sessionMatch) {
       let hour = parseInt(sessionMatch[1]);
       const minute = sessionMatch[2] ? parseInt(sessionMatch[2]) : 0;
       const meridiem = sessionMatch[3] ? sessionMatch[3].toLowerCase() : null;
-      
+
       // Convert to 24-hour format
       if (meridiem === 'pm' && hour !== 12) {
         hour += 12;
       } else if (meridiem === 'am' && hour === 12) {
         hour = 0;
       }
-      
+
       // Calculate reset time
       const now = new Date();
       const resetTime = new Date(now);
       resetTime.setHours(hour, minute, 0, 0);
-      
+
       // If reset time is in the past, it's tomorrow
       if (resetTime <= now) {
         resetTime.setDate(resetTime.getDate() + 1);
       }
-      
+
       return resetTime.getTime() - now.getTime();
     }
-    
+
     // Match patterns like "15m5.472s" or "1h30m" or "45s"
     const timeMatch = errorMessage.match(/try again in ([\d.]+h)?\s?([\d.]+m)?\s?([\d.]+s)?/i);
     if (!timeMatch) return null;
@@ -147,8 +221,11 @@ class ProviderManager {
    * @param {string} errorMessage - Full error message containing duration
    */
   markRateLimited(provider, model, errorMessage) {
+    // Normalize model: if model is missing/undefined, assume it's the provider name.
+    model = model || provider;
+
     let duration = this.parseRateLimitDuration(errorMessage);
-    if (!duration) {
+    if (duration === null || duration === undefined) {
       console.warn(`Could not parse rate limit duration from: ${errorMessage}`);
       // Default to 15 minutes if we can't parse
       duration = 15 * 60 * 1000;
@@ -162,6 +239,7 @@ class ProviderManager {
       model,
       resetTime,
       resetDate: new Date(resetTime).toISOString(),
+      reason: errorMessage,
       markedAt: new Date().toISOString()
     };
 
@@ -196,17 +274,28 @@ class ProviderManager {
     const key = `${provider}:${model}`;
     const limit = this.rateLimits[key];
 
-    if (!limit) return false;
+    if (limit) {
+      // Check if rate limit has expired
+      if (Date.now() >= limit.resetTime) {
+        // Clean up expired rate limit
+        delete this.rateLimits[key];
+        this.saveRateLimits();
+        return false;
+      }
 
-    // Check if rate limit has expired
-    if (Date.now() >= limit.resetTime) {
-      // Clean up expired rate limit
-      delete this.rateLimits[key];
-      this.saveRateLimits();
-      return false;
+      return true;
     }
 
-    return true;
+    // Fall back to any provider-level entries (handles older or model-agnostic keys)
+    const providerPrefix = `${provider}:`;
+    for (const k in this.rateLimits) {
+      if (k.startsWith(providerPrefix)) {
+        const l = this.rateLimits[k];
+        if (l && Date.now() < l.resetTime) return true;
+      }
+    }
+
+    return false;
   }
 
   /**
@@ -252,6 +341,31 @@ class ProviderManager {
           reason: limit.reason
         };
       }
+
+      // Fallback: check other keys for this provider and return earliest reset
+      const providerPrefix = `${provider}:`;
+      let earliestReset = null;
+      let reason = null;
+
+      for (const k in this.rateLimits) {
+        if (k.startsWith(providerPrefix)) {
+          const l = this.rateLimits[k];
+          if (l && Date.now() < l.resetTime) {
+            if (!earliestReset || l.resetTime < earliestReset) {
+              earliestReset = l.resetTime;
+              reason = l.reason;
+            }
+          }
+        }
+      }
+
+      if (earliestReset) {
+        return {
+          isRateLimited: true,
+          resetTime: earliestReset,
+          reason
+        };
+      }
     }
 
     return {
@@ -285,9 +399,25 @@ class ProviderManager {
     const key = `${provider}:${model}`;
     const limit = this.rateLimits[key];
 
-    if (!limit) return null;
+    if (limit && Date.now() < limit.resetTime) {
+      const remaining = limit.resetTime - Date.now();
+      return remaining > 0 ? remaining : null;
+    }
 
-    const remaining = limit.resetTime - Date.now();
+    // Fallback: check other keys for this provider (handles legacy or model-agnostic entries)
+    const providerPrefix = `${provider}:`;
+    let earliest = null;
+    for (const k in this.rateLimits) {
+      if (k.startsWith(providerPrefix)) {
+        const l = this.rateLimits[k];
+        if (l && Date.now() < l.resetTime) {
+          if (!earliest || l.resetTime < earliest) earliest = l.resetTime;
+        }
+      }
+    }
+
+    if (!earliest) return null;
+    const remaining = earliest - Date.now();
     return remaining > 0 ? remaining : null;
   }
 
@@ -356,7 +486,7 @@ class ProviderManager {
    */
   recordPerformance(provider, model, durationMs) {
     const key = `${provider}:${model}`;
-    
+
     if (!this.performance[key]) {
       this.performance[key] = {
         provider,
@@ -365,19 +495,19 @@ class ProviderManager {
         avgSpeed: 0
       };
     }
-    
+
     const perf = this.performance[key];
     perf.samples.push(durationMs);
-    
+
     // Keep only last 10 samples
     if (perf.samples.length > 10) {
       perf.samples.shift();
     }
-    
+
     // Calculate average
     perf.avgSpeed = perf.samples.reduce((a, b) => a + b, 0) / perf.samples.length;
     perf.lastUsed = Date.now();
-    
+
     this.savePerformance();
   }
 
@@ -388,10 +518,10 @@ class ProviderManager {
    */
   getFastestAvailable(providers) {
     const available = providers.filter(p => !this.isRateLimited(p.provider, p.model));
-    
+
     if (available.length === 0) return null;
     if (available.length === 1) return available[0];
-    
+
     // Sort by average speed (fastest first)
     available.sort((a, b) => {
       const aKey = `${a.provider}:${a.model}`;
@@ -402,7 +532,7 @@ class ProviderManager {
       const bSpeed = (bAvg ?? b.estimatedSpeed ?? Infinity);
       return aSpeed - bSpeed;
     });
-    
+
     return available[0];
   }
 

package/src/ide-integration/quota-detector.cjs

@@ -1,33 +1,356 @@
-// @vibecodingmachine/core - Quota Detector (CommonJS) - Stub
+// @vibecodingmachine/core - Quota Detector (CommonJS)
 // Handles quota detection for different IDEs using CDP and AppleScript
 
+const CDP = require('chrome-remote-interface');
+const { AppleScriptManager } = require('./applescript-manager.cjs');
+
+/**
+ * Quota Detector for IDE interactions
+ * Detects quota warnings in different IDEs using CDP and AppleScript
+ */
 class QuotaDetector {
   constructor() {
     this.logger = console;
+    this.appleScriptManager = new AppleScriptManager();
+  }
+
+  /**
+   * Timeout utility function
+   * @param {number} ms - Timeout in milliseconds
+   * @param {Promise} promise - Promise to timeout
+   * @returns {Promise} Promise with timeout
+   */
+  timeout(ms, promise) {
+    return Promise.race([
+      promise,
+      new Promise((_, reject) =>
+        setTimeout(() => reject(new Error(`Operation timed out after ${ms}ms`)), ms)
+      )
+    ]);
   }
 
+  /**
+   * Detect quota warnings in an IDE
+   * @param {string} ide - The IDE name ('vscode', 'cursor', 'windsurf')
+   * @returns {Promise<Object>} Quota detection result
+   */
   async detectQuotaWarning(ide = 'vscode') {
-    this.logger.log(`🔍 Quota detection stub for ${ide}`);
-    return {
-      hasQuotaWarning: false,
-      method: 'stub',
-      note: 'Quota detection not implemented in stub'
-    };
+    this.logger.log(`🔍 Starting quota detection for ${ide}...`);
+
+    // Determine the port based on the IDE
+    const port = ide === 'windsurf' ? 9224 : ide === 'cursor' ? 9225 : 9222;
+    const ideName = ide === 'windsurf' ? 'Windsurf' : ide === 'cursor' ? 'Cursor' : 'VS Code';
+
+    this.logger.log(`🔌 Checking ${ideName} on port ${port}...`);
+
+    // For Windsurf, use AppleScript detection since CDP is not supported
+    if (ide === 'windsurf') {
+      this.logger.log('🔍 Windsurf detected - using AppleScript quota detection');
+      return await this.appleScriptManager.detectQuotaWarning(ide);
+    }
+
+    // For VS Code and Cursor, use CDP detection
+    try {
+      this.logger.log(`🔍 Attempting CDP connection to ${ideName} on port ${port}...`);
+
+      // Try to connect to CDP
+      const targets = await this.timeout(5000, CDP.List({ port }));
+
+      if (!targets || targets.length === 0) {
+        this.logger.log(`❌ No CDP targets found on port ${port}`);
+
+        // For Windsurf, fall back to AppleScript
+        if (ide === 'windsurf') {
+          this.logger.log('🔍 Falling back to enhanced AppleScript quota detection...');
+          return await this.appleScriptManager.detectQuotaWarning(ide);
+        }
+
+        return {
+          hasQuotaWarning: false,
+          error: `Could not find ${ideName}. Make sure ${ideName} is running with --remote-debugging-port=${port}`,
+          note: 'CDP connection failed'
+        };
+      }
+
+      this.logger.log(`✅ Found ${targets.length} CDP targets`);
+
+      // For Cursor, prefer the workspace target over settings
+      let workbench;
+      if (ide === 'cursor') {
+        workbench = targets.find(t => t.title !== 'Cursor Settings' && t.type === 'page') ||
+                    targets.find(t => t.url && t.url.includes('workbench')) ||
+                    targets[0];
+      } else {
+        workbench = targets.find(t => t.url && t.url.includes('workbench')) || targets[0];
+      }
+
+      if (!workbench) {
+        this.logger.log(`❌ No suitable workbench target found`);
+        return {
+          hasQuotaWarning: false,
+          error: `No ${ideName} workbench target found.`,
+          note: 'No workbench target available'
+        };
+      }
+
+      this.logger.log(`✅ Selected workbench: ${workbench.title}`);
+
+      // Connect to CDP
+      const client = await this.timeout(10000, CDP({ port, target: workbench }));
+      const { Runtime, Page } = client;
+
+      await this.timeout(5000, Runtime.enable());
+      if (Page && Page.bringToFront) {
+        try {
+          await this.timeout(3000, Page.bringToFront());
+        } catch (error) {
+          this.logger.log(`⚠️ Bring to front failed: ${error.message}`);
+        }
+      }
+
+      // Execute JavaScript to detect quota warnings
+      const detectionScript = `
+        (() => {
+          console.log('🔍 Starting quota detection in ${ideName}...');
+
+          // Common quota warning patterns
+          const quotaPatterns = [
+            'not enough credits',
+            'upgrade to a paid plan',
+            'switch to swe-1-lite',
+            'quota exceeded',
+            'credits exhausted',
+            'payment required',
+            'out of credits',
+            'insufficient credits',
+            'billing required',
+            'subscription needed',
+            'monthly chat messages quota',
+            'upgrade to copilot pro',
+            'allowance to renew',
+            'reached your monthly',
+            'wait for your allowance'
+          ];
+
+          // Function to check if text contains quota warnings
+          function containsQuotaWarning(text) {
+            if (!text) return false;
+            const lowerText = text.toLowerCase();
+            return quotaPatterns.some(pattern => lowerText.includes(pattern));
+          }
+
+          // Method 1: Check all text content in the document
+          const allText = document.body.innerText || document.body.textContent || '';
+          if (containsQuotaWarning(allText)) {
+            console.log('❌ Quota warning detected in document text');
+            return {
+              hasQuotaWarning: true,
+              method: 'document-text',
+              matchedText: allText.substring(0, 200) + '...'
+            };
+          }
+
+          // Method 2: Check specific elements that might contain quota warnings
+          const quotaElements = [
+            // VS Code specific selectors
+            '.monaco-workbench .part.auxiliarybar',
+            '.monaco-workbench .part.sidebar.right',
+            '.monaco-workbench .chat-view',
+            '.monaco-workbench .chat-input',
+
+            // Cursor specific selectors
+            '.aislash-editor-input',
+            '.aislash-chat-container',
+            '.aislash-panel',
+
+            // Generic selectors
+            '[data-testid*="chat"]',
+            '[aria-label*="chat"]',
+            '[class*="chat"]',
+            '[class*="quota"]',
+            '[class*="credits"]',
+            '[class*="billing"]'
+          ];
+
+          for (const selector of quotaElements) {
+            const elements = document.querySelectorAll(selector);
+            for (const element of elements) {
+              const elementText = element.innerText || element.textContent || '';
+              if (containsQuotaWarning(elementText)) {
+                console.log('❌ Quota warning detected in element:', selector);
+                return {
+                  hasQuotaWarning: true,
+                  method: 'element-specific',
+                  selector: selector,
+                  matchedText: elementText.substring(0, 200) + '...'
+                };
+              }
+            }
+          }
+
+          // Method 3: Check for disabled input fields (common when quota is exceeded)
+          const disabledInputs = document.querySelectorAll('input[disabled], textarea[disabled], [contenteditable="true"][aria-disabled="true"]');
+          if (disabledInputs.length > 0) {
+            console.log('⚠️ Found disabled input fields, checking for quota context...');
+
+            // Check if there are quota-related messages near disabled inputs
+            for (const input of disabledInputs) {
+              const parentText = input.parentElement?.innerText || '';
+              if (containsQuotaWarning(parentText)) {
+                console.log('❌ Quota warning detected near disabled input');
+                return {
+                  hasQuotaWarning: true,
+                  method: 'disabled-input-context',
+                  matchedText: parentText.substring(0, 200) + '...'
+                };
+              }
+            }
+          }
+
+          // Method 4: Check for specific UI elements that indicate quota issues
+          const quotaButtons = document.querySelectorAll('button, a, [role="button"]');
+          for (const button of quotaButtons) {
+            const buttonText = button.innerText || button.textContent || '';
+            if (containsQuotaWarning(buttonText)) {
+              console.log('❌ Quota warning detected in button:', buttonText);
+              return {
+                hasQuotaWarning: true,
+                method: 'button-text',
+                matchedText: buttonText
+              };
+            }
+          }
+
+          // Method 5: Check for error messages or notifications
+          const errorElements = document.querySelectorAll('[class*="error"], [class*="warning"], [class*="notification"], [role="alert"]');
+          for (const error of errorElements) {
+            const errorText = error.innerText || error.textContent || '';
+            if (containsQuotaWarning(errorText)) {
+              console.log('❌ Quota warning detected in error element');
+              return {
+                hasQuotaWarning: true,
+                method: 'error-element',
+                matchedText: errorText.substring(0, 200) + '...'
+              };
+            }
+          }
+
+          console.log('✅ No quota warnings detected');
+          return {
+            hasQuotaWarning: false,
+            method: 'cdp-comprehensive',
+            note: 'No quota warnings found in ${ideName}'
+          };
+        })()
+      `;
+
+      const { result } = await this.timeout(10000, Runtime.evaluate({
+        expression: detectionScript,
+        returnByValue: true
+      }));
+
+      const detectionResult = result.value || result.unserializableValue;
+
+      this.logger.log('🔍 CDP quota detection result:', detectionResult);
+
+      if (detectionResult && detectionResult.hasQuotaWarning) {
+        this.logger.log('❌ Quota warning detected via CDP');
+        return {
+          hasQuotaWarning: true,
+          method: detectionResult.method,
+          matchedText: detectionResult.matchedText || 'Quota warning detected via CDP',
+          note: detectionResult.matchedText || 'Quota warning detected via CDP',
+          debug: detectionResult
+        };
+      }
+
+      this.logger.log('✅ No quota warnings detected via CDP');
+      return {
+        hasQuotaWarning: false,
+        method: 'cdp-comprehensive',
+        note: 'No quota warnings found in ' + ideName,
+        debug: detectionResult
+      };
+
+    } catch (error) {
+      this.logger.log(`❌ CDP quota detection failed: ${error.message}`);
+
+      // For Windsurf, fall back to AppleScript
+      if (ide === 'windsurf') {
+        this.logger.log('🔍 Falling back to AppleScript quota detection...');
+        return await this.appleScriptManager.detectQuotaWarning(ide);
+      }
+
+      return {
+        hasQuotaWarning: false,
+        error: error.message,
+        note: `CDP quota detection failed for ${ideName}`
+      };
+    }
   }
 
+  /**
+   * Get available IDEs without quota warnings
+   * @param {Array<string>} ides - Array of IDE names to check
+   * @returns {Promise<Array<string>>} Array of available IDE names
+   */
   async getAvailableIdes(ides = ['vscode', 'cursor', 'windsurf']) {
-    this.logger.log('🔍 Available IDEs stub');
-    return ides;
+    this.logger.log('🔍 Checking available IDEs without quota warnings...');
+
+    const availableIdes = [];
+
+    for (const ide of ides) {
+      try {
+        const quotaResult = await this.detectQuotaWarning(ide);
+
+        if (!quotaResult.hasQuotaWarning) {
+          availableIdes.push(ide);
+          this.logger.log(`✅ ${ide} is available (no quota warnings)`);
+        } else {
+          this.logger.log(`❌ ${ide} has quota warnings: ${quotaResult.note || 'Unknown quota issue'}`);
+        }
+      } catch (error) {
+        this.logger.log(`⚠️ Error checking ${ide}: ${error.message}`);
+        // If we can't check quota, assume the IDE is available
+        availableIdes.push(ide);
+      }
+    }
+
+    this.logger.log(`📋 Available IDEs: ${availableIdes.join(', ')}`);
+    return availableIdes;
   }
 
+  /**
+   * Test quota detection with a test message
+   * @param {string} ide - The IDE name to test
+   * @returns {Promise<Object>} Test result
+   */
   async testQuotaDetection(ide) {
-    this.logger.log(`🧪 Quota detection test stub for ${ide}`);
-    return {
-      ide,
-      success: true,
-      hasQuotaWarning: false,
-      method: 'stub'
-    };
+    this.logger.log(`🧪 Testing quota detection for ${ide}...`);
+
+    try {
+      const quotaResult = await this.detectQuotaWarning(ide);
+
+      this.logger.log(`🧪 Quota detection test result for ${ide}:`, quotaResult);
+
+      return {
+        ide,
+        success: true,
+        hasQuotaWarning: quotaResult.hasQuotaWarning,
+        method: quotaResult.method,
+        note: quotaResult.note,
+        debug: quotaResult
+      };
+    } catch (error) {
+      this.logger.log(`❌ Quota detection test failed for ${ide}: ${error.message}`);
+
+      return {
+        ide,
+        success: false,
+        error: error.message,
+        note: `Quota detection test failed for ${ide}`
+      };
+    }
   }
 }
 

package/src/ide-integration/quota-detector.js

@@ -124,7 +124,12 @@ export class QuotaDetector {
             'out of credits',
             'insufficient credits',
             'billing required',
-            'subscription needed'
+            'subscription needed',
+            'monthly chat messages quota',
+            'upgrade to copilot pro',
+            'allowance to renew',
+            'reached your monthly',
+            'wait for your allowance'
           ];
 
           // Function to check if text contains quota warnings