@enricai/barnacle 1.7.5 → 1.9.0

package/dist/scraper/flow-runner.js

@@ -22,6 +22,7 @@ exports.findRecentBackendError = findRecentBackendError;
 exports.findRecentPageTransition = findRecentPageTransition;
 exports.isWizardExitAction = isWizardExitAction;
 exports.isAdvanceStep = isAdvanceStep;
+exports.shouldWarnMissingAdvancePattern = shouldWarnMissingAdvancePattern;
 exports.parseCaptureIndex = parseCaptureIndex;
 exports.latestCaptureIndex = latestCaptureIndex;
 exports.capturesAfterIndex = capturesAfterIndex;
@@ -51,6 +52,7 @@ exports.extractSubmitFailureEvidence = extractSubmitFailureEvidence;
 exports.extractGaEventEvidence = extractGaEventEvidence;
 exports.normalizeDateValue = normalizeDateValue;
 exports.fillHtml5DateTimeInput = fillHtml5DateTimeInput;
+exports.fillTextDatepickerInput = fillTextDatepickerInput;
 exports.verifyFillReadback = verifyFillReadback;
 exports.isUploadAffordanceLabel = isUploadAffordanceLabel;
 exports.writeFixtureToTempFile = writeFixtureToTempFile;
@@ -78,6 +80,7 @@ const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const ai_1 = require("ai");
+const date_fns_1 = require("date-fns");
 const config_1 = require("../config");
 const errors_1 = require("../lib/errors");
 const error_messages_1 = require("../lib/llm/judges/error-messages");
@@ -530,8 +533,8 @@ async function snapshotPage(target, signalCounter, page) {
  * application despite returning a 2xx HTTP status. Many ATSs use a "200 OK
  * with rejection envelope" pattern instead of a 4xx: one JSON-envelope ATS returns
  * `{not_qualified: true, error: "Not qualified reason: <field>"}`,
- * Greenhouse uses `{rejected: true, reason: "..."}`, Lever uses
- * `{qualified: false, reason: "..."}`, Workday uses
+ * others use `{rejected: true, reason: "..."}`,
+ * `{qualified: false, reason: "..."}`, or
  * `{status: "rejected"}`. Empirically verified on a JSON-envelope ATS: 4/6 historical
  * /integrated_apply 200s on this codebase had `not_qualified: true` and
  * we treated them as wins because the audit only checked HTTP status.
@@ -694,6 +697,20 @@ function isAdvanceStep(instruction) {
     const haystack = instruction.toLowerCase();
     return ADVANCE_STEP_PHRASES.some((p) => haystack.includes(p));
 }
+/**
+ * Whether a flow should be WARNed that its DOM-only advance guard is disarmed.
+ * `isDomOnlyAdvanceVerified` only vetoes a DOM-only "advance" when
+ * `advanceTransitionBodyPattern` is set; a flow with advance steps but no
+ * pattern silently loses that veto, so a validation-re-render wizard can desync
+ * its step pointer from the page. Pure + exported so the WARN condition is
+ * unit-testable without driving the whole runner. Author-side guard-rail only —
+ * no behavior change.
+ */
+function shouldWarnMissingAdvancePattern(instructions, advanceTransitionBodyPattern) {
+    if (advanceTransitionBodyPattern)
+        return false;
+    return instructions.some((s) => isAdvanceStep(s));
+}
 /**
  * Parse the monotonic capture index from a capture filename. Every capture is
  * written as `<idx>-<phase>-<unix-ms>-<hash>.json` where `<idx>` is a
@@ -928,7 +945,7 @@ function isDomOnlyAdvanceVerified(params) {
  * **Small-delta reveal credit:** a sub-section unhiding within an
  * already-loaded page (e.g. a validation-triggered "Work History requirement"
  * gate message) grows the DOM by far less than a full screen swap — measured
- * case: +789B on UCHealth, ~63x below the 5000B full-swap default. Below
+ * case: +789B on the top-window site, ~63x below the 5000B full-swap default. Below
  * `viewSwapMinBytesThreshold`, credit the click anyway when the growth ALSO
  * changed visible text (`textChanged`) and clears the lower
  * `viewSwapRevealMinBytesThreshold` floor (default 500B, matching
@@ -960,7 +977,7 @@ function isClickViewSwapVerified(params) {
  * questions" — when this count grows from 0 (pre-submit) to ≥1 (post-attempt-1),
  * attempts 2-5 cannot succeed and the cascade should route to replan
  * immediately instead of burning Stagehand calls. Accepts a `FrameTarget` so a
- * wizard embedded in a cross-origin iframe (e.g. UCHealth's Talemetry form) is
+ * wizard embedded in a cross-origin iframe (e.g. an embedded apply-wizard form) is
  * scanned on its own frame; a main-frame target delegates straight to
  * `page.evaluate`, matching today's behavior byte-for-byte.
  */
@@ -2150,6 +2167,200 @@ async function fillHtml5DateTimeInput(target, xpath, value) {
         return null;
     }
 }
+/**
+ * Parse a loosely-formatted date string into calendar parts. The recon flow
+ * passes dates in whatever shape the plan text used (ISO `yyyy-MM`, US
+ * `MM/dd/yyyy`, etc.), but a react-datepicker commits through year/month/day
+ * selection, so we need the numeric parts, not a display string. Uses date-fns
+ * per project convention; returns null when no candidate format matches so the
+ * caller skips the datepicker path rather than picking a wrong month.
+ */
+function parseDatepickerValue(value) {
+    const candidates = ["yyyy-MM", "yyyy-MM-dd", "MM/dd/yyyy", "MM-dd-yyyy", "MM/yyyy", "M/yyyy"];
+    for (const fmt of candidates) {
+        const parsed = (0, date_fns_1.parse)(value.trim(), fmt, new Date(2000, 0, 1));
+        if ((0, date_fns_1.isValid)(parsed)) {
+            return { year: parsed.getFullYear(), monthIndex: parsed.getMonth(), day: parsed.getDate() };
+        }
+    }
+    return null;
+}
+/** Dispatch a real Enter keydown/keyup on the element (Stagehand's Locator has no `press`). */
+async function dispatchEnterKey(target, xpath) {
+    const expr = `(() => {
+    const r = document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+    const el = r.singleNodeValue;
+    if (!el) return "no-element";
+    const opts = { key: "Enter", code: "Enter", keyCode: 13, which: 13, bubbles: true };
+    el.dispatchEvent(new KeyboardEvent("keydown", opts));
+    el.dispatchEvent(new KeyboardEvent("keyup", opts));
+    return "dispatched";
+  })()`;
+    try {
+        await target.evaluate(expr);
+    }
+    catch {
+        // best-effort: an Enter-dispatch failure shouldn't fail the fill
+    }
+}
+/** A readback whose value is a non-empty, date-shaped string counts as committed. */
+function isCommittedDateReadback(readback) {
+    if (readback === null)
+        return false;
+    if (readback.outcome === "rejected")
+        return false;
+    // A datepicker reformats what it accepts (e.g. "01/2020" → "2020-01"), so
+    // "differs" is a commit, not a rejection — require only a non-empty value
+    // that contains a 4-digit year, ruling out stray placeholder text.
+    return readback.postValue.trim().length > 0 && /\d{4}/.test(readback.postValue);
+}
+/**
+ * Fill a `type="text"` datepicker widget (react-datepicker — the standard
+ * ATS start/end-date control), which `fillHtml5DateTimeInput`
+ * cannot: react-datepicker rejects a programmatic `.value` write and commits
+ * only through its own keyboard/calendar `onChange`. Returns `null` for any
+ * input that is NOT a date-like text control, so every other text field stays
+ * on today's exact fill path.
+ *
+ * Two gestures, in order:
+ *  1. Keyboard entry — real keystrokes via `locator.type` (the proven
+ *     framework-control path at {@link verifyDomEffect}) + Enter. Works for
+ *     *typeable* datepickers.
+ *  2. Open-and-pick — click to open `.react-datepicker`, then either set the
+ *     year/month `.range-select` dropdowns and click the `.react-datepicker__month-N`
+ *     cell (month/year-picker variant — the reported ATS widget, which is
+ *     picker-only and ignores typed input) or click the matching
+ *     `.react-datepicker__day` cell (day-grid variant). Commit fires on the cell
+ *     click.
+ *
+ * The committed value is confirmed via {@link verifyFillReadback}; a datepicker
+ * reformats what it accepts, so a non-empty date-shaped readback is success.
+ *
+ * Return contract mirrors {@link fillHtml5DateTimeInput}: `null` means "not a
+ * datepicker — caller falls through to the generic readback verifier"; a
+ * non-null object means "this WAS a datepicker, here's the outcome". A non-null
+ * `filled:false` therefore deliberately TERMINATES the cascade (the caller
+ * records the failure and does NOT run the generic verifier) — a gated-in
+ * datepicker that neither gesture commits is a real fill failure, not an
+ * unrecognized field.
+ *
+ * Site-agnostic: react-datepicker's markup + commit model is universal across
+ * ATS tenants using it.
+ */
+async function fillTextDatepickerInput(target, selector, value) {
+    const xpath = xpathBody(selector);
+    if (!xpath)
+        return null;
+    const parts = parseDatepickerValue(value);
+    if (!parts)
+        return null;
+    // Gate: only proceed for a text input that looks like a datepicker. The
+    // definitive signal is a `.react-datepicker__input-container` wrapper; we
+    // also accept id/name/class/aria date hints for non-react libraries.
+    const gateExpr = `(() => {
+    const r = document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+    const el = r.singleNodeValue;
+    if (!el || el.tagName !== "INPUT") return { match: false };
+    const type = (el.getAttribute("type") || "text").toLowerCase();
+    if (type !== "text") return { match: false };
+    const inContainer = !!(el.closest && el.closest(".react-datepicker__input-container, .react-datepicker-wrapper"));
+    const hint = ((el.id || "") + " " + (el.name || "") + " " + (el.className || "") + " " + (el.getAttribute("aria-label") || "") + " " + (el.getAttribute("placeholder") || "")).toLowerCase();
+    const looksDate = /date|datepicker/.test(hint) || /\\bmm[\\/-]?(dd[\\/-]?)?yyyy\\b/.test(hint);
+    return { match: inContainer || looksDate };
+  })()`;
+    try {
+        const gate = await target.evaluate(gateExpr);
+        if (!gate || typeof gate !== "object" || gate.match !== true) {
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+    // Strategy 1 — keyboard entry (typeable datepickers). Mirrors the Angular
+    // reactive-form re-type at verifyDomEffect: real CDP keystrokes flow through
+    // the widget's own onChange, unlike a programmatic value write.
+    const typed = (0, date_fns_1.format)(new Date(parts.year, parts.monthIndex, parts.day), "MM/dd/yyyy");
+    try {
+        const locator = target.locator(selector).first();
+        await locator.fill("");
+        await locator.type(typed, { delay: 50 });
+        // react-datepicker commits typed input on Enter/blur. The Stagehand Locator
+        // has no `press`, so dispatch the Enter keydown/keyup from page context
+        // (the widget's own keydown handler listens here) then blur via the shared
+        // jQuery-change helper.
+        await dispatchEnterKey(target, xpath);
+        await dispatchJqueryChangeEvent(target, selector);
+        const readback = await verifyFillReadback(target, xpath, value);
+        if (isCommittedDateReadback(readback)) {
+            return { filled: true, postValue: readback.postValue, strategy: "keyboard" };
+        }
+    }
+    catch {
+        // fall through to open-and-pick
+    }
+    // Strategy 2 — open-and-pick. Required for picker-only widgets (the reported
+    // month/year picker ignores typed input entirely).
+    try {
+        const locator = target.locator(selector).first();
+        await locator.click();
+    }
+    catch {
+        return { filled: false, postValue: "", strategy: "none" };
+    }
+    const pickExpr = `(() => {
+    const year = ${parts.year};
+    const monthIndex = ${parts.monthIndex};
+    const day = ${parts.day};
+    const cal = document.querySelector(".react-datepicker");
+    if (!cal) return { picked: false, reason: "no-calendar" };
+    const fireChange = (el) => { el.dispatchEvent(new Event("input", { bubbles: true })); el.dispatchEvent(new Event("change", { bubbles: true })); };
+    const monthCells = cal.querySelectorAll(".react-datepicker__month-text");
+    const dayGrid = cal.querySelectorAll(".react-datepicker__day:not(.react-datepicker__day--outside-month):not(.react-datepicker__day--disabled)");
+    // Month/year-picker variant: click the target month cell (0-based month
+    // index maps to the __month-N class) — THIS is the commit. The year/month
+    // dropdowns are set first only so the calendar shows the right year's month
+    // page. NOTE: "range-select" is a SITE-SPECIFIC class (the ATS site's own
+    // CSS), not a react-datepicker class; the bare "select" fallback covers
+    // other wrappers.
+    // Stock react-datepicker renders its month/year dropdowns as clickable divs,
+    // so on those the select loop is inert and the month-cell click carries it.
+    if (monthCells.length > 0) {
+      const selects = cal.querySelectorAll("select.range-select, select");
+      for (const sel of selects) {
+        const opts = Array.from(sel.options).map((o) => (o.value || "").trim());
+        const yearOpt = opts.indexOf(String(year));
+        if (yearOpt >= 0) { sel.selectedIndex = yearOpt; fireChange(sel); continue; }
+        const monthOpt = opts.indexOf(String(monthIndex));
+        if (monthOpt >= 0) { sel.selectedIndex = monthOpt; fireChange(sel); }
+      }
+      const monthCell = cal.querySelector(".react-datepicker__month-" + monthIndex + ".react-datepicker__month-text");
+      const cell = monthCell || cal.querySelectorAll(".react-datepicker__month-text")[monthIndex];
+      if (cell) { cell.click(); return { picked: true, variant: "month-year" }; }
+      return { picked: false, reason: "no-month-cell" };
+    }
+    // Day-grid variant: click the day cell matching the parsed day number.
+    if (dayGrid.length > 0) {
+      for (const cell of dayGrid) {
+        if ((cell.textContent || "").trim() === String(day)) { cell.click(); return { picked: true, variant: "day-grid" }; }
+      }
+      return { picked: false, reason: "no-day-cell" };
+    }
+    return { picked: false, reason: "empty-calendar" };
+  })()`;
+    try {
+        const picked = await target.evaluate(pickExpr);
+        const didPick = !!picked && typeof picked === "object" && picked.picked === true;
+        const readback = await verifyFillReadback(target, xpath, value);
+        if (didPick && isCommittedDateReadback(readback)) {
+            return { filled: true, postValue: readback.postValue, strategy: "calendar-pick" };
+        }
+        return { filled: false, postValue: readback?.postValue ?? "", strategy: "none" };
+    }
+    catch {
+        return { filled: false, postValue: "", strategy: "none" };
+    }
+}
 /**
  * Read back an element's value after a fill action and compare to the
  * expected value. Catches silent-value-rejection cases that the verifier's
@@ -2217,7 +2428,7 @@ function harvestFieldErrors(body) {
         return [];
     const out = [];
     const rec = body;
-    // Singular `{error: "message"}` shape used by JSON-envelope ATSs, Lever, Greenhouse,
+    // Singular `{error: "message"}` shape used by JSON-envelope ATSs
     // and any REST API following the {error:string} terse-error convention.
     // Verified on a JSON-envelope ATS tenant: /integrated_apply 422 body is
     // exactly {"error":"Resume is blank"} — no `errors`, no `message`. Before
@@ -2586,7 +2797,7 @@ async function surfaceAndUpload(params) {
         }
     }
     // The file-chooser CDP interception below must run on the upload target's
-    // OWN session — an OOPIF (e.g. UCHealth's Talemetry wizard) has its own CDP
+    // OWN session — an OOPIF (e.g. a cross-origin OOPIF apply wizard) has its own CDP
     // target, and a chooser it opens is only observable via that frame's
     // session, not the main session. Main-frame targets fall back to
     // page.getSessionForFrame(page.mainFrameId()), matching today's behavior.
@@ -5721,20 +5932,42 @@ async function executeStepWithHealing(params) {
                                 }
                             }
                             else {
-                                // Fix I: not a date input — verify the regular fill landed.
-                                // Catches silent-value-rejection cases (HTML5 type validation
-                                // on number/email/url/tel inputs, framework-controlled-
-                                // component rejection, masked-input library reformatting).
-                                // Generic primitive that the verifier's existing signals
-                                // (network/url/dom/htmlDelta/textChanged) miss.
-                                const readback = await verifyFillReadback(dateFillTarget, overriddenTarget.selector, fillValue);
-                                if (readback !== null) {
-                                    if (readback.outcome === "rejected") {
-                                        record.errorMessage = `fill-value-rejected: tried "${fillValue.slice(0, 60)}" on <${readback.tag}>; element value remains empty (silent rejection — HTML5 type validation, framework controlled-component, or masked-input library)`;
+                                // Not an HTML5 date input. First try the text-datepicker
+                                // primitive (react-datepicker — ATS start/end-date
+                                // controls): those are `type="text"`, so fillHtml5DateTimeInput
+                                // returns null, and the generic fill's value-write never commits
+                                // the widget. Returns null for any non-datepicker text input, so
+                                // every other field falls through to the readback verifier below
+                                // unchanged.
+                                const datepickerFill = await fillTextDatepickerInput(dateFillTarget, overriddenTarget.selector, fillValue);
+                                if (datepickerFill !== null) {
+                                    record.errorMessage = datepickerFill.filled
+                                        ? `text-datepicker-fill: filled via ${datepickerFill.strategy} "${datepickerFill.postValue}"`
+                                        : `text-datepicker-fill: failed to commit "${fillValue.slice(0, 60)}" (post=${datepickerFill.postValue})`;
+                                    if (datepickerFill.filled) {
+                                        record.actResultSuccess = true;
+                                        resolvedAction = overriddenTarget;
+                                    }
+                                    else {
                                         record.actResultSuccess = false;
                                     }
-                                    else if (readback.outcome === "differs") {
-                                        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} fill-value-differs: tried "${fillValue.slice(0, 60)}" got "${readback.postValue.slice(0, 60)}" (framework reformatted)`);
+                                }
+                                else {
+                                    // Fix I: not a date input — verify the regular fill landed.
+                                    // Catches silent-value-rejection cases (HTML5 type validation
+                                    // on number/email/url/tel inputs, framework-controlled-
+                                    // component rejection, masked-input library reformatting).
+                                    // Generic primitive that the verifier's existing signals
+                                    // (network/url/dom/htmlDelta/textChanged) miss.
+                                    const readback = await verifyFillReadback(dateFillTarget, overriddenTarget.selector, fillValue);
+                                    if (readback !== null) {
+                                        if (readback.outcome === "rejected") {
+                                            record.errorMessage = `fill-value-rejected: tried "${fillValue.slice(0, 60)}" on <${readback.tag}>; element value remains empty (silent rejection — HTML5 type validation, framework controlled-component, or masked-input library)`;
+                                            record.actResultSuccess = false;
+                                        }
+                                        else if (readback.outcome === "differs") {
+                                            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} fill-value-differs: tried "${fillValue.slice(0, 60)}" got "${readback.postValue.slice(0, 60)}" (framework reformatted)`);
+                                        }
                                     }
                                 }
                             }
@@ -6052,10 +6285,10 @@ async function executeStepWithHealing(params) {
         }
         // Client-side view-swap gate: credit a click that produces substantial
         // DOM growth (≥5KB) with zero network when it's NOT a submit/final step
-        // and NOT an advance-pattern step. Fixes the UCHealth "Manual Application"
+        // and NOT an advance-pattern step. Fixes the top-window site "Manual Application"
         // case where a +49KB DOM-only view swap was scored as "no observable effect".
         // Below that threshold, also credits a smaller text-changing reveal (≥500B) —
-        // fixes the UCHealth Work-History gate-message reveal (+789B) that used to
+        // fixes the top-window site Work-History gate-message reveal (+789B) that used to
         // cascade to a 5-attempt failure and global replan.
         const clickViewSwapVerified = isClickViewSwapVerified({
             resolvedAction,
@@ -6707,6 +6940,9 @@ async function runHealingFlow(deps) {
             }
         },
     });
+    if (shouldWarnMissingAdvancePattern(steps.map((s) => s.instruction), deps.advanceTransitionBodyPattern ?? null)) {
+        logger.warn("flow has advance steps but no advanceTransitionBodyPattern — DOM-only advance guard is disarmed; pointer/page desync is possible on validation-re-render wizards");
+    }
     try {
         for (const [i, s] of steps.entries()) {
             if (maxFlowMs !== undefined && Date.now() - start > maxFlowMs) {