@cutleryapp/agent 1.0.38 → 1.0.40

package/dist/mcp-executor.js

@@ -334,36 +334,37 @@ class TestExecutor {
                             const optionValue = selMatch[1].trim();
                             const fieldLabel = selMatch[2].trim();
                             let selHandled = false;
-                            // Try native <select>
+                            // 1. Native <select> — fastest for actual <select> elements
                             try {
                                 const fieldLoc = page.getByLabel(new RegExp(fieldLabel, 'i')).first();
-                                await fieldLoc.selectOption({ label: optionValue }, { timeout: 3000 });
+                                await fieldLoc.selectOption({ label: optionValue }, { timeout: 800 });
                                 selHandled = true;
                             }
                             catch { /* not a native select */ }
-                            // Try React-select / autocomplete typeahead
-                            if (!selHandled) {
-                                selHandled = await tryAutocomplete(page, fieldLabel, optionValue);
-                            }
-                            // Try clicking a visible option in an already-open dropdown
+                            // 2. Radio / checkbox label click — do this BEFORE autocomplete so radio buttons
+                            //    are handled in <100ms instead of waiting through autocomplete timeouts
                             if (!selHandled) {
                                 try {
-                                    await page.locator(`[role="option"]:has-text("${optionValue}"), [class*="option"]:has-text("${optionValue}")`).first().click({ timeout: 1500 });
+                                    await page.locator(`label:has-text("${optionValue}")`).first().click({ timeout: 800 });
                                     selHandled = true;
                                 }
-                                catch { /* try checkbox */ }
+                                catch { /* not a labelled radio/checkbox */ }
                             }
-                            // Checkbox / radio fallback — label click or direct input click
                             if (!selHandled) {
                                 try {
-                                    await page.locator(`label:has-text("${optionValue}")`).first().click({ timeout: 2000 });
+                                    await page.locator(`input[type="radio"][value="${optionValue}" i], input[type="checkbox"][value="${optionValue}" i]`).first().click({ force: true, timeout: 800 });
                                     selHandled = true;
                                 }
-                                catch { /* try input by value */ }
+                                catch { /* not an input with matching value */ }
                             }
+                            // 3. React-select / autocomplete typeahead
+                            if (!selHandled) {
+                                selHandled = await tryAutocomplete(page, fieldLabel, optionValue);
+                            }
+                            // 4. Already-open dropdown option
                             if (!selHandled) {
                                 try {
-                                    await page.locator(`input[type="radio"][value="${optionValue}" i], input[type="checkbox"][value="${optionValue}" i]`).first().click({ force: true, timeout: 2000 });
+                                    await page.locator(`[role="option"]:has-text("${optionValue}"), [class*="option"]:has-text("${optionValue}")`).first().click({ timeout: 1000 });
                                     selHandled = true;
                                 }
                                 catch { /* fall to AI */ }
@@ -415,14 +416,17 @@ class TestExecutor {
                     stepError = err.message;
                     result.success = false;
                 }
-                // Screenshot after each step
+                // Screenshot on failure, on the last step, or every 5 steps — not every step
                 let screenshotB64 = "";
-                try {
-                    const buf = await page.screenshot({ fullPage: false });
-                    screenshotB64 = buf.toString("base64");
-                    result.screenshots.push(screenshotB64);
+                const isLastStep = i === steps.length - 1;
+                if (stepError || isLastStep || i % 5 === 0) {
+                    try {
+                        const buf = await page.screenshot({ fullPage: false });
+                        screenshotB64 = buf.toString("base64");
+                        result.screenshots.push(screenshotB64);
+                    }
+                    catch { /* ignore screenshot errors */ }
                 }
-                catch { /* ignore screenshot errors */ }
                 result.steps.push({
                     step: raw,
                     action: raw,
@@ -468,24 +472,32 @@ 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 = 800;
-    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 }),
-        // data-* attributes (common in test automation)
-        () => page.locator(`[data-test*="${label}" i], [data-testid*="${label}" i], [id*="${label}" i]`).first().click({ timeout: FAST }),
+    // Race all common role/text strategies simultaneously — first one wins
+    const T = 1000;
+    const raceStrategies = [
+        page.getByRole('button', { name: nameRe }).first().click({ timeout: T }),
+        page.getByRole('link', { name: nameRe }).first().click({ timeout: T }),
+        page.getByRole('tab', { name: nameRe }).first().click({ timeout: T }),
+        page.getByText(nameRe, { exact: false }).first().click({ timeout: T }),
+        page.locator(`[aria-label="${label}" i],[title="${label}" i],[data-test*="${label}" i],[data-testid*="${label}" i]`).first().click({ timeout: T }),
     ];
-    for (const fn of strategies) {
+    try {
+        await Promise.any(raceStrategies);
+        return true;
+    }
+    catch { /* all failed, try sequential fallbacks */ }
+    // Sequential fallbacks for id/value/role selectors
+    for (const fn of [
+        () => page.locator(`#${label.replace(/\s+/g, '-')}, #${label.replace(/\s+/g, '_')}, [id*="${label}" i]`).first().click({ timeout: 500 }),
+        () => page.locator(`input[value="${label}" i], button[value="${label}" i]`).first().click({ timeout: 500 }),
+    ]) {
         try {
             await fn();
             return true;
         }
-        catch { /* try next */ }
+        catch { /* next */ }
     }
-    // AI vision fallback
-    return await aiClickFallback(page, label);
+    return false;
 }
 function buildAgentPrompt(stepText, round, hasAttachment = false) {
     const attachmentSection = hasAttachment ? `
@@ -944,12 +956,12 @@ async function tryAutocomplete(page, fieldLabel, value) {
             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 });
+                await innerInput.type(value, { delay: 30 });
             }
             catch {
-                await page.keyboard.type(value, { delay: 60 });
+                await page.keyboard.type(value, { delay: 30 });
             }
-            await page.waitForTimeout(600);
+            await page.waitForTimeout(400);
             if (await clickOpenOption())
                 return true;
             // No confirmed click → don't claim success, fall through to next strategy
@@ -967,18 +979,22 @@ async function tryAutocomplete(page, fieldLabel, value) {
     for (const loc of inputLocators) {
         try {
             const input = loc.first();
-            // Skip wrapper divs — getByLabel can return the React-select container div
+            // Skip wrapper divs and non-text inputs (radio/checkbox handled by label click above)
             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 });
+            if (tag === 'input') {
+                const inputType = await input.evaluate((el) => el.type || '').catch(() => '');
+                if (['radio', 'checkbox', 'submit', 'button', 'file', 'hidden'].includes(inputType))
+                    continue;
+            }
+            await input.waitFor({ state: 'visible', timeout: 500 });
+            await input.click({ timeout: 500 });
             await input.fill('');
-            await input.type(value, { delay: 60 });
-            await page.waitForTimeout(500);
+            await input.type(value, { delay: 30 });
+            await page.waitForTimeout(350);
             if (await clickOpenOption())
                 return true;
-            // Only count success when the option was actually clicked
         }
         catch { /* try next */ }
     }
@@ -1077,7 +1093,7 @@ async function aiFillFallback(page, label, value) {
     }
 }
 async function tryClickScoped(page, nameRe, target, scope) {
-    const FAST = 3000;
+    const FAST = 1000;
     // Strip trailing generic nouns that won't appear verbatim on the page
     const cleanScope = scope.replace(/\s+(?:product|item|section|card|row|container|element|button|link|area|panel|block)$/i, '').trim();
     // Use card/item container selectors — these are tight enough to contain the button
@@ -1131,59 +1147,44 @@ async function tryClickScoped(page, nameRe, target, scope) {
     return false;
 }
 async function tryFill(page, label, value) {
-    const FAST = 500;
     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.
+    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),
-        // 3. Accessible role match.
         () => page.getByRole("textbox", { name: labelRe }).first().fill(value),
-        // 4. Common automation hooks.
+    ];
+    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("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) {
+    for (const fn of phase2) {
         try {
-            await Promise.race([
-                fn(),
-                new Promise((_, r) => setTimeout(() => r(new Error("timeout")), FAST)),
-            ]);
+            await withTimeout(fn, 300);
             return;
         }
-        catch (e) {
-            errors.push(e?.message?.split("\n")[0] || String(e));
-        }
+        catch { /* next */ }
     }
-    throw new Error(`Could not find input field: "${label}". Tried ${strategies.length} strategies.`);
+    throw new Error(`Could not find input field: "${label}"`);
 }
 /** Token-aware variant generation matching executor.ts/labelVariants. */
 function labelVariants(label) {

package/package.json

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