halo-agent 2.6.1 → 2.6.2

package/package.json

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

package/scanAccessibility.js

@@ -643,6 +643,107 @@ async function scanAccessibility(page) {
     }
   }
 
+  // ── Toggle-group coalescing (Ashby, similar custom designs) ─────────────
+  // Some ATSes render Yes/No (and similar pick-one) questions as a pair of
+  // <button> elements above a hidden <input type="checkbox">. The buttons
+  // have no role attribute, no name connecting them, and they're scanned
+  // as independent fields with label "Yes" or "No" — the planner can't tell
+  // them apart from a true Yes/No without knowing the QUESTION.
+  //
+  // We detect these groups ONLY via two well-defined hooks:
+  //   1. Ashby's `_yesno_` container class (the explicit yes/no widget)
+  //   2. The generic shape: a `_fieldEntry_` wrapper containing a question
+  //      label + a sibling div whose ONLY children are 2-3 <button> elements
+  //      with short text labels (Yes/No or short option text).
+  //
+  // For each detected group we:
+  //   - Pick a "primary" mmid (the first button) and rewrite its label to
+  //     the QUESTION text, role to 'radio', options to ['Yes','No'], and
+  //     groupLabel to the question. The planner now sees this as a single
+  //     radio question with two options.
+  //   - Mark the OTHER button(s) in the group as droppable so the dedupe
+  //     loop below skips them — the planner only sees one synthetic radio
+  //     per group.
+  //
+  // Scoped tightly to avoid touching Greenhouse / Lever / Workday, all of
+  // which use native <input type="radio"> with `name` attributes for their
+  // pick-one questions.
+  let toggleGroupInfo = { primaries: {}, drop: new Set() };
+  try {
+    toggleGroupInfo = await page.evaluate(({ mmidAttr }) => {
+      function safeText(t) { return (t || '').replace(/\s+/g, ' ').trim(); }
+      const out = { primaries: {}, drop: [] };
+
+      // Pass 1: Ashby's explicit _yesno_ widget. CSS module hashing means
+      // the class name is like "_yesno_1e3gg_148" — match by substring.
+      const ashbyYesno = document.querySelectorAll('[class*="_yesno_"]');
+      ashbyYesno.forEach((container) => {
+        const buttons = Array.from(container.querySelectorAll('button'));
+        if (buttons.length < 2 || buttons.length > 4) return;
+        // The question label lives on a sibling <label> inside the same
+        // _fieldEntry_ wrapper.
+        const wrapper = container.closest('[class*="_fieldEntry_"], [data-field-path], .ashby-application-form-field-entry');
+        let question = '';
+        if (wrapper) {
+          const lbl = wrapper.querySelector('label');
+          if (lbl) question = safeText(lbl.textContent || '').replace(/\s*\*\s*$/, '').trim();
+        }
+        if (!question) return;
+        const mmids = buttons.map((b) => b.getAttribute(mmidAttr)).filter(Boolean);
+        if (mmids.length < 2) return;
+        const options = buttons.map((b) => safeText(b.textContent || '').trim()).filter(Boolean);
+        // First button is the primary — it'll be rewritten into the radio
+        // question. The rest get dropped from the field list.
+        out.primaries[mmids[0]] = { question, options };
+        for (let i = 1; i < mmids.length; i++) out.drop.push(mmids[i]);
+      });
+
+      // Pass 2: generic shape — _fieldEntry_ wrapper with a label + an
+      // option container whose direct children are only buttons (no inputs,
+      // no other interactive elements). Catches less-tagged variants of the
+      // same pattern. Conservative: only if EVERY direct interactive child
+      // is a button with short text.
+      const wrappers = document.querySelectorAll('[class*="_fieldEntry_"], [data-field-path], .ashby-application-form-field-entry');
+      wrappers.forEach((wrapper) => {
+        // Skip wrappers we've already coalesced via Pass 1.
+        if (wrapper.querySelector('[class*="_yesno_"]')) return;
+        const lbl = wrapper.querySelector('label');
+        if (!lbl) return;
+        const question = safeText(lbl.textContent || '').replace(/\s*\*\s*$/, '').trim();
+        if (!question || question.length > 200) return;
+        // Look for a button-only group sibling/descendant.
+        const candidates = Array.from(wrapper.querySelectorAll('div'))
+          .filter((d) => {
+            const kids = Array.from(d.children);
+            if (kids.length < 2 || kids.length > 4) return false;
+            return kids.every((k) => {
+              if (k.tagName !== 'BUTTON') return false;
+              const t = safeText(k.textContent || '').trim();
+              return t.length > 0 && t.length < 80;
+            });
+          });
+        if (!candidates.length) return;
+        const buttons = Array.from(candidates[0].children);
+        const mmids = buttons.map((b) => b.getAttribute(mmidAttr)).filter(Boolean);
+        if (mmids.length < 2) return;
+        // Skip if we already have a primary registered for these (Pass 1 ran).
+        if (out.primaries[mmids[0]]) return;
+        const options = buttons.map((b) => safeText(b.textContent || '').trim());
+        out.primaries[mmids[0]] = { question, options };
+        for (let i = 1; i < mmids.length; i++) out.drop.push(mmids[i]);
+      });
+
+      return out;
+    }, { mmidAttr: MMID_ATTR });
+  } catch (e) {
+    console.warn(`[scanAx] toggle-group detection failed: ${e.message}`);
+  }
+  const dropSet = new Set(toggleGroupInfo.drop || []);
+  const primaries = toggleGroupInfo.primaries || {};
+  if (Object.keys(primaries).length > 0) {
+    console.log(`[scanAx] coalesced ${Object.keys(primaries).length} toggle-button group(s) into radio questions`);
+  }
+
   // Normalize, dedupe by mmid (frames could collide, though we offset above)
   const seen = new Set();
   const out = [];
@@ -650,6 +751,10 @@ async function scanAccessibility(page) {
     if (seen.has(f.mmid)) continue;
     seen.add(f.mmid);
 
+    // Drop secondary buttons in coalesced toggle groups — the primary will
+    // be emitted as a synthetic radio question covering all options.
+    if (dropSet.has(f.mmid)) continue;
+
     // Frame-DOM fields are ALREADY normalized (scanFrameDom produced the
     // public shape: role/label/options as strings). Re-running pickLabel /
     // normalizeRole / options.map(o=>o.label) on them would break (those
@@ -718,6 +823,35 @@ async function scanAccessibility(page) {
       // descendant content.
       if (label.length > 80) continue;
     }
+    // Coalesce toggle-button group: rewrite this primary mmid into a single
+    // synthetic radio question so the planner sees ONE field with the real
+    // question as its label and ['Yes','No'] (or similar) as options.
+    const primary = primaries[f.mmid];
+    if (primary) {
+      out.push({
+        mmid: f.mmid,
+        role: 'radio',
+        label: primary.question,
+        description: '',
+        required: f.required,
+        disabled: f.disabled,
+        options: primary.options,
+        selectorHint: f.selectorHint,
+        inputType: 'radio',
+        currentValue: '',
+        isTypeahead: false,
+        groupLabel: primary.question,
+        textContent: primary.options.join(' / '),
+        filledAlready: false,
+        frameUrl: null,
+        // Signal to the executor: this is a toggle-button group, so
+        // set_radio should locate buttons by their visible text within
+        // the same _fieldEntry_ wrapper.
+        isToggleButtonGroup: true,
+      });
+      continue;
+    }
+
     out.push({
       mmid: f.mmid,
       role: normalizeRole(f),

package/smartFill.js

@@ -224,6 +224,36 @@ async function executePlanItem(page, item, fieldByMmid, ctx) {
         }).catch(() => null);
 
         const groupRoot = groupId ? root.locator(`[data-halo-rg="${groupId}"]`) : root;
+        // If the scanner coalesced this from a toggle-button group (Ashby
+        // _yesno_), prefer a direct button-by-text lookup — these are plain
+        // <button> elements with no role=radio attribute.
+        if (field.isToggleButtonGroup) {
+          // Match buttons whose entire trimmed text equals the value (avoid
+          // matching descendants by accident).
+          const btn = groupRoot.locator('button').filter({ hasText: new RegExp(`^\\s*${v.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\$&')}\\s*$`, 'i') }).first();
+          if (await btn.isVisible({ timeout: 1000 }).catch(() => false)) {
+            await btn.click({ timeout: 1500 }).catch(async () => {
+              await btn.click({ force: true, timeout: 1500 });
+            });
+            await page.waitForTimeout(150);
+            // Verify via aria-pressed / aria-checked / explicit selected class.
+            const stuck = await btn.evaluate((el) => {
+              if (el.getAttribute('aria-pressed') === 'true') return true;
+              if (el.getAttribute('aria-checked') === 'true') return true;
+              const cls = String(el.className || '');
+              if (/selected|active|checked/i.test(cls)) return true;
+              // Also check the sibling hidden checkbox the widget controls.
+              const grp = el.closest('[class*="_yesno_"], [class*="_fieldEntry_"]');
+              if (grp) {
+                const hidden = grp.querySelector('input[type="checkbox"], input[type="hidden"]');
+                if (hidden && hidden.value && String(hidden.value).length > 0) return true;
+              }
+              return false;
+            }).catch(() => true);
+            return { ok: true, reason: `toggle button: ${v}${stuck ? '' : ' (unverified)'}` };
+          }
+          // Fall through to the generic lookup below if direct button lookup missed.
+        }
         // Within the group, find the option whose visible label matches value.
         // Try role=radio, label, and a generic clickable row with the text.
         const optInGroup = groupRoot.locator(