@cutleryapp/agent 1.0.3

package/dist/executor.js

@@ -0,0 +1,420 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestExecutor = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const playwright_1 = require("playwright");
+class TestExecutor {
+    options;
+    browser = null;
+    context = null;
+    page = null;
+    screenshots = [];
+    constructor(options) {
+        this.options = options;
+    }
+    async execute(testCase) {
+        const result = {
+            success: true,
+            steps: [],
+            screenshots: [],
+        };
+        try {
+            // Ensure output directory exists
+            if (!(0, fs_1.existsSync)(this.options.outputDir)) {
+                (0, fs_1.mkdirSync)(this.options.outputDir, { recursive: true });
+            }
+            // Launch browser
+            await this.launchBrowser();
+            // Process test variables
+            const variables = testCase.test_variables || {};
+            // Execute each step
+            for (let i = 0; i < testCase.automated_steps.length; i++) {
+                let step = testCase.automated_steps[i];
+                const startTime = Date.now();
+                // Replace variables in step
+                Object.entries(variables).forEach(([key, value]) => {
+                    step = step.replace(new RegExp(`{{${key}}}`, "g"), value);
+                    step = step.replace(new RegExp(`\\$\\{${key}\\}`, "g"), value);
+                });
+                const stepResult = {
+                    step,
+                    action: step,
+                };
+                try {
+                    // Notify step start
+                    if (this.options.onProgress) {
+                        this.options.onProgress({
+                            type: "step-start",
+                            step: i + 1,
+                            total: testCase.automated_steps.length,
+                            message: step,
+                        });
+                    }
+                    await this.executeStep(step, i + 1);
+                    stepResult.duration = Date.now() - startTime;
+                    result.steps.push(stepResult);
+                    // Take screenshot after successful step
+                    const screenshot = await this.takeScreenshot(`step-${i + 1}`);
+                    // Notify step complete with screenshot
+                    if (this.options.onProgress) {
+                        this.options.onProgress({
+                            type: "step-complete",
+                            step: i + 1,
+                            total: testCase.automated_steps.length,
+                            message: step,
+                            screenshot: screenshot || undefined,
+                        });
+                    }
+                    if (this.options.verbose) {
+                        console.log(`   ✅ Step ${i + 1}: ${step}`);
+                    }
+                }
+                catch (error) {
+                    stepResult.error = error.message;
+                    stepResult.duration = Date.now() - startTime;
+                    result.steps.push(stepResult);
+                    result.success = false;
+                    // Take screenshot on error
+                    const screenshot = await this.takeScreenshot(`error-step-${i + 1}`);
+                    // Notify step error with screenshot
+                    if (this.options.onProgress) {
+                        this.options.onProgress({
+                            type: "step-error",
+                            step: i + 1,
+                            total: testCase.automated_steps.length,
+                            message: step,
+                            error: error.message,
+                            screenshot: screenshot || undefined,
+                        });
+                    }
+                    if (this.options.verbose) {
+                        console.log(`   ❌ Step ${i + 1}: ${step}`);
+                        console.log(`      Error: ${error.message}`);
+                    }
+                }
+            }
+            // Take final screenshot
+            await this.takeScreenshot("final");
+            result.screenshots = this.screenshots;
+        }
+        catch (error) {
+            result.success = false;
+            result.error = error.message;
+        }
+        finally {
+            await this.cleanup();
+        }
+        return result;
+    }
+    async launchBrowser() {
+        const browsers = { chromium: playwright_1.chromium, firefox: playwright_1.firefox, webkit: playwright_1.webkit };
+        const browserType = browsers[this.options.browserType];
+        this.browser = await browserType.launch({
+            headless: this.options.headless,
+        });
+        this.context = await this.browser.newContext({
+            viewport: { width: 1280, height: 720 },
+        });
+        this.page = await this.context.newPage();
+    }
+    async executeStep(step, stepNumber) {
+        if (!this.page)
+            throw new Error("Browser not initialized");
+        const lowerStep = step.toLowerCase();
+        // Navigate
+        if (lowerStep.includes("navigate") || lowerStep.includes("go to")) {
+            const urlMatch = step.match(/https?:\/\/[^\s"']+/) ||
+                step.match(/navigate\s+to\s+(.+)/i);
+            if (urlMatch) {
+                const url = urlMatch[0] || urlMatch[1];
+                await this.page.goto(url.trim().replace(/["',;]+$/, ""));
+                await this.page.waitForLoadState("networkidle");
+                return;
+            }
+        }
+        // Wait
+        if (lowerStep.includes("wait")) {
+            const secondsMatch = step.match(/(\d+)\s*seconds?/i);
+            if (secondsMatch) {
+                await this.page.waitForTimeout(parseInt(secondsMatch[1]) * 1000);
+                return;
+            }
+            const selectorMatch = step.match(/wait\s+for\s+["']?(.+?)["']?\s+to\s+be\s+visible/i);
+            if (selectorMatch) {
+                await this.page.waitForSelector(selectorMatch[1], {
+                    state: "visible",
+                    timeout: 30000,
+                });
+                return;
+            }
+        }
+        // Fill (supports both formats: "Fill X in Y" and "Fill X with Y")
+        let fillMatch = step.match(/fill\s+["']?(.+?)["']?\s+with\s+["']?(.+?)["']?$/i);
+        let text;
+        let selector;
+        // Strip a single layer of matched outer quotes (straight, smart, or
+        // backtick) so values like `"foo"` or `“foo”` aren't typed verbatim.
+        const stripQuotes = (raw) => {
+            const t = raw.trim();
+            if (t.length < 2)
+                return t;
+            const pairs = [
+                ['"', '"'],
+                ["'", "'"],
+                ["“", "”"],
+                ["‘", "’"],
+                ["`", "`"],
+            ];
+            const f = t[0];
+            const l = t[t.length - 1];
+            for (const [o, c] of pairs)
+                if (f === o && l === c)
+                    return t.slice(1, -1);
+            return t;
+        };
+        if (fillMatch) {
+            // Format: Fill "selector" with "value"
+            selector = stripQuotes(fillMatch[1]);
+            text = stripQuotes(fillMatch[2]);
+        }
+        else {
+            // Try alternate format: Fill "value" in "selector"
+            fillMatch = step.match(/fill\s+["']?(.+?)["']?\s+in\s+["']?(.+?)["']?$/i);
+            if (fillMatch) {
+                text = stripQuotes(fillMatch[1]);
+                selector = stripQuotes(fillMatch[2]);
+            }
+        }
+        if (fillMatch && selector && text !== undefined) {
+            // If the captured selector looks like a real CSS selector, trust it.
+            if (/[#.\[\]:>]/.test(selector)) {
+                await this.page.fill(selector, text);
+                return;
+            }
+            // Otherwise treat it as a human-readable label and try a battery of
+            // strategies until one resolves a unique, visible element. This makes
+            // steps like `Fill "standard_user" in "Username"` work against pages
+            // where the actual field is `<input name="user-name" placeholder="Username">`.
+            await this.fillByLabel(selector, text);
+            return;
+        }
+        // Click
+        const clickMatch = step.match(/click\s+["']?(.+?)["']?$/i);
+        if (clickMatch) {
+            let selector = clickMatch[1].trim().replace(/^["']|["']$/g, "");
+            // Smart button selector
+            if (!/[#.\[\]:>]/.test(selector)) {
+                selector = `button:has-text("${selector}"), a:has-text("${selector}"), [role="button"]:has-text("${selector}")`;
+            }
+            await this.page.click(selector);
+            await this.page.waitForTimeout(500);
+            return;
+        }
+        // Verify text is present in element
+        // Format: Verify "text" is present in "selector" OR Check if "text" is present
+        const verifyMatch = step.match(/(?:verify|check\s+if)\s+.*?["'](.+?)["'].*?(?:is\s+present|visible)(?:\s+in\s+["']?(.+?)["']?)?/i);
+        if (verifyMatch) {
+            const text = verifyMatch[1].trim();
+            let selector = verifyMatch[2]?.trim().replace(/^["']|["']$/g, "");
+            // If selector contains "locator(", extract the actual selector
+            if (selector && selector.includes("locator(")) {
+                const locatorMatch = selector.match(/locator\(['"](.+?)['"]\)/);
+                if (locatorMatch) {
+                    selector = locatorMatch[1];
+                }
+            }
+            if (selector) {
+                // Check if element with selector contains the text
+                await this.page.waitForSelector(selector, {
+                    state: "visible",
+                    timeout: 10000,
+                });
+                const element = await this.page.locator(selector);
+                const content = await element.textContent();
+                if (!content?.includes(text)) {
+                    throw new Error(`Expected "${text}" to be present in element "${selector}", but got "${content}"`);
+                }
+            }
+            else {
+                // Check if text is visible anywhere on the page
+                await this.page.waitForSelector(`text="${text}"`, {
+                    state: "visible",
+                    timeout: 10000,
+                });
+            }
+            return;
+        }
+        // Check visibility (legacy format)
+        const visibleMatch = step.match(/check\s+if\s+["']?(.+?)["']?\s+is\s+visible/i);
+        if (visibleMatch) {
+            const text = visibleMatch[1].trim();
+            await this.page.waitForSelector(`text="${text}"`, {
+                state: "visible",
+                timeout: 10000,
+            });
+            return;
+        }
+        // Screenshot
+        if (lowerStep.includes("screenshot") || lowerStep.includes("capture")) {
+            await this.takeScreenshot(`step-${stepNumber}`);
+            return;
+        }
+        throw new Error(`Could not interpret step: ${step}`);
+    }
+    /**
+     * Resolve a human-readable field label to a real input and fill it.
+     *
+     * Tries strategies in order from most specific to most fuzzy. Each strategy
+     * is given a short probe timeout so a missing match falls through quickly.
+     * Stops on the first strategy that finds exactly one visible element.
+     */
+    async fillByLabel(label, value) {
+        if (!this.page)
+            throw new Error("Page not initialised");
+        const page = this.page;
+        const probeMs = 1500;
+        const variants = labelVariants(label); // e.g. ["Username", "username", "user-name", "user_name", "userName"]
+        const labelRe = new RegExp(escapeRegex(label), "i");
+        // Build CSS attribute selectors with case-insensitive flag (` i`).
+        // [attr*=value i] matches when attr CONTAINS value, case-insensitive.
+        const attrContains = (attr) => variants.map((v) => `input[${attr}*="${cssEscape(v)}" i], textarea[${attr}*="${cssEscape(v)}" i], [contenteditable="true"][${attr}*="${cssEscape(v)}" i]`).join(", ");
+        const strategies = [
+            // 1. Playwright accessibility — best signal when present.
+            { name: "getByLabel", run: () => page.getByLabel(labelRe).first().fill(value, { timeout: probeMs }) },
+            { name: "getByPlaceholder", run: () => page.getByPlaceholder(labelRe).first().fill(value, { timeout: probeMs }) },
+            { name: "getByRole(textbox,name)", run: () => page.getByRole("textbox", { name: labelRe }).first().fill(value, { timeout: probeMs }) },
+            // 2. Common automation hooks.
+            { name: "data-test", run: () => page.locator(attrContains("data-test")).first().fill(value, { timeout: probeMs }) },
+            { name: "data-testid", run: () => page.locator(attrContains("data-testid")).first().fill(value, { timeout: probeMs }) },
+            // 3. Native attributes — exact then contains, with variant expansion.
+            { name: "name/id exact (variants)", run: async () => {
+                    const exact = variants.flatMap((v) => [
+                        `input[name="${cssEscape(v)}" i]`,
+                        `input[id="${cssEscape(v)}" i]`,
+                        `textarea[name="${cssEscape(v)}" i]`,
+                        `textarea[id="${cssEscape(v)}" i]`,
+                    ]).join(", ");
+                    await page.locator(exact).first().fill(value, { timeout: probeMs });
+                } },
+            { name: "name/id contains (variants)", run: () => page.locator(`${attrContains("name")}, ${attrContains("id")}`).first().fill(value, { timeout: probeMs }) },
+            // 4. ARIA / placeholder / autocomplete fallbacks via attribute contains.
+            { name: "aria-label contains", run: () => page.locator(attrContains("aria-label")).first().fill(value, { timeout: probeMs }) },
+            { name: "placeholder contains", run: () => page.locator(attrContains("placeholder")).first().fill(value, { timeout: probeMs }) },
+            // 5. Last resort: fuzzy "label-near-input" — a label/legend/span
+            //    containing the text whose nearest input we then fill.
+            { name: "label-text → following input", run: async () => {
+                    const handle = await page.locator(`label:has-text("${escapeForCssContains(label)}")`).first().elementHandle({ timeout: probeMs });
+                    if (!handle)
+                        throw new Error("no label");
+                    // Try `for` attribute first.
+                    const forAttr = await handle.getAttribute("for");
+                    if (forAttr) {
+                        await page.locator(`#${cssEscape(forAttr)}`).first().fill(value, { timeout: probeMs });
+                        return;
+                    }
+                    // Otherwise nearest descendant or following input.
+                    const nested = handle.asElement()?.$$('input, textarea, [contenteditable="true"]');
+                    const inputs = await nested;
+                    if (inputs && inputs.length > 0) {
+                        await inputs[0].fill(value, { timeout: probeMs });
+                        return;
+                    }
+                    throw new Error("no input near label");
+                } },
+        ];
+        const errors = [];
+        for (const s of strategies) {
+            try {
+                await s.run();
+                if (this.options.verbose) {
+                    console.log(`[fill] resolved "${label}" via ${s.name}`);
+                }
+                return;
+            }
+            catch (e) {
+                errors.push(`${s.name}: ${e?.message?.split("\n")[0] || String(e)}`);
+            }
+        }
+        throw new Error(`Could not find input field for label "${label}". Tried ${strategies.length} strategies:\n  - ${errors.slice(0, 5).join("\n  - ")}${errors.length > 5 ? "\n  - …" : ""}`);
+    }
+    async takeScreenshot(name) {
+        if (!this.page)
+            return null;
+        try {
+            const timestamp = Date.now();
+            const filename = `${name}-${timestamp}.png`;
+            const filepath = (0, path_1.join)(this.options.outputDir, filename);
+            // Take screenshot and get buffer for base64 encoding
+            const buffer = await this.page.screenshot({
+                path: filepath,
+                fullPage: false,
+            });
+            this.screenshots.push(filepath);
+            // Return base64 encoded screenshot
+            return buffer.toString("base64");
+        }
+        catch (error) {
+            // Ignore screenshot errors
+            return null;
+        }
+    }
+    async cleanup() {
+        try {
+            if (this.context)
+                await this.context.close();
+            if (this.browser)
+                await this.browser.close();
+        }
+        catch (error) {
+            // Ignore cleanup errors
+        }
+    }
+}
+exports.TestExecutor = TestExecutor;
+/**
+ * Generate plausible attribute-value variants of a label so we can match
+ * common naming conventions used in real apps. e.g.:
+ *   "Username"          → ["Username", "username", "user name", "user-name", "user_name", "userName", "UserName"]
+ *   "Email Address"     → ["Email Address", "email address", "email-address", "email_address", "emailAddress", "EmailAddress"]
+ *   "First Name"        → ["First Name", "first name", "first-name", "first_name", "firstName", "FirstName"]
+ *   "Confirm-Password"  → ["Confirm-Password", "confirm-password", "confirm password", "confirm_password", "confirmPassword", "ConfirmPassword"]
+ */
+function labelVariants(label) {
+    const cleaned = label.trim();
+    if (!cleaned)
+        return [];
+    // Tokenise on whitespace, hyphens, underscores, and camelCase boundaries.
+    const tokens = cleaned
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .split(/[\s\-_]+/)
+        .filter(Boolean);
+    if (tokens.length === 0)
+        return [cleaned];
+    const lowerTokens = tokens.map((t) => t.toLowerCase());
+    const variants = new Set();
+    variants.add(cleaned);
+    variants.add(cleaned.toLowerCase());
+    variants.add(lowerTokens.join(" "));
+    variants.add(lowerTokens.join("-"));
+    variants.add(lowerTokens.join("_"));
+    variants.add(lowerTokens.join("")); // smashed: "username"
+    // camelCase
+    variants.add(lowerTokens[0] + lowerTokens.slice(1).map((t) => t[0].toUpperCase() + t.slice(1)).join(""));
+    // PascalCase
+    variants.add(lowerTokens.map((t) => t[0].toUpperCase() + t.slice(1)).join(""));
+    return Array.from(variants).filter((v) => v.length > 0);
+}
+/** Escape characters that have special meaning in CSS attribute string values. */
+function cssEscape(value) {
+    return value.replace(/[\\"]/g, "\\$&");
+}
+/** Escape for use inside Playwright `:has-text("...")`. */
+function escapeForCssContains(value) {
+    return value.replace(/["\\]/g, "\\$&");
+}
+/** Escape regex metacharacters in a label that becomes a RegExp. */
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//# sourceMappingURL=executor.js.map