@cutleryapp/agent 1.0.40 → 1.0.42

package/dist/mcp-executor.js

@@ -175,7 +175,14 @@ class TestExecutor {
                                 await page.fill(fieldLabel, value);
                             }
                             else {
-                                await tryFill(page, fieldLabel, value);
+                                // Check if it's a date/birth field and use date-aware fill
+                                const isDateField = /date|birth|dob/i.test(fieldLabel);
+                                if (isDateField) {
+                                    await tryFillDate(page, fieldLabel, value);
+                                }
+                                else {
+                                    await tryFill(page, fieldLabel, value);
+                                }
                             }
                             handled = true;
                         }
@@ -334,14 +341,36 @@ class TestExecutor {
                             const optionValue = selMatch[1].trim();
                             const fieldLabel = selMatch[2].trim();
                             let selHandled = false;
-                            // 1. Native <select> — fastest for actual <select> elements
-                            try {
-                                const fieldLoc = page.getByLabel(new RegExp(fieldLabel, 'i')).first();
-                                await fieldLoc.selectOption({ label: optionValue }, { timeout: 800 });
-                                selHandled = true;
+                            // 1. Native <select> — try by label, name, id
+                            if (!selHandled) {
+                                const fieldRe = new RegExp(fieldLabel.replace(/[\s_-]+/g, '[\\s_-]*'), 'i');
+                                const selectLocators = [
+                                    page.getByLabel(fieldRe),
+                                    page.locator(`select[name*="${fieldLabel}" i]`),
+                                    page.locator(`select[id*="${fieldLabel}" i]`),
+                                    page.locator(`select[data-test*="${fieldLabel}" i]`),
+                                ];
+                                for (const loc of selectLocators) {
+                                    try {
+                                        const el = loc.first();
+                                        const tag = await el.evaluate((n) => n.tagName.toLowerCase()).catch(() => '');
+                                        if (tag !== 'select')
+                                            continue; // only drive actual <select> elements
+                                        // Try matching by label text, then by value
+                                        const matched = await Promise.any([
+                                            el.selectOption({ label: optionValue }, { timeout: 1000 }),
+                                            el.selectOption({ value: optionValue }, { timeout: 1000 }),
+                                            el.selectOption(optionValue, { timeout: 1000 }),
+                                        ]).then(() => true).catch(() => false);
+                                        if (matched) {
+                                            selHandled = true;
+                                            break;
+                                        }
+                                    }
+                                    catch { /* next */ }
+                                }
                             }
-                            catch { /* not a native select */ }
-                            // 2. Radio / checkbox label click — do this BEFORE autocomplete so radio buttons
+                            // 2. Radio / checkbox label click — before autocomplete so radio buttons
                             //    are handled in <100ms instead of waiting through autocomplete timeouts
                             if (!selHandled) {
                                 try {
@@ -367,6 +396,14 @@ class TestExecutor {
                                     await page.locator(`[role="option"]:has-text("${optionValue}"), [class*="option"]:has-text("${optionValue}")`).first().click({ timeout: 1000 });
                                     selHandled = true;
                                 }
+                                catch { /* try text input fallback */ }
+                            }
+                            // 5. Text input / textarea fallback — handles "Select X in Y" where Y is a textarea
+                            if (!selHandled) {
+                                try {
+                                    await tryFill(page, fieldLabel, optionValue);
+                                    selHandled = true;
+                                }
                                 catch { /* fall to AI */ }
                             }
                             if (selHandled)
@@ -1146,6 +1183,68 @@ async function tryClickScoped(page, nameRe, target, scope) {
     catch { }
     return false;
 }
+/** Parse a date string in any common format and return {day, month, year} */
+function parseDate(value) {
+    // Formats: DD/MM/YYYY, MM/DD/YYYY, YYYY-MM-DD, DD-MM-YYYY, DD Mon YYYY, etc.
+    const patterns = [
+        /^(\d{1,2})[\/\-](\d{1,2})[\/\-](\d{4})$/, // DD/MM/YYYY or MM/DD/YYYY
+        /^(\d{4})[\/\-](\d{1,2})[\/\-](\d{1,2})$/, // YYYY-MM-DD
+    ];
+    for (const p of patterns) {
+        const m = value.match(p);
+        if (m) {
+            const [, a, b, c] = m;
+            // Heuristic: if first group is 4 digits → YYYY-MM-DD
+            const [year, month, day] = a.length === 4 ? [a, b, c] : [c, b, a];
+            const iso = `${year}-${month.padStart(2, '0')}-${day.padStart(2, '0')}`;
+            return { iso, day: day.padStart(2, '0'), month: month.padStart(2, '0'), year };
+        }
+    }
+    return null;
+}
+/** Fill a date field — handles input[type=date], calendar pickers, and plain text inputs */
+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
+    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;
+                }
+            }
+            catch { /* try next */ }
+        }
+    }
+    // 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
+            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
+            return;
+        }
+    }
+    catch { /* fall through */ }
+    // Strategy 3: fallback to regular fill
+    await tryFill(page, label, value);
+}
 async function tryFill(page, label, value) {
     const labelRe = new RegExp(escapeRegex(label), "i");
     const variants = labelVariants(label);

package/package.json

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