@cutleryapp/agent 1.0.35 → 1.0.37

package/dist/mcp-executor.js

@@ -230,6 +230,21 @@ class TestExecutor {
                                     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 */ }
                             }
                             if (selHandled)
@@ -748,54 +763,103 @@ 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 = 2000;
-    const locators = [
-        page.getByLabel(new RegExp(labelOrSelector, 'i')),
-        page.getByPlaceholder(new RegExp(labelOrSelector, 'i')),
-        page.locator(labelOrSelector),
-    ];
-    for (const loc of locators) {
-        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: 500 })) {
-                        await opt.click({ timeout: TIMEOUT });
-                        console.log(`  ✓ Autocomplete: typed "${value}", clicked option via "${optSel}"`);
-                        return true;
-                    }
+/** Select an option from a React-select / autocomplete / combobox / dropdown */
+async function tryAutocomplete(page, fieldLabel, value) {
+    // Click the matching option in whatever dropdown is currently open — returns true only on success
+    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 — find the control that BELONGS to this label via DOM traversal
+    // so we don't accidentally open the wrong dropdown on a page with multiple selects
+    try {
+        const opened = await page.evaluate((lbl) => {
+            const allEls = Array.from(document.querySelectorAll('label, legend, [class*="label"]'));
+            const labelEl = allEls.find(el => (el.textContent || '').trim().toLowerCase().includes(lbl.toLowerCase()));
+            if (!labelEl)
+                return false;
+            // Walk up ancestors looking for a container that holds a react-select control
+            let ancestor = labelEl.parentElement;
+            for (let i = 0; i < 6 && ancestor; i++) {
+                const ctrl = ancestor.querySelector('[class*="react-select__control"],[class*="select__control"],[class*="Select__control"]');
+                if (ctrl) {
+                    ctrl.click();
+                    return true;
+                }
+                ancestor = ancestor.parentElement;
+            }
+            // Try label[for] → wrapper containing a react-select
+            if (labelEl.tagName === 'LABEL') {
+                const forId = labelEl.htmlFor;
+                const wrapper = forId ? document.getElementById(forId) : null;
+                const ctrl = wrapper?.querySelector('[class*="control"]');
+                if (ctrl) {
+                    ctrl.click();
+                    return true;
                 }
-                catch { /* try next */ }
             }
-            // Fallback: press Enter if a highlighted option exists
-            await page.keyboard.press('Enter');
+            return false;
+        }, fieldLabel);
+        if (opened) {
             await page.waitForTimeout(300);
-            return true;
+            // Type into the now-visible input inside the react-select
+            const innerInput = page.locator('[class*="react-select__input"] input,[class*="select__input"] input').first();
+            try {
+                await innerInput.waitFor({ state: 'visible', timeout: 800 });
+                await innerInput.type(value, { delay: 60 });
+            }
+            catch {
+                await page.keyboard.type(value, { delay: 60 });
+            }
+            await page.waitForTimeout(600);
+            if (await clickOpenOption())
+                return true;
+            // No confirmed click → don't claim success, fall through to next strategy
+        }
+    }
+    catch { /* DOM eval failed, try next */ }
+    // Strategy 2: combobox / text input by label or placeholder — type + pick option
+    const esc = (s) => s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+    const labelRe = new RegExp(esc(fieldLabel), 'i');
+    const inputLocators = [
+        page.getByRole('combobox', { name: labelRe }),
+        page.getByLabel(labelRe),
+        page.getByPlaceholder(labelRe),
+    ];
+    for (const loc of inputLocators) {
+        try {
+            const input = loc.first();
+            // Skip wrapper divs — getByLabel can return the React-select container div
+            const tag = await input.evaluate((el) => el.tagName.toLowerCase()).catch(() => '');
+            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;
+            // Only count success when the option was actually clicked
         }
-        catch { /* try next locator */ }
+        catch { /* try next */ }
     }
     return false;
 }

package/package.json

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