halo-agent 2.6.0 → 2.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "halo-agent",
-  "version": "2.6.0",
+  "version": "2.6.2",
   "description": "HALO local apply agent — auto-fills job applications using your real Chrome session",
   "main": "index.js",
   "bin": {
@@ -30,7 +30,6 @@
     "vision.js",
     "manusAutomate.js",
     "ui.js",
-    "resolveLinkedIn.js",
     "README.md"
   ],
   "keywords": [

package/poller.js

@@ -31,43 +31,6 @@ async function startPolling(chromeConn, config) {
     const item = await fetchNextJob(config);
     if (!item) continue;
 
-    // ── resolve_linkedin task branch ──────────────────────────────────
-    // Quick (<5s) URL-read tasks live alongside apply tasks. The agent's
-    // Chrome is already authenticated to LinkedIn, so we read the offsite
-    // "Apply on company website" URL from the live DOM and POST it back.
-    // No tab churn, no full apply flow.
-    if (item.intent === 'resolve_linkedin') {
-      active = true;
-      try {
-        const linkedinUrl = item.step_detail || item.apply_url || item.url;
-        ui.info(`${ui.gray('//')} resolving ${ui.bold(item.company)} ${ui.gray('on linkedin')}`);
-        const { resolveLinkedInOnPage } = require('./resolveLinkedIn');
-        const result = await resolveLinkedInOnPage(chromeConn, linkedinUrl).catch((e) => ({
-          resolved_url: null, reason: e?.message || 'resolve threw',
-        }));
-        await fetch(`${config.apiUrl}/apply-queue/${item.id}/resolved`, {
-          method: 'POST',
-          headers: {
-            Authorization: `Bearer ${config.token}`,
-            'Content-Type': 'application/json',
-            ...cfAccessHeaders(config),
-          },
-          body: JSON.stringify({
-            resolved_url: result.resolved_url || null,
-            reason: result.reason || undefined,
-          }),
-        }).catch(() => {});
-        if (result.resolved_url) {
-          ui.info(`  ${ui.sym.tick} ${ui.gray('→')} ${result.resolved_url}`);
-        } else {
-          ui.warn(`  ${ui.sym.cross} could not resolve · ${result.reason || 'no URL found'}`);
-        }
-      } finally {
-        active = false;
-      }
-      continue;
-    }
-
     active = true;
     console.log('');
     ui.info(`${ui.bold(item.company)} ${ui.gray(ui.sym.dot)} ${item.title}`);

package/scanAccessibility.js

@@ -76,6 +76,12 @@ async function injectMmid(page) {
       '[role="option"]',
       '[role="menuitem"]',
       'button[type="submit"]',
+      // ATS toggle-button pairs (Ashby "Yes"/"No", some Greenhouse choice
+      // chips) are rendered as plain `<button>` elements without an explicit
+      // role attribute. Without this, the scan misses every required Yes/No
+      // question on Ashby and the planner silently leaves them blank.
+      // Downstream filters drop nav/close/submit buttons by label heuristic.
+      'button',
       'a[href]',
     ].join(',');
     const all = document.querySelectorAll(sel);
@@ -496,7 +502,7 @@ async function scanFrameDom(frame, frameUrl) {
     const seen = new Set();
     let n = Math.floor(Math.random() * 800000) + 200000; // high offset, no main-frame collision
 
-    const sel = 'input,textarea,select,[contenteditable="true"],[role="textbox"],[role="combobox"],[role="listbox"],[role="radio"],[role="checkbox"],[role="switch"],[role="button"],button[type="submit"]';
+    const sel = 'input,textarea,select,[contenteditable="true"],[role="textbox"],[role="combobox"],[role="listbox"],[role="radio"],[role="checkbox"],[role="switch"],[role="button"],button[type="submit"],button';
     document.querySelectorAll(sel).forEach((el) => {
       const tag = el.tagName.toLowerCase();
       const type = (el.type || '').toLowerCase();
@@ -567,6 +573,7 @@ async function scanFrameDom(frame, frameUrl) {
   return raw.map((f) => ({
     mmid: f.mmid,
     role: f.forceRole || normalizeRole(f),
+    tag: f.tag, // needed by main-frame filter to distinguish <button> from [role=button]
     label: f.label || f.textContent || '',
     description: '',
     required: false,
@@ -636,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 = [];
@@ -643,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
@@ -651,6 +763,21 @@ async function scanAccessibility(page) {
     if (f.frameUrl) {
       const fl = (f.label || '').trim();
       if (f.role === 'button' && (/^remove\s+\S/i.test(fl) || /^clear\s+selection/i.test(fl) || fl === '×' || fl === '✕' || fl === 'x')) continue;
+      // Apply the same nav-button filter for in-frame buttons.
+      if (f.role === 'button' && f.tag === 'button') {
+        const ll = fl.toLowerCase().trim();
+        const navWords = [
+          'back', 'cancel', 'close', 'menu', 'open menu', 'dismiss',
+          'submit', 'submit application', 'apply', 'apply now',
+          'sign in', 'sign up', 'log in', 'login', 'logout',
+          'next', 'previous', 'continue', 'edit', 'save',
+          'save and continue', 'save & continue',
+          'toggle theme', 'change theme', 'show password', 'hide password',
+        ];
+        if (navWords.includes(ll)) continue;
+        if (f.inputType === 'submit') continue;
+        if (fl.length > 80) continue;
+      }
       if (!fl && !['button', 'link'].includes(f.role)) continue;
       out.push(f); // already in public shape, carries frameUrl
       continue;
@@ -673,6 +800,58 @@ async function scanAccessibility(page) {
     )) {
       continue;
     }
+    // Filter out navigation / submit / close buttons surfaced by the
+    // broader generic-button selector. Answer-choice buttons (Yes / No /
+    // short option text) stay — they're what powers Ashby's toggle pairs.
+    if (normalizeRole(f) === 'button' && f.tag === 'button') {
+      const ll = label.toLowerCase().trim();
+      // Drop common nav buttons by exact-ish label
+      const navWords = [
+        'back', 'cancel', 'close', 'menu', 'open menu', 'dismiss',
+        'submit', 'submit application', 'apply', 'apply now',
+        'sign in', 'sign up', 'log in', 'login', 'logout',
+        'next', 'previous', 'continue',  // multi-step nav — filter; the form's own pagination handles
+        'edit', 'save', 'save and continue', 'save & continue',
+        'toggle theme', 'change theme', 'show password', 'hide password',
+        'view jd', 'view job', 'open application',
+      ];
+      if (navWords.includes(ll)) continue;
+      // Drop submit-type buttons even without a matching label
+      if (f.inputType === 'submit') continue;
+      // Drop very long labels — answer choices are short. >80 chars is
+      // almost certainly help text, fineprint, or accidentally-captured
+      // 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(

package/resolveLinkedIn.js

@@ -1,161 +0,0 @@
-// resolveLinkedIn — open a LinkedIn job-view URL in the agent's
-// authenticated Chrome session, read the offsite "Apply on company website"
-// URL from the live DOM, return it. The user is already logged into
-// LinkedIn here, so the offsite URL is actually present (unlike the
-// unauthenticated page Cloudflare Browser Run sees).
-//
-// Strategies, in order:
-//   1. <code id="applyUrl"> JSON-encoded URL
-//   2. <a data-tracking-control-name*="apply-link-offsite"> href
-//   3. Voyager / inline JSON dump with companyApplyUrl / applyMethod
-//   4. Click intercept — click the visible Apply button, capture the
-//      destination URL from a new-tab event (works for the modern UI where
-//      the apply button JS-navigates instead of using an <a href>).
-//
-// Returns { resolved_url: string | null, reason?: string }.
-
-const RESOLVE_TIMEOUT_MS = 15_000;
-
-async function resolveLinkedInOnPage(chromeConn, linkedinUrl) {
-  if (!linkedinUrl || !/linkedin\.com\/jobs\/view/i.test(linkedinUrl)) {
-    return { resolved_url: null, reason: 'not a linkedin job-view url' };
-  }
-
-  let page;
-  try {
-    page = await chromeConn.newPage();
-  } catch (e) {
-    return { resolved_url: null, reason: `couldn't open page: ${e.message}` };
-  }
-
-  // Listen for new-tab events on the same context — this catches the
-  // "Apply on company website" button when it opens the ATS in a new tab.
-  let newTabUrl = null;
-  const onNewPage = async (p) => {
-    try {
-      // The new tab navigates through a LinkedIn redirector first, then
-      // lands on the final ATS URL. We wait briefly, then capture.
-      await new Promise((r) => setTimeout(r, 1200));
-      const u = p.url();
-      if (u && /^https?:\/\//i.test(u) && !/linkedin\.com/i.test(u)) {
-        newTabUrl = u;
-      }
-      // Close the new tab — we have what we need, no point loading it.
-      try { await p.close(); } catch {}
-    } catch {}
-  };
-  try { chromeConn.context.on('page', onNewPage); } catch {}
-
-  try {
-    await Promise.race([
-      page.goto(linkedinUrl, { waitUntil: 'domcontentloaded', timeout: RESOLVE_TIMEOUT_MS }),
-      new Promise((_, reject) => setTimeout(() => reject(new Error('navigation timeout')), RESOLVE_TIMEOUT_MS)),
-    ]);
-    // Let LinkedIn's JS render the apply button (lazy-loaded).
-    await page.waitForSelector('#applyUrl, [data-tracking-control-name*="apply"], button[aria-label*="Apply" i], a[aria-label*="Apply" i]', { timeout: 6000 }).catch(() => {});
-
-    // Run the 1-3 strategies inline.
-    const found = await page.evaluate(() => {
-      const isExt = (u) =>
-        !!u && typeof u === 'string' && /^https?:\/\//i.test(u) && !/linkedin\.com/i.test(u);
-
-      // 1. <code id="applyUrl">
-      try {
-        const code = document.getElementById('applyUrl');
-        if (code && code.textContent) {
-          let raw = code.textContent.trim();
-          try { const p = JSON.parse(raw); if (isExt(p)) return p; } catch (e) {}
-          raw = raw.replace(/^"+|"+$/g, '');
-          if (isExt(raw)) return raw;
-        }
-      } catch (e) {}
-
-      // 2. data-tracking-control-name=apply-link-offsite anchors.
-      try {
-        const sel = [
-          'a[data-tracking-control-name*="apply-link-offsite"]',
-          'a[data-tracking-control-name*="apply_unify"]',
-          'a[data-tracking-control-name*="apply-link"]',
-        ].join(', ');
-        const els = Array.from(document.querySelectorAll(sel));
-        for (const el of els) {
-          const href = el.getAttribute('href') || '';
-          if (isExt(href)) return new URL(href, document.baseURI).href;
-        }
-      } catch (e) {}
-
-      // 3. Inline JSON dumps in <code> elements.
-      try {
-        const codes = Array.from(document.querySelectorAll('code'));
-        for (const c of codes) {
-          const txt = c.textContent || '';
-          if (!txt.includes('companyApplyUrl') && !txt.includes('applyMethod')) continue;
-          try {
-            const obj = JSON.parse(txt);
-            const stack = [obj];
-            while (stack.length) {
-              const cur = stack.pop();
-              if (!cur || typeof cur !== 'object') continue;
-              if (isExt(cur.companyApplyUrl)) return cur.companyApplyUrl;
-              if (isExt(cur.applyUrl)) return cur.applyUrl;
-              if (isExt(cur.url) && cur.applyMethod) return cur.url;
-              for (const k of Object.keys(cur)) {
-                if (typeof cur[k] === 'object') stack.push(cur[k]);
-              }
-            }
-          } catch (e) {}
-        }
-      } catch (e) {}
-
-      return null;
-    }).catch(() => null);
-
-    if (found) {
-      // Clean up listener and page.
-      try { chromeConn.context.off('page', onNewPage); } catch {}
-      try { await page.close(); } catch {}
-      return { resolved_url: found };
-    }
-
-    // Strategy 4 — click the Apply button and watch for a new tab.
-    try {
-      const clicked = await page.evaluate(() => {
-        const candidates = [
-          'button[data-tracking-control-name*="apply"]',
-          'a[data-tracking-control-name*="apply"]',
-          'button[aria-label*="Apply" i]',
-          'a[aria-label*="Apply" i]',
-        ];
-        for (const sel of candidates) {
-          const el = document.querySelector(sel);
-          if (el) {
-            try { el.click(); return true; } catch (e) {}
-          }
-        }
-        return false;
-      });
-      if (clicked) {
-        // Wait up to 5s for the new tab listener to populate newTabUrl.
-        const start = Date.now();
-        while (Date.now() - start < 5000 && !newTabUrl) {
-          await new Promise((r) => setTimeout(r, 200));
-        }
-        if (newTabUrl) {
-          try { chromeConn.context.off('page', onNewPage); } catch {}
-          try { await page.close(); } catch {}
-          return { resolved_url: newTabUrl };
-        }
-      }
-    } catch {}
-
-    try { chromeConn.context.off('page', onNewPage); } catch {}
-    try { await page.close(); } catch {}
-    return { resolved_url: null, reason: 'no offsite URL found in any strategy' };
-  } catch (e) {
-    try { chromeConn.context.off('page', onNewPage); } catch {}
-    try { await page.close(); } catch {}
-    return { resolved_url: null, reason: e?.message || 'navigation failed' };
-  }
-}
-
-module.exports = { resolveLinkedInOnPage };