vibecodingmachine-core 2026.3.14-1528 → 2026.6.17-1835

package/src/ide-integration/applescript-kiro-quota.cjs

@@ -0,0 +1,549 @@
+// @vibecodingmachine/core - AppleScript Kiro Quota Detection + OCR Helpers (CommonJS)
+'use strict';
+
+const { execSync } = require('child_process');
+
+class AppleScriptKiroQuota {
+  async _performOCR(imagePath) {
+    try {
+      const { execSync } = require('child_process');
+      
+      // Check if Tesseract is available
+      try {
+        execSync('which tesseract', { timeout: 3000 });
+      } catch (error) {
+        return {
+          success: false,
+          error: 'Tesseract OCR not found. Please install with: brew install tesseract'
+        };
+      }
+
+      // Create temporary text file for OCR output
+      const os = require('os');
+      const path = require('path');
+      const tempDir = os.tmpdir();
+      const outputPath = path.join(tempDir, `ocr-output-${Date.now()}`);
+
+      try {
+        // Run Tesseract OCR with specific settings for better accuracy
+        execSync(`tesseract "${imagePath}" "${outputPath}" -l eng --psm 6 --oem 1`, {
+          timeout: 15000,
+          stdio: 'pipe'
+        });
+
+        // Read the OCR result
+        const fs = require('fs');
+        const textFilePath = `${outputPath}.txt`;
+        
+        if (!fs.existsSync(textFilePath)) {
+          return {
+            success: false,
+            error: 'OCR output file not created'
+          };
+        }
+
+        let text = fs.readFileSync(textFilePath, 'utf8').trim();
+
+        // Clean up OCR output file
+        try {
+          fs.unlinkSync(textFilePath);
+        } catch (cleanupError) {
+          // Ignore cleanup errors
+        }
+
+        // Filter out gibberish and clean up the text
+        text = this._cleanOCRText(text);
+
+        // Validate that we have meaningful text
+        if (!this._isValidText(text)) {
+          return {
+            success: false,
+            error: 'OCR produced only gibberish or no meaningful text'
+          };
+        }
+
+        return {
+          success: true,
+          text: text
+        };
+
+      } catch (tesseractError) {
+        return {
+          success: false,
+          error: `Tesseract execution failed: ${tesseractError.message}`
+        };
+      }
+
+    } catch (error) {
+      return {
+        success: false,
+        error: `OCR setup failed: ${error.message}`
+      };
+    }
+  }
+
+  /**
+   * Clean and filter OCR text to remove gibberish
+   * @param {string} text - Raw OCR text
+   * @returns {string} - Cleaned text
+   */
+  _cleanOCRText(text) {
+    if (!text) return '';
+
+    // Remove common OCR artifacts and gibberish patterns
+    let cleaned = text
+      // Remove single characters on separate lines
+      .replace(/^[a-zA-Z0-9]$/gm, '')
+      // Remove lines with mostly numbers (terminal line numbers)
+      .replace(/^\d+\s*$/gm, '')
+      // Remove lines with special characters only
+      .replace(/^[^\w\s]+$/gm, '')
+      // Remove common terminal artifacts
+      .replace(/^[>»]$/gm, '')
+      // Remove very short lines (likely noise)
+      .replace(/^(.{1,2})$/gm, '')
+      // Clean up multiple spaces
+      .replace(/\s+/g, ' ')
+      // Remove empty lines
+      .replace(/\n\s*\n/g, '\n')
+      .trim();
+
+    return cleaned;
+  }
+
+  /**
+   * Validate that OCR text is meaningful and not gibberish
+   * @param {string} text - OCR text to validate
+   * @returns {boolean} - Whether the text is valid
+   */
+  _isValidText(text) {
+    if (!text || text.length < 10) {
+      return false;
+    }
+
+    // Check for meaningful content
+    const words = text.split(/\s+/);
+    const meaningfulWords = words.filter(word => 
+      word.length > 2 && // Skip very short words
+      !/^\d+$/.test(word) && // Skip pure numbers
+      !/^[^\w]+$/.test(word) // Skip special characters only
+    );
+
+    // Need at least 3 meaningful words
+    if (meaningfulWords.length < 3) {
+      return false;
+    }
+
+    // Check for quota-related keywords (this is what we're looking for)
+    const hasQuotaKeywords = /\b(usage|limit|quota|agent|cursor|pro|upgrade|hit)\b/i.test(text);
+    
+    // If we have quota keywords, be more lenient
+    if (hasQuotaKeywords) {
+      return meaningfulWords.length >= 2;
+    }
+
+    // Otherwise, require more meaningful content
+    return meaningfulWords.length >= 5;
+  }
+
+  /**
+   * Check AWS Kiro UI for quota limit messages
+   * This is best-effort: Kiro may render quota messages in different UI elements or web-based UI
+   * @returns {Promise<{isRateLimited: boolean, message?: string, resumeAt?: string, note?: string}>}
+   */
+  async checkKiroQuotaLimit() {
+    try {
+      // First try AppleScript UI detection
+      const script = `
+        tell application "System Events"
+          set processName to "AWS Kiro"
+          try
+            if not (exists process "AWS Kiro") then
+              set processName to "Kiro"
+            end if
+          on error
+            set processName to "Kiro"
+          end try
+          
+          if not (exists process processName) then
+            return "NOT_RUNNING"
+          end if
+          
+          tell process processName
+            set frontmost to true
+            delay 0.4
+
+            set allText to ""
+            
+            -- Get window title (might contain quota info)
+            try
+              set windowTitle to title of window 1
+              set allText to allText & "WINDOW_TITLE: " & windowTitle & "\\n"
+            end try
+            
+            -- Get window description
+            try
+              set windowDesc to description of window 1
+              set allText to allText & "WINDOW_DESC: " & windowDesc & "\\n"
+            end try
+            
+            -- Get window help text
+            try
+              set windowHelp to help of window 1
+              set allText to allText & "WINDOW_HELP: " & windowHelp & "\\n"
+            end try
+            
+            -- Try to get text from main window
+            try
+              set windowText to (value of static text of window 1 as string)
+              set allText to allText & "WINDOW_STATIC: " & windowText & "\\n"
+            end try
+
+            -- Try to get text from groups in main window
+            try
+              set groupsList to groups of window 1
+              repeat with g in groupsList
+                try
+                  set groupText to (value of static text of g as string)
+                  set allText to allText & "GROUP: " & groupText & "\\n"
+                end try
+              end repeat
+            end try
+
+            -- Try to get text from buttons in main window
+            try
+              set buttonsList to buttons of window 1
+              repeat with b in buttonsList
+                try
+                  set buttonText to (name of b as string)
+                  set allText to allText & "BUTTON: " & buttonText & "\\n"
+                end try
+              end repeat
+            end try
+
+            -- Try to get text from text fields in main window
+            try
+              set textFieldsList to text fields of window 1
+              repeat with tf in textFieldsList
+                try
+                  set fieldText to (value of tf as string)
+                  set allText to allText & "TEXT_FIELD: " & fieldText & "\\n"
+                end try
+              end repeat
+            end try
+
+            -- Try to get text from text views in main window
+            try
+              set textViewsList to text views of window 1
+              repeat with tv in textViewsList
+                try
+                  set viewText to (value of tv as string)
+                  set allText to allText & "TEXT_VIEW: " & viewText & "\\n"
+                end try
+              end repeat
+            end try
+
+            -- Try to get text from sheets (dialogs/alerts)
+            try
+              set sheetsList to sheets of window 1
+              repeat with s in sheetsList
+                try
+                  set sheetText to (value of static text of s as string)
+                  set allText to allText & "SHEET: " & sheetText & "\\n"
+                end try
+              end repeat
+            end try
+
+            -- Try to get text from all UI elements (catch-all)
+            try
+              set uiElementsList to every UI element of window 1
+              repeat with element in uiElementsList
+                try
+                  set elementText to value of element as string
+                  if elementText is not missing value and elementText is not "" then
+                    set allText to allText & "UI_ELEMENT: " & elementText & "\\n"
+                  end if
+                end try
+              end repeat
+            end try
+
+            -- Try to get accessibility attributes
+            try
+              set windowRole to role of window 1
+              set allText to allText & "WINDOW_ROLE: " & windowRole & "\\n"
+            end try
+            
+            try
+              set windowSubrole to subrole of window 1
+              set allText to allText & "WINDOW_SUBROLE: " & windowSubrole & "\\n"
+            end try
+
+            return allText
+          end tell
+        end tell
+      `;
+
+      const raw = execSync(`osascript -e '${script.replace(/'/g, "'\\''")}'`, {
+        encoding: 'utf8',
+        timeout: 8000
+      }).trim();
+
+      if (!raw || raw === 'NOT_RUNNING') {
+        return {
+          isRateLimited: false,
+          note: raw === 'NOT_RUNNING' ? 'AWS Kiro not running' : 'No readable UI text'
+        };
+      }
+
+      const text = raw.replace(/\s+/g, ' ').trim();
+      const lower = text.toLowerCase();
+
+      // Check for Kiro-specific quota limit patterns (expanded for better detection)
+      const hasKiroQuota = lower.includes('quota limit exceeded') ||
+        lower.includes('usage limit reached') ||
+        lower.includes('rate limit exceeded') ||
+        lower.includes('api limit exceeded') ||
+        lower.includes('request limit exceeded') ||
+        lower.includes('too many requests') ||
+        lower.includes('quota exceeded') ||
+        lower.includes('limit exceeded') ||
+        lower.includes('usage exceeded') ||
+        lower.includes('rate limited') ||
+        lower.includes('api limited') ||
+        lower.includes('request limited') ||
+        lower.includes('quota reached') ||
+        lower.includes('limit reached') ||
+        lower.includes('usage reached') ||
+        lower.includes('cap reached') ||
+        lower.includes('cap exceeded') ||
+        lower.includes('spending cap') ||
+        lower.includes('usage cap') ||
+        lower.includes('daily limit') ||
+        lower.includes('monthly limit') ||
+        lower.includes('hourly limit') ||
+        lower.includes('request limit') ||
+        lower.includes('token limit') ||
+        lower.includes('credit limit') ||
+        lower.includes('billing limit') ||
+        lower.includes('subscription limit') ||
+        lower.includes('plan limit') ||
+        lower.includes('tier limit') ||
+        lower.includes('upgrade required') ||
+        lower.includes('upgrade needed') ||
+        lower.includes('upgrade to pro') ||
+        lower.includes('upgrade to premium') ||
+        lower.includes('upgrade plan') ||
+        lower.includes('increase limit') ||
+        lower.includes('exhausted') ||
+        lower.includes('no more requests') ||
+        lower.includes('no more credits') ||
+        lower.includes('insufficient credits') ||
+        lower.includes('insufficient quota') ||
+        lower.includes('maximum reached') ||
+        lower.includes('max requests') ||
+        lower.includes('max usage') ||
+        lower.includes('over limit') ||
+        lower.includes('over quota') ||
+        lower.includes('over usage') ||
+        lower.includes('out of credits') ||
+        lower.includes('out of credit') ||
+        lower.includes('credits exhausted') ||
+        lower.includes('credits depleted') ||
+        lower.includes('credits used up') ||
+        lower.includes('credit exhausted') ||
+        lower.includes('credit depleted') ||
+        lower.includes('credit used up') ||
+        lower.includes('credit balance is too low') ||
+        lower.includes('not enough credits') ||
+        lower.includes('credits: 0') ||
+        lower.includes('credit balance: 0') ||
+        lower.includes('no credits available') ||
+        lower.includes('purchase more credits') ||
+        lower.includes('credits: 0 remaining') ||
+        lower.includes('credit balance: 0') ||
+        (lower.includes('credits') && (lower.includes('out of') || lower.includes('exhausted') || lower.includes('depleted') || lower.includes('used up'))) ||
+        (lower.includes('credit') && (lower.includes('out of') || lower.includes('exhausted') || lower.includes('depleted') || lower.includes('used up') || lower.includes('balance is too low') || lower.includes('balance: 0'))) ||
+        (lower.includes('quota') && (lower.includes('exceeded') || lower.includes('reached') || lower.includes('exhaust'))) ||
+        (lower.includes('limit') && (lower.includes('exceeded') || lower.includes('reached') || lower.includes('exhaust'))) ||
+        (lower.includes('cap') && (lower.includes('exceeded') || lower.includes('reached') || lower.includes('exhaust')));
+
+      if (hasKiroQuota) {
+        // Try to extract reset time from various formats (expanded for better detection)
+        const resumeAtMatch = text.match(/(?:resume|reset|available|renew|refresh|restart|continue|try again)\s+(?:at|in|on)\s+(\d{1,2}\/\d{1,2}\/\d{4})\s*,?\s*(\d{1,2}:\d{2}(?::\d{2})?)\s*(am|pm)/i);
+        const resumeAt = resumeAtMatch
+          ? `${resumeAtMatch[1]}, ${resumeAtMatch[2]} ${resumeAtMatch[3].toUpperCase()}`
+          : undefined;
+
+        // Also try other time formats
+        if (!resumeAt) {
+          const timeMatch = text.match(/(?:try again|resume|reset|available|renew|refresh|restart|continue)\s+(?:in|after)\s+(\d+)\s*(?:minutes?|hours?|days?|seconds?)/i);
+          if (timeMatch) {
+            // For "in X minutes/hours/days" format, we'll return the raw text
+            return {
+              isRateLimited: true,
+              message: text,
+              resumeTime: timeMatch[1] + ' ' + timeMatch[2]
+            };
+          }
+        }
+
+        // Try specific time patterns like "resets at 12pm" or "resets at 3:30 PM"
+        if (!resumeAt) {
+          const timeOnlyMatch = text.match(/(?:resets|reset|resume|available)\s+(?:at|@)\s+(\d{1,2}:\d{2}(?::\d{2})?)\s*(am|pm)?/i);
+          if (timeOnlyMatch) {
+            const time = timeOnlyMatch[1] + (timeOnlyMatch[2] ? ' ' + timeOnlyMatch[2].toUpperCase() : '');
+            return {
+              isRateLimited: true,
+              message: text,
+              resumeTime: time
+            };
+          }
+        }
+
+        // Try date patterns like "resets on January 15" or "resets on 1/15"
+        if (!resumeAt) {
+          const dateMatch = text.match(/(?:resets|reset|resume|available)\s+(?:on|at)\s+(\d{1,2}\/\d{1,2})(?:\/\d{4})?/i);
+          if (dateMatch) {
+            return {
+              isRateLimited: true,
+              message: text,
+              resumeTime: dateMatch[1]
+            };
+          }
+        }
+
+        return {
+          isRateLimited: true,
+          message: text,
+          resumeAt
+        };
+      }
+
+      // If AppleScript didn't find quota messages, try fallback methods
+      return await this.checkKiroQuotaLimitFallback();
+
+    } catch (error) {
+      return {
+        isRateLimited: false,
+        note: `Failed to check AWS Kiro quota: ${error.message}`
+      };
+    }
+  }
+
+  /**
+   * Fallback method to check Kiro quota using alternative approaches
+   * @returns {Promise<{isRateLimited: boolean, message?: string, note?: string}>}
+   */
+  async checkKiroQuotaLimitFallback() {
+    try {
+      // Method 1: Check if Kiro process is running and consuming high CPU (might indicate quota error)
+      const processCheck = execSync('ps aux | grep -i kiro | grep -v grep', {
+        encoding: 'utf8',
+        timeout: 3000
+      }).trim();
+
+      if (!processCheck) {
+        return {
+          isRateLimited: false,
+          note: 'AWS Kiro process not found'
+        };
+      }
+
+      // Method 2: Check for system notifications (macOS notifications about quota)
+      try {
+        const notifications = execSync('log show --predicate \'subsystem == "com.apple.notificationcenter"\' --info --last 5m | grep -i "kiro\\|quota\\|limit"', {
+          encoding: 'utf8',
+          timeout: 5000
+        }).trim();
+
+        if (notifications) {
+          const lower = notifications.toLowerCase();
+          if (lower.includes('quota') || lower.includes('limit') || lower.includes('exceeded')) {
+            return {
+              isRateLimited: true,
+              message: 'Quota limit detected in system notifications',
+              note: 'Detected via system notifications'
+            };
+          }
+        }
+      } catch (notifError) {
+        // Notifications check failed, continue
+      }
+
+      // Method 3: Check console logs for Kiro-related quota messages
+      try {
+        const consoleLogs = execSync('log show --predicate \'process == "Kiro" OR process == "AWS Kiro"\' --info --last 10m | grep -i "quota\\|limit\\|exceeded\\|error"', {
+          encoding: 'utf8',
+          timeout: 5000
+        }).trim();
+
+        if (consoleLogs) {
+          const lower = consoleLogs.toLowerCase();
+          if (lower.includes('quota') || lower.includes('limit') || lower.includes('exceeded')) {
+            return {
+              isRateLimited: true,
+              message: 'Quota limit detected in console logs',
+              note: 'Detected via console logs'
+            };
+          }
+        }
+      } catch (logError) {
+        // Console log check failed, continue
+      }
+
+      // Method 4: Check if Kiro window title contains quota information
+      try {
+        const windowTitle = execSync(`osascript -e '
+          tell application "System Events"
+            set processName to "AWS Kiro"
+            try
+              if not (exists process "AWS Kiro") then
+                set processName to "Kiro"
+              end if
+            on error
+              set processName to "Kiro"
+            end try
+            
+            if exists process processName then
+              return title of window 1 of process processName
+            end if
+          end tell
+        '`, {
+          encoding: 'utf8',
+          timeout: 3000
+        }).trim();
+
+        if (windowTitle) {
+          const lower = windowTitle.toLowerCase();
+          if (lower.includes('quota') || lower.includes('limit') || lower.includes('exceeded')) {
+            return {
+              isRateLimited: true,
+              message: `Quota limit detected in window title: ${windowTitle}`,
+              note: 'Detected via window title'
+            };
+          }
+        }
+      } catch (titleError) {
+        // Window title check failed, continue
+      }
+
+      return {
+        isRateLimited: false,
+        note: 'No quota limit detected via fallback methods'
+      };
+
+    } catch (error) {
+      return {
+        isRateLimited: false,
+        note: `Fallback quota check failed: ${error.message}`
+      };
+    }
+  }
+
+  /**
+   * Open Cursor IDE
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+}
+
+module.exports = AppleScriptKiroQuota;

package/src/ide-integration/applescript-manager-core.js

@@ -46,7 +46,7 @@ class AppleScriptManagerCore {
 
   /**
    * Generic IDE opener - routes to specific IDE methods
-   * @param {string} ide - The IDE name ('cursor', 'windsurf', 'antigravity', 'vscode', etc.')
+   * @param {string} ide - The IDE name ('cursor', 'devin', 'antigravity', 'vscode', etc.')
    * @param {string} repoPath - Optional repository path to open
    * @returns {Promise<Object>} Result object
    */
@@ -57,7 +57,7 @@ class AppleScriptManagerCore {
   /**
    * Send text to an IDE using platform-specific methods
    * @param {string} text - The text to send
-   * @param {string} ide - The IDE name ('cursor', 'windsurf', 'claude')
+   * @param {string} ide - The IDE name ('cursor', 'devin', 'claude')
    * @param {string} repoPath - The repository path (optional, used for Claude)
    * @returns {Promise<Object>} Result object with success status and details
    */
@@ -75,7 +75,7 @@ class AppleScriptManagerCore {
 
   /**
    * Read chat response from IDE using platform-specific methods
-   * @param {string} ide - The IDE name ('cursor', 'windsurf', 'vscode')
+   * @param {string} ide - The IDE name ('cursor', 'devin', 'vscode')
    * @returns {Promise<string>} The chat response text
    */
   async readChatResponse(ide) {
@@ -93,7 +93,7 @@ class AppleScriptManagerCore {
 
   /**
    * Close previous chat thread in an IDE to prevent conflicts
-   * @param {string} ide - The IDE name ('cursor', 'vscode', 'windsurf', 'claude')
+   * @param {string} ide - The IDE name ('cursor', 'vscode', 'devin', 'claude')
    * @returns {Promise<Object>} Result object with success status and details
    */
   async closePreviousChatThread(ide) {
@@ -103,7 +103,7 @@ class AppleScriptManagerCore {
   /**
    * Send text to an IDE with automatic thread closure
    * @param {string} text - The text to send
-   * @param {string} ide - The IDE name ('cursor', 'vscode', 'windsurf')
+   * @param {string} ide - The IDE name ('cursor', 'vscode', 'devin')
    * @returns {Promise<Object>} Result object with success status and details
    */
   async sendTextWithThreadClosure(text, ide) {
@@ -179,7 +179,7 @@ class AppleScriptManagerCore {
 
   /**
    * Detect quota warnings using platform-specific methods
-   * @param {string} ide - The IDE name ('windsurf')
+   * @param {string} ide - The IDE name ('devin')
    * @returns {Promise<Object>} Quota detection result
    */
   async detectQuotaWarning(ide) {
@@ -187,11 +187,11 @@ class AppleScriptManagerCore {
   }
 
   /**
-   * Check Windsurf for rate limit errors
+   * Check Devin for rate limit errors
    * @returns {Promise<Object>} Result object with isRateLimited flag and details
    */
-  async checkWindsurfRateLimit() {
-    return await this.ideManager.checkWindsurfRateLimit();
+  async checkDevinRateLimit() {
+    return await this.ideManager.checkDevinRateLimit();
   }
 
   /**
@@ -204,12 +204,30 @@ class AppleScriptManagerCore {
   }
 
   /**
-   * Send text to Windsurf extension within VS Code
+   * Send text to Devin extension within VS Code
    * @param {string} text - The text to send
    * @returns {Promise<Object>} Result object with success status
    */
-  async sendTextToWindsurfExtension(text) {
-    return await this.ideManager.sendTextToWindsurfExtension(text);
+  async sendTextToDevinExtension(text) {
+    return await this.ideManager.sendTextToDevinExtension(text);
+  }
+
+  /**
+   * Send text to Devin IDE (alias for sendTextToDevinExtension)
+   * @param {string} text - The text to send
+   * @returns {Promise<Object>} Result object with success status
+   */
+  async sendTextToDevin(text) {
+    return await this.ideManager.sendTextToDevinExtension(text);
+  }
+
+  /**
+   * Send text to Cursor IDE
+   * @param {string} text - The text to send
+   * @returns {Promise<Object>} Result object with success status
+   */
+  async sendTextToCursor(text) {
+    return await this.ideManager.sendTextToCursor(text);
   }
 
   /**