halo-agent 2.0.4 → 2.0.6

package/detectFormErrors.js

@@ -118,8 +118,74 @@ async function detectFormErrors(page) {
     const invalidFields = [];
     const seenMmids = new Set();
 
+    // CRITICAL: only flag fields that are ACTUALLY empty. Otherwise we
+    // get a cascade of false positives — Greenhouse marks every required
+    // field's LABEL red after a failed submit (visual highlight), and the
+    // text-pattern walk matches "First Name is required" near a perfectly-
+    // filled First Name field. That triggered the retry to re-touch fields
+    // that didn't need fixing, which is how Gender went from Male → Female
+    // and Ethnicity East Asian → South Asian.
+    function isEmptyField(el) {
+      const tag = el.tagName.toLowerCase();
+      const type = (el.type || '').toLowerCase();
+      // Checkboxes / radios: empty means !checked.
+      if (type === 'checkbox' || type === 'radio') return !el.checked;
+      // Native select: empty value or selected option is the placeholder.
+      if (tag === 'select') {
+        if (!el.value) return true;
+        const selOpt = el.options[el.selectedIndex];
+        // A select whose first option is "Select..." with empty value AND
+        // that option is selected → empty.
+        if (selOpt && !selOpt.value) return true;
+        return false;
+      }
+      // File inputs: empty means files.length === 0.
+      if (type === 'file') return !el.files || el.files.length === 0;
+      // contenteditable: empty when innerText is whitespace.
+      if (el.isContentEditable) return !(el.innerText || '').trim();
+      // Combobox / custom-select: React-Select (which Greenhouse uses for
+      // ALL its dropdowns) renders the selected value as a
+      // .select__single-value or .select__multi-value chip INSIDE the
+      // control wrapper, NOT as the input's .value. We must look there or
+      // we falsely flag every filled dropdown as empty (the bug that made
+      // the retry re-pick Gender + Ethnicity).
+      if (el.getAttribute('role') === 'combobox' || tag === 'select') {
+        // Walk up to the React-Select control wrapper (a few class variants).
+        const wrap = el.closest(
+          '[class*="select__control"], [class*="select-control"], ' +
+          '[class*="select__value-container"], [class*="select"], ' +
+          '[class*="combobox"], [class*="Select"]'
+        ) || el.parentElement;
+        if (wrap) {
+          // Any rendered value chip → NOT empty.
+          const valueEl = wrap.querySelector(
+            '[class*="single-value"], [class*="multi-value"], ' +
+            '[class*="multiValue"], [class*="singleValue"], ' +
+            '[class*="chip"], [class*="tag"], [class*="__value"]'
+          );
+          if (valueEl && (valueEl.innerText || valueEl.textContent || '').trim()) return false;
+          // Also: the control's own text, minus the placeholder. If the
+          // control shows "Male" it's filled; if it shows "Select..." it's empty.
+          const wrapText = (wrap.innerText || '').trim();
+          const placeholderEl = wrap.querySelector('[class*="placeholder"]');
+          const placeholderText = placeholderEl ? (placeholderEl.innerText || '').trim() : '';
+          if (wrapText && wrapText !== placeholderText && !/^select\b|^choose\b|^\.\.\./i.test(wrapText)) {
+            return false;
+          }
+        }
+        const v = (el.value || el.innerText || '').trim();
+        return !v;
+      }
+      // Plain inputs / textareas
+      return !(el.value || '').trim();
+    }
+
     function addField(el, errorText) {
       if (!el) return;
+      // Skip fields that are already filled — they're not the cause of
+      // the form rejection even if their label happens to be near
+      // required-text styling.
+      if (!isEmptyField(el)) return;
       const sel = bestSelector(el);
       const key = sel.mmid || sel.selector || el.outerHTML.slice(0, 80);
       if (seenMmids.has(key)) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "halo-agent",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "HALO local apply agent — auto-fills job applications using your real Chrome session",
   "main": "index.js",
   "bin": {

package/scanAccessibility.js

@@ -429,6 +429,20 @@ async function scanAccessibility(page) {
     const label = pickLabel(f);
     // Filter noise: no label AND no visible role → skip
     if (!label && !['button', 'link'].includes(normalizeRole(f))) continue;
+    // Filter out the "Remove X" chip-clear buttons that React-Select
+    // renders next to selected items in multi-select dropdowns. The
+    // planner was treating these as separate fields and "filling" them
+    // (clicking them, which DELETED the correct answer) on the retry
+    // pass — that's how Gender flipped Male → Female on retry. Same for
+    // the X button that clears a single-select's value.
+    if (normalizeRole(f) === 'button' && (
+      /^remove\s+\S/i.test(label) ||
+      /^clear\s+selection/i.test(label) ||
+      /^remove\s+item/i.test(label) ||
+      label === '×' || label === '✕' || label === 'x'
+    )) {
+      continue;
+    }
     out.push({
       mmid: f.mmid,
       role: normalizeRole(f),

package/smartFill.js

@@ -208,53 +208,81 @@ async function executePlanItem(page, item, fieldByMmid, ctx) {
  */
 async function tryIntlTelCountry(page, triggerLocator, value) {
   try {
-    // Is this field wrapped by an .iti container?
-    const wrap = await triggerLocator.evaluate((el) => {
-      const c = el.closest('.iti, .iti--allow-dropdown');
-      return c ? { has: true } : null;
-    }).catch(() => null);
-    if (!wrap) return null;
-
-    // Click the flag button to open the country list. There's only one
-    // active flag per .iti wrapper.
+    // Detect intl-tel-input by looking for ANY characteristic class within
+    // a reasonable ancestor radius. Newer versions (v18+) shifted from
+    // .iti to .iti--allow-dropdown / .iti-mobile, plus they may wrap
+    // in .country-select instead. Scan up to 6 ancestors.
+    const probe = await triggerLocator.evaluate((el) => {
+      let p = el; let hops = 0;
+      while (p && hops < 6) {
+        const cls = String(p.className || '');
+        if (/\biti\b|\biti--|country-select|country-picker/i.test(cls)) {
+          // Found the wrapper. Find the flag/trigger inside.
+          const flag = p.querySelector(
+            '.iti__selected-flag, .iti__country-container, ' +
+            '[class*="selected-flag"], [class*="country-button"], ' +
+            '[aria-haspopup="listbox"][class*="iti"], ' +
+            'button[class*="country"]'
+          );
+          return { found: true, wrapperOuterClass: cls.slice(0, 200), hasFlag: !!flag };
+        }
+        p = p.parentElement; hops += 1;
+      }
+      return { found: false };
+    }).catch(() => ({ found: false }));
+    if (!probe.found) return null;
+
+    // Click the flag/trigger element to open the country list.
     const flag = await triggerLocator.evaluateHandle((el) => {
-      const c = el.closest('.iti, .iti--allow-dropdown');
-      return c?.querySelector('.iti__selected-flag, [aria-label*="country" i]') || null;
+      let p = el; let hops = 0;
+      while (p && hops < 6) {
+        const cls = String(p.className || '');
+        if (/\biti\b|\biti--|country-select|country-picker/i.test(cls)) {
+          return p.querySelector(
+            '.iti__selected-flag, .iti__country-container, ' +
+            '[class*="selected-flag"], [class*="country-button"], ' +
+            '[aria-haspopup="listbox"][class*="iti"], ' +
+            'button[class*="country"]'
+          ) || null;
+        }
+        p = p.parentElement; hops += 1;
+      }
+      return null;
     });
-    if (!flag || !(await flag.evaluate((n) => !!n).catch(() => false))) return null;
+    if (!flag || !(await flag.evaluate((n) => !!n).catch(() => false))) {
+      return { ok: false, reason: `intl-tel wrapper found (${probe.wrapperOuterClass}) but no flag button inside` };
+    }
     await flag.click({ timeout: 1500 }).catch(async () => {
-      // Some intl-tel versions need force-click because the flag is
-      // positioned absolute under the input
       await flag.click({ force: true, timeout: 1500 }).catch(() => {});
     });
-    await page.waitForTimeout(400);
+    await page.waitForTimeout(500);
 
-    // Find the country whose name OR dial code matches `value`. Strip
-    // "+1" / parens for matching ("United States +1" → "United States").
-    const v = String(value).toLowerCase().replace(/\s*\+\d+\s*$/, '').trim();
-    const items = page.locator('.iti__country-list:visible .iti__country, .iti__dropdown-content .iti__country');
+    // Country items — try several known class patterns
+    const itemSel = '.iti__country-list:visible .iti__country, .iti__dropdown-content .iti__country, [class*="country-list"] [class*="country-item"], [role="listbox"] [role="option"][class*="iti"]';
+    const items = page.locator(itemSel);
     const count = await items.count().catch(() => 0);
     if (count === 0) {
-      // Country list never opened
       await page.keyboard.press('Escape').catch(() => {});
-      return { ok: false, reason: 'intl-tel country list did not open' };
+      return { ok: false, reason: `intl-tel country list did not open (wrapper=${probe.wrapperOuterClass})` };
     }
-    // Collect the country names to find the right one
+    const v = String(value).toLowerCase().replace(/\s*\+\d+\s*$/, '').trim();
     const names = await items.evaluateAll((nodes) => nodes.map((n) => {
-      const nm = n.querySelector('.iti__country-name')?.textContent?.trim() || '';
-      const dial = n.querySelector('.iti__dial-code')?.textContent?.trim() || '';
+      const nm = n.querySelector('.iti__country-name, [class*="country-name"]')?.textContent?.trim()
+        || (n.getAttribute('data-country-name') || '').trim()
+        || (n.textContent || '').replace(/\+\d+/, '').trim();
+      const dial = n.querySelector('.iti__dial-code, [class*="dial-code"]')?.textContent?.trim()
+        || (n.getAttribute('data-dial-code') ? `+${n.getAttribute('data-dial-code')}` : '');
       return { name: nm, dial };
     })).catch(() => []);
     let idx = names.findIndex((n) => n.name.toLowerCase() === v);
     if (idx === -1) idx = names.findIndex((n) => n.name.toLowerCase().includes(v) || v.includes(n.name.toLowerCase()));
     if (idx === -1) {
-      // Try matching by dial code (e.g. "+1")
       const dialMatch = String(value).match(/\+(\d+)/);
       if (dialMatch) idx = names.findIndex((n) => n.dial === `+${dialMatch[1]}`);
     }
     if (idx === -1) {
       await page.keyboard.press('Escape').catch(() => {});
-      return { ok: false, reason: `no intl-tel country matched "${value}"` };
+      return { ok: false, reason: `no intl-tel country matched "${value}" (${count} items)` };
     }
     await items.nth(idx).click({ timeout: 1500 }).catch(async () => {
       await items.nth(idx).click({ force: true, timeout: 1500 });
@@ -275,6 +303,30 @@ async function openAndPickOption(page, triggerLocator, value, llmCtx) {
     if (itlResult !== null) return itlResult;
   } catch {}
 
+  // Second: Google Places typeahead. The Greenhouse Location field is
+  // marked role=combobox in AX, so the planner sends click_option — but
+  // it's really a type-then-pick autocomplete that opens a .pac-container
+  // mounted at document.body (NOT inside the field's wrapper). Detect
+  // by checking for adjacent "Locate me" UI or for an existing pac-container.
+  try {
+    const isPac = await triggerLocator.evaluate((el) => {
+      // Heuristic 1: a "Locate me" link/button nearby (Greenhouse-specific)
+      const ancestor = el.closest('div, section, fieldset') || el.parentElement;
+      const hasLocateMe = ancestor && Array.from(ancestor.querySelectorAll('a, button')).some((b) => /locate\s*me/i.test(b.textContent || ''));
+      // Heuristic 2: a pac-container is mounted somewhere on the page
+      const hasPacContainer = !!document.querySelector('.pac-container, .pac-target-input');
+      // Heuristic 3: the input itself is a pac-target-input (Google sets this when initialized)
+      const isPacInput = el.classList?.contains('pac-target-input');
+      return hasLocateMe || hasPacContainer || isPacInput;
+    }).catch(() => false);
+    if (isPac) {
+      const r = await typeAndPickSuggestion(page, triggerLocator, value);
+      // If typeahead failed, fall through to the normal dropdown path
+      // (some fields are both, weirdly)
+      if (r.ok) return r;
+    }
+  } catch {}
+
   try {
     // Snapshot option-list state BEFORE opening so we can identify
     // the new options. Includes:
@@ -310,6 +362,21 @@ async function openAndPickOption(page, triggerLocator, value, llmCtx) {
     }
 
     if (candidates.length === 0) {
+      // DIAGNOSTIC: dump the field's actual DOM so we can see what widget
+      // this really is (intl-tel? react-select? custom?). One-line summary
+      // of the element + its 2 nearest ancestors' classes + any sibling
+      // input/button. This is how we stop guessing selectors.
+      const diag = await triggerLocator.evaluate((el) => {
+        const summ = (n) => n ? `<${n.tagName.toLowerCase()} class="${(n.className || '').toString().slice(0, 120)}" role="${n.getAttribute?.('role') || ''}" aria-haspopup="${n.getAttribute?.('aria-haspopup') || ''}">` : 'null';
+        const p1 = el.parentElement;
+        const p2 = p1?.parentElement;
+        const siblingInputs = Array.from((p2 || p1 || el).querySelectorAll('input, button, [role="combobox"], [role="button"]'))
+          .slice(0, 5)
+          .map((s) => `${s.tagName.toLowerCase()}.${(s.className || '').toString().split(' ')[0]}`)
+          .join(', ');
+        return `self=${summ(el)} | p1=${summ(p1)} | p2=${summ(p2)} | nearby=[${siblingInputs}]`;
+      }).catch(() => 'diag failed');
+      console.warn(`[smartFill] DROPDOWN-DIAG: ${diag}`);
       await page.keyboard.press('Escape').catch(() => {});
       return { ok: false, reason: 'dropdown opened but no visible options found' };
     }