@cutleryapp/agent 1.0.42 → 1.0.44

package/dist/mcp-executor.js

@@ -85,6 +85,9 @@ class TestExecutor {
                 const stepAttachment = (testCase.step_attachments || {})[String(i)] || null;
                 console.log(`  📎 Step ${i} attachment: ${stepAttachment ? `YES (${stepAttachment.length} chars)` : 'none'}`);
                 let stepError;
+                // Dismiss any open overlay (date picker, dropdown, modal) from the previous step
+                if (i > 0)
+                    await page.keyboard.press('Escape').catch(() => { });
                 try {
                     // When a reference image is attached, skip MCP strategies entirely and go
                     // straight to the AI multi-field loop so it can scan the form and fill everything.
@@ -182,6 +185,20 @@ class TestExecutor {
                                 }
                                 else {
                                     await tryFill(page, fieldLabel, value);
+                                    // After filling, check if an autocomplete dropdown appeared and click the option
+                                    try {
+                                        const optSel = [
+                                            `[role="option"]:has-text("${value}")`,
+                                            `[class*="option"]:has-text("${value}")`,
+                                            `[class*="suggestion"]:has-text("${value}")`,
+                                            `li:has-text("${value}")`,
+                                        ].join(', ');
+                                        const opt = page.locator(optSel).first();
+                                        if (await opt.isVisible({ timeout: 400 })) {
+                                            await opt.click({ timeout: 1000 });
+                                        }
+                                    }
+                                    catch { /* no autocomplete dropdown, that's fine */ }
                                 }
                             }
                             handled = true;
@@ -448,10 +465,23 @@ class TestExecutor {
                     }
                 }
                 catch (err) {
-                    // Log the error — do NOT call AI here, it's too slow and usually can't recover either
-                    console.log(`  ⚠️  Step failed: ${err.message.split('\n')[0]}`);
-                    stepError = err.message;
-                    result.success = false;
+                    // AI last-resort recovery — only when Playwright strategies all failed
+                    if (process.env.OPENAI_API_KEY) {
+                        console.log(`  🤖 Playwright failed, trying AI: ${err.message.split('\n')[0]}`);
+                        try {
+                            await aiSingleShot(page, raw);
+                        }
+                        catch (aiErr) {
+                            console.log(`  ⚠️  AI recovery also failed: ${aiErr.message.split('\n')[0]}`);
+                            stepError = err.message;
+                            result.success = false;
+                        }
+                    }
+                    else {
+                        console.log(`  ⚠️  Step failed: ${err.message.split('\n')[0]}`);
+                        stepError = err.message;
+                        result.success = false;
+                    }
                 }
                 // Screenshot on failure, on the last step, or every 5 steps — not every step
                 let screenshotB64 = "";
@@ -1206,42 +1236,47 @@ function parseDate(value) {
 async function tryFillDate(page, label, value) {
     const labelRe = new RegExp(escapeRegex(label), 'i');
     const parsed = parseDate(value);
-    // Strategy 1: input[type="date"] — needs YYYY-MM-DD format
+    // First close any already-open calendar/overlay before we start
+    await page.keyboard.press('Escape').catch(() => { });
+    await page.waitForTimeout(100);
+    // Strategy 1: native input[type="date"] — fill with ISO format, no calendar involved
     if (parsed) {
-        const dateInputSelectors = [
-            `input[type="date"]`,
-            `input[type="datetime-local"]`,
-        ];
-        for (const sel of dateInputSelectors) {
-            try {
-                const loc = page.locator(sel).first();
-                if (await loc.isVisible({ timeout: 400 })) {
-                    await loc.fill(parsed.iso, { timeout: 1000 });
-                    return;
-                }
+        try {
+            const native = page.locator('input[type="date"], input[type="datetime-local"]').first();
+            if (await native.isVisible({ timeout: 300 })) {
+                await native.fill(parsed.iso, { timeout: 1000 });
+                return;
             }
-            catch { /* try next */ }
         }
+        catch { /* not a native date input */ }
     }
-    // Strategy 2: plain text input — type the value as-is, dismiss any calendar that opens
-    try {
-        const input = await Promise.any([
-            page.getByLabel(labelRe).first().elementHandle({ timeout: 500 }),
-            page.getByPlaceholder(labelRe).first().elementHandle({ timeout: 500 }),
-            page.getByRole('textbox', { name: labelRe }).first().elementHandle({ timeout: 500 }),
-        ]);
-        if (input) {
-            await input.click();
-            await page.keyboard.press('Escape'); // close any calendar that opened
+    // Strategy 2: react-datepicker / custom date input — click, select-all, type, Tab to commit
+    const dateLocators = [
+        page.getByLabel(labelRe).first(),
+        page.getByPlaceholder(labelRe).first(),
+        page.getByRole('textbox', { name: labelRe }).first(),
+    ];
+    for (const loc of dateLocators) {
+        try {
+            if (!await loc.isVisible({ timeout: 400 }))
+                continue;
+            // Click to focus (may open calendar)
+            await loc.click({ timeout: 800 });
+            await page.waitForTimeout(150);
+            // Select all existing text and replace
+            await page.keyboard.press('Control+a');
+            await page.keyboard.press('Meta+a'); // Mac
+            await page.keyboard.type(value, { delay: 40 });
             await page.waitForTimeout(150);
-            await input.click({ clickCount: 3 }); // select all existing text
-            await page.keyboard.type(value, { delay: 30 });
-            await page.keyboard.press('Escape'); // close calendar again after typing
-            await page.keyboard.press('Tab'); // commit the value
+            // Tab out to commit — this also closes the calendar
+            await page.keyboard.press('Tab');
+            await page.waitForTimeout(200);
+            // If calendar is still open, press Escape
+            await page.keyboard.press('Escape').catch(() => { });
             return;
         }
+        catch { /* try next */ }
     }
-    catch { /* fall through */ }
     // Strategy 3: fallback to regular fill
     await tryFill(page, label, value);
 }
@@ -1249,39 +1284,27 @@ async function tryFill(page, label, value) {
     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(", ");
-    function withTimeout(fn, ms) {
-        return Promise.race([fn(), new Promise((_, r) => setTimeout(() => r(new Error('timeout')), ms))]);
-    }
-    // Phase 1: race the 3 highest-coverage strategies simultaneously (500ms cap)
-    // These cover labelled inputs, placeholder inputs, and role-textbox — 95%+ of forms
-    const phase1 = [
-        () => page.getByLabel(labelRe).first().fill(value),
-        () => page.getByPlaceholder(labelRe).first().fill(value),
-        () => page.getByRole("textbox", { name: labelRe }).first().fill(value),
-    ];
-    try {
-        await Promise.any(phase1.map(fn => withTimeout(fn, 500)));
-        return;
-    }
-    catch { /* all 3 failed, try phase 2 */ }
-    // Phase 2: attribute-based selectors covering name/id/data-test variants (300ms each)
-    const exactAttrs = variants.flatMap(v => [
-        `input[name="${cssEscape(v)}" i]`, `input[id="${cssEscape(v)}" i]`,
-        `textarea[name="${cssEscape(v)}" i]`, `textarea[id="${cssEscape(v)}" i]`,
-    ]).join(", ");
-    const phase2 = [
-        () => page.locator(exactAttrs).first().fill(value),
-        () => page.locator(`${attrContains("name")}, ${attrContains("id")}`).first().fill(value),
-        () => page.locator(attrContains("data-test")).first().fill(value),
-        () => page.locator(attrContains("aria-label")).first().fill(value),
-        () => page.locator(attrContains("placeholder")).first().fill(value),
+    // Sequential strategies — do NOT run concurrently (concurrent fills can cross-contaminate fields)
+    // Each uses a short timeout since if the element exists, Playwright resolves near-instantly.
+    const strategies = [
+        ['getByLabel', () => page.getByLabel(labelRe).first().fill(value)],
+        ['getByPlaceholder', () => page.getByPlaceholder(labelRe).first().fill(value)],
+        ['getByRole', () => page.getByRole("textbox", { name: labelRe }).first().fill(value)],
+        ['id/name exact', () => 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)],
+        ['id/name contains', () => page.locator(`${attrContains("name")}, ${attrContains("id")}`).first().fill(value)],
+        ['data-test', () => page.locator(attrContains("data-test")).first().fill(value)],
+        ['aria-label', () => page.locator(attrContains("aria-label")).first().fill(value)],
+        ['placeholder attr', () => page.locator(attrContains("placeholder")).first().fill(value)],
     ];
-    for (const fn of phase2) {
+    for (const [, fn] of strategies) {
         try {
-            await withTimeout(fn, 300);
+            await Promise.race([fn(), new Promise((_, r) => setTimeout(() => r(new Error('t')), 400))]);
             return;
         }
-        catch { /* next */ }
+        catch { /* next strategy */ }
     }
     throw new Error(`Could not find input field: "${label}"`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cutleryapp/agent",
-    "version": "1.0.42",
+    "version": "1.0.44",
     "description": "Local agent that connects your machine to the Cutlery QA platform and runs UI tests via Playwright",
     "main": "dist/cli.js",
     "bin": {