@cutleryapp/agent 1.0.34 → 1.0.36

package/dist/mcp-executor.js

@@ -216,7 +216,7 @@ class TestExecutor {
                             // Try native <select>
                             try {
                                 const fieldLoc = page.getByLabel(new RegExp(fieldLabel, 'i')).first();
-                                await fieldLoc.selectOption({ label: optionValue });
+                                await fieldLoc.selectOption({ label: optionValue }, { timeout: 3000 });
                                 selHandled = true;
                             }
                             catch { /* not a native select */ }
@@ -227,7 +227,22 @@ class TestExecutor {
                             // Try clicking a visible option in an already-open dropdown
                             if (!selHandled) {
                                 try {
-                                    await page.locator(`[role="option"]:has-text("${optionValue}"), [class*="option"]:has-text("${optionValue}")`).first().click({ timeout: 3000 });
+                                    await page.locator(`[role="option"]:has-text("${optionValue}"), [class*="option"]:has-text("${optionValue}")`).first().click({ timeout: 1500 });
+                                    selHandled = true;
+                                }
+                                catch { /* try checkbox */ }
+                            }
+                            // Checkbox / radio fallback — label click or direct input click
+                            if (!selHandled) {
+                                try {
+                                    await page.locator(`label:has-text("${optionValue}")`).first().click({ timeout: 2000 });
+                                    selHandled = true;
+                                }
+                                catch { /* try input by value */ }
+                            }
+                            if (!selHandled) {
+                                try {
+                                    await page.locator(`input[type="radio"][value="${optionValue}" i], input[type="checkbox"][value="${optionValue}" i]`).first().click({ force: true, timeout: 2000 });
                                     selHandled = true;
                                 }
                                 catch { /* fall to AI */ }
@@ -243,12 +258,12 @@ class TestExecutor {
                             const labelText = cbMatch[1].trim();
                             try {
                                 // Try label click (works for hidden checkboxes with styled labels)
-                                await page.locator(`label:has-text("${labelText}")`).first().click({ timeout: 3000 });
+                                await page.locator(`label:has-text("${labelText}")`).first().click({ timeout: 2000 });
                                 handled = true;
                             }
                             catch {
                                 try {
-                                    await page.getByLabel(new RegExp(labelText, 'i')).first().check({ timeout: 3000 });
+                                    await page.getByLabel(new RegExp(labelText, 'i')).first().check({ timeout: 2000 });
                                     handled = true;
                                 }
                                 catch { /* fall to AI */ }
@@ -332,7 +347,7 @@ function extractSelector(step, pattern) {
 }
 // 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 FAST = 800;
     const strategies = [
         () => page.getByRole('button', { name: nameRe }).first().click({ timeout: FAST }),
         () => page.getByRole('link', { name: nameRe }).first().click({ timeout: FAST }),
@@ -584,7 +599,7 @@ async function aiStepFallback(page, stepText, stepAttachment = null) {
     console.log(`  🤖 aiStepFallback called. hasAttachment=${!!stepAttachment}`);
     const { default: OpenAI } = await import('openai');
     const openai = new OpenAI({ apiKey: openaiKey });
-    const MAX_ROUNDS = stepAttachment ? 10 : 6;
+    const MAX_ROUNDS = stepAttachment ? 6 : 3;
     let consecutiveFailures = 0;
     for (let round = 0; round < MAX_ROUNDS; round++) {
         const domElements = await extractDomElements(page);
@@ -642,9 +657,9 @@ ${domElements}` + (stepAttachment ? `\n\nThe REFERENCE IMAGE (second image) show
                 else if (act.action === 'select') {
                     let done = false;
                     for (const fn of [
-                        () => page.locator(act.selector).first().selectOption({ label: act.value }, { timeout: 4000 }),
-                        () => page.locator(act.selector).first().selectOption({ value: act.value }, { timeout: 4000 }),
-                        async () => { await page.locator(act.selector).first().click({ timeout: 3000 }); await page.getByText(act.value, { exact: false }).first().click({ timeout: 3000 }); },
+                        () => page.locator(act.selector).first().selectOption({ label: act.value }, { timeout: 2000 }),
+                        () => page.locator(act.selector).first().selectOption({ value: act.value }, { timeout: 2000 }),
+                        async () => { await page.locator(act.selector).first().click({ timeout: 2000 }); await page.getByText(act.value, { exact: false }).first().click({ timeout: 2000 }); },
                     ]) {
                         try {
                             await fn();
@@ -664,11 +679,11 @@ ${domElements}` + (stepAttachment ? `\n\nThe REFERENCE IMAGE (second image) show
                         // Derive a label text from selector for label-based fallbacks
                         const labelHint = act.label || act.selector.replace(/[#.\[\]"'=*^$]/g, ' ').trim();
                         for (const fn of [
-                            () => el.click({ force: true, timeout: 4000 }), // force bypasses visibility
-                            () => el.check({ force: true, timeout: 4000 }),
-                            () => page.locator(`label[for="${act.selector.replace('#', '')}"]`).click({ timeout: 4000 }),
-                            () => page.locator(`label:has-text("${labelHint}")`).first().click({ timeout: 4000 }),
-                            () => page.locator(`label:has(${act.selector})`).click({ timeout: 4000 }),
+                            () => el.click({ force: true, timeout: 2000 }), // force bypasses visibility
+                            () => el.check({ force: true, timeout: 2000 }),
+                            () => page.locator(`label[for="${act.selector.replace('#', '')}"]`).click({ timeout: 2000 }),
+                            () => page.locator(`label:has-text("${labelHint}")`).first().click({ timeout: 2000 }),
+                            () => page.locator(`label:has(${act.selector})`).click({ timeout: 2000 }),
                         ]) {
                             try {
                                 await fn();
@@ -726,7 +741,7 @@ ${domElements}` + (stepAttachment ? `\n\nThe REFERENCE IMAGE (second image) show
 }
 /** Try clicking with multiple selector strategies derived from AI suggestion */
 async function tryAIClick(page, selector) {
-    const TIMEOUT = 5000;
+    const TIMEOUT = 3000;
     // Build fallback variants: the AI selector + text-based alternatives
     const textMatch = selector.match(/:has-text\("([^"]+)"\)|:text\("([^"]+)"\)/);
     const text = textMatch ? (textMatch[1] || textMatch[2]) : null;
@@ -748,54 +763,88 @@ async function tryAIClick(page, selector) {
     }
     return false;
 }
-/** Fill an autocomplete/typeahead input: type value, wait for dropdown, click first matching option */
-async function tryAutocomplete(page, labelOrSelector, value) {
-    const TIMEOUT = 4000;
-    const locators = [
-        page.getByLabel(new RegExp(labelOrSelector, 'i')),
-        page.getByPlaceholder(new RegExp(labelOrSelector, 'i')),
-        page.locator(labelOrSelector),
+/** Select an option from a React-select / autocomplete / combobox / dropdown */
+async function tryAutocomplete(page, fieldLabel, value) {
+    const esc = (s) => s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+    const labelRe = new RegExp(esc(fieldLabel), 'i');
+    // Click an option from whatever dropdown is currently open on the page
+    async function clickOpenOption() {
+        const optionSelectors = [
+            `[role="option"]:has-text("${value}")`,
+            `[class*="option"]:has-text("${value}")`,
+            `[class*="suggestion"]:has-text("${value}")`,
+            `[class*="item"]:has-text("${value}")`,
+            `li:has-text("${value}")`,
+        ];
+        for (const sel of optionSelectors) {
+            try {
+                const opt = page.locator(sel).first();
+                if (await opt.isVisible({ timeout: 600 })) {
+                    await opt.click({ timeout: 1500 });
+                    console.log(`  ✓ Dropdown option clicked via "${sel}"`);
+                    return true;
+                }
+            }
+            catch { /* try next */ }
+        }
+        return false;
+    }
+    // Strategy 1: React-select — click the control div, type into its hidden input
+    const reactControlSelectors = [
+        `[class*="react-select__control"]`,
+        `[class*="select__control"]`,
+        `[class*="Select__control"]`,
     ];
-    for (const loc of locators) {
+    for (const ctrlSel of reactControlSelectors) {
+        try {
+            // Find a React-select control near the label text
+            // Find label element, then look for the control near it via DOM traversal
+            const labelEl = page.getByText(labelRe, { exact: false }).first();
+            if (!await labelEl.isVisible({ timeout: 500 }).catch(() => false))
+                continue;
+            // Try sibling/parent-scoped control
+            const ctrl = page.locator(ctrlSel);
+            if (await ctrl.count() === 0)
+                continue;
+            await ctrl.first().click({ timeout: 2000 });
+            // The hidden input inside the control is now active
+            const innerInput = page.locator(`[class*="react-select__input"] input, [class*="select__input"] input`).first();
+            await innerInput.type(value, { delay: 60 });
+            await page.waitForTimeout(500);
+            if (await clickOpenOption())
+                return true;
+            // If specific option not found, press Enter
+            await page.keyboard.press('Enter');
+            await page.waitForTimeout(200);
+            return true;
+        }
+        catch { /* try next */ }
+    }
+    // Strategy 2: combobox / input by label or placeholder — type and pick option
+    const inputLocators = [
+        page.getByRole('combobox', { name: labelRe }),
+        page.getByLabel(labelRe),
+        page.getByPlaceholder(labelRe),
+    ];
+    for (const loc of inputLocators) {
         try {
             const input = loc.first();
-            await input.waitFor({ state: 'visible', timeout: TIMEOUT });
-            await input.click({ timeout: TIMEOUT });
-            await input.fill('', { timeout: TIMEOUT });
-            // Type slowly so the autocomplete can react
-            await input.type(value, { delay: 80 });
-            // Wait for dropdown options to appear
-            await page.waitForTimeout(600);
-            // Try common dropdown option selectors
-            const optionSelectors = [
-                `[class*="option"]:has-text("${value}")`,
-                `[class*="suggestion"]:has-text("${value}")`,
-                `[class*="item"]:has-text("${value}")`,
-                `[role="option"]:has-text("${value}")`,
-                `[role="listbox"] [class*="option"]`,
-                `[class*="menu"] [class*="option"]`,
-                `[class*="dropdown"] li`,
-                `ul[class*="auto"] li`,
-                `.react-select__option`,
-                `.autocomplete-item`,
-            ];
-            for (const optSel of optionSelectors) {
-                try {
-                    const opt = page.locator(optSel).first();
-                    if (await opt.isVisible({ timeout: 800 })) {
-                        await opt.click({ timeout: TIMEOUT });
-                        console.log(`  ✓ Autocomplete: typed "${value}", clicked option via "${optSel}"`);
-                        return true;
-                    }
-                }
-                catch { /* try next */ }
-            }
-            // Fallback: press Enter if a highlighted option exists
+            const tag = await input.evaluate((el) => el.tagName.toLowerCase()).catch(() => '');
+            // Skip non-input elements (e.g. wrapper divs returned by getByLabel for React-select)
+            if (tag && !['input', 'textarea'].includes(tag))
+                continue;
+            await input.waitFor({ state: 'visible', timeout: 1500 });
+            await input.click({ timeout: 1500 });
+            await input.fill('');
+            await input.type(value, { delay: 60 });
+            await page.waitForTimeout(500);
+            if (await clickOpenOption())
+                return true;
             await page.keyboard.press('Enter');
-            await page.waitForTimeout(300);
+            await page.waitForTimeout(200);
             return true;
         }
-        catch { /* try next locator */ }
+        catch { /* try next */ }
     }
     return false;
 }
@@ -946,7 +995,7 @@ async function tryClickScoped(page, nameRe, target, scope) {
     return false;
 }
 async function tryFill(page, label, value) {
-    const FAST = 1500;
+    const FAST = 800;
     const labelRe = new RegExp(escapeRegex(label), "i");
     const variants = labelVariants(label);
     const attrContains = (attr) => variants

package/package.json

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