@cutleryapp/agent 1.0.3

package/dist/mcp-executor.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestExecutor = void 0;
+const playwright_1 = require("playwright");
+const fs_1 = require("fs");
+class TestExecutor {
+    options;
+    activeBrowser = null;
+    constructor(options) {
+        this.options = options;
+    }
+    cancel() {
+        this.activeBrowser?.close().catch(() => { });
+        this.activeBrowser = null;
+    }
+    async execute(testCase) {
+        const result = { success: true, steps: [], screenshots: [] };
+        if (!(0, fs_1.existsSync)(this.options.outputDir)) {
+            (0, fs_1.mkdirSync)(this.options.outputDir, { recursive: true });
+        }
+        const variables = testCase.test_variables || {};
+        const baseUrlValue = this.options.baseUrl;
+        console.log('[executor] test_variables received:', JSON.stringify(variables));
+        console.log('[executor] baseUrl option:', baseUrlValue);
+        console.log('[executor] raw steps:', JSON.stringify(testCase.automated_steps));
+        // Build a case-insensitive lookup map
+        const varMap = {};
+        for (const [k, v] of Object.entries(variables)) {
+            varMap[k] = v;
+            varMap[k.toLowerCase()] = v;
+            varMap[k.toUpperCase()] = v;
+        }
+        // Always resolve BASE_URL from the executor's baseUrl option as fallback
+        if (baseUrlValue && !varMap['BASE_URL']) {
+            varMap['BASE_URL'] = baseUrlValue;
+            varMap['base_url'] = baseUrlValue;
+        }
+        console.log('[executor] varMap:', JSON.stringify(varMap));
+        const resolveVars = (s) => s.replace(/\{\{([^}]+)\}\}/g, (match, key) => varMap[key.trim()] ?? match).trim();
+        const steps = testCase.automated_steps.map(resolveVars);
+        console.log('[executor] resolved steps:', JSON.stringify(steps));
+        const browserLaunchers = { chromium: playwright_1.chromium, firefox: playwright_1.firefox, webkit: playwright_1.webkit };
+        const launchFn = browserLaunchers[this.options.browserType] ?? playwright_1.chromium;
+        let browser = null;
+        let page = null;
+        try {
+            browser = await launchFn.launch({ headless: this.options.headless !== false });
+            this.activeBrowser = browser;
+            page = await browser.newPage();
+            await page.setViewportSize({ width: 1280, height: 720 });
+            for (let i = 0; i < steps.length; i++) {
+                const raw = steps[i];
+                const lower = raw.toLowerCase();
+                const t0 = Date.now();
+                this.options.onProgress?.({
+                    type: "step-start",
+                    step: i + 1,
+                    total: steps.length,
+                    message: raw,
+                });
+                let stepError;
+                try {
+                    if (lower.includes("navigate to") || lower.includes("go to")) {
+                        // Extract URL wherever it appears in the step (handles emoji/symbol prefixes)
+                        const urlMatch = raw.match(/(?:navigate to|go to)\s+(https?:\/\/\S+|\/\S*|\S+\.\S+)/i);
+                        if (urlMatch) {
+                            let url = urlMatch[1].trim();
+                            if (url.startsWith("/") && this.options.baseUrl) {
+                                url = this.options.baseUrl.replace(/\/$/, "") + url;
+                            }
+                            await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
+                        }
+                        else if (this.options.baseUrl) {
+                            // Step says "navigate to" but no URL found — go to baseUrl
+                            await page.goto(this.options.baseUrl, { waitUntil: "domcontentloaded", timeout: 30000 });
+                        }
+                    }
+                    else if (lower.includes("click")) {
+                        const labelMatch = raw.match(/click\s+(?:on\s+)?(?:the\s+)?"?([^"]+?)"?\s*(?:button|link|tab)?$/i);
+                        const label = labelMatch?.[1]?.trim();
+                        if (label) {
+                            const nameRe = new RegExp(label, 'i');
+                            // Use a short probe timeout so fallbacks are fast
+                            const clicked = await tryClick(page, nameRe, label);
+                            if (!clicked)
+                                throw new Error(`Could not find clickable element: "${label}"`);
+                        }
+                    }
+                    else if (lower.includes("fill") || lower.includes("type") || lower.includes("enter")) {
+                        const quoted = raw.match(/(?:enter|fill|type)\s+"([^"]+)"\s+(?:in|into)\s+(?:the\s+)?(?:"([^"]+)"|(\w[\w\s]*?)\s*(?:field|input|box|area)?)\s*$/i);
+                        if (quoted) {
+                            const value = quoted[1];
+                            const quotedTarget = quoted[2];
+                            const bareLabel = quoted[3];
+                            // A token in quotes is usually a human-readable label
+                            // (e.g. `Fill "standard_user" in "Username"`), not a CSS
+                            // selector. Only treat it as a CSS selector when it actually
+                            // looks like one — otherwise resolve via tryFill so the
+                            // label can match placeholder/aria/data-test/label etc.
+                            const looksLikeCss = (s) => /[#.\[\]:>]/.test(s);
+                            if (quotedTarget && looksLikeCss(quotedTarget)) {
+                                await page.waitForSelector(quotedTarget, { state: "visible", timeout: 5000 });
+                                await page.fill(quotedTarget, value);
+                            }
+                            else if (quotedTarget) {
+                                await tryFill(page, quotedTarget.trim(), value);
+                            }
+                            else if (bareLabel) {
+                                await tryFill(page, bareLabel.trim(), value);
+                            }
+                        }
+                    }
+                    else if (lower.includes("wait") && lower.includes("second")) {
+                        const ms = raw.match(/wait\s+(\d+)\s*sec/i);
+                        if (ms)
+                            await page.waitForTimeout(parseInt(ms[1]) * 1000);
+                    }
+                    else if (lower.includes("wait for") && !lower.includes("second")) {
+                        const sel = extractSelector(raw, /wait for\s+"?([^"]+)"?\s+to be/i);
+                        if (sel)
+                            await page.waitForSelector(sel, { state: "visible", timeout: 15000 });
+                    }
+                    else if (lower.includes("verify") || lower.includes("check") || lower.includes("assert") || lower.includes("should")) {
+                        // Extract the quoted text to verify it's present on the page
+                        const textMatch = raw.match(/"([^"]+)"/);
+                        if (textMatch) {
+                            const expected = textMatch[1];
+                            try {
+                                await page.waitForFunction((text) => document.body.innerText.includes(text), expected, { timeout: 10000 });
+                            }
+                            catch {
+                                throw new Error(`Expected text not found: "${expected}"`);
+                            }
+                        }
+                    }
+                    else if (lower.includes("select") || lower.includes("choose")) {
+                        const selMatch = raw.match(/select\s+"([^"]+)"\s+(?:from|in)\s+"([^"]+)"/i);
+                        if (selMatch) {
+                            await page.selectOption(selMatch[2], { label: selMatch[1] });
+                        }
+                    }
+                    else {
+                        console.log(`  ⚠️  Unrecognised step (skipped): ${raw}`);
+                    }
+                }
+                catch (err) {
+                    stepError = err.message;
+                    result.success = false;
+                }
+                // Screenshot after each step
+                let screenshotB64 = "";
+                try {
+                    const buf = await page.screenshot({ fullPage: false });
+                    screenshotB64 = buf.toString("base64");
+                    result.screenshots.push(screenshotB64);
+                }
+                catch { /* ignore screenshot errors */ }
+                result.steps.push({
+                    step: raw,
+                    action: raw,
+                    duration: Date.now() - t0,
+                    error: stepError,
+                });
+                this.options.onProgress?.({
+                    type: stepError ? "step-error" : "step-complete",
+                    step: i + 1,
+                    total: steps.length,
+                    message: raw,
+                    error: stepError,
+                    screenshot: screenshotB64,
+                });
+                if (this.options.verbose) {
+                    console.log(`  ${stepError ? "✗" : "✓"} Step ${i + 1}/${steps.length}: ${raw}`);
+                    if (stepError)
+                        console.log(`    Error: ${stepError}`);
+                }
+            }
+        }
+        catch (err) {
+            result.success = false;
+            result.error = err.message;
+        }
+        finally {
+            await browser?.close().catch(() => { });
+            this.activeBrowser = null;
+        }
+        return result;
+    }
+}
+exports.TestExecutor = TestExecutor;
+function extractSelector(step, pattern) {
+    const m = step.match(pattern);
+    if (!m)
+        return null;
+    const raw = m[1].trim().replace(/^["']|["']$/g, "");
+    if (/^[\w\s-]+$/.test(raw) && !raw.startsWith("#") && !raw.startsWith(".")) {
+        return `text=${raw}`;
+    }
+    return raw;
+}
+// Fast probe: try each locator strategy with a short timeout so fallbacks don't stall
+async function tryClick(page, nameRe, label) {
+    const FAST = 1500;
+    const strategies = [
+        () => page.getByRole('button', { name: nameRe }).first().click({ timeout: FAST }),
+        () => page.getByRole('link', { name: nameRe }).first().click({ timeout: FAST }),
+        () => page.getByText(nameRe).first().click({ timeout: FAST }),
+        () => page.locator(`[value="${label}"], [aria-label="${label}"], [title="${label}"]`).first().click({ timeout: FAST }),
+    ];
+    for (const fn of strategies) {
+        try {
+            await fn();
+            return true;
+        }
+        catch { /* try next */ }
+    }
+    return false;
+}
+async function tryFill(page, label, value) {
+    const FAST = 1500;
+    const labelRe = new RegExp(escapeRegex(label), "i");
+    const variants = labelVariants(label);
+    const attrContains = (attr) => variants
+        .map((v) => `input[${attr}*="${cssEscape(v)}" i], textarea[${attr}*="${cssEscape(v)}" i], [contenteditable="true"][${attr}*="${cssEscape(v)}" i]`)
+        .join(", ");
+    // Ordered most-likely-to-resolve first so the success path matches the old
+    // 4-strategy implementation in latency. The extra strategies only run when
+    // the cheaper ones miss (i.e. the field genuinely needs fuzzier matching).
+    const strategies = [
+        // 1–2. Same as before — covers labelled inputs and placeholder-only inputs.
+        () => page.getByLabel(labelRe).first().fill(value),
+        () => page.getByPlaceholder(labelRe).first().fill(value),
+        // 3. Accessible role match.
+        () => page.getByRole("textbox", { name: labelRe }).first().fill(value),
+        // 4. Common automation hooks.
+        () => page.locator(attrContains("data-test")).first().fill(value),
+        () => page.locator(attrContains("data-testid")).first().fill(value),
+        // 5. Native attributes — exact across all variants (kebab/snake/camel/etc.).
+        () => page
+            .locator(variants
+            .flatMap((v) => [
+            `input[name="${cssEscape(v)}" i]`,
+            `input[id="${cssEscape(v)}" i]`,
+            `textarea[name="${cssEscape(v)}" i]`,
+            `textarea[id="${cssEscape(v)}" i]`,
+        ])
+            .join(", "))
+            .first()
+            .fill(value),
+        // 6. Native attributes — contains across all variants.
+        () => page
+            .locator(`${attrContains("name")}, ${attrContains("id")}`)
+            .first()
+            .fill(value),
+        // 7. ARIA / placeholder fallbacks.
+        () => page.locator(attrContains("aria-label")).first().fill(value),
+        () => page.locator(attrContains("placeholder")).first().fill(value),
+    ];
+    const errors = [];
+    for (const fn of strategies) {
+        try {
+            await Promise.race([
+                fn(),
+                new Promise((_, r) => setTimeout(() => r(new Error("timeout")), FAST)),
+            ]);
+            return;
+        }
+        catch (e) {
+            errors.push(e?.message?.split("\n")[0] || String(e));
+        }
+    }
+    throw new Error(`Could not find input field: "${label}". Tried ${strategies.length} strategies.`);
+}
+/** Token-aware variant generation matching executor.ts/labelVariants. */
+function labelVariants(label) {
+    const cleaned = label.trim();
+    if (!cleaned)
+        return [];
+    const tokens = cleaned
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .split(/[\s\-_]+/)
+        .filter(Boolean);
+    if (tokens.length === 0)
+        return [cleaned];
+    const lower = tokens.map((t) => t.toLowerCase());
+    const out = new Set([
+        cleaned,
+        cleaned.toLowerCase(),
+        lower.join(" "),
+        lower.join("-"),
+        lower.join("_"),
+        lower.join(""),
+        lower[0] +
+            lower
+                .slice(1)
+                .map((t) => t[0].toUpperCase() + t.slice(1))
+                .join(""),
+        lower.map((t) => t[0].toUpperCase() + t.slice(1)).join(""),
+    ]);
+    return Array.from(out).filter((v) => v.length > 0);
+}
+function cssEscape(value) {
+    return value.replace(/[\\"]/g, "\\$&");
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//# sourceMappingURL=mcp-executor.js.map

package/package.json

@@ -0,0 +1,61 @@
+{
+    "name": "@cutleryapp/agent",
+    "version": "1.0.3",
+    "description": "Local agent that connects your machine to the Cutlery QA platform and runs UI tests via Playwright",
+    "main": "dist/cli.js",
+    "bin": {
+        "cutlery-agent": "./dist/cli.js"
+    },
+    "files": [
+        "dist/cli.js",
+        "dist/executor.js",
+        "dist/mcp-executor.js",
+        "README.md"
+    ],
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "scripts": {
+        "build": "tsc && chmod +x dist/cli.js",
+        "watch": "tsc --watch",
+        "prepublishOnly": "npm run build",
+        "package": "npm run build && pkg . --targets node18-macos-x64,node18-linux-x64,node18-win-x64 --output dist/cutlery-agent",
+        "package:mac": "npm run build && pkg . --targets node18-macos-x64 --output dist/cutlery-agent-macos",
+        "package:linux": "npm run build && pkg . --targets node18-linux-x64 --output dist/cutlery-agent-linux",
+        "package:win": "npm run build && pkg . --targets node18-win-x64 --output dist/cutlery-agent-win.exe"
+    },
+    "keywords": [
+        "test-automation",
+        "ai-testing",
+        "playwright",
+        "e2e-testing",
+        "cutlery"
+    ],
+    "author": "Cutlery",
+    "license": "MIT",
+    "publishConfig": {
+        "access": "public"
+    },
+    "dependencies": {
+        "@playwright/test": "^1.48.0",
+        "playwright": "^1.48.0",
+        "openai": "^4.28.0",
+        "commander": "^11.1.0",
+        "chalk": "^4.1.2",
+        "ora": "^5.4.1",
+        "dotenv": "^16.3.1",
+        "ws": "^8.16.0"
+    },
+    "devDependencies": {
+        "@types/node": "^20.10.0",
+        "@types/ws": "^8.5.10",
+        "typescript": "^5.3.3",
+        "pkg": "^5.8.1"
+    },
+    "pkg": {
+        "assets": [
+            "node_modules/@playwright/**/*"
+        ],
+        "outputPath": "dist"
+    }
+}