browser-assistant 0.0.0-stage → 2.8.1

package/extension/background.js

@@ -0,0 +1,284 @@
+// Background script for Browser Assistant
+importScripts('editor-bridge.js');
+// Local unpacked development updates: only reload when the files in Chrome's
+// own extension folder match the workspace release, and every running task is idle.
+let updateCheckRunning = false;
+async function checkWorkspaceUpdate() {
+    if (updateCheckRunning)
+        return;
+    updateCheckRunning = true;
+    try {
+        const release = await fetch('http://127.0.0.1:8000/extension-release', { cache: 'no-store', signal: AbortSignal.timeout(4000) }).then(r => r.ok ? r.json() : null);
+        const current = chrome.runtime.getManifest().version;
+        if (!release?.version || release.version === current)
+            return;
+        const disk = await fetch(chrome.runtime.getURL('manifest.json'), { cache: 'no-store' }).then(r => r.json());
+        // Never loop reloading an old ZIP extraction. Load the workspace's
+        // extension directory once to enable local file updates.
+        if (disk.version !== release.version)
+            return;
+        const tabs = (await chrome.tabs.query({})).filter(tab => /^https?:\/\//.test(tab.url || ''));
+        const states = await Promise.all(tabs.map(async (tab) => {
+            try {
+                return { tab, state: await chrome.tabs.sendMessage(tab.id, { action: 'assistantUpdateStatus' }) };
+            }
+            catch {
+                return { tab, state: null };
+            }
+        }));
+        if (states.some(item => item.state?.busy))
+            return;
+        for (const { tab, state } of states) {
+            if (!state)
+                continue;
+            const prepared = await chrome.tabs.sendMessage(tab.id, { action: 'assistantPrepareUpdate' });
+            if (!prepared?.ready) {
+                await attachUpdatedPanels();
+                return;
+            }
+        }
+        chrome.runtime.reload();
+    }
+    catch { /* Offline server or restricted tab: retry on the next alarm. */ }
+    finally {
+        updateCheckRunning = false;
+    }
+}
+async function attachUpdatedPanels() {
+    const manifest = chrome.runtime.getManifest();
+    const tabs = (await chrome.tabs.query({})).filter(tab => /^https?:\/\//.test(tab.url || ''));
+    for (const tab of tabs) {
+        try {
+            const existing = await chrome.scripting.executeScript({ target: { tabId: tab.id }, func: () => Boolean(document.getElementById('assistant-root')) });
+            if (existing[0]?.result)
+                continue;
+            for (const group of manifest.content_scripts) {
+                await chrome.scripting.insertCSS({ target: { tabId: tab.id }, files: group.css || [] });
+                await chrome.scripting.executeScript({ target: { tabId: tab.id }, files: group.js });
+            }
+        }
+        catch { /* Chrome may restrict particular sites; leave them alone. */ }
+    }
+}
+chrome.alarms.create('assistant-workspace-update', { periodInMinutes: 1 });
+chrome.alarms.onAlarm.addListener(alarm => { if (alarm.name === 'assistant-workspace-update')
+    void checkWorkspaceUpdate(); });
+chrome.runtime.onInstalled.addListener(() => { void attachUpdatedPanels(); });
+chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
+    if (!request || typeof request.action !== 'string') {
+        sendResponse({ error: 'Invalid extension message' });
+        return false;
+    }
+    if (request.action === 'questionImage') {
+        let url;
+        try {
+            url = new URL(request.url);
+        }
+        catch { }
+        if (sender.id !== chrome.runtime.id || !sender.tab || !/^https?:/.test(sender.url || '')
+            || !url || !['https:', 'http:'].includes(url.protocol) || url.username || url.password) {
+            sendResponse({ error: 'Question image access is not authorized.' });
+            return false;
+        }
+        (async () => {
+            const response = await fetch(url.href, { credentials: 'omit', signal: AbortSignal.timeout(10000) });
+            if (!response.ok || !response.headers.get('content-type')?.startsWith('image/'))
+                throw new Error('Question image download failed.');
+            if (Number(response.headers.get('content-length')) > 10000000)
+                throw new Error('Question image is too large.');
+            const reader = response.body.getReader();
+            const parts = [];
+            let size = 0;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                size += value.length;
+                if (size > 10000000) {
+                    await reader.cancel();
+                    throw new Error('Question image is too large.');
+                }
+                parts.push(value);
+            }
+            let binary = '';
+            for (const part of parts)
+                for (let i = 0; i < part.length; i += 8192)
+                    binary += String.fromCharCode(...part.subarray(i, i + 8192));
+            return { dataUrl: `data:${response.headers.get('content-type').split(';')[0]};base64,${btoa(binary)}` };
+        })().then(sendResponse).catch(error => sendResponse({ error: error.message }));
+        return true;
+    }
+    if (request.action === 'mcqSnippets') {
+        let allowed = false;
+        // Chrome's document URL may retain the route where this SPA first
+        // loaded. This read-only bridge must also work after in-page navigation
+        // and on review routes. Keep the exact portal origin and sender checks;
+        // use the tab URL only for a top frame with no document URL.
+        try {
+            const topFrame = sender.frameId === undefined || sender.frameId === 0;
+            const url = new URL(sender.url || (topFrame ? sender.tab?.url : ''));
+            allowed = url.origin === 'https://learning.ccbp.in';
+        }
+        catch { }
+        if (!sender.tab || sender.id !== chrome.runtime.id || !allowed) {
+            sendResponse({ ok: false, error: 'Full snippet access is unavailable on this page/frame.' });
+            return false;
+        }
+        chrome.scripting.executeScript({ target: { tabId: sender.tab.id, frameIds: [sender.frameId || 0] }, world: 'MAIN', func: browserAssistantReadMcqSnippets })
+            .then(results => sendResponse(results[0]?.result || { ok: false, error: results[0]?.error?.message || 'The snippet reader returned no result. The page may still be loading.' }))
+            .catch(error => sendResponse({ ok: false, error: error.message }));
+        return true;
+    }
+    if (request.action === 'orderingDrag') {
+        if (!sender.tab || sender.id !== chrome.runtime.id || !sender.url?.startsWith('https://learning.ccbp.in/')) {
+            sendResponse({ ok: false });
+            return false;
+        }
+        chrome.scripting.executeScript({
+            target: { tabId: sender.tab.id, frameIds: [sender.frameId || 0] }, world: 'MAIN',
+            func: browserAssistantOrderingDrag, args: [request.prompt, request.options, request.from, request.to],
+        }).then(results => sendResponse(results[0]?.result || { ok: false }))
+            .catch(error => sendResponse({ ok: false, error: error.message }));
+        return true;
+    }
+    if (['focusOnlineIde', 'runOnlineIde', 'onlineIdeStatus'].includes(request.action)) {
+        const questionPath = /^\/question\/([a-f0-9-]{36})\/?$/i;
+        let questionId;
+        try {
+            const page = new URL(sender.tab.url || sender.url);
+            const source = new URL(sender.url);
+            if (page.origin === 'https://learning.ccbp.in' && source.origin === page.origin) {
+                questionId = page.pathname.match(questionPath)?.[1];
+            }
+        }
+        catch { /* Only a portal question tab can request its IDE. */ }
+        if (!questionId || sender.id !== chrome.runtime.id || sender.frameId > 0) {
+            sendResponse({ ok: false, error: 'Online IDE access requires the portal question tab.' });
+            return false;
+        }
+        (async () => {
+            const tabs = await chrome.tabs.query({ windowId: sender.tab.windowId });
+            const matches = tabs.filter(tab => {
+                try {
+                    const url = new URL(tab.url || tab.pendingUrl);
+                    return url.origin === 'https://learning.ccbp.in' && /^\/ide\/[a-z0-9]+\/?$/i.test(url.pathname)
+                        && url.searchParams.get('q_id') === questionId;
+                }
+                catch {
+                    return false;
+                }
+            });
+            const ide = matches.find(tab => tab.active) || matches[0];
+            if (request.action !== 'focusOnlineIde') {
+                if (!ide || matches.length !== 1)
+                    return { ok: false, error: 'A unique IDE tab for this question is required.' };
+                const workspace = new URL(ide.url || ide.pendingUrl).pathname.split('/')[2];
+                if (request.workspace !== workspace || !/^[a-z0-9]{6,24}$/i.test(workspace)
+                    || !/^[a-f0-9-]{36}$/.test(request.token || ''))
+                    return { ok: false, error: 'The portal submit command and IDE workspace do not match.' };
+                if (request.action === 'runOnlineIde' && (!ide.active || typeof request.code !== 'string'
+                    || !request.code.trim() || new TextEncoder().encode(request.code).length > 12000)) {
+                    return { ok: false, error: 'The matching IDE must be active and the source must fit the terminal input limit.' };
+                }
+                const results = await chrome.scripting.executeScript({ target: { tabId: ide.id, allFrames: true }, world: 'MAIN',
+                    func: browserAssistantOnlineIdeTerminal,
+                    args: [request.action, workspace, questionId, request.token, request.action === 'runOnlineIde' ? request.code : null] });
+                const frameResults = results.map(entry => entry.result).filter(Boolean);
+                return frameResults.length === 1 ? frameResults[0] : { ok: false, retry: true, error: 'The IDE workspace is still opening.' };
+            }
+            if (ide && !ide.active)
+                await chrome.tabs.update(ide.id, { active: true });
+            return { ok: true, found: Boolean(ide) };
+        })().then(sendResponse).catch(error => sendResponse({ ok: false, error: error.message }));
+        return true;
+    }
+    if (request.action === 'codingEditor') {
+        let protocol = '';
+        try {
+            protocol = new URL(sender.url).protocol;
+        }
+        catch { /* Invalid senders are rejected below. */ }
+        if (!sender.tab || sender.id !== chrome.runtime.id || !['https:', 'http:'].includes(protocol)
+            || !['read', 'write', 'readProject', 'writeProject'].includes(request.operation)
+            || (request.operation.endsWith('Project') && new URL(sender.url).origin !== 'https://learning.ccbp.in')) {
+            sendResponse({ ok: false, error: 'Editor access is not authorized.' });
+            return false;
+        }
+        chrome.scripting.executeScript({
+            target: { tabId: sender.tab.id, frameIds: [sender.frameId || 0] }, world: 'MAIN',
+            func: browserAssistantEditor, args: [request.operation, request.selector, request.expected ?? null, request.value ?? null],
+        }).then(results => sendResponse(results[0]?.result || { ok: false, error: 'Editor unavailable.' }))
+            .catch(error => sendResponse({ ok: false, error: error.message }));
+        return true;
+    }
+    if (request.action === "captureVisibleTab") {
+        if (sender.id !== chrome.runtime.id || !sender.tab || !/^https?:\/\//.test(sender.url || sender.tab.url || '')) {
+            sendResponse({ error: 'Screenshot access is not authorized.' });
+            return false;
+        }
+        // A tab can lose focus while capture is queued. Never capture another
+        // tab/window and send that screenshot with the requesting page's URL.
+        chrome.tabs.query({ active: true, windowId: sender.tab.windowId }).then(active => {
+            if (active.length !== 1 || active[0].id !== sender.tab.id) {
+                sendResponse({ error: 'The requesting tab is no longer active. Focus it and try Vision Scan again.' });
+                return;
+            }
+            chrome.tabs.captureVisibleTab(sender.tab.windowId, { format: "png" }, (dataUrl) => {
+                if (chrome.runtime.lastError) {
+                    console.error("Capture failed:", chrome.runtime.lastError.message);
+                    sendResponse({ error: chrome.runtime.lastError.message });
+                }
+                else {
+                    sendResponse({ dataUrl: dataUrl });
+                }
+            });
+        }).catch(() => sendResponse({ error: 'Could not verify the active screenshot tab.' }));
+        return true; // Keep the message channel open for async response
+    }
+    if (request.action === "apiRequest") {
+        const allowedMethods = { '/health': ['GET'], '/solve': ['POST'], '/solve-vision': ['POST'],
+            '/history': ['GET', 'POST', 'DELETE'], '/journal': ['POST'] };
+        const method = request.method || 'POST';
+        if (sender.id !== chrome.runtime.id || !allowedMethods[request.path]?.includes(method)) {
+            sendResponse({ error: "Blocked API sender, path or method" });
+            return false;
+        }
+        let body;
+        try {
+            body = request.body === undefined ? undefined : JSON.stringify(request.body);
+        }
+        catch {
+            sendResponse({ error: 'Invalid API request body' });
+            return false;
+        }
+        // Chrome documents an API pulse for bounded long-running operations.
+        // Keep only an active inference request alive; never run an idle timer.
+        const longRequest = ['/solve', '/solve-vision', '/journal'].includes(request.path);
+        const keepAlive = longRequest && typeof chrome.runtime.getPlatformInfo === 'function'
+            ? setInterval(() => chrome.runtime.getPlatformInfo(() => { void chrome.runtime.lastError; }), 25000) : null;
+        fetch(`http://127.0.0.1:8000${request.path}`, {
+            signal: AbortSignal.timeout(['/solve', '/solve-vision', '/journal'].includes(request.path) ? 360000 : 8000),
+            method,
+            headers: { "Content-Type": "application/json" },
+            body,
+        })
+            .then(async (response) => {
+            const text = await response.text();
+            let data;
+            try {
+                data = text ? JSON.parse(text) : {};
+            }
+            catch {
+                data = { detail: text || "Unexpected server response" };
+            }
+            sendResponse({ ok: response.ok, status: response.status, data });
+        })
+            .catch(error => sendResponse({ error: error.name === 'TimeoutError' ? 'Local server request timed out.' : 'Local server is offline. Start it with: python main.py' }))
+            .finally(() => { if (keepAlive !== null)
+            clearInterval(keepAlive); });
+        return true;
+    }
+    // Unknown action — respond immediately so the sender doesn't hang
+    sendResponse({ error: `Unknown action: ${request.action}` });
+    return false;
+});

package/extension/coding-automation.js

@@ -0,0 +1,209 @@
+// Coding detection is separate from the existing MCQ adapters.
+(function () {
+    const visible = element => element.getClientRects().length > 0 && !element.closest('#assistant-root');
+    const text = element => (element?.innerText || element?.textContent || '').trim();
+    const editorSelector = '.monaco-editor,.ace_editor,.CodeMirror,textarea[data-code-editor],textarea[name="code"],textarea[id="code"]';
+    let detectionError = '';
+    let editorSequence = 0;
+    const editorIds = new WeakMap();
+    function unavailable(message) { detectionError = message; return null; }
+    function isReadOnly(editor) {
+        return editor.matches('[readonly],[disabled],[aria-readonly="true"],.ace_read-only,.cm-readonly')
+            || Boolean(editor.querySelector('textarea[readonly],textarea[disabled],[contenteditable="false"][role="textbox"]'));
+    }
+    function chooseEditor(editors, doc) {
+        const editable = editors.filter(editor => !isReadOnly(editor));
+        if (editable.length === 1)
+            return editable[0];
+        // Example inputs/outputs can themselves be Ace editors. The solution
+        // editor has its own Run/Submit controls; never choose by size or order.
+        const candidates = editable.filter(editor => {
+            for (let scope = editor.parentElement; scope && scope !== doc.body; scope = scope.parentElement) {
+                if (editable.filter(candidate => scope.contains(candidate)).length !== 1)
+                    break;
+                const actions = [...scope.querySelectorAll('button,[role="button"]')].filter(visible);
+                if (actions.some(action => /^(run|run code|submit|submit code|submit solution)$/i.test(text(action))))
+                    return true;
+            }
+            return false;
+        });
+        return candidates.length === 1 ? candidates[0] : null;
+    }
+    function selectorFor(editor) {
+        if (!editorIds.has(editor))
+            editorIds.set(editor, `editor-${++editorSequence}`);
+        const id = editorIds.get(editor);
+        editor.setAttribute('data-browser-assistant-editor', id);
+        return `[data-browser-assistant-editor="${id}"]`;
+    }
+    // Some practice pages use generated CSS classes and plain text labels.
+    // Find the Description pane by its visible content, keeping editor/sidebar text out.
+    function findDescription(doc, editor) {
+        const anchors = [...doc.querySelectorAll('h1,h2,h3,h4,p,span,div,button,[role="tab"]')]
+            .filter(element => visible(element) && /^(description|(?:sample\s+)?output\s*:?|(?:sample\s+)?input\s*:?)$/i.test(text(element)));
+        for (const anchor of anchors) {
+            for (let region = anchor.parentElement; region && region !== doc.body; region = region.parentElement) {
+                if (region.contains(editor) || region.querySelector('#assistant-root'))
+                    break;
+                const content = text(region);
+                const hasOutputHeading = [...region.querySelectorAll('h1,h2,h3,h4,h5,h6,p,span,div,strong,b')]
+                    .some(node => /^(?:sample\s+)?output\s*:?$/i.test(text(node)));
+                if ((hasOutputHeading || /sample\s+output|output\s*:/i.test(content)) && /write a program|given\b|you are given|implement\b|print\b|return\b/i.test(content)
+                    && content.length >= 40 && content.length <= 30000)
+                    return region;
+            }
+        }
+        return null;
+    }
+    const aliases = { python: 'python', python3: 'python', javascript: 'javascript', 'node.js': 'javascript', java: 'java', 'c++': 'cpp', cpp: 'cpp', c: 'c', 'c#': 'csharp', go: 'go', rust: 'rust', kotlin: 'kotlin', php: 'php', sql: 'sql' };
+    function parseLanguage(label) {
+        const value = String(label || '').normalize('NFKC').toLowerCase().replace(/\s+/g, ' ').trim()
+            .replace(/^(?:selected )?language\s*:\s*/, '');
+        // Portal dropdowns use both "JavaScript" and versioned Node.js
+        // runtime names. Match the WHOLE label, not arbitrary page/code text.
+        if (/^(?:javascript|js|node\.?js)(?:\s+v?\d+(?:\.\d+)*|\s*\(\s*(?:node\.?js\s*)?v?\d+(?:\.\d+)*\s*\)|\s*\(\s*node\.?js\s*\))?$/.test(value))
+            return 'javascript';
+        if (/^javascript\s*\(\s*node\.?js\s+v?\d+(?:\.\d+)*\s*\)$/.test(value))
+            return 'javascript';
+        const name = value.replace(/\s*v?\d[\d.]*\s*$/, '').trim();
+        return aliases[name] || null;
+    }
+    function findLanguage(doc, editor) {
+        const controls = [...doc.querySelectorAll('[data-code-language],select,[role="combobox"]')].filter(node => visible(node)
+            && !node.closest('[role="listbox"],[role="option"],#assistant-root'));
+        const selected = new Set(controls.map(control => parseLanguage(control.dataset.codeLanguage || control.selectedOptions?.[0]?.textContent || text(control))
+            || parseLanguage(control.getAttribute('aria-label')) || parseLanguage(control.getAttribute('title'))).filter(Boolean));
+        if (selected.size === 1)
+            return [...selected][0];
+        if (selected.size > 1)
+            return null;
+        // Search the editor's nearest toolbar/container before considering wider ancestors.
+        for (let scope = editor.parentElement; scope && scope !== doc.body; scope = scope.parentElement) {
+            const labels = [...scope.querySelectorAll('span,div,button,p')].filter(element => visible(element)
+                && !element.closest(editorSelector) && !element.closest('[role="option"],[role="listbox"],pre,code,option'));
+            const languages = new Set(labels.map(element => parseLanguage(text(element))).filter(Boolean));
+            if (languages.size)
+                return languages.size === 1 ? [...languages][0] : null;
+        }
+        return null;
+    }
+    function getQuestion(doc) {
+        detectionError = '';
+        const editors = [...doc.querySelectorAll(editorSelector)].filter(visible);
+        if (!editors.length)
+            return unavailable(`CODE-EDITOR: No supported visible editor found (${doc.querySelectorAll('iframe').length} embedded frames).`);
+        const editor = chooseEditor(editors, doc);
+        if (!editor)
+            return unavailable(`CODE-EDITORS: Found ${editors.length} visible editors, but no unique editable solution editor with Run/Submit controls.`);
+        const regions = [...doc.querySelectorAll('#codingQuestionInfoContainer,[data-coding-question],.problem-statement,.problem-description,[class*="problemDescription"],[class*="ProblemDescription"],[class*="questionDescription"],[class*="QuestionDescription"]')].filter(visible);
+        const region = regions.find(element => !element.contains(editor)) || findDescription(doc, editor) || [...doc.querySelectorAll('main,article')].find(element => visible(element) && !element.contains(editor));
+        if (!region || text(region).length < 20)
+            return unavailable('CODE-DESCRIPTION: Editor found, but the problem description could not be identified.');
+        const webProject = ['htmlEditor', 'cssEditor', 'javascriptEditor'].every(id => doc.getElementById(id)?.matches('.ace_editor'))
+            && ['HTML', 'CSS', 'JAVASCRIPT'].every(name => doc.querySelector(`[data-testid="${name}"]`));
+        const language = webProject ? 'web' : findLanguage(doc, editor);
+        // Require an explicit language; do not overwrite an editor using a guessed default.
+        if (!language)
+            return unavailable('CODE-LANGUAGE: Editor and description found, but the selected language is missing or ambiguous.');
+        const description = region.cloneNode(true);
+        for (const node of description.querySelectorAll('button,[role="tab"],script,style'))
+            node.remove();
+        for (const node of [...description.querySelectorAll('*')].reverse()) {
+            if (/^(solved|in progress|not attempted)$/i.test(text(node)))
+                node.remove();
+        }
+        const statuses = [...region.querySelectorAll('span,div,p')].filter(node => visible(node)
+            && !node.children.length && /^(solved|in progress|not attempted)$/i.test(text(node)));
+        const problemStatus = statuses.length === 1 ? text(statuses[0]).toLowerCase() : null;
+        const sectionLabel = /^(input|output|explanation|description|submissions|tutorial|get help|note|topics|companies|easy|medium|hard|sample.*)$/i;
+        const heading = [...description.querySelectorAll('h1,h2,h3,h4,[role="heading"]')]
+            .find(node => text(node) && text(node).length < 200 && !sectionLabel.test(text(node)));
+        const portalTitle = region.querySelector('[class*="QuestionShortText-"]');
+        let title = text(portalTitle) || text(heading);
+        // CCBP often uses a styled div beside "In Progress", not h1/h2.
+        // Do not use the Input heading or the entire description as its title.
+        if (!title && statuses.length === 1) {
+            for (let branch = statuses[0], depth = 0; branch && region.contains(branch) && depth < 3 && !title; branch = branch.parentElement, depth++) {
+                for (let sibling = branch.previousElementSibling; sibling; sibling = sibling.previousElementSibling) {
+                    const candidate = text(sibling);
+                    if (candidate.length >= 3 && candidate.length < 200 && !sectionLabel.test(candidate)
+                        && !/description.*submissions/i.test(candidate)
+                        && !sibling.querySelector('input,textarea,pre,.ace_editor')) {
+                        title = candidate;
+                        break;
+                    }
+                }
+            }
+        }
+        return { type: 'code', title, text: text(description), language, problemStatus, editorSelector: selectorFor(editor), options: [] };
+    }
+    function getOnlineIdeQuestion(doc, location) {
+        if (location.origin !== 'https://learning.ccbp.in'
+            || !/^\/question\/[a-f0-9-]{36}\/?$/i.test(location.pathname))
+            return null;
+        const description = doc.querySelector('#codingQuestionInfoContainer #mark-down')
+            || doc.querySelector('#codingQuestionInfoContainer');
+        const buttons = [...doc.querySelectorAll('button:not(:disabled),a[href],[role="button"]:not([aria-disabled="true"])')]
+            .filter(node => visible(node) && /^open ide$/i.test(text(node)));
+        if (!description || !visible(description) || buttons.length !== 1)
+            return null;
+        const requirements = text(description);
+        if (!/\bapp\.js\b/i.test(requirements) || !/\b(?:express|common\s*js|node\.?js)\b/i.test(requirements))
+            return null;
+        const title = text(description.querySelector('h1,h2')) || 'Node.js IDE assignment';
+        const panel = doc.querySelector('#codingQuestionInfoContainer');
+        const solved = [...panel.querySelectorAll('span,div')].some(node => !node.children.length && visible(node) && /^solved$/i.test(text(node)));
+        const commands = new Set([...doc.querySelectorAll('code,span,div,p,input')]
+            .filter(node => visible(node) && !description.contains(node))
+            .map(node => (node.value || text(node)).match(/^ccbp\s+submit\s+([a-z0-9]{6,24})$/i)?.[1]).filter(Boolean));
+        return { title, text: requirements, button: buttons[0], solved, workspace: commands.size === 1 ? [...commands][0] : null };
+    }
+    function getSubmit(doc) {
+        const buttons = [...doc.querySelectorAll('button:not(:disabled),[role="button"]:not([aria-disabled="true"])')]
+            .filter(visible).filter(button => /^(submit|submit code|submit solution)$/i.test(text(button)));
+        return buttons.length === 1 ? buttons[0] : null;
+    }
+    function getResult(doc) {
+        const webResult = doc.querySelector('#submitResultContainer');
+        if (webResult && visible(webResult)) {
+            const cards = [...webResult.querySelectorAll('[class*="TestCaseSummaryCard-"]')];
+            const counts = {};
+            for (const card of cards) {
+                const label = text(card.querySelector('[class*="TestCaseSummaryLabel-"]')).toLowerCase();
+                const value = text(card.querySelector('[class*="TestCaseSummaryCount-"]'));
+                if (/^\d+$/.test(value))
+                    counts[label] = Number(value);
+            }
+            if (counts.total > 0 && counts.passed + counts.failed === counts.total) {
+                return counts.failed > 0 ? 'failed' : counts.passed === counts.total ? 'passed' : null;
+            }
+        }
+        const resultNodes = [...doc.querySelectorAll('[data-coding-result],[role="status"],[role="alert"],.submission-result,.test-results')];
+        const labels = [...doc.querySelectorAll('span,p,div')].filter(node => !node.closest('table,[role="table"],tr,[role="row"]') && !node.children.length
+            && /^(accepted|all test cases passed|all tests passed|correct answer|wrong answer|compilation error|runtime error|time limit exceeded|tests? failed)[.!\s]*$/i.test(text(node)));
+        const results = [...resultNodes, ...labels].filter(visible).map(text).join('\n');
+        const latest = labels.filter(visible)[0];
+        if (latest)
+            return /^(accepted|all test cases passed|all tests passed|correct answer)/i.test(text(latest)) ? 'passed' : 'failed';
+        if (/wrong answer|compilation error|runtime error|time limit exceeded|tests? failed/i.test(results))
+            return 'failed';
+        if (/^(accepted|all test cases passed|all tests passed|correct answer)[.!\s]*$/im.test(results))
+            return 'passed';
+        // Only the selected problem's status counts; sidebar/course completion does not.
+        if (getQuestion(doc)?.problemStatus === 'solved')
+            return 'passed';
+        return null;
+    }
+    function getFailureFeedback(doc) {
+        const copy = doc.body.cloneNode(true);
+        for (const node of copy.querySelectorAll('#assistant-root,.ace_editor,.monaco-editor,.CodeMirror,script,style,table,[role="table"]'))
+            node.remove();
+        return text(copy).slice(0, 16000);
+    }
+    function getDescriptionTab(doc) {
+        const tabs = [...doc.querySelectorAll('button,[role="tab"],a,span,div')].filter(node => visible(node)
+            && /^description$/i.test(text(node)) && ![...node.children].some(child => /^description$/i.test(text(child))));
+        return tabs.length === 1 ? tabs[0] : null;
+    }
+    window.BrowserAssistantCoding = { getQuestion, getOnlineIdeQuestion, getSubmit, getResult, getFailureFeedback, getDescriptionTab, getDetectionError: () => detectionError };
+})();