neuron-inspector 0.8.0 → 1.0.0

package/dist/automations/executor.js

@@ -0,0 +1,835 @@
+/**
+ * Step Execution Engine — Browser Automation
+ *
+ * Dispatches automation steps to bridge primitives via WebSocket.
+ * Handles variable substitution, tab tracking, assertions, extraction,
+ * retry logic, and error handling.
+ */
+import { handleRecipeTool } from "../recipe-tools.js";
+// ============================================================================
+// Helpers
+// ============================================================================
+async function call(ctx, primitive, args, timeoutMs = 15000) {
+    return ctx.pending.call(ctx.ws, primitive, args, timeoutMs);
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+/**
+ * Substitute {{variable}} placeholders in a string
+ */
+function substituteVars(text, vars) {
+    return text.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`);
+}
+/**
+ * Deep substitute variables in all string fields of a config object
+ */
+function substituteInConfig(config, vars) {
+    if (typeof config === "string") {
+        return substituteVars(config, vars);
+    }
+    if (Array.isArray(config)) {
+        return config.map((item) => substituteInConfig(item, vars));
+    }
+    if (config && typeof config === "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(config)) {
+            result[key] = substituteInConfig(value, vars);
+        }
+        return result;
+    }
+    return config;
+}
+// ============================================================================
+// Recipe Loading
+// ============================================================================
+async function loadRecipe(slug, variables) {
+    const args = { slug };
+    if (variables)
+        args.variables = variables;
+    return handleRecipeTool("neuron_recipe_run", args);
+}
+// ============================================================================
+// Assertion Checking
+// ============================================================================
+async function checkAssertion(ctx, tabId, assertion, vars) {
+    const check = assertion.check;
+    const value = substituteVars(assertion.value, vars);
+    const expected = assertion.expected;
+    try {
+        switch (check) {
+            case "selector_exists": {
+                const result = (await call(ctx, "queryDom", { tabId, selector: value }));
+                const exists = !!(result.elements && result.elements.length > 0);
+                return { check, passed: exists, actual: exists, expected: true };
+            }
+            case "selector_not_exists": {
+                const result = (await call(ctx, "queryDom", { tabId, selector: value }));
+                const exists = !!(result.elements && result.elements.length > 0);
+                return { check, passed: !exists, actual: exists, expected: false };
+            }
+            case "text_contains": {
+                const text = (await call(ctx, "evaluateJS", {
+                    tabId,
+                    expression: "document.body.innerText",
+                }));
+                const contains = text.includes(value);
+                return { check, passed: contains, actual: contains, expected: true };
+            }
+            case "text_not_contains": {
+                const text = (await call(ctx, "evaluateJS", {
+                    tabId,
+                    expression: "document.body.innerText",
+                }));
+                const contains = text.includes(value);
+                return { check, passed: !contains, actual: contains, expected: false };
+            }
+            case "url_matches": {
+                const url = (await call(ctx, "evaluateJS", {
+                    tabId,
+                    expression: "location.href",
+                }));
+                const matches = new RegExp(value).test(url);
+                return { check, passed: matches, actual: url, expected: value };
+            }
+            case "title_matches": {
+                const title = (await call(ctx, "evaluateJS", {
+                    tabId,
+                    expression: "document.title",
+                }));
+                const matches = new RegExp(value).test(title);
+                return { check, passed: matches, actual: title, expected: value };
+            }
+            case "element_visible": {
+                const visible = (await call(ctx, "evaluateJS", {
+                    tabId,
+                    expression: `
+            (() => {
+              const el = document.querySelector(${JSON.stringify(value)});
+              if (!el) return false;
+              const rect = el.getBoundingClientRect();
+              const style = window.getComputedStyle(el);
+              return rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none';
+            })()
+          `,
+                }));
+                return { check, passed: visible, actual: visible, expected: true };
+            }
+            case "element_count": {
+                const result = (await call(ctx, "queryDom", { tabId, selector: value }));
+                const count = result.elements?.length ?? 0;
+                const expectedCount = Number(expected ?? 0);
+                const op = assertion.op ?? "eq";
+                let passed = false;
+                if (op === "eq")
+                    passed = count === expectedCount;
+                else if (op === "gt")
+                    passed = count > expectedCount;
+                else if (op === "lt")
+                    passed = count < expectedCount;
+                return { check, passed, actual: count, expected: expectedCount };
+            }
+            case "js_truthy": {
+                const result = await call(ctx, "evaluateJS", { tabId, expression: value });
+                const truthy = Boolean(result);
+                return { check, passed: truthy, actual: result, expected: true };
+            }
+            default:
+                return { check, passed: false, actual: null, expected: null };
+        }
+    }
+    catch (err) {
+        return {
+            check,
+            passed: false,
+            actual: err.message,
+            expected,
+        };
+    }
+}
+// ============================================================================
+// Action Dispatchers
+// ============================================================================
+async function executeNavigate(ctx, config, tabId, vars) {
+    const url = substituteVars(config.url, vars);
+    if (tabId === null) {
+        // Open new tab
+        const result = (await call(ctx, "openTab", { url }));
+        const newTabId = result.tabId;
+        if (!newTabId)
+            throw new Error("Failed to open tab");
+        await sleep(2000); // Wait for initial load
+        return { tabId: newTabId, result };
+    }
+    else {
+        // Navigate existing tab
+        const result = await call(ctx, "navigate", { tabId, url });
+        await sleep(1500);
+        return { tabId, result };
+    }
+}
+async function executeClick(ctx, config, tabId, vars) {
+    const selector = substituteVars(config.selector, vars);
+    const text = config.text ? substituteVars(config.text, vars) : undefined;
+    return call(ctx, "smartClick", {
+        tabId,
+        selectors: [selector],
+        texts: text ? [text] : undefined,
+        scrollToFind: true,
+    });
+}
+async function executeType(ctx, config, tabId, vars) {
+    const selector = substituteVars(config.selector, vars);
+    const text = substituteVars(config.text, vars);
+    if (config.clear) {
+        await call(ctx, "evaluateJS", {
+            tabId,
+            expression: `
+        (() => {
+          const el = document.querySelector(${JSON.stringify(selector)});
+          if (el) el.value = '';
+        })()
+      `,
+        });
+    }
+    const result = await call(ctx, "smartType", {
+        tabId,
+        selectors: [selector],
+        value: text,
+        pressEnter: config.press_enter ?? false,
+    });
+    return result;
+}
+async function executeSelect(ctx, config, tabId, vars) {
+    const selector = substituteVars(config.selector, vars);
+    const value = config.value ? substituteVars(config.value, vars) : undefined;
+    const text = config.text ? substituteVars(config.text, vars) : undefined;
+    let expression = "";
+    if (value !== undefined) {
+        expression = `
+      (() => {
+        const sel = document.querySelector(${JSON.stringify(selector)});
+        if (sel) {
+          sel.value = ${JSON.stringify(value)};
+          sel.dispatchEvent(new Event('change', { bubbles: true }));
+          return true;
+        }
+        return false;
+      })()
+    `;
+    }
+    else if (text !== undefined) {
+        expression = `
+      (() => {
+        const sel = document.querySelector(${JSON.stringify(selector)});
+        if (sel) {
+          for (const opt of sel.options) {
+            if (opt.text === ${JSON.stringify(text)}) {
+              sel.value = opt.value;
+              sel.dispatchEvent(new Event('change', { bubbles: true }));
+              return true;
+            }
+          }
+        }
+        return false;
+      })()
+    `;
+    }
+    else if (config.index !== undefined) {
+        expression = `
+      (() => {
+        const sel = document.querySelector(${JSON.stringify(selector)});
+        if (sel && sel.options[${config.index}]) {
+          sel.selectedIndex = ${config.index};
+          sel.dispatchEvent(new Event('change', { bubbles: true }));
+          return true;
+        }
+        return false;
+      })()
+    `;
+    }
+    return call(ctx, "evaluateJS", { tabId, expression });
+}
+async function executeScroll(ctx, config, tabId, vars) {
+    const selector = config.selector ? substituteVars(config.selector, vars) : undefined;
+    if (selector) {
+        // Scroll to element
+        await call(ctx, "evaluateJS", {
+            tabId,
+            expression: `
+        (() => {
+          const el = document.querySelector(${JSON.stringify(selector)});
+          if (el) el.scrollIntoView({ behavior: 'smooth', block: 'center' });
+        })()
+      `,
+        });
+        return { scrolled_to: selector };
+    }
+    const deltaY = config.y ?? (config.direction === "up" ? -600 : 600);
+    const pages = config.pages ?? 1;
+    for (let i = 0; i < pages; i++) {
+        await call(ctx, "scrollPage", { tabId, deltaY, smooth: true });
+        await sleep(400);
+    }
+    return { scrolled: pages };
+}
+async function executeWait(ctx, config, tabId, vars, timeoutMs) {
+    const value = substituteVars(config.value, vars);
+    const timeout = config.timeout_ms ?? timeoutMs;
+    switch (config.type) {
+        case "selector":
+            return call(ctx, "waitFor", {
+                tabId,
+                condition: "element",
+                selectors: [value],
+                timeoutMs: timeout,
+            });
+        case "text":
+            return call(ctx, "waitFor", {
+                tabId,
+                condition: "text",
+                text: value,
+                timeoutMs: timeout,
+            });
+        case "url":
+            return call(ctx, "waitFor", {
+                tabId,
+                condition: "url",
+                urlContains: value,
+                timeoutMs: timeout,
+            });
+        case "time":
+            await sleep(Number(value));
+            return { waited_ms: Number(value) };
+        case "network_idle":
+            await sleep(2000); // Simple network idle approximation
+            return { network_idle: true };
+        default:
+            throw new Error(`Unknown wait type: ${config.type}`);
+    }
+}
+async function executeExtract(ctx, config, tabId, vars) {
+    if (config.expression) {
+        const expr = substituteVars(config.expression, vars);
+        return call(ctx, "evaluateJS", { tabId, expression: expr });
+    }
+    if (config.selector) {
+        const selector = substituteVars(config.selector, vars);
+        const result = (await call(ctx, "queryDom", { tabId, selector }));
+        if (config.attribute) {
+            const attr = config.attribute;
+            const extracted = await call(ctx, "evaluateJS", {
+                tabId,
+                expression: `
+          Array.from(document.querySelectorAll(${JSON.stringify(selector)}))
+            .map(el => el.getAttribute(${JSON.stringify(attr)}))
+        `,
+            });
+            return config.all ? extracted : extracted[0];
+        }
+        if (config.property) {
+            const prop = config.property;
+            const extracted = await call(ctx, "evaluateJS", {
+                tabId,
+                expression: `
+          Array.from(document.querySelectorAll(${JSON.stringify(selector)}))
+            .map(el => el[${JSON.stringify(prop)}])
+        `,
+            });
+            return config.all ? extracted : extracted[0];
+        }
+        return result;
+    }
+    return call(ctx, "extractData", { tabId });
+}
+async function executeScreenshot(ctx, config, tabId) {
+    return call(ctx, "screenshot", { tabId });
+}
+async function executeEvaluate(ctx, config, tabId, vars) {
+    const expression = substituteVars(config.expression, vars);
+    return call(ctx, "evaluateJS", { tabId, expression });
+}
+async function executeAssert(ctx, config, tabId, vars) {
+    return checkAssertion(ctx, tabId, config, vars);
+}
+async function executeKeyboard(ctx, config, tabId, vars) {
+    const key = substituteVars(config.key, vars);
+    return call(ctx, "pressKey", {
+        tabId,
+        key,
+        modifiers: config.modifiers ?? [],
+    });
+}
+async function executeHover(ctx, config, tabId, vars) {
+    const selector = substituteVars(config.selector, vars);
+    return call(ctx, "evaluateJS", {
+        tabId,
+        expression: `
+      (() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (el) {
+          el.dispatchEvent(new MouseEvent('mouseover', { bubbles: true, cancelable: true }));
+          el.dispatchEvent(new MouseEvent('mouseenter', { bubbles: true, cancelable: true }));
+          return true;
+        }
+        return false;
+      })()
+    `,
+    });
+}
+async function executeTab(ctx, config, vars) {
+    switch (config.action) {
+        case "new": {
+            const url = config.url ? substituteVars(config.url, vars) : "about:blank";
+            const result = (await call(ctx, "openTab", { url }));
+            return { tabId: result.tabId ?? null, result };
+        }
+        case "close": {
+            if (config.index !== undefined) {
+                // Close by index - we don't have direct tab list access, skip
+                return { tabId: null, result: { closed: false } };
+            }
+            return { tabId: null, result: { closed: true } };
+        }
+        case "switch": {
+            if (config.index !== undefined) {
+                // Switch by index - call focusTab with the index
+                await call(ctx, "focusTab", { tabId: config.index });
+                return { tabId: config.index, result: { switched: true } };
+            }
+            return { tabId: null, result: { switched: false } };
+        }
+        default:
+            throw new Error(`Unknown tab action: ${config.action}`);
+    }
+}
+async function executeGroup(ctx, config, tabId, vars, suiteDefaults) {
+    const results = [];
+    let currentTabId = tabId;
+    let currentVars = { ...vars };
+    // Handle condition
+    if (config.condition) {
+        const condExpr = substituteVars(config.condition, currentVars);
+        let condResult = false;
+        if (currentTabId !== null) {
+            try {
+                condResult = Boolean(await call(ctx, "evaluateJS", { tabId: currentTabId, expression: condExpr }));
+            }
+            catch {
+                condResult = false;
+            }
+        }
+        if (!condResult) {
+            return { results, tabId: currentTabId, variables: currentVars };
+        }
+    }
+    // Handle loop
+    if (config.loop) {
+        const loop = config.loop;
+        let iterations = 0;
+        const maxIterations = loop.count ?? 1000; // Safety limit
+        while (iterations < maxIterations) {
+            if (loop.while) {
+                const whileExpr = substituteVars(loop.while, currentVars);
+                if (currentTabId === null)
+                    break;
+                const condResult = Boolean(await call(ctx, "evaluateJS", { tabId: currentTabId, expression: whileExpr }));
+                if (!condResult)
+                    break;
+            }
+            // Execute steps
+            for (const step of config.steps) {
+                const stepResult = await executeStep(ctx, step, currentVars, currentTabId, suiteDefaults);
+                results.push(stepResult.result);
+                currentTabId = stepResult.tabId;
+                currentVars = stepResult.variables;
+                if (stepResult.result.status === "failed" || stepResult.result.status === "error") {
+                    return { results, tabId: currentTabId, variables: currentVars };
+                }
+            }
+            iterations++;
+            if (loop.count !== undefined && iterations >= loop.count)
+                break;
+        }
+    }
+    else {
+        // Execute steps once
+        for (const step of config.steps) {
+            const stepResult = await executeStep(ctx, step, currentVars, currentTabId, suiteDefaults);
+            results.push(stepResult.result);
+            currentTabId = stepResult.tabId;
+            currentVars = stepResult.variables;
+            if (stepResult.result.status === "failed" || stepResult.result.status === "error") {
+                break;
+            }
+        }
+    }
+    return { results, tabId: currentTabId, variables: currentVars };
+}
+// ============================================================================
+// Step Execution
+// ============================================================================
+export async function executeStep(ctx, step, variables, tabId, suiteDefaults) {
+    const startTime = Date.now();
+    const logs = [];
+    let currentTabId = tabId;
+    let currentVars = { ...variables };
+    // Handle disabled steps
+    if (step.disabled) {
+        return {
+            result: {
+                step_id: step.id,
+                step_name: step.name,
+                action: step.action,
+                status: "skipped",
+                duration_ms: 0,
+            },
+            tabId: currentTabId,
+            variables: currentVars,
+        };
+    }
+    // Wait before execution
+    if (step.wait_before_ms) {
+        await sleep(step.wait_before_ms);
+    }
+    const timeout = step.timeout_ms ?? suiteDefaults?.timeout_ms ?? 15000;
+    const onError = step.on_error ?? suiteDefaults?.on_error ?? "stop";
+    const retryConfig = step.retry ?? { max: 0, delay_ms: 1000 };
+    let attempts = 0;
+    let lastError = null;
+    let actionResult = null;
+    // Retry loop
+    while (attempts <= retryConfig.max) {
+        try {
+            // Substitute variables in config
+            const config = substituteInConfig(step.config, currentVars);
+            // Execute action
+            switch (step.action) {
+                case "navigate": {
+                    const navResult = await executeNavigate(ctx, config, currentTabId, currentVars);
+                    currentTabId = navResult.tabId;
+                    actionResult = navResult.result;
+                    break;
+                }
+                case "click":
+                    if (currentTabId === null)
+                        throw new Error("No active tab for click action");
+                    actionResult = await executeClick(ctx, config, currentTabId, currentVars);
+                    break;
+                case "type":
+                    if (currentTabId === null)
+                        throw new Error("No active tab for type action");
+                    actionResult = await executeType(ctx, config, currentTabId, currentVars);
+                    break;
+                case "select":
+                    if (currentTabId === null)
+                        throw new Error("No active tab for select action");
+                    actionResult = await executeSelect(ctx, config, currentTabId, currentVars);
+                    break;
+                case "scroll":
+                    if (currentTabId === null)
+                        throw new Error("No active tab for scroll action");
+                    actionResult = await executeScroll(ctx, config, currentTabId, currentVars);
+                    break;
+                case "wait":
+                    if (currentTabId === null)
+                        throw new Error("No active tab for wait action");
+                    actionResult = await executeWait(ctx, config, currentTabId, currentVars, timeout);
+                    break;
+                case "extract":
+                    if (currentTabId === null)
+                        throw new Error("No active tab for extract action");
+                    actionResult = await executeExtract(ctx, config, currentTabId, currentVars);
+                    break;
+                case "screenshot":
+                    if (currentTabId === null)
+                        throw new Error("No active tab for screenshot action");
+                    actionResult = await executeScreenshot(ctx, config, currentTabId);
+                    break;
+                case "evaluate":
+                    if (currentTabId === null)
+                        throw new Error("No active tab for evaluate action");
+                    actionResult = await executeEvaluate(ctx, config, currentTabId, currentVars);
+                    break;
+                case "assert":
+                    if (currentTabId === null)
+                        throw new Error("No active tab for assert action");
+                    actionResult = await executeAssert(ctx, config, currentTabId, currentVars);
+                    break;
+                case "keyboard":
+                    if (currentTabId === null)
+                        throw new Error("No active tab for keyboard action");
+                    actionResult = await executeKeyboard(ctx, config, currentTabId, currentVars);
+                    break;
+                case "hover":
+                    if (currentTabId === null)
+                        throw new Error("No active tab for hover action");
+                    actionResult = await executeHover(ctx, config, currentTabId, currentVars);
+                    break;
+                case "tab": {
+                    const tabResult = await executeTab(ctx, config, currentVars);
+                    if (tabResult.tabId !== null)
+                        currentTabId = tabResult.tabId;
+                    actionResult = tabResult.result;
+                    break;
+                }
+                case "group": {
+                    const groupResult = await executeGroup(ctx, config, currentTabId, currentVars, suiteDefaults);
+                    currentTabId = groupResult.tabId;
+                    currentVars = groupResult.variables;
+                    actionResult = { steps: groupResult.results };
+                    break;
+                }
+                case "recipe": {
+                    const cfg = config;
+                    const recipeSlug = substituteVars(cfg.slug, currentVars);
+                    const recipeVars = cfg.variables
+                        ? Object.fromEntries(Object.entries(cfg.variables).map(([k, v]) => [k, substituteVars(v, currentVars)]))
+                        : undefined;
+                    actionResult = await loadRecipe(recipeSlug, recipeVars);
+                    break;
+                }
+                default:
+                    throw new Error(`Unknown action: ${step.action}`);
+            }
+            // Success - break retry loop
+            lastError = null;
+            break;
+        }
+        catch (err) {
+            lastError = err;
+            attempts++;
+            if (onError === "retry" && attempts <= retryConfig.max) {
+                logs.push(`Attempt ${attempts} failed: ${lastError.message}. Retrying...`);
+                await sleep(retryConfig.delay_ms);
+            }
+            else {
+                break;
+            }
+        }
+    }
+    // Handle final error
+    if (lastError) {
+        const duration = Date.now() - startTime;
+        if (onError === "continue") {
+            logs.push(`Error (continuing): ${lastError.message}`);
+            return {
+                result: {
+                    step_id: step.id,
+                    step_name: step.name,
+                    action: step.action,
+                    status: "error",
+                    duration_ms: duration,
+                    error: lastError.message,
+                    logs,
+                },
+                tabId: currentTabId,
+                variables: currentVars,
+            };
+        }
+        return {
+            result: {
+                step_id: step.id,
+                step_name: step.name,
+                action: step.action,
+                status: "failed",
+                duration_ms: duration,
+                error: lastError.message,
+                logs,
+            },
+            tabId: currentTabId,
+            variables: currentVars,
+        };
+    }
+    // Run assertions
+    const assertionResults = [];
+    if (step.assertions && currentTabId !== null) {
+        for (const assertion of step.assertions) {
+            const result = await checkAssertion(ctx, currentTabId, assertion, currentVars);
+            assertionResults.push(result);
+            if (!result.passed) {
+                logs.push(`Assertion failed: ${assertion.check} - expected ${assertion.expected}, got ${result.actual}`);
+            }
+        }
+    }
+    // Extract variables
+    const extracted = {};
+    if (step.extract && currentTabId !== null) {
+        for (const [varName, expression] of Object.entries(step.extract)) {
+            try {
+                const expr = substituteVars(expression, currentVars);
+                const value = await call(ctx, "evaluateJS", { tabId: currentTabId, expression: expr });
+                extracted[varName] = String(value ?? "");
+                currentVars[varName] = extracted[varName];
+            }
+            catch (err) {
+                logs.push(`Failed to extract ${varName}: ${err.message}`);
+            }
+        }
+    }
+    // Wait after execution
+    if (step.wait_after_ms) {
+        await sleep(step.wait_after_ms);
+    }
+    const duration = Date.now() - startTime;
+    const allAssertionsPassed = assertionResults.length === 0 || assertionResults.every((a) => a.passed);
+    return {
+        result: {
+            step_id: step.id,
+            step_name: step.name,
+            action: step.action,
+            status: allAssertionsPassed ? "passed" : "failed",
+            duration_ms: duration,
+            assertions: assertionResults.length > 0 ? assertionResults : undefined,
+            extracted: Object.keys(extracted).length > 0 ? extracted : undefined,
+            logs: logs.length > 0 ? logs : undefined,
+        },
+        tabId: currentTabId,
+        variables: currentVars,
+    };
+}
+// ============================================================================
+// Suite Execution
+// ============================================================================
+export async function executeSuite(ctx, suiteId, suite) {
+    const startTime = new Date();
+    const steps = [];
+    let currentTabId = null;
+    let variables = { ...suite.variables };
+    let status = "passed";
+    try {
+        // Execute setup recipe (before setup steps)
+        if (suite.setup_recipe) {
+            const recipeStart = Date.now();
+            try {
+                const recipeResult = await loadRecipe(suite.setup_recipe.slug, suite.setup_recipe.variables);
+                steps.push({
+                    step_id: "__setup_recipe",
+                    step_name: `Recipe: ${suite.setup_recipe.slug}`,
+                    action: "recipe",
+                    status: "passed",
+                    duration_ms: Date.now() - recipeStart,
+                    logs: [JSON.stringify(recipeResult)],
+                });
+            }
+            catch (err) {
+                steps.push({
+                    step_id: "__setup_recipe",
+                    step_name: `Recipe: ${suite.setup_recipe.slug}`,
+                    action: "recipe",
+                    status: "failed",
+                    duration_ms: Date.now() - recipeStart,
+                    error: err.message,
+                });
+                status = "failed";
+            }
+        }
+        // Execute setup steps
+        if (suite.setup && status === "passed") {
+            for (const step of suite.setup) {
+                const result = await executeStep(ctx, step, variables, currentTabId, suite.defaults);
+                steps.push(result.result);
+                currentTabId = result.tabId;
+                variables = result.variables;
+                if (result.result.status === "failed" || result.result.status === "error") {
+                    status = "failed";
+                    break;
+                }
+            }
+        }
+        // Execute main steps (only if setup succeeded)
+        if (status === "passed") {
+            for (const step of suite.steps) {
+                const result = await executeStep(ctx, step, variables, currentTabId, suite.defaults);
+                steps.push(result.result);
+                currentTabId = result.tabId;
+                variables = result.variables;
+                if (result.result.status === "failed") {
+                    status = "failed";
+                    // Continue or stop based on on_error
+                    if (step.on_error !== "continue")
+                        break;
+                }
+                else if (result.result.status === "error") {
+                    status = "error";
+                    if (step.on_error !== "continue")
+                        break;
+                }
+                // Wait between steps
+                if (suite.defaults?.wait_between_ms) {
+                    await sleep(suite.defaults.wait_between_ms);
+                }
+            }
+        }
+    }
+    catch (err) {
+        status = "error";
+        steps.push({
+            step_id: "suite_error",
+            action: "error",
+            status: "error",
+            duration_ms: 0,
+            error: err.message,
+        });
+    }
+    finally {
+        // Always execute teardown steps
+        if (suite.teardown) {
+            for (const step of suite.teardown) {
+                try {
+                    const result = await executeStep(ctx, step, variables, currentTabId, suite.defaults);
+                    steps.push(result.result);
+                    currentTabId = result.tabId;
+                    variables = result.variables;
+                }
+                catch (err) {
+                    steps.push({
+                        step_id: step.id,
+                        step_name: step.name,
+                        action: step.action,
+                        status: "error",
+                        duration_ms: 0,
+                        error: err.message,
+                    });
+                }
+            }
+        }
+        // Always execute teardown recipe (after teardown steps)
+        if (suite.teardown_recipe) {
+            const recipeStart = Date.now();
+            try {
+                const recipeResult = await loadRecipe(suite.teardown_recipe.slug, suite.teardown_recipe.variables);
+                steps.push({
+                    step_id: "__teardown_recipe",
+                    step_name: `Recipe: ${suite.teardown_recipe.slug}`,
+                    action: "recipe",
+                    status: "passed",
+                    duration_ms: Date.now() - recipeStart,
+                    logs: [JSON.stringify(recipeResult)],
+                });
+            }
+            catch (err) {
+                steps.push({
+                    step_id: "__teardown_recipe",
+                    step_name: `Recipe: ${suite.teardown_recipe.slug}`,
+                    action: "recipe",
+                    status: "error",
+                    duration_ms: Date.now() - recipeStart,
+                    error: err.message,
+                });
+            }
+        }
+    }
+    const endTime = new Date();
+    return {
+        suite_id: suiteId,
+        suite_name: suite.name,
+        status,
+        started_at: startTime.toISOString(),
+        completed_at: endTime.toISOString(),
+        duration_ms: endTime.getTime() - startTime.getTime(),
+        steps,
+        extracted: variables,
+    };
+}
+//# sourceMappingURL=executor.js.map