vision-navigator 1.0.0

package/dist/navigator.js

@@ -0,0 +1,897 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Navigator = void 0;
+require("dotenv/config");
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const cdp_driver_1 = require("./cdp-driver");
+const storage_1 = require("./storage");
+class Navigator {
+    constructor(ollamaUrl = "http://localhost:11434", model = "qwen2.5:3b", opts) {
+        this.ollamaUrl = process.env.OLLAMA_HOST || process.env.OLLAMA_URL || ollamaUrl;
+        this.model = process.env.OLLAMA_MODEL || process.env.MODEL || model;
+        this.groqKey = opts?.groqApiKey || process.env.GROQ_API_KEY || process.env.GROQ_KEY;
+        this.groqModel = opts?.groqModel || process.env.GROQ_MODEL || "llama-3.1-8b-instant";
+        this.openrouterKey = opts?.openrouterApiKey || process.env.OPENROUTER_API_KEY;
+        this.openrouterModel = opts?.openrouterModel || process.env.OPENROUTER_MODEL || "google/gemini-2.0-flash-exp:free";
+        this.storage = new storage_1.Storage();
+        this.fastMode = String(process.env.FAST_MODE || '').toLowerCase() === 'true' || process.env.FAST_MODE === '1';
+        this.skipAnalysis = String(process.env.SKIP_ANALYSIS || '') === '1' || String(process.env.SKIP_ANALYSIS || '').toLowerCase() === 'true';
+        const analysisAsyncEnv = String(process.env.ANALYSIS_ASYNC || '').toLowerCase();
+        this.analysisAsync = analysisAsyncEnv === '1' || analysisAsyncEnv === 'true' || (this.fastMode && analysisAsyncEnv !== '0' && analysisAsyncEnv !== 'false');
+        const verifyEnv = String(process.env.VERIFY_WITH_AI || '').toLowerCase();
+        this.verifyWithAi = verifyEnv === '1' || verifyEnv === 'true' || (this.fastMode && verifyEnv !== '0' && verifyEnv !== 'false');
+        if (!this.groqKey && this.openrouterKey && String(this.openrouterKey).startsWith('gsk_')) {
+            this.groqKey = this.openrouterKey;
+            this.openrouterKey = undefined;
+        }
+        if (opts?.provider) {
+            this.provider = opts.provider;
+        }
+        else if (this.groqKey) {
+            this.provider = 'groq';
+        }
+        else if (this.openrouterKey) {
+            this.provider = 'openrouter';
+        }
+        else {
+            this.provider = 'ollama';
+        }
+        if (this.provider === 'groq' && !this.groqKey) {
+            if (this.openrouterKey) {
+                this.provider = 'openrouter';
+            }
+            else {
+                this.provider = 'ollama';
+            }
+        }
+        if (this.provider === 'groq') {
+            console.log(`Using Groq with model: ${this.groqModel}`);
+            this.model = this.groqModel;
+        }
+        else if (this.provider === 'openrouter') {
+            console.log(`Using OpenRouter with model: ${this.openrouterModel}`);
+            this.model = this.openrouterModel;
+        }
+        else {
+            console.log(`Using Local Ollama with model: ${this.model}`);
+        }
+    }
+    async ensureModelReady() {
+        if (this.provider === 'groq') {
+            console.log(`Skipping local model check. Using Groq model: ${this.groqModel}`);
+            return;
+        }
+        if (this.provider === 'openrouter') {
+            console.log(`Skipping local model check. Using OpenRouter model: ${this.openrouterModel}`);
+            return;
+        }
+        try {
+            console.log(`Checking for model ${this.model} at ${this.ollamaUrl}...`);
+            const resp = await axios_1.default.get(`${this.ollamaUrl}/api/tags`, { timeout: 5000 });
+            if (resp.status === 200) {
+                const models = resp.data.models.map((m) => m.name);
+                if (!models.includes(this.model) && !models.includes(`${this.model}:latest`)) {
+                    console.log(`Model ${this.model} not found. Pulling...`);
+                    await axios_1.default.post(`${this.ollamaUrl}/api/pull`, { name: this.model, stream: false });
+                }
+                else {
+                    console.log(`Model ${this.model} is available.`);
+                }
+            }
+        }
+        catch (e) {
+            console.log(`Warning: Could not check/pull model: ${e}`);
+        }
+    }
+    async callOpenRouter(prompt, systemPrompt) {
+        const headers = {
+            "Authorization": `Bearer ${this.openrouterKey}`,
+            "HTTP-Referer": "http://localhost:8000",
+            "X-Title": "VisionNavigator",
+            "Content-Type": "application/json"
+        };
+        const messages = [];
+        if (systemPrompt) {
+            messages.push({ role: "system", content: systemPrompt });
+        }
+        messages.push({ role: "user", content: prompt });
+        const data = {
+            model: this.openrouterModel,
+            messages: messages,
+            temperature: 0.0
+        };
+        try {
+            const resp = await axios_1.default.post("https://openrouter.ai/api/v1/chat/completions", data, { headers, timeout: this.fastMode ? 8000 : 30000 });
+            if (resp.status !== 200) {
+                console.log(`OpenRouter Error ${resp.status}: ${JSON.stringify(resp.data)}`);
+                return null;
+            }
+            if (resp.data.choices && resp.data.choices.length > 0) {
+                return resp.data.choices[0].message.content;
+            }
+            return null;
+        }
+        catch (e) {
+            console.log(`OpenRouter Exception: ${e}`);
+            return null;
+        }
+    }
+    async callGroq(prompt, systemPrompt) {
+        const headers = {
+            "Authorization": `Bearer ${this.groqKey}`,
+            "Content-Type": "application/json"
+        };
+        const messages = [];
+        if (systemPrompt) {
+            messages.push({ role: "system", content: systemPrompt });
+        }
+        messages.push({ role: "user", content: prompt });
+        const data = {
+            model: this.groqModel,
+            messages,
+            temperature: 0.0
+        };
+        try {
+            const resp = await axios_1.default.post("https://api.groq.com/openai/v1/chat/completions", data, { headers, timeout: this.fastMode ? 8000 : 30000 });
+            if (resp.status !== 200) {
+                console.log(`Groq Error ${resp.status}: ${JSON.stringify(resp.data)}`);
+                return null;
+            }
+            if (resp.data.choices && resp.data.choices.length > 0) {
+                return resp.data.choices[0].message.content;
+            }
+            return null;
+        }
+        catch (e) {
+            console.log(`Groq Exception: ${e}`);
+            return null;
+        }
+    }
+    async queryModel(modelName, prompt, isAnalysis = false) {
+        const systemPrompt = isAnalysis
+            ? (this.fastMode ? "Return only: Verdict: PASS | FAIL | FLAKY — One short reason." : "You are a web performance and usability expert. Analyze the data and provide concise, actionable feedback.")
+            : "";
+        if (this.provider === 'groq') {
+            const resp = await this.callGroq(prompt, systemPrompt);
+            return resp || "Failed to generate analysis via Groq.";
+        }
+        if (this.provider === 'openrouter') {
+            const resp = await this.callOpenRouter(prompt, systemPrompt);
+            return resp || "Failed to generate analysis via OpenRouter.";
+        }
+        else {
+            try {
+                const messages = [];
+                if (systemPrompt) {
+                    messages.push({ role: "system", content: systemPrompt });
+                }
+                messages.push({ role: "user", content: prompt });
+                const resp = await axios_1.default.post(`${this.ollamaUrl}/api/chat`, {
+                    model: this.model,
+                    messages: messages,
+                    stream: false,
+                    options: { temperature: 0.2 }
+                });
+                if (resp.data && resp.data.message) {
+                    return resp.data.message.content;
+                }
+                return "Failed to generate analysis via Ollama.";
+            }
+            catch (e) {
+                console.log(`Ollama Query Error: ${e.message}`);
+                return "Error generating analysis.";
+            }
+        }
+    }
+    shouldVerifyStep(instruction, actionText) {
+        if (!this.verifyWithAi)
+            return false;
+        const instr = String(instruction || '').toLowerCase();
+        const action = String(actionText || '').toLowerCase();
+        const critical = /log\s?in|login|sign\s?in|submit|continue|next|checkout|pay|confirm|create|save|delete|remove|register|sign\s?up/.test(instr);
+        const likelyNoop = /Action:\s*(done)/i.test(actionText || '');
+        return critical || likelyNoop;
+    }
+    async verifyStepOutcome(input) {
+        const systemPrompt = "You are a strict QA verifier. Decide if the instruction was successfully completed based only on the provided before/after URL/title and simplified HTML.\n" +
+            "Output exactly two lines:\n" +
+            "Verdict: PASS | FAIL | UNCERTAIN\n" +
+            "Reason: <short>\n" +
+            "Do not output markdown.";
+        const domLimit = this.fastMode ? 2500 : 6000;
+        const prompt = `Instruction:\n${input.instruction}\n\n` +
+            `Action Taken:\n${input.actionTaken}\n\n` +
+            `Before Page:\n${JSON.stringify(input.before || {}, null, 2)}\n\n` +
+            `After Page:\n${JSON.stringify(input.after || {}, null, 2)}\n\n` +
+            `Before DOM (truncated):\n${String(input.domBefore || '').slice(0, domLimit)}\n\n` +
+            `After DOM (truncated):\n${String(input.domAfter || '').slice(0, domLimit)}\n`;
+        if (this.provider === 'groq')
+            return await this.callGroq(prompt, systemPrompt);
+        if (this.provider === 'openrouter')
+            return await this.callOpenRouter(prompt, systemPrompt);
+        try {
+            const messages = [{ role: "system", content: systemPrompt }, { role: "user", content: prompt }];
+            const resp = await axios_1.default.post(`${this.ollamaUrl}/api/chat`, {
+                model: this.model,
+                messages,
+                stream: false,
+                options: { temperature: 0.0 }
+            }, { timeout: this.fastMode ? 8000 : 30000 });
+            if (resp.data && resp.data.message)
+                return resp.data.message.content;
+            return null;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    async getActionFromModel(modelName, instruction, pageContent, history = []) {
+        // Heuristic for Navigation
+        const urlMatch = instruction.match(/http[s]?:\/\/(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+/);
+        if (instruction.toLowerCase().match(/navigate to|go to|open url|visit/) && urlMatch) {
+            console.log(`Heuristic: Found navigation URL ${urlMatch[0]}`);
+            return JSON.stringify({ action: "navigate", url: urlMatch[0], reasoning: "Heuristic navigation" });
+        }
+        const systemPrompt = this.fastMode
+            ? `You are an end-to-end web testing agent controlling a real browser.
+Output Format:
+Thought: <short>
+Action: <click|type|scroll|navigate|done> <target> <optional_text_or_url>
+Action: <...> (optional, up to 3 actions total)
+Rules:
+- Output 1 to 3 actions max.
+- Prefer deterministic targets.
+- If unsure: scroll down (once) or done.
+- Do not output JSON or markdown.`
+            : `You are an end-to-end web testing agent executing QA steps in a real browser.
+You will be given:
+1. An instruction of what to do.
+2. A Simplified HTML representation of the current page.
+   - Interactive elements have an id attribute (e.g. <button id="42">).
+3. A history of actions taken so far.
+
+Your goal is to pick the ONE best next action to fulfill the instruction in a stable, test-friendly way.
+
+Output Format:
+Thought: <Reasoning>
+Action: <action_type> <element_id> <optional_text_or_url>
+Action: <...> (optional, up to 3 actions total)
+
+Supported Actions:
+- click <element_id>
+- type <element_id> <text>
+- scroll <direction> (up or down)
+- navigate <url>
+- done
+
+EXAMPLES:
+
+Instruction: "Click the search button"
+HTML: <button id="42">Search</button>
+Output:
+Thought: Found search button with id 42
+Action: click 42
+
+Instruction: "Type 'hello' into the input"
+HTML: <input id="15" placeholder="Enter text" />
+Output:
+Thought: Found input 15, typing 'hello'
+Action: type 15 hello
+
+Instruction: "Verify that the heading says 'Welcome'"
+HTML: <h1>Welcome to our site</h1>
+Output:
+Thought: The heading says 'Welcome', so the verification is complete.
+Action: done
+
+RULES:
+- Do NOT output JSON.
+- Follow the format exactly.
+- Output 1 to 3 actions max.
+- If the exact wording in the instruction does not match the HTML, make a smart guess based on context. For example, "Risk Register" might be represented by a "Risks" button with a shield icon, or "Login" might be "Sign in".
+- Do NOT click random elements. If you cannot confidently identify the correct element, prefer: scroll down (once) or done.
+- Prefer deterministic targets: explicit labels/placeholder text, primary CTA buttons, and clearly matching inputs.
+- When the instruction is a verification/assertion and the condition is already visible in the HTML, respond with Action: done.
+`;
+        const historyText = history.length > 0 ? `History:\n${history.join('\n')}\n` : '';
+        const prompt = `Instruction: ${instruction}\n\n${historyText}\nCurrent Page HTML:\n${pageContent}\n\nResponse:`;
+        if (!this.fastMode) {
+            const fs = require('fs');
+            fs.writeFileSync('last_dom.txt', pageContent);
+        }
+        let responseText = null;
+        if (this.provider === 'groq') {
+            responseText = await this.callGroq(prompt, systemPrompt);
+        }
+        else if (this.provider === 'openrouter') {
+            responseText = await this.callOpenRouter(prompt, systemPrompt);
+        }
+        else {
+            // Ollama fallback
+            try {
+                // Use /api/chat for better instruction following with System prompt
+                const messages = [];
+                if (systemPrompt) {
+                    messages.push({ role: "system", content: systemPrompt });
+                }
+                // One-shot example to guide the model
+                messages.push({
+                    role: "user",
+                    content: `Instruction: Click the 'Search' button\nCurrent Page HTML:\n<button id="42">Search</button>\n\nResponse:`
+                });
+                messages.push({
+                    role: "assistant",
+                    content: `Thought: Found search button with id 42\nAction: click 42`
+                });
+                messages.push({ role: "user", content: prompt });
+                const resp = await axios_1.default.post(`${this.ollamaUrl}/api/chat`, {
+                    model: this.model, // Use the instance model property
+                    messages: messages,
+                    stream: false,
+                    options: {
+                        temperature: 0.0 // Deterministic
+                    }
+                });
+                if (resp.data && resp.data.message) {
+                    responseText = resp.data.message.content;
+                }
+            }
+            catch (e) {
+                console.log(`Ollama Error: ${e.message}`);
+                if (e.response && e.response.data) {
+                    console.log(`Ollama Response Data: ${JSON.stringify(e.response.data)}`);
+                }
+                else if (e.request) {
+                    console.log(`Ollama Request Error (No response): ${e.request}`);
+                }
+                else {
+                    console.log(`Ollama Unknown Error:`, e);
+                }
+                return null;
+            }
+        }
+        if (responseText) {
+            console.log(`Raw Model Response: ${responseText}`);
+            // Clean up markdown code blocks if present
+            responseText = responseText.replace(/```json/g, "").replace(/```/g, "").trim();
+        }
+        return responseText;
+    }
+    async runWorkflow(workflow, onProgress, meta, control) {
+        const results = [];
+        const driver = new cdp_driver_1.CDPDriver();
+        const runId = meta?.runId || Date.now().toString();
+        const collectedImages = [];
+        const screenshotsBaseDir = path_1.default.join(process.cwd(), 'screenshots');
+        const runDir = path_1.default.join(screenshotsBaseDir, `run_${runId}`);
+        const actionHistory = [];
+        let finalStatus = "failed";
+        let issues = [];
+        let reportObjName = undefined;
+        let pbRecordId = undefined;
+        const analysisPromises = [];
+        if (!fs_1.default.existsSync(runDir)) {
+            fs_1.default.mkdirSync(runDir, { recursive: true });
+        }
+        console.log(`Saving screenshots to ${runDir}`);
+        try {
+            const record = await this.storage.createRun(runId, "running", [], undefined, [], meta);
+            if (record?.id)
+                pbRecordId = record.id;
+        }
+        catch (e) {
+            console.log(`Failed to create running record: ${e}`);
+        }
+        try {
+            await driver.start();
+            const steps = workflow.steps || [];
+            if (pbRecordId) {
+                await this.storage.updateRun(pbRecordId, {
+                    status: "running",
+                    currentStep: "",
+                    currentStepIndex: 0,
+                    currentStepTotal: steps.length,
+                    currentScreenshots: {}
+                });
+            }
+            for (let i = 0; i < steps.length; i++) {
+                if (control?.aborted) {
+                    finalStatus = "stopped";
+                    break;
+                }
+                const step = steps[i];
+                const stepStartMs = Date.now();
+                await new Promise(resolve => setTimeout(resolve, this.fastMode ? 300 : 2000));
+                const instruction = step.instruction;
+                console.log(`Step ${i + 1}: ${instruction}`);
+                if (pbRecordId) {
+                    await this.storage.updateRun(pbRecordId, {
+                        status: "running",
+                        currentStep: instruction,
+                        currentStepIndex: i + 1,
+                        currentStepTotal: steps.length,
+                        currentScreenshots: { before: null, after: null },
+                        images: collectedImages
+                    });
+                }
+                const stepResult = {
+                    step: instruction,
+                    status: "pending",
+                    screenshots: {},
+                    logs: []
+                };
+                let beforeObjName = null;
+                let afterObjName = null;
+                try {
+                    stepResult.page = {
+                        url_before: await driver.executeScript(`location.href`),
+                        title_before: await driver.executeScript(`document.title`)
+                    };
+                }
+                catch (e) {
+                    stepResult.page = {};
+                }
+                if (onProgress) {
+                    onProgress({ ...stepResult });
+                }
+                // Before Screenshot (Record only, not used for logic)
+                try {
+                    const screenshotData = await driver.getScreenshot();
+                    if (screenshotData) {
+                        const fileName = `step_${i + 1}_before.png`;
+                        const filePath = path_1.default.join(runDir, fileName);
+                        fs_1.default.writeFileSync(filePath, Buffer.from(screenshotData, 'base64'));
+                        stepResult.screenshots.before = `screenshots/run_${runId}/${fileName}`;
+                        beforeObjName = `run_${runId}/${fileName}`;
+                        collectedImages.push(beforeObjName);
+                        try {
+                            await this.storage.uploadFile(filePath, beforeObjName);
+                        }
+                        catch (uploadErr) {
+                            console.log(`Failed to upload before screenshot: ${uploadErr}`);
+                        }
+                        if (pbRecordId) {
+                            await this.storage.updateRun(pbRecordId, {
+                                images: collectedImages,
+                                currentScreenshots: { before: beforeObjName, after: afterObjName }
+                            });
+                        }
+                    }
+                }
+                catch (e) {
+                    console.log(`Failed to save before screenshot: ${e}`);
+                }
+                // Get Simplified DOM instead of JSON list
+                try {
+                    const cookieHit = await driver.dismissCookieBanners();
+                    if (cookieHit?.clicked) {
+                        await new Promise(resolve => setTimeout(resolve, this.fastMode ? 200 : 800));
+                    }
+                }
+                catch (e) { }
+                let pageContent = await driver.getSimplifiedDOM();
+                console.log(`Page Content Length: ${pageContent.length}`);
+                console.log("Page Content (First 500 chars):", pageContent.substring(0, 500));
+                // Truncate to avoid context window limits
+                const domLimit = this.fastMode ? 6000 : 20000;
+                if (pageContent.length > domLimit) {
+                    pageContent = pageContent.substring(0, domLimit) + "\n... [DOM Truncated]";
+                }
+                // Save DOM for debugging
+                if (!this.fastMode) {
+                    const domDebugPath = path_1.default.join(runDir, `step_${i + 1}_dom.html`);
+                    fs_1.default.writeFileSync(domDebugPath, pageContent);
+                }
+                if (!pageContent || pageContent.trim().length === 0) {
+                    console.log("Warning: Empty DOM content received from driver.");
+                }
+                console.log(`Consulting ${this.model}...`);
+                const isCookieStep = /cookie|cookies|consent|gdpr|kaka|kakor|integritet/i.test(instruction);
+                let modelResponse = null;
+                if (isCookieStep) {
+                    const cookieHit = await driver.dismissCookieBanners({ aggressive: true });
+                    if (cookieHit?.clicked) {
+                        modelResponse = `Thought: Cookie consent handled\nAction: done`;
+                        stepResult.action = `cookie:clicked:${cookieHit.label || 'accept'}`;
+                        actionHistory.push(`Cookie consent clicked: ${cookieHit.label || 'accept'}`);
+                    }
+                    else {
+                        modelResponse = await this.getActionFromModel(this.model, instruction, pageContent, actionHistory);
+                    }
+                }
+                else {
+                    modelResponse = await this.getActionFromModel(this.model, instruction, pageContent, actionHistory);
+                }
+                console.log(`Model Response: ${modelResponse}`);
+                if (!stepResult.action)
+                    stepResult.action = modelResponse;
+                let executed = false;
+                if (modelResponse) {
+                    try {
+                        const thoughtMatch = modelResponse.match(/Thought:\s*(.+)/i);
+                        if (thoughtMatch)
+                            console.log(`Thought: ${thoughtMatch[1]}`);
+                        const actionRegex = /Action:\s*(\w+)(?:\s+([^\s]+))?(?:\s+(.+))?/ig;
+                        const actions = [];
+                        let m = null;
+                        while ((m = actionRegex.exec(modelResponse)) !== null) {
+                            actions.push({ action: String(m[1] || '').toLowerCase(), target: m[2], extra: m[3] });
+                            if (actions.length >= 3)
+                                break;
+                        }
+                        let actionObj = {};
+                        if (actions.length > 0) {
+                            for (const a of actions) {
+                                if (control?.aborted) {
+                                    stepResult.status = "stopped";
+                                    results.push(stepResult);
+                                    finalStatus = "stopped";
+                                    break;
+                                }
+                                actionObj = { action: a.action };
+                                if (a.action === 'click')
+                                    actionObj.element_id = a.target;
+                                if (a.action === 'type') {
+                                    actionObj.element_id = a.target;
+                                    actionObj.text = a.extra;
+                                }
+                                if (a.action === 'navigate')
+                                    actionObj.url = a.target;
+                                if (a.action === 'scroll')
+                                    actionObj.direction = a.target;
+                                let actionType = String(actionObj.action || '').toLowerCase();
+                                if (actionType === "visit" || actionType === "goto")
+                                    actionType = "navigate";
+                                if (actionType === "edit" || actionType === "fill" || actionType === "input")
+                                    actionType = "type";
+                                if (actionType === "navigate") {
+                                    const url = actionObj.url || actionObj.link;
+                                    if (url) {
+                                        await driver.navigate(url);
+                                        executed = true;
+                                        actionHistory.push(`Navigated to ${url}`);
+                                    }
+                                }
+                                else if (actionType === "click") {
+                                    const id = actionObj.element_id;
+                                    if (id) {
+                                        await driver.clickById(id);
+                                        executed = true;
+                                        actionHistory.push(`Clicked element ${id}`);
+                                    }
+                                }
+                                else if (actionType === "type") {
+                                    const id = actionObj.element_id;
+                                    const text = actionObj.text || actionObj.content || actionObj.value;
+                                    if (id && text) {
+                                        await driver.typeById(id, text);
+                                        executed = true;
+                                        actionHistory.push(`Typed into element ${id}`);
+                                    }
+                                }
+                                else if (actionType === "scroll") {
+                                    const direction = actionObj.direction || "down";
+                                    await driver.scroll(direction);
+                                    executed = true;
+                                    actionHistory.push(`Scrolled ${direction}`);
+                                }
+                                else if (actionType === "done") {
+                                    stepResult.status = "completed";
+                                    executed = true;
+                                    actionHistory.push(`Task done`);
+                                }
+                                await new Promise(resolve => setTimeout(resolve, this.fastMode ? 150 : 600));
+                            }
+                        }
+                        else {
+                            try {
+                                const jsonMatch = modelResponse.match(/\{[\s\S]*\}/);
+                                const jsonStr = jsonMatch ? jsonMatch[0] : modelResponse;
+                                actionObj = JSON.parse(jsonStr);
+                            }
+                            catch (e) {
+                                console.log("Failed to parse response as JSON or Action format.");
+                            }
+                        }
+                        if (!executed && actionObj && actionObj.action) {
+                            if (control?.aborted) {
+                                stepResult.status = "stopped";
+                                results.push(stepResult);
+                                finalStatus = "stopped";
+                                break;
+                            }
+                            if (!actionObj.element_id) {
+                                actionObj.element_id = actionObj.id || actionObj.item || actionObj.target || actionObj.element;
+                            }
+                            let actionType = actionObj.action?.toLowerCase();
+                            if (actionType === "visit" || actionType === "goto")
+                                actionType = "navigate";
+                            if (actionType === "edit" || actionType === "fill" || actionType === "input")
+                                actionType = "type";
+                            if (actionType === "navigate") {
+                                const url = actionObj.url || actionObj.link;
+                                if (url) {
+                                    await driver.navigate(url);
+                                    executed = true;
+                                    actionHistory.push(`Navigated to ${url}`);
+                                }
+                            }
+                            else if (actionType === "click") {
+                                const id = actionObj.element_id;
+                                if (id) {
+                                    await driver.clickById(id);
+                                    executed = true;
+                                    actionHistory.push(`Clicked element ${id}`);
+                                }
+                            }
+                            else if (actionType === "type") {
+                                const id = actionObj.element_id;
+                                const text = actionObj.text || actionObj.content || actionObj.value;
+                                if (id && text) {
+                                    await driver.typeById(id, text);
+                                    executed = true;
+                                    actionHistory.push(`Typed into element ${id}`);
+                                }
+                            }
+                            else if (actionType === "scroll") {
+                                const direction = actionObj.direction || "down";
+                                await driver.scroll(direction);
+                                executed = true;
+                                actionHistory.push(`Scrolled ${direction}`);
+                            }
+                            else if (actionType === "done") {
+                                stepResult.status = "completed";
+                                executed = true;
+                                actionHistory.push(`Task done`);
+                            }
+                        }
+                        if (executed) {
+                            stepResult.status = "executed";
+                            await new Promise(resolve => setTimeout(resolve, this.fastMode ? 300 : 2000));
+                            // After Screenshot
+                            try {
+                                const screenshotData = await driver.getScreenshot();
+                                if (screenshotData) {
+                                    const fileName = `step_${i + 1}_after.png`;
+                                    const filePath = path_1.default.join(runDir, fileName);
+                                    fs_1.default.writeFileSync(filePath, Buffer.from(screenshotData, 'base64'));
+                                    stepResult.screenshots.after = `screenshots/run_${runId}/${fileName}`;
+                                    afterObjName = `run_${runId}/${fileName}`;
+                                    collectedImages.push(afterObjName);
+                                    try {
+                                        await this.storage.uploadFile(filePath, afterObjName);
+                                    }
+                                    catch (uploadErr) {
+                                        console.log(`Failed to upload after screenshot: ${uploadErr}`);
+                                    }
+                                    if (pbRecordId) {
+                                        await this.storage.updateRun(pbRecordId, {
+                                            images: collectedImages,
+                                            currentScreenshots: { before: beforeObjName, after: afterObjName }
+                                        });
+                                    }
+                                }
+                            }
+                            catch (e) {
+                                console.log(`Failed to save after screenshot: ${e}`);
+                            }
+                        }
+                        else {
+                            stepResult.status = "failed_parse";
+                        }
+                    }
+                    catch (e) {
+                        console.log(`Execution error: ${e}`);
+                        stepResult.status = "failed_exec";
+                    }
+                }
+                try {
+                    stepResult.page = {
+                        ...(stepResult.page || {}),
+                        url_after: await driver.executeScript(`location.href`),
+                        title_after: await driver.executeScript(`document.title`)
+                    };
+                }
+                catch (e) { }
+                let pageAfterContent = '';
+                try {
+                    pageAfterContent = await driver.getSimplifiedDOM();
+                    const domLimit = this.fastMode ? 6000 : 20000;
+                    if (pageAfterContent.length > domLimit) {
+                        pageAfterContent = pageAfterContent.substring(0, domLimit) + "\n... [DOM Truncated]";
+                    }
+                }
+                catch (e) {
+                    pageAfterContent = '';
+                }
+                stepResult.logs = driver.getLogs();
+                stepResult.network_issues = driver.getNetworkIssues();
+                stepResult.performance_metrics = await driver.getPerformanceMetrics();
+                stepResult.duration_ms = Date.now() - stepStartMs;
+                if (this.shouldVerifyStep(instruction, stepResult.action)) {
+                    try {
+                        const verdict = await this.verifyStepOutcome({
+                            instruction,
+                            actionTaken: String(stepResult.action || ''),
+                            before: stepResult.page ? { url: stepResult.page.url_before, title: stepResult.page.title_before } : {},
+                            after: stepResult.page ? { url: stepResult.page.url_after, title: stepResult.page.title_after } : {},
+                            domBefore: pageContent,
+                            domAfter: pageAfterContent
+                        });
+                        stepResult.ai_verdict = verdict || undefined;
+                        if (verdict && /Verdict:\s*FAIL/i.test(verdict)) {
+                            stepResult.status = "failed_verify";
+                        }
+                    }
+                    catch (e) { }
+                }
+                // Add AI Analysis on gathered data
+                const analysisPrompt = this.fastMode
+                    ? `Verdict only (PASS/FAIL/FLAKY) and one sentence reason.\nInstruction:\n${instruction}\nAction:\n${stepResult.action || 'None'}\nConsole:\n${(stepResult.logs || []).slice(0, 10).join('\n') || 'None'}\nNetwork:\n${(stepResult.network_issues || []).slice(0, 5).join('\n') || 'None'}`
+                    : `You are a senior web QA engineer analyzing an end-to-end browser test step.\n\nConsole and network issues matter: treat console ERROR/EXCEPTION/WARNING and HTTP failures (>=400) as potential test failures or flakiness.\n\nYour job:\n1) Summarize whether this step should be considered PASS / FAIL / FLAKY and why.\n2) Call out console errors/warnings and likely root cause.\n3) Call out network failures/statuses and likely root cause.\n4) Call out performance timing/metrics concerns that could impact UX or cause flaky tests.\n5) Provide specific, actionable next steps (what to fix or what assertions to add).\n\nBe concise but concrete. Use headings:\n- Verdict:\n- Console:\n- Network:\n- Performance:\n- Suggested Assertions:\n- Next Steps:\n\nInstruction:\n${instruction}\n\nAction Taken:\n${stepResult.action || 'None'}\n\nPage:\n${JSON.stringify(stepResult.page || {}, null, 2)}\n\nConsole Logs:\n${stepResult.logs.join('\n') || 'None'}\n\nNetwork Issues:\n${stepResult.network_issues.join('\n') || 'None'}\n\nPerformance Metrics:\n${JSON.stringify(stepResult.performance_metrics, null, 2)}\n                `;
+                if (this.skipAnalysis) {
+                    stepResult.ai_suggestions = this.fastMode ? "Skipped (FAST_MODE)." : "Skipped.";
+                }
+                else if (this.analysisAsync) {
+                    const p = (async () => {
+                        try {
+                            const analysis = await this.queryModel(this.model, analysisPrompt, true);
+                            stepResult.ai_suggestions = analysis;
+                        }
+                        catch (e) {
+                            stepResult.ai_suggestions = "Could not generate suggestions.";
+                        }
+                    })();
+                    analysisPromises.push(p);
+                }
+                else {
+                    try {
+                        console.log(`Getting AI analysis for step ${i + 1}...`);
+                        const analysis = await this.queryModel(this.model, analysisPrompt, true);
+                        stepResult.ai_suggestions = analysis;
+                    }
+                    catch (e) {
+                        console.log(`Failed to get AI analysis: ${e}`);
+                        stepResult.ai_suggestions = "Could not generate suggestions.";
+                    }
+                }
+                const hasErrors = stepResult.logs.some((log) => log.toLowerCase().includes("error") ||
+                    log.toLowerCase().includes("exception") ||
+                    log.toLowerCase().includes("failed"));
+                if (hasErrors) {
+                    stepResult.has_console_errors = true;
+                    console.log(`Step ${i + 1} has console errors.`);
+                }
+                results.push(stepResult);
+                if (onProgress) {
+                    onProgress({ ...stepResult });
+                }
+            }
+        }
+        catch (e) {
+            console.error(`Workflow error: ${e}`);
+        }
+        finally {
+            await driver.stop();
+            if (analysisPromises.length) {
+                await Promise.allSettled(analysisPromises);
+            }
+            // Create run record
+            if (control?.aborted) {
+                finalStatus = "stopped";
+            }
+            else if (finalStatus !== "stopped") {
+                finalStatus = "completed";
+                for (const r of results) {
+                    if (String(r.status || '').startsWith("failed")) {
+                        finalStatus = "failed";
+                        break;
+                    }
+                    // Check logs for errors
+                    if (r.logs) {
+                        for (const log of r.logs) {
+                            if (log.toLowerCase().includes("error") || log.toLowerCase().includes("exception")) {
+                                console.log(`Found error in logs: ${log}`);
+                            }
+                        }
+                    }
+                }
+            }
+            console.log(`Run ${runId} completed with status ${finalStatus}`);
+            // Build issues summary
+            issues = [];
+            for (const r of results) {
+                if (r.ai_verdict && /Verdict:\s*FAIL/i.test(String(r.ai_verdict))) {
+                    issues.push({ type: "verify", message: String(r.ai_verdict), step: r.step });
+                }
+                if (r.logs) {
+                    for (const log of r.logs) {
+                        const lower = log.toLowerCase();
+                        if (lower.includes("error") || lower.includes("exception") || lower.includes("failed")) {
+                            issues.push({ type: "console", message: log, step: r.step });
+                        }
+                    }
+                }
+                if (r.network_issues && r.network_issues.length) {
+                    for (const ni of r.network_issues) {
+                        issues.push({ type: "network", message: ni, step: r.step });
+                    }
+                }
+            }
+            // Save summary.json locally and upload to Minio
+            const summary = {
+                runId,
+                status: finalStatus,
+                suiteName: meta?.suiteName,
+                testName: meta?.testName,
+                issues,
+                steps: results.map(r => ({
+                    step: r.step,
+                    status: r.status,
+                    action: r.action,
+                    page: r.page,
+                    duration_ms: r.duration_ms,
+                    screenshots: r.screenshots,
+                    logs: r.logs,
+                    network_issues: r.network_issues,
+                    performance_metrics: r.performance_metrics,
+                    has_console_errors: r.has_console_errors,
+                    ai_suggestions: r.ai_suggestions,
+                    ai_verdict: r.ai_verdict,
+                })),
+            };
+            const summaryPath = path_1.default.join(runDir, 'summary.json');
+            fs_1.default.writeFileSync(summaryPath, JSON.stringify(summary, null, 2), 'utf8');
+            try {
+                reportObjName = `run_${runId}/summary.json`;
+                await this.storage.uploadFile(summaryPath, reportObjName);
+            }
+            catch (e) {
+                console.log(`Failed to upload summary.json: ${e}`);
+            }
+            if (pbRecordId) {
+                await this.storage.updateRun(pbRecordId, {
+                    status: finalStatus,
+                    images: collectedImages,
+                    report: reportObjName,
+                    issues: issues || [],
+                    suiteName: meta?.suiteName,
+                    testName: meta?.testName,
+                    currentScreenshots: {},
+                    currentStep: "",
+                    currentStepIndex: workflow.steps ? workflow.steps.length : results.length
+                });
+            }
+            else {
+                await this.storage.createRun(runId, finalStatus, collectedImages, reportObjName, issues, meta);
+            }
+            // Save run to local history
+            try {
+                const historyPath = path_1.default.join(screenshotsBaseDir, 'runs.json');
+                let history = [];
+                if (fs_1.default.existsSync(historyPath)) {
+                    history = JSON.parse(fs_1.default.readFileSync(historyPath, 'utf8'));
+                }
+                history.push({
+                    id: `run_${runId}`,
+                    timestamp: Date.now(),
+                    status: finalStatus,
+                    suiteName: meta?.suiteName,
+                    testName: meta?.testName,
+                    steps: results.length
+                });
+                fs_1.default.writeFileSync(historyPath, JSON.stringify(history, null, 2));
+            }
+            catch (err) {
+                console.error("Failed to save run history:", err);
+            }
+        }
+        return { runId, status: finalStatus, results, report: reportObjName, issues };
+    }
+}
+exports.Navigator = Navigator;