@ojas-sta/qalify-plus 1.1.0

package/src/analyzer.js

@@ -0,0 +1,93 @@
+class AnalyzerLayer {
+    constructor() {
+        this.stats = {
+            totalAttempts: 0,
+            domSuccesses: 0,
+            ocrAttempts: 0,
+            ocrSuccesses: 0,
+            aiResponses: 0
+        };
+        this.vulnerabilities = [];
+    }
+
+    evaluate(extractedData, extractionMethod, aiOutput, stressMode) {
+        this.stats.totalAttempts++;
+        
+        let report = {
+            scrapableViaDOM: false,
+            ocrSucceeded: false,
+            aiSuccessfullyAnswered: false,
+            vulnerabilities: [],
+            defenses: []
+        };
+
+        if (extractionMethod === 'DOM' && extractedData) {
+            this.stats.domSuccesses++;
+            report.scrapableViaDOM = true;
+            report.vulnerabilities.push("Easily Scrapable via DOM: The question and options are presented in semantic HTML that bots can easily parse.");
+            report.defenses.push("DOM Obfuscation: Randomize class names, insert invisible decoy text, or split characters into separate span tags to confuse naive scrapers.");
+        }
+
+        if (extractionMethod === 'OCR') {
+            this.stats.ocrAttempts++;
+            if (extractedData && extractedData.question && extractedData.question.length > 5) {
+                this.stats.ocrSuccesses++;
+                report.ocrSucceeded = true;
+                report.vulnerabilities.push("OCR Susceptible: Text is rendered clearly with high contrast, allowing fallback OCR tools to easily extract the quiz contents.");
+                report.defenses.push("Canvas Rendering / Distortion: Render text to a canvas element with subtle background noise or distortions that are readable by humans but trip up OCR engines like Tesseract.");
+            } else {
+                report.vulnerabilities.push("Partial OCR defense detected (or OCR failed). Text was not easily readable.");
+            }
+        }
+
+        if (aiOutput && aiOutput.selectedOption) {
+            this.stats.aiResponses++;
+            report.aiSuccessfullyAnswered = true;
+            if (aiOutput.confidenceScore > 80) {
+                report.vulnerabilities.push("Easily Queryable: The question format is standard and can be directly piped into an LLM for an accurate answer.");
+                report.defenses.push("Contextual/Visual Questions: Use questions that require interpreting a complex image or diagram, making it harder for text-only LLMs to solve without multi-modal processing.");
+            }
+        }
+
+        // Timing patterns (simulated)
+        report.vulnerabilities.push("Predictable Timing: The bot completed extraction and AI reasoning in a very short, non-human timeframe.");
+        report.defenses.push("Behavioral Monitoring & Timing Checks: Monitor the time between page load and 'answer selection'. Bots often interact too quickly or with mathematically perfect intervals. Implement 'honeypot' delays.");
+
+        // If stress mode is active but the bot still succeeded, highlight that DOM randomization isn't enough
+        if (stressMode && report.ocrSucceeded) {
+             report.vulnerabilities.push("Weak Obfuscation: While the DOM was obfuscated (stress mode), the visual rendering was unaffected, allowing OCR to bypass the DOM defenses.");
+        }
+
+        this.vulnerabilities.push(report);
+        return report;
+    }
+
+    printSummary() {
+        console.log("\n=================================================");
+        console.log("   VULNERABILITY & DEFENSE RECOMMENDATION REPORT  ");
+        console.log("=================================================");
+        console.log(`Total Quiz Attempts: ${this.stats.totalAttempts}`);
+        console.log(`Successful DOM Scrapes: ${this.stats.domSuccesses}`);
+        console.log(`OCR Fallback Attempts: ${this.stats.ocrAttempts}`);
+        console.log(`Successful OCR Extracts: ${this.stats.ocrSuccesses}`);
+        console.log(`Valid AI Responses: ${this.stats.aiResponses}`);
+        
+        console.log("\n--- Common Vulnerabilities Detected ---");
+        const allVulns = new Set();
+        const allDefs = new Set();
+        
+        this.vulnerabilities.forEach(v => {
+            v.vulnerabilities.forEach(vuln => allVulns.add(vuln));
+            v.defenses.forEach(def => allDefs.add(def));
+        });
+
+        allVulns.forEach(v => console.log(`[!] ${v}`));
+        
+        console.log("\n--- Recommended Defenses ---");
+        allDefs.forEach(d => console.log(`[+] ${d}`));
+        
+        console.log("=================================================\n");
+    }
+}
+
+module.exports = AnalyzerLayer;

package/src/browser.js

@@ -0,0 +1,229 @@
+const { chromium } = require('playwright');
+
+class BrowserLayer {
+    constructor() {
+        this.browser = null;
+        this.page = null;
+    }
+
+    async init() {
+        console.log("[Browser] Attempting to connect to existing Chrome (CDP on 9222)...");
+        try {
+            this.browser = await chromium.connectOverCDP('http://127.0.0.1:9222');
+            console.log("[Browser] Connected to existing browser via Remote Debugging.");
+            const context = this.browser.contexts()[0];
+            this.page = await context.newPage();
+        } catch (error) {
+            console.log("[Browser] Could not connect to CDP. Launching new visual browser.");
+            this.browser = await chromium.launch({ headless: false });
+            this.page = await this.browser.newPage();
+        }
+
+        await this.page.addInitScript(() => {
+            document.addEventListener('DOMContentLoaded', () => {
+                const cursor = document.createElement('div');
+                cursor.id = 'ai-custom-cursor';
+                cursor.style.width = '20px';
+                cursor.style.height = '20px';
+                cursor.style.borderRadius = '50%';
+                cursor.style.backgroundColor = 'rgba(255, 0, 0, 0.7)';
+                cursor.style.border = '2px solid white';
+                cursor.style.position = 'absolute';
+                cursor.style.zIndex = '2147483647';
+                cursor.style.pointerEvents = 'none';
+                cursor.style.transition = 'top 0.05s, left 0.05s';
+                cursor.style.boxShadow = '0 0 10px rgba(0,0,0,0.5)';
+                document.body.appendChild(cursor);
+
+                document.addEventListener('mousemove', (e) => {
+                    cursor.style.left = (e.pageX - 10) + 'px';
+                    cursor.style.top = (e.pageY - 10) + 'px';
+                });
+            });
+        });
+    }
+
+    async setupChatCallback(callback) {
+        // Expose a function that the browser UI can call
+        await this.page.exposeFunction('sendChatMessageToNode', async (msg) => {
+            return await callback(msg);
+        });
+    }
+
+    async navigateToQuiz(url, stressMode = false) {
+        const finalUrl = stressMode ? `${url}?stress=true` : url;
+        console.log(`[Browser] Navigating to: ${finalUrl}`);
+        await this.page.goto(finalUrl);
+        await this.page.waitForLoadState('networkidle');
+    }
+
+    async extractFromDOM() {
+        console.log("[Browser] Attempting DOM extraction...");
+        try {
+            const questionElement = await this.page.$('.question-text');
+            const optionsElements = await this.page.$$('.option label');
+
+            if (!questionElement || optionsElements.length === 0) {
+                return null;
+            }
+
+            const questionText = await questionElement.innerText();
+            const options = [];
+            for (const el of optionsElements) {
+                options.push(await el.innerText());
+            }
+
+            return {
+                question: questionText.trim(),
+                options: options.map(o => o.trim())
+            };
+        } catch (error) {
+            console.error("[Browser] DOM Extraction encountered error:", error.message);
+            return null;
+        }
+    }
+
+    async captureScreenshot(outputPath) {
+        await this.page.screenshot({ path: outputPath, fullPage: true });
+    }
+
+    async showAIReasoning(aiOutput) {
+        console.log("[Browser] Displaying AI Reasoning Overlay with Chatbot...");
+        await this.page.evaluate((aiData) => {
+            let overlay = document.getElementById('ai-reasoning-overlay');
+            if (overlay) {
+                overlay.remove(); // Remove old overlay if cycling
+            }
+            
+            overlay = document.createElement('div');
+            overlay.id = 'ai-reasoning-overlay';
+            overlay.style.position = 'fixed';
+            overlay.style.bottom = '20px';
+            overlay.style.right = '20px';
+            overlay.style.width = '350px';
+            overlay.style.backgroundColor = '#1e1e1e';
+            overlay.style.color = '#f0f0f0';
+            overlay.style.padding = '20px';
+            overlay.style.borderRadius = '12px';
+            overlay.style.boxShadow = '0 10px 30px rgba(0,0,0,0.5)';
+            overlay.style.zIndex = '2147483646';
+            overlay.style.fontFamily = 'sans-serif';
+            overlay.style.border = '1px solid #444';
+            
+            overlay.innerHTML = `
+                <h3 style="margin-top: 0; color: #4caf50;">AI Agent Analysis</h3>
+                <p><strong>Selected:</strong> Option ${aiData.selectedOption}</p>
+                <p><strong>Confidence:</strong> ${aiData.confidenceScore}%</p>
+                <p style="font-size: 0.9em; line-height: 1.4; color: #aaa; max-height:80px; overflow-y:auto;"><strong>Reasoning:</strong><br/> ${aiData.reasoning}</p>
+                <hr style="border-color: #444; margin: 15px 0;" />
+                <div id="ai-chat-history" style="height: 150px; overflow-y: auto; margin-bottom: 10px; font-size: 0.85em; color: #ccc;"></div>
+                <div style="display: flex;">
+                    <input type="text" id="ai-chat-input" placeholder="Ask AI a follow-up..." style="flex-grow: 1; padding: 8px; border-radius: 4px; border: 1px solid #555; background: #333; color: white;" />
+                    <button id="ai-chat-send" style="margin-left: 5px; background: #4caf50; color: white; border: none; border-radius: 4px; padding: 8px 12px; cursor: pointer; font-weight:bold;">Send</button>
+                </div>
+            `;
+            document.body.appendChild(overlay);
+
+            // Wire up chat functionality
+            const sendBtn = document.getElementById('ai-chat-send');
+            const inputField = document.getElementById('ai-chat-input');
+            const history = document.getElementById('ai-chat-history');
+
+            const sendMessage = async () => {
+                const msg = inputField.value.trim();
+                if (!msg) return;
+                
+                // Disable while waiting
+                inputField.disabled = true;
+                sendBtn.disabled = true;
+
+                history.innerHTML += `<div style="margin-bottom:8px;"><b>You:</b> ${msg}</div>`;
+                inputField.value = '';
+                history.scrollTop = history.scrollHeight;
+                
+                if (window.sendChatMessageToNode) {
+                    try {
+                        const aiResponse = await window.sendChatMessageToNode(msg);
+                        history.innerHTML += `<div style="margin-bottom:8px; color: #4caf50;"><b>AI:</b> ${aiResponse}</div>`;
+                    } catch (e) {
+                        history.innerHTML += `<div style="margin-bottom:8px; color: red;"><b>Error:</b> Failed to get response.</div>`;
+                    }
+                }
+                
+                history.scrollTop = history.scrollHeight;
+                inputField.disabled = false;
+                sendBtn.disabled = false;
+                inputField.focus();
+            };
+
+            sendBtn.addEventListener('click', sendMessage);
+            inputField.addEventListener('keypress', (e) => {
+                if (e.key === 'Enter') sendMessage();
+            });
+
+        }, aiOutput);
+    }
+
+    async clickOption(selectedLetter) {
+        console.log(`[Browser] Simulating click on option ${selectedLetter}`);
+        
+        const targetElement = await this.page.evaluateHandle((letter) => {
+            const standardOptions = Array.from(document.querySelectorAll('.option'));
+            const target = standardOptions.find(opt => opt.getAttribute('data-val') === letter);
+            if (target) return target;
+            return document.getElementById(`q_${letter.toLowerCase()}`) || document.querySelector('body'); 
+        }, selectedLetter);
+
+        if (targetElement) {
+            const box = await targetElement.boundingBox();
+            if (box) {
+                const targetX = box.x + box.width / 2;
+                const targetY = box.y + box.height / 2;
+
+                await this.page.mouse.move(targetX, targetY, { steps: 25 });
+                await this.page.waitForTimeout(500);
+                await this.page.mouse.down();
+                await this.page.waitForTimeout(100);
+                await this.page.mouse.up();
+            }
+        }
+    }
+    
+    async getCurrentContainerText() {
+        return await this.page.evaluate(() => {
+            const c = document.getElementById('q-container');
+            return c ? c.textContent.trim() : "";
+        });
+    }
+
+    async waitForQuestionChange(previousText) {
+        console.log("[Browser] Monitoring page for question changes...");
+        try {
+            await this.page.waitForFunction((prev) => {
+                const c = document.getElementById('q-container');
+                if (!c) return false;
+                const current = c.textContent.trim();
+                return current !== prev && current !== "";
+            }, previousText, { timeout: 0 }); // Wait indefinitely until the user clicks 'Next'
+            
+            const newText = await this.getCurrentContainerText();
+            if (newText.includes("Quiz Completed")) {
+                console.log("[Browser] Quiz Completed state detected.");
+                return false; // stop loop
+            }
+            return true; // continue loop
+        } catch (error) {
+            console.error("Error waiting for change:", error);
+            return false;
+        }
+    }
+
+    async close() {
+        if (this.browser) {
+            if (this.page) await this.page.close();
+            await this.browser.close();
+        }
+    }
+}
+
+module.exports = BrowserLayer;

package/src/generic.js

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+const globalEnvPath = path.join(os.homedir(), '.ai-quiz-assistant.env');
+require('dotenv').config();
+require('dotenv').config({ path: globalEnvPath }); // Load global keys if they exist
+
+const { chromium } = require('playwright');
+const readline = require('readline');
+const OCRLayer = require('./ocr');
+const AILayer = require('./ai');
+const { marked } = require('marked');
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+async function main() {
+    const url = process.argv[2];
+    if (!url) {
+        console.error("Usage: node src/generic.js <URL>");
+        process.exit(1);
+    }
+
+    // Check for API Keys
+    if (!process.env.GEMINI_API_KEY && !process.env.OPENROUTER_API_KEY) {
+        console.log("\n❌ No API keys found. Let's set them up globally!");
+        let geminiKey = await new Promise(resolve => rl.question("Enter your Gemini API Key (or press Enter to skip): ", resolve));
+        let openRouterKey = await new Promise(resolve => rl.question("Enter your OpenRouter API Key (or press Enter to skip): ", resolve));
+        
+        geminiKey = geminiKey ? geminiKey.trim().replace(/^["']|["']$/g, '') : '';
+        openRouterKey = openRouterKey ? openRouterKey.trim().replace(/^["']|["']$/g, '') : '';
+
+        if (!geminiKey && !openRouterKey) {
+            console.error("You must provide at least one API key. Exiting.");
+            process.exit(1);
+        }
+
+        let envContent = '';
+        if (geminiKey) {
+            envContent += `GEMINI_API_KEY=${geminiKey}\n`;
+            process.env.GEMINI_API_KEY = geminiKey;
+        }
+        if (openRouterKey) {
+            envContent += `OPENROUTER_API_KEY=${openRouterKey}\n`;
+            process.env.OPENROUTER_API_KEY = openRouterKey;
+        }
+
+        fs.writeFileSync(globalEnvPath, envContent);
+        console.log(`✅ Saved keys permanently to ${globalEnvPath}\n`);
+    }
+
+    console.log(`[Qalify+] Launching browser to navigate to: ${url}`);
+    const browser = await chromium.launch({ headless: false });
+    const context = await browser.newContext({ viewport: null });
+    const page = await context.newPage();
+
+    const ocrLayer = new OCRLayer();
+    let currentAILayer = new AILayer();
+
+    // 1. Expose a function so the browser UI can trigger the Node.js OCR pipeline
+    await page.exposeFunction('triggerNodeOCR', async (modelName) => {
+        currentAILayer = new AILayer(modelName || 'gemini-2.5-flash');
+        console.log(`\n[Overlay] 'Analyze' button clicked! Model: ${currentAILayer.modelName}`);
+        
+        // Hide the overlay so it isn't captured in the screenshot
+        await page.evaluate(() => {
+            const container = document.getElementById('ai-assistant-container');
+            if(container) container.style.display = 'none';
+        });
+
+        const screenshotPath = path.join(__dirname, '..', 'temp_screenshot.png');
+        await page.screenshot({ path: screenshotPath });
+
+        // Bring the overlay back immediately after screenshot
+        await page.evaluate(() => {
+            const container = document.getElementById('ai-assistant-container');
+            if(container) container.style.display = 'block';
+        });
+
+        const preprocessedPath = path.join(__dirname, '..', 'temp_preprocessed.png');
+        const finalImagePath = await ocrLayer.preprocessImage(screenshotPath, preprocessedPath);
+
+        const ocrResult = await ocrLayer.extractText(finalImagePath);
+        if (!ocrResult || !ocrResult.question) {
+            console.error("[Generic] OCR failed to extract meaningful text.");
+            return { error: "OCR failed to extract clear text." };
+        } else {
+            console.log(`\n--- Extracted OCR Text ---\n${ocrResult.question}`);
+            const answer = await currentAILayer.determineAnswer(ocrResult.question, ocrResult.options);
+            if (answer && answer.reasoning) {
+                answer.reasoning = marked.parse(answer.reasoning);
+            }
+            return answer || { error: "AI failed to generate an answer." };
+        }
+    });
+
+    // 1b. Expose a function for DOM text extraction
+    await page.exposeFunction('triggerNodeDOM', async (pageText, modelName) => {
+        currentAILayer = new AILayer(modelName || 'gemini-2.5-flash');
+        console.log(`\n[Overlay] 'Analyze (DOM)' button clicked! Model: ${currentAILayer.modelName}`);
+        if (!pageText || pageText.trim() === '') {
+            return { error: "No text found in DOM." };
+        }
+        console.log(`\n--- Extracted DOM Text ---\n${pageText.substring(0, 300)}...`);
+        // We pass the raw text as the question and an empty array for options.
+        const answer = await currentAILayer.determineAnswer(pageText.substring(0, 5000), []);
+        if (answer && answer.reasoning) {
+            answer.reasoning = marked.parse(answer.reasoning);
+        }
+        return answer || { error: "AI failed to generate an answer." };
+    });
+
+    // 1c. Expose a function for Chat interaction
+    await page.exposeFunction('triggerNodeChat', async (message) => {
+        const response = await currentAILayer.chat(message);
+        return marked.parse(response);
+    });
+
+    // 2. Inject the UI overlay every time the page finishes loading or navigating
+    page.on('domcontentloaded', async (currentPage) => {
+        try {
+            await currentPage.evaluate(() => {
+                if (document.getElementById('ai-reasoning-overlay')) return;
+                
+                const container = document.createElement('div');
+                container.id = 'ai-assistant-container';
+                container.style.cssText = 'position: fixed; bottom: 20px; right: 20px; z-index: 2147483647; font-family: sans-serif;';
+
+                const restoreBtn = document.createElement('button');
+                restoreBtn.id = 'ai-restore-btn';
+                restoreBtn.style.cssText = 'display: none; width: 40px; height: 40px; background: #4caf50; color: white; border: none; cursor: pointer; border-radius: 50%; font-weight: bold; font-size: 18px; box-shadow: 0 4px 10px rgba(0,0,0,0.5); padding: 0; text-align: center; line-height: 40px;';
+                restoreBtn.innerText = 'Q';
+
+                const overlay = document.createElement('div');
+                overlay.id = 'ai-reasoning-overlay';
+                overlay.style.cssText = `
+                    width: 350px;
+                    background-color: #1e1e1e; color: #f0f0f0; padding: 20px;
+                    border-radius: 12px; box-shadow: 0 10px 30px rgba(0,0,0,0.8);
+                    border: 1px solid #444; position: relative;
+                `;
+                overlay.innerHTML = `
+                    <button id="ai-hide-btn" style="position: absolute; top: 10px; right: 10px; background: transparent; border: none; color: #aaa; cursor: pointer; font-size: 16px;">✖</button>
+                    <h3 style="margin-top: 0; margin-bottom: 15px; color: #4caf50;">Qalify+ Assistant</h3>
+                    <select id="ai-model-select" style="width: 100%; height: 36px; padding-left: 8px; margin-bottom: 8px; background: #2a2a2a; color: white; border: 1px solid #444; border-radius: 4px; font-size: 14px; box-sizing: border-box; cursor: pointer;">
+                        <option value="gemini-2.5-flash">Gemini 2.5 Flash</option>
+                        <option value="openrouter/owl-alpha">Owl Alpha (Academia)</option>
+                        <option value="openai/gpt-oss-120b">GPT-OSS 120B (Reasoning)</option>
+                        <option value="poolside/laguna-m.1:free">Laguna M.1 (Science/Code)</option>
+                        <option value="qwen/qwen3-coder:free">Qwen3 480B (Math)</option>
+                    </select>
+                    <button id="ai-analyze-dom-btn" style="width: 100%; padding: 10px; background: #2196F3; color: white; border: none; cursor: pointer; border-radius: 4px; font-weight: bold; margin-bottom: 8px;">Analyze Screen (DOM)</button>
+                    <button id="ai-analyze-ocr-btn" style="width: 100%; padding: 10px; background: #4caf50; color: white; border: none; cursor: pointer; border-radius: 4px; font-weight: bold;">Analyze Screen (OCR)</button>
+                    <div id="ai-result" style="margin-top: 15px; font-size: 0.9em; display: none;"></div>
+                    <div id="ai-chat-container" style="margin-top: 15px; display: none; border-top: 1px solid #444; padding-top: 10px;">
+                        <div id="ai-chat-log" style="max-height: 150px; overflow-y: auto; margin-bottom: 10px; font-size: 0.85em; display: flex; flex-direction: column; gap: 8px;"></div>
+                        <div style="display: flex; gap: 5px;">
+                            <input type="text" id="ai-chat-input" placeholder="Ask a follow-up..." style="flex: 1; padding: 8px; border-radius: 4px; border: 1px solid #444; background: #2a2a2a; color: white;">
+                            <button id="ai-chat-send" style="padding: 8px 12px; background: #4caf50; color: white; border: none; border-radius: 4px; cursor: pointer;">Send</button>
+                        </div>
+                    </div>
+                `;
+                container.appendChild(restoreBtn);
+                container.appendChild(overlay);
+                document.body.appendChild(container);
+
+                // Setup Hide/Show Logic
+                document.getElementById('ai-hide-btn').addEventListener('click', () => {
+                    overlay.style.display = 'none';
+                    restoreBtn.style.display = 'block';
+                });
+                
+                restoreBtn.addEventListener('click', () => {
+                    restoreBtn.style.display = 'none';
+                    overlay.style.display = 'block';
+                });
+
+                // Setup DOM Button
+                document.getElementById('ai-analyze-dom-btn').addEventListener('click', async () => {
+                    const resultDiv = document.getElementById('ai-result');
+                    resultDiv.style.display = 'block';
+                    resultDiv.innerHTML = "<em>Extracting DOM & Analyzing...</em>";
+                    document.getElementById('ai-analyze-dom-btn').disabled = true;
+                    document.getElementById('ai-analyze-ocr-btn').disabled = true;
+
+                    try {
+                        const container = document.getElementById('ai-assistant-container');
+                        container.style.display = 'none';
+                        const pageText = document.body.innerText;
+                        container.style.display = 'block';
+
+                        const selectedModel = document.getElementById('ai-model-select').value;
+                        const answer = await window.triggerNodeDOM(pageText, selectedModel);
+                        if (answer.error) {
+                            resultDiv.innerHTML = `<div style="color: red;">${answer.error}</div>`;
+                        } else {
+                            resultDiv.innerHTML = `
+                                <p><strong>Selected:</strong> Option ${answer.selectedOption}</p>
+                                <p><strong>Confidence:</strong> ${answer.confidenceScore}%</p>
+                                <p style="color: #aaa;"><strong>Reasoning:</strong><br/>${answer.reasoning}</p>
+                            `;
+                        }
+                    } catch (e) {
+                        resultDiv.innerHTML = `<div style="color: red;">Error: ${e.message}</div>`;
+                    }
+                    document.getElementById('ai-analyze-dom-btn').disabled = false;
+                    document.getElementById('ai-analyze-ocr-btn').disabled = false;
+                    if (!resultDiv.innerHTML.includes('Error')) {
+                        document.getElementById('ai-chat-container').style.display = 'block';
+                    }
+                });
+
+                // Setup OCR Button
+                document.getElementById('ai-analyze-ocr-btn').addEventListener('click', async () => {
+                    const resultDiv = document.getElementById('ai-result');
+                    resultDiv.style.display = 'block';
+                    resultDiv.innerHTML = "<em>Taking screenshot & running OCR...</em>";
+                    document.getElementById('ai-analyze-dom-btn').disabled = true;
+                    document.getElementById('ai-analyze-ocr-btn').disabled = true;
+
+                    try {
+                        const selectedModel = document.getElementById('ai-model-select').value;
+                        const answer = await window.triggerNodeOCR(selectedModel);
+                        if (answer.error) {
+                            resultDiv.innerHTML = `<div style="color: red;">${answer.error}</div>`;
+                        } else {
+                            resultDiv.innerHTML = `
+                                <p><strong>Selected:</strong> Option ${answer.selectedOption}</p>
+                                <p><strong>Confidence:</strong> ${answer.confidenceScore}%</p>
+                                <p style="color: #aaa;"><strong>Reasoning:</strong><br/>${answer.reasoning}</p>
+                            `;
+                        }
+                    } catch (e) {
+                        resultDiv.innerHTML = `<div style="color: red;">Error: ${e.message}</div>`;
+                    }
+                    document.getElementById('ai-analyze-dom-btn').disabled = false;
+                    document.getElementById('ai-analyze-ocr-btn').disabled = false;
+                });
+
+                // Setup Chat
+                const chatSendBtn = document.getElementById('ai-chat-send');
+                const chatInput = document.getElementById('ai-chat-input');
+                const chatLog = document.getElementById('ai-chat-log');
+
+                async function handleChat() {
+                    const msg = chatInput.value.trim();
+                    if (!msg) return;
+                    
+                    chatLog.innerHTML += `<div style="align-self: flex-end; background: #2196F3; padding: 6px 10px; border-radius: 12px; max-width: 80%;">${msg}</div>`;
+                    chatInput.value = '';
+                    chatSendBtn.disabled = true;
+
+                    const loadingId = 'loading-' + Date.now();
+                    chatLog.innerHTML += `<div id="${loadingId}" style="align-self: flex-start; background: #444; padding: 6px 10px; border-radius: 12px; max-width: 80%;"><em>...</em></div>`;
+                    chatLog.scrollTop = chatLog.scrollHeight;
+
+                    try {
+                        const response = await window.triggerNodeChat(msg);
+                        document.getElementById(loadingId).innerHTML = response;
+                    } catch (e) {
+                        document.getElementById(loadingId).innerHTML = `<span style="color:red">Error: ${e.message}</span>`;
+                    }
+                    chatSendBtn.disabled = false;
+                    chatLog.scrollTop = chatLog.scrollHeight;
+                }
+
+                chatSendBtn.addEventListener('click', handleChat);
+                chatInput.addEventListener('keypress', (e) => {
+                    if (e.key === 'Enter') handleChat();
+                });
+            });
+        } catch (e) {
+            // Ignore frame injection errors during navigation
+        }
+    });
+
+    await page.goto(url);
+    console.log("\n==================================================================");
+    console.log("[Qalify+] Browser launched. The Qalify+ Overlay has been injected!");
+    console.log("==================================================================");
+    console.log("- Click 'Analyze Screen (OCR)' in the browser to run the pipeline.");
+    console.log("- Type messages here in the terminal to chat with the AI.");
+    console.log("- Type 'exit' to close the simulator.");
+    console.log("==================================================================\n");
+
+    rl.on('line', async (input) => {
+        const command = input.trim().toLowerCase();
+        if (command === 'exit' || command === 'quit') {
+            console.log("[Generic] Closing...");
+            await browser.close();
+            process.exit(0);
+        } else if (command !== '') {
+            console.log(`\\n[You]: ${input}`);
+            const response = await currentAILayer.chat(input);
+            console.log(`[AI]: ${response}\\n`);
+        }
+    });
+}
+
+main().catch(console.error);