vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/ide-integration/cdp-manager.js

@@ -318,4 +318,310 @@ export class CDPManager {
       return `Error: ${error.message}`;
     }
   }
+
+  /**
+   * Detect continuation prompts using DOM inspection
+   * @param {Object} client - CDP client
+   * @returns {Promise<boolean>} True if continuation prompt detected
+   */
+  async detectContinuationPrompt(client) {
+    try {
+      const { DOM, Runtime } = client;
+
+      // Get document root
+      const { result: { root } } = await DOM.getDocument();
+      
+      // Query for continuation buttons
+      const continuationSelectors = [
+        'button[title*="Continue"]',
+        'button[title*="Proceed"]',
+        'button[title*="Next"]',
+        'button[title*="Keep Going"]',
+        'button[title*="Resume"]',
+        'button[aria-label*="Continue"]',
+        'button[aria-label*="Proceed"]',
+        'button[aria-label*="Next"]',
+        'button[aria-label*="Keep Going"]',
+        'button[aria-label*="Resume"]',
+        '[class*="continue"] button',
+        '[class*="proceed"] button',
+        '[class*="next"] button',
+        'button:contains("Continue")',
+        'button:contains("Proceed")',
+        'button:contains("Next")',
+        'button:contains("Keep Going")',
+        'button:contains("Resume")',
+        'button:contains("Continue Generation")'
+      ];
+
+      for (const selector of continuationSelectors) {
+        try {
+          const { result: { nodes } } = await DOM.querySelectorAll({
+            nodeId: root.nodeId,
+            selector: selector.replace(':contains(', '[text*="').replace(')', '"]')
+          });
+
+          if (nodes && nodes.length > 0) {
+            // Check if button text contains continuation keywords
+            for (const node of nodes) {
+              const { result: { value } } = await DOM.getAttributes({ nodeId: node.nodeId });
+              if (value) {
+                const attributes = value.split(' ').map(attr => attr.replace(/"/g, ''));
+                const textContent = attributes.find(attr => 
+                  attr.toLowerCase().includes('continue') ||
+                  attr.toLowerCase().includes('proceed') ||
+                  attr.toLowerCase().includes('next') ||
+                  attr.toLowerCase().includes('keep going') ||
+                  attr.toLowerCase().includes('resume')
+                );
+                
+                if (textContent) {
+                  return true;
+                }
+              }
+            }
+          }
+        } catch (e) {
+          // Continue with next selector if this one fails
+        }
+      }
+
+      return false;
+    } catch (error) {
+      console.error('Error detecting continuation prompt:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Click detected continuation button
+   * @param {Object} client - CDP client
+   * @returns {Promise<boolean>} True if button clicked successfully
+   */
+  async clickContinuationButton(client) {
+    try {
+      const { DOM, Runtime } = client;
+
+      // Get document root
+      const { result: { root } } = await DOM.getDocument();
+      
+      // Query for continuation buttons
+      const continuationSelectors = [
+        'button[title*="Continue"]',
+        'button[title*="Proceed"]',
+        'button[title*="Next"]',
+        'button[title*="Keep Going"]',
+        'button[title*="Resume"]',
+        'button[aria-label*="Continue"]',
+        'button[aria-label*="Proceed"]',
+        'button[aria-label*="Next"]',
+        'button[aria-label*="Keep Going"]',
+        'button[aria-label*="Resume"]',
+        '[class*="continue"] button',
+        '[class*="proceed"] button',
+        '[class*="next"] button'
+      ];
+
+      for (const selector of continuationSelectors) {
+        try {
+          const { result: { nodes } } = await DOM.querySelectorAll({
+            nodeId: root.nodeId,
+            selector: selector
+          });
+
+          if (nodes && nodes.length > 0) {
+            // Click the first found button
+            const node = nodes[0];
+            await DOM.resolveNode({ nodeId: node.nodeId });
+            
+            // Use Runtime to click the button
+            const clickExpression = `document.querySelector('${selector}').click()`;
+            await Runtime.evaluate({ expression: clickExpression });
+            
+            return true;
+          }
+        } catch (e) {
+          // Continue with next selector if this one fails
+        }
+      }
+
+      return false;
+    } catch (error) {
+      console.error('Error clicking continuation button:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Check for continuation prompts in the IDE
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result with continuation detected and button info
+   */
+  async checkForContinuation(ide) {
+    try {
+      const { Runtime } = await this.connectToIDE(ide);
+
+      const expression = `(() => {
+        try {
+          // Look for continuation buttons or prompts
+          const continuationSelectors = [
+            'button[title*="Continue"]',
+            'button[title*="Proceed"]',
+            'button:contains("Continue")',
+            'button:contains("Proceed")',
+            'button:contains("Next")',
+            'button:contains("Continue Generation")',
+            'button:contains("Keep Going")',
+            '[class*="continue"] button',
+            '[class*="proceed"] button',
+            '[class*="next"] button',
+            'button[aria-label*="Continue"]',
+            'button[aria-label*="Proceed"]'
+          ];
+
+          // Look for continuation text prompts
+          const textSelectors = [
+            '[class*="message"]:contains("Continue")',
+            '[class*="message"]:contains("Proceed")',
+            '[class*="prompt"]:contains("Continue")',
+            '[class*="prompt"]:contains("Proceed")',
+            '[class*="dialog"]:contains("Continue")',
+            '[class*="dialog"]:contains("Proceed")'
+          ];
+
+          const foundButtons = [];
+          const foundTexts = [];
+
+          // Check for buttons
+          continuationSelectors.forEach(selector => {
+            try {
+              const elements = document.querySelectorAll(selector);
+              elements.forEach(el => {
+                if (el && el.offsetParent !== null) { // Check if visible
+                  foundButtons.push({
+                    selector,
+                    text: el.textContent || el.innerText || '',
+                    title: el.title || '',
+                    ariaLabel: el.getAttribute('aria-label') || ''
+                  });
+                }
+              });
+            } catch (e) {
+              // Some selectors may not be supported, ignore
+            }
+          });
+
+          // Check for text prompts
+          textSelectors.forEach(selector => {
+            try {
+              const elements = document.querySelectorAll(selector);
+              elements.forEach(el => {
+                if (el && el.offsetParent !== null) { // Check if visible
+                  const text = el.textContent || el.innerText || '';
+                  if (text.toLowerCase().includes('continue') || 
+                      text.toLowerCase().includes('proceed') ||
+                      text.toLowerCase().includes('keep going')) {
+                    foundTexts.push({
+                      selector,
+                      text: text.trim()
+                    });
+                  }
+                }
+              });
+            } catch (e) {
+              // Some selectors may not be supported, ignore
+            }
+          });
+
+          return {
+            continuationDetected: foundButtons.length > 0 || foundTexts.length > 0,
+            buttons: foundButtons,
+            texts: foundTexts,
+            totalFound: foundButtons.length + foundTexts.length
+          };
+        } catch (error) {
+          return {
+            continuationDetected: false,
+            error: error.message,
+            buttons: [],
+            texts: []
+          };
+        }
+      })()`;
+
+      const { result } = await Runtime.evaluate({ expression, returnByValue: true });
+      return result.value || { continuationDetected: false, buttons: [], texts: [] };
+    } catch (error) {
+      console.error(`Error checking for continuation in ${ide}:`, error);
+      return { continuationDetected: false, error: error.message, buttons: [], texts: [] };
+    }
+  }
+
+  /**
+   * Click a continuation button if found
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result of the operation
+   */
+  async clickContinuationButton(ide) {
+    try {
+      const { Runtime } = await this.connectToIDE(ide);
+
+      const expression = `(() => {
+        try {
+          // Look for continuation buttons
+          const continuationSelectors = [
+            'button[title*="Continue"]',
+            'button[title*="Proceed"]',
+            'button:contains("Continue")',
+            'button:contains("Proceed")',
+            'button:contains("Next")',
+            'button:contains("Continue Generation")',
+            'button:contains("Keep Going")',
+            '[class*="continue"] button',
+            '[class*="proceed"] button',
+            '[class*="next"] button',
+            'button[aria-label*="Continue"]',
+            'button[aria-label*="Proceed"]'
+          ];
+
+          for (const selector of continuationSelectors) {
+            try {
+              const elements = document.querySelectorAll(selector);
+              for (const el of elements) {
+                if (el && el.offsetParent !== null) { // Check if visible
+                  el.click();
+                  return {
+                    success: true,
+                    clicked: true,
+                    selector: selector,
+                    text: el.textContent || el.innerText || ''
+                  };
+                }
+              }
+            } catch (e) {
+              // Some selectors may not be supported, continue
+            }
+          }
+
+          return {
+            success: false,
+            clicked: false,
+            message: 'No continuation button found'
+          };
+        } catch (error) {
+          return {
+            success: false,
+            clicked: false,
+            error: error.message
+          };
+        }
+      })()`;
+
+      const { result } = await Runtime.evaluate({ expression, returnByValue: true });
+      return result.value || { success: false, clicked: false, message: 'No result' };
+    } catch (error) {
+      console.error(`Error clicking continuation button in ${ide}:`, error);
+      return { success: false, clicked: false, error: error.message };
+    }
+  }
 }

package/src/ide-integration/claude-code-cli-manager.cjs

@@ -312,7 +312,7 @@ class ClaudeCodeCLIManager {
             // If we have a reset time, update the provider manager
             if (rateLimitInfo.resetTime) {
               try {
-                const ProviderManager = require('vibecodingmachine-core/src/ide-integration/provider-manager.cjs');
+                const ProviderManager = require('../ide-integration/provider-manager.cjs');
                 const providerManager = new ProviderManager();
                 providerManager.markRateLimited('claude-code', 'claude-code-cli', rateLimitInfo.message);
               } catch (e) {

package/src/ide-integration/continuation-handler.js

@@ -0,0 +1,337 @@
+// @vibecodingmachine/core - Continuation Handler
+// Cross-platform continuation button detection and clicking
+
+const { execSync } = require('child_process');
+
+/**
+ * Continuation Handler for cross-platform continuation button operations
+ * Handles continuation detection and clicking for all supported IDEs
+ */
+class ContinuationHandler {
+  constructor(platform, windowsManager = null) {
+    this.logger = console;
+    this.platform = platform;
+    this.windowsManager = windowsManager;
+  }
+
+  /**
+   * Detect continuation prompts using platform-specific methods
+   * @returns {Promise<boolean>} True if continuation prompt detected
+   */
+  async detectContinuationPrompt() {
+    try {
+      const continuationVariations = ['Continue', 'Proceed', 'Next', 'Keep Going', 'Resume'];
+      
+      for (const variation of continuationVariations) {
+        try {
+          const script = this._getContinuationButtonScript(variation);
+          const result = execSync(`osascript -e '${script.replace(/'/g, "'\\\\''")}'`, {
+            encoding: 'utf8',
+            timeout: 5000,
+            stdio: 'pipe'
+          }).trim();
+
+          if (result && result.toLowerCase().includes('found')) {
+            return true;
+          }
+        } catch (error) {
+          // Continue with next variation
+        }
+      }
+
+      return false;
+    } catch (error) {
+      console.error('Error detecting continuation prompt:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Click detected continuation button using platform-specific methods
+   * @returns {Promise<boolean>} True if button clicked successfully
+   */
+  async clickContinuationButton() {
+    try {
+      const continuationVariations = ['Continue', 'Proceed', 'Next', 'Keep Going', 'Resume'];
+      
+      for (const variation of continuationVariations) {
+        try {
+          const script = this._getClickButtonScript(variation);
+          const result = execSync(`osascript -e '${script.replace(/'/g, "'\\\\''")}'`, {
+            encoding: 'utf8',
+            timeout: 5000,
+            stdio: 'pipe'
+          }).trim();
+
+          if (result && result.toLowerCase().includes('clicked')) {
+            return true;
+          }
+        } catch (error) {
+          // Continue with next variation
+        }
+      }
+
+      return false;
+    } catch (error) {
+      console.error('Error clicking continuation button:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Check for continuation prompts using platform-specific methods
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result with continuation detected and button info
+   */
+  async checkForContinuation(ide) {
+    try {
+      if (this.platform === 'darwin') {
+        return await this.checkForContinuationMacOS(ide);
+      } else if (this.platform === 'win32' && this.windowsManager) {
+        return await this.checkForContinuationWindows(ide);
+      } else {
+        return { continuationDetected: false, error: 'Unsupported platform' };
+      }
+    } catch (error) {
+      this.logger.error(`Error checking for continuation in ${ide}:`, error);
+      return { continuationDetected: false, error: error.message };
+    }
+  }
+
+  /**
+   * Click a continuation button if found
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result of operation
+   */
+  async clickContinuationButton(ide) {
+    try {
+      if (this.platform === 'darwin') {
+        return await this.clickContinuationButtonMacOS(ide);
+      } else if (this.platform === 'win32' && this.windowsManager) {
+        return await this.clickContinuationButtonWindows(ide);
+      } else {
+        return { success: false, error: 'Unsupported platform' };
+      }
+    } catch (error) {
+      this.logger.error(`Error clicking continuation button in ${ide}:`, error);
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Check for continuation prompts on macOS using AppleScript
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result with continuation detected and button info
+   */
+  async checkForContinuationMacOS(ide) {
+    try {
+      const script = `
+        tell application "System Events"
+          try
+            set frontApp to first application process whose frontmost is true
+            set appName to name of frontApp
+            
+            -- Look for continuation buttons
+            set continuationButtons to {}
+            set buttonNames to {"Continue", "Proceed", "Next", "Continue Generation", "Keep Going"}
+            
+            repeat with buttonName in buttonNames
+              try
+                set foundButtons to (buttons of frontApp whose name contains buttonName)
+                repeat with aButton in foundButtons
+                  if exists aButton then
+                    set end of continuationButtons to {name:aButton, visible:true}
+                  end if
+                end repeat
+              end try
+            end repeat
+            
+            -- Look for continuation text in UI elements
+            set continuationTexts to {}
+            set textElements to (static texts of frontApp)
+            repeat with textElement in textElements
+              try
+                set elementText to name of textElement
+                if elementText contains "Continue" or elementText contains "Proceed" or elementText contains "Keep Going" then
+                  set end of continuationTexts to {name: elementText, visible: true}
+                end if
+              end try
+            end repeat
+            
+            return {buttons: continuationButtons, texts: continuationTexts}
+          on error errMsg number errNum
+            return {errorMsg:errMsg}
+          end try
+        end tell
+      `;
+
+      const result = execSync(`osascript -e '${script}'`, { 
+        encoding: 'utf8', 
+        timeout: 10000 
+      });
+
+      // Parse result (simplified parsing)
+      const continuationDetected = result.includes('Continue') || result.includes('Proceed');
+      
+      return {
+        continuationDetected,
+        buttons: continuationDetected ? [{ text: 'Continue button detected' }] : [],
+        texts: continuationDetected ? [{ text: 'Continuation prompt detected' }] : [],
+        rawResult: result
+      };
+    } catch (error) {
+      return { continuationDetected: false, error: error.message };
+    }
+  }
+
+  /**
+   * Check for continuation prompts on Windows using UI automation
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result with continuation detected and button info
+   */
+  async checkForContinuationWindows(ide) {
+    try {
+      // Use Windows automation manager to check for continuation buttons
+      const result = await this.windowsManager.checkForContinuationButtons(ide);
+      return result || { continuationDetected: false, buttons: [], texts: [] };
+    } catch (error) {
+      return { continuationDetected: false, error: error.message };
+    }
+  }
+
+  /**
+   * Click continuation button on macOS using AppleScript
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result of operation
+   */
+  async clickContinuationButtonMacOS(ide) {
+    try {
+      const script = `
+        tell application "System Events"
+          try
+            set frontApp to first application process whose frontmost is true
+            set appName to name of frontApp
+            
+            -- Look for and click continuation buttons
+            set buttonNames to {"Continue", "Proceed", "Next", "Continue Generation", "Keep Going"}
+            
+            repeat with buttonName in buttonNames
+              try
+                set foundButtons to (buttons of frontApp whose name contains buttonName)
+                repeat with aButton in foundButtons
+                  if exists aButton then
+                    click aButton
+                    return {success:true, clicked:true, button:buttonName}
+                  end if
+                end repeat
+              end try
+            end repeat
+            
+            return {success:false, clicked:false, message:"No continuation button found"}
+          on error errMsg number errNum
+            return {success:false, errorMsg:errMsg}
+          end try
+        end tell
+      `;
+
+      const result = execSync(`osascript -e '${script}'`, { 
+        encoding: 'utf8', 
+        timeout: 10000 
+      });
+
+      return {
+        success: result.includes('success:true'),
+        clicked: result.includes('clicked:true'),
+        rawResult: result
+      };
+    } catch (error) {
+      return { success: false, clicked: false, error: error.message };
+    }
+  }
+
+  /**
+   * Click continuation button on Windows using UI automation
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result of operation
+   */
+  async clickContinuationButtonWindows(ide) {
+    try {
+      // Use Windows automation manager to click continuation buttons
+      const result = await this.windowsManager.clickContinuationButton(ide);
+      return result || { success: false, clicked: false, message: 'No result' };
+    } catch (error) {
+      return { success: false, clicked: false, error: error.message };
+    }
+  }
+
+  /**
+   * Generate AppleScript for detecting continuation buttons
+   * @param {string} buttonText - Text to search for (Continue, Proceed, etc.)
+   * @returns {string} AppleScript code
+   */
+  _getContinuationButtonScript(buttonText) {
+    return `
+      tell application "System Events"
+        set foundButton to false
+        repeat with proc in (every process)
+          try
+            repeat with w in (every window of proc)
+              try
+                repeat with btn in (every button of w)
+                  try
+                    set btnTitle to title of btn as string
+                    if btnTitle contains "${buttonText}" then
+                      set foundButton to true
+                      exit repeat
+                    end if
+                  end try
+                end repeat
+                if foundButton then exit repeat
+              end try
+            end repeat
+            if foundButton then exit repeat
+          end try
+        end repeat
+        
+        if foundButton then
+          return "${buttonText} button found"
+        else
+          return "${buttonText} button not found"
+        end if
+      end tell
+    `;
+  }
+
+  /**
+   * Generate AppleScript for clicking continuation buttons
+   * @param {string} buttonText - Text to search for (Continue, Proceed, etc.)
+   * @returns {string} AppleScript code
+   */
+  _getClickButtonScript(buttonText) {
+    return `
+      tell application "System Events"
+        repeat with proc in (every process)
+          try
+            repeat with w in (every window of proc)
+              try
+                repeat with btn in (every button of w)
+                  try
+                    set btnTitle to title of btn as string
+                    if btnTitle contains "${buttonText}" then
+                      click btn
+                      return "${buttonText} button clicked"
+                    end if
+                  end try
+                end repeat
+              end try
+            end repeat
+          end try
+        end repeat
+        
+        return "${buttonText} button not found"
+      end tell
+    `;
+  }
+}
+
+module.exports = ContinuationHandler;