halo-agent 2.2.6 → 2.4.0

package/orchestrator.js

@@ -53,9 +53,18 @@ async function fillFields(page, aep, opts) {
 }
 const { detectCaptcha, solveCaptcha, injectCaptchaToken } = require('./captcha');
 const { visionFill, visionNavigateAndSubmit, visionFillSkipped } = require('./vision');
-
-// ATS types that need vision fallback due to shadow DOM / canvas
-const VISION_ATS = new Set(['workday', 'icims', 'taleo', 'sap', 'successfactors']);
+const { scanWorkday } = require('./scanWorkday');
+const { scanAccessibility } = require('./scanAccessibility');
+const { findApplyPath } = require('./findApplyPath');
+
+// ATS types that need vision fallback due to shadow DOM / canvas.
+// 'workday' was here historically because the AX-tree scan returned no usable
+// fields on Workday's shadow-DOM forms. Phase 3 of the Workday end-to-end fix
+// added scanWorkday() (DOM walk via [data-automation-id^="formField-"]) +
+// pickWorkdayOption (scroll-and-scrape for long dropdowns), so Workday is now
+// DOM-first like Greenhouse/Lever, with vision reserved as fallback only.
+const VISION_ATS = new Set(['icims', 'taleo', 'sap', 'successfactors']);
+const WORKDAY_ATS = 'workday';
 
 /**
  * Create a fresh FormContext for tracking state across a multi-page application.
@@ -157,6 +166,36 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
     // May return a new page object if Apply opened a new tab.
     page = await clickApplyIfNeeded(page);
 
+    // STEP 1.5: Find the apply path if the page still has no fields.
+    //
+    // clickApplyIfNeeded only handles obvious cases (a literal "Apply" button
+    // outside the form). It misses:
+    //   - tabs (Overview / Application on Mercor's Ashby-wrapped careers page)
+    //   - "Continue to application" CTAs below the fold
+    //   - non-semantic styled divs that act as the entry point
+    //
+    // findApplyPath checks the cache, then probes the AX tree for apply-keyword
+    // clickables, then falls back to vision. Bounded to 2 click hops. If it
+    // still can't find fields, we surface NEEDS_ATTENTION below instead of the
+    // blind resume-uploader hack.
+    try {
+      const earlyScan = await scanAccessibility(page);
+      if (!earlyScan || earlyScan.length === 0) {
+        console.log('[orchestrator] No fields after clickApplyIfNeeded  invoking findApplyPath');
+        const result = await findApplyPath(page, { config, anthropicKey });
+        if (result.found) {
+          console.log(`[orchestrator] findApplyPath: ${result.method} succeeded (${result.fields_after} fields)`);
+        } else {
+          console.warn('[orchestrator] findApplyPath: no apply path found  form may need manual navigation');
+          // We continue anyway  handlePageGate / smartFill may still find
+          // something. If everything fails downstream, the existing NEEDS_ATTENTION
+          // surface fires from the orchestrator's terminal error handler.
+        }
+      }
+    } catch (e) {
+      console.warn(`[orchestrator] findApplyPath threw: ${e.message}`);
+    }
+
     // STEP 2: Vision gate detection — handles modals, resume prompts, login walls, preamble screens.
     // Runs before captcha check so the form is actually visible before we try to fill it.
     const gateResult = await handlePageGate(page, aep, tempResumeFile, config);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "halo-agent",
-  "version": "2.2.6",
+  "version": "2.4.0",
   "description": "HALO local apply agent — auto-fills job applications using your real Chrome session",
   "main": "index.js",
   "bin": {
@@ -23,6 +23,7 @@
     "filler.js",
     "scanPage.js",
     "scanAccessibility.js",
+    "scanWorkday.js",
     "smartFill.js",
     "detectFormErrors.js",
     "captcha.js",

package/scanAccessibility.js

@@ -609,4 +609,4 @@ async function scanAccessibility(page) {
   return out;
 }
 
-module.exports = { scanAccessibility };
+module.exports = { scanAccessibility, injectMmid };

package/scanWorkday.js

@@ -0,0 +1,154 @@
+'use strict';
+
+/**
+ * Workday DOM scanner (Phase 3 of the Workday end-to-end fix).
+ *
+ * Workday forms live in a React shadow-DOM and the canonical anchor for every
+ * fillable widget is `[data-automation-id^="formField-"]`. The public repo
+ * shanjilcoding/resume-tailor-public's workday.js proved this approach is
+ * reliable enough for the common case — we borrow the SELECTORS and
+ * HEURISTICS (not the bookmarklet runtime) into Playwright.
+ *
+ * Why it exists: previously the agent treated Workday as VISION-ONLY in
+ * orchestrator.js (VISION_ATS set), which meant every Workday job cost a
+ * Claude Opus call per field (~40 iterations / $0.06 per job, slow). This
+ * scanner returns fields in the same shape scanAccessibility produces, so the
+ * existing smartFillPage / planner pipeline can drive Workday DOM-first.
+ * Vision stays as a fallback for fields this DOM pass misses (custom widgets,
+ * vendor-extended Workday tenants).
+ *
+ * Output shape (matches scanAccessibility for executor compatibility):
+ *   {
+ *     mmid, role, label, description, required, options, selectorHint,
+ *     inputType, value, isTypeahead, groupLabel, filledAlready,
+ *   }
+ */
+
+const { injectMmid } = require('./scanAccessibility');
+
+async function scanWorkday(page) {
+  await injectMmid(page).catch(() => 0);
+
+  return await page.evaluate(() => {
+    function clean(s) { return String(s || '').replace(/\s+/g, ' ').trim(); }
+
+    // Workday inputs live INSIDE the formField wrapper; pick the most
+    // representative one (the visible interactive element).
+    function pickInner(root) {
+      return root.querySelector(
+        'input:not([type=hidden]):not([type=submit]),' +
+        'textarea, select,' +
+        '[role="combobox"], button[aria-haspopup="listbox"], button[aria-haspopup="dialog"],' +
+        '[role="checkbox"], [role="radio"]'
+      );
+    }
+
+    // Map DOM tag/role → the same role string scanAccessibility uses, so the
+    // planner doesn't need a special case for Workday.
+    function inferRole(root, inner) {
+      if (!inner) return 'textbox';
+      const tag = (inner.tagName || '').toLowerCase();
+      const role = inner.getAttribute('role');
+      const type = (inner.getAttribute('type') || '').toLowerCase();
+      if (tag === 'textarea') return 'textarea';
+      if (tag === 'select') return 'listbox';
+      if (role === 'combobox' || (tag === 'button' && /listbox|dialog/.test(inner.getAttribute('aria-haspopup') || ''))) return 'combobox';
+      if (role === 'checkbox' || type === 'checkbox') return 'checkbox';
+      if (role === 'radio' || type === 'radio') return 'radio';
+      if (type === 'file' || root.querySelector('input[type=file]')) return 'file_upload';
+      return 'textbox';
+    }
+
+    function nearestLabel(root, inner) {
+      // 1. label[for=id]
+      if (inner && inner.id) {
+        const lbl = document.querySelector(`label[for="${inner.id}"]`);
+        if (lbl) return clean(lbl.innerText || lbl.textContent || '').replace(/\*\s*$/, '').trim();
+      }
+      // 2. aria-labelledby
+      const ariaLbl = (inner && inner.getAttribute('aria-labelledby')) || root.getAttribute('aria-labelledby');
+      if (ariaLbl) {
+        const t = ariaLbl.split(/\s+/).map((id) => document.getElementById(id)).filter(Boolean)
+          .map((n) => clean(n.innerText || '')).join(' ').trim();
+        if (t) return t.replace(/\*\s*$/, '').trim();
+      }
+      // 3. A label/legend inside the formField wrapper (Workday's typical layout)
+      const lbl = root.querySelector('label, legend, [class*="label"]');
+      if (lbl) return clean(lbl.innerText || '').replace(/\*\s*$/, '').trim();
+      // 4. data-automation-id minus prefix as a last resort
+      const daid = root.getAttribute('data-automation-id') || '';
+      return daid.replace(/^formField-/, '').replace(/[-_]/g, ' ').trim() || '(unknown)';
+    }
+
+    function isRequired(root, inner) {
+      if (inner) {
+        if (inner.required) return true;
+        if (inner.getAttribute('aria-required') === 'true') return true;
+      }
+      // Workday marks required labels with a trailing * inside the wrapper.
+      const lbl = root.querySelector('label, legend');
+      const raw = lbl ? (lbl.innerText || lbl.textContent || '') : '';
+      return /\*\s*$/.test(raw.trim()) || /\brequired\b/i.test(raw);
+    }
+
+    // Get options if they're eagerly rendered. Workday's dropdowns mount their
+    // listbox on click, so this often returns null — smartFill's openAndPickOption
+    // already handles the click-then-look-then-scrape pattern.
+    function eagerOptions(root) {
+      const opts = [];
+      root.querySelectorAll('option, [role="option"]').forEach((o) => {
+        const t = clean(o.innerText || o.textContent || '');
+        if (t && opts.indexOf(t) === -1) opts.push(t);
+      });
+      return opts.length > 0 ? opts.slice(0, 200) : null;
+    }
+
+    function isCurrentlyFilled(inner, root) {
+      if (!inner) return false;
+      const tag = (inner.tagName || '').toLowerCase();
+      const type = (inner.getAttribute('type') || '').toLowerCase();
+      if (type === 'checkbox' || type === 'radio') return !!inner.checked;
+      if (type === 'file') return !!(inner.files && inner.files.length > 0);
+      if (tag === 'select') return !!inner.value && !!inner.value.trim();
+      // Combobox / button trigger: look for the value display sibling.
+      if (inner.getAttribute('role') === 'combobox' || tag === 'button') {
+        // Workday renders the selected value in a span with the displayed text.
+        const valEl = root.querySelector('[data-automation-id*="value"], [class*="selectedValue"]');
+        if (valEl) return !!clean(valEl.innerText || valEl.textContent || '');
+      }
+      return !!clean(inner.value || '');
+    }
+
+    const results = [];
+    const seen = new Set();
+    document.querySelectorAll('[data-automation-id^="formField-"]').forEach((node) => {
+      const root = node;
+      const daid = root.getAttribute('data-automation-id') || '';
+      // De-dup: some Workday templates nest formField wrappers; keep the outermost.
+      if (seen.has(daid)) return;
+      seen.add(daid);
+      const inner = pickInner(root);
+      const mmid = (inner && inner.getAttribute('mmid')) || root.getAttribute('mmid') || null;
+      if (!mmid) return; // injectMmid skipped it — likely not interactive
+      const label = nearestLabel(root, inner);
+      const role = inferRole(root, inner);
+      results.push({
+        mmid: String(mmid),
+        role,
+        label,
+        description: (inner && (inner.getAttribute('aria-description') || inner.getAttribute('placeholder'))) || null,
+        required: isRequired(root, inner),
+        options: eagerOptions(root),
+        selectorHint: `[data-automation-id="${daid}"]`,
+        inputType: (inner && inner.getAttribute('type')) || null,
+        value: (inner && clean(inner.value || '')) || '',
+        isTypeahead: role === 'combobox',
+        groupLabel: null,
+        filledAlready: isCurrentlyFilled(inner, root),
+      });
+    });
+    return results;
+  }).catch(() => []);
+}
+
+module.exports = { scanWorkday };

package/smartFill.js

@@ -17,6 +17,7 @@
  */
 
 const { scanAccessibility } = require('./scanAccessibility');
+const { scanWorkday } = require('./scanWorkday');
 const { fillFields: legacyFillFields } = require('./filler');
 
 // ── Plan executor ───────────────────────────────────────────────────────────
@@ -503,6 +504,133 @@ async function tryReactSelect(root, triggerLocator, value) {
   }
 }
 
+/**
+ * Workday combobox / multi-select option picker.
+ *
+ * Workday's dropdowns mount a popover with [data-automation-id="activeListContainer"]
+ * holding [data-automation-id="promptOption"] entries. Long lists (country,
+ * university, state) are VIRTUALIZED — only ~10 entries render at once; you
+ * have to scroll the container to materialize the rest. The legacy
+ * openAndPickOption path would click + look once + give up on a 5-of-200 hit
+ * rate, which is why VISION_ATS = ['workday'] existed in the first place.
+ *
+ * Strategy (borrowed from shanjilcoding/resume-tailor-public/src/lib/workday.js
+ * lines ~600-750):
+ *   1. Click trigger, wait for activeListContainer.
+ *   2. Type the value to filter (Workday narrows the list as you type — saves
+ *      most of the scrolling).
+ *   3. Snapshot visible promptOptions, scroll the container, snapshot again.
+ *      Repeat until the option set is stable for 2 consecutive rounds OR we
+ *      exceed a scroll budget.
+ *   4. Fuzzy-match the typed value against the union of all option texts.
+ *   5. Click the matching promptOption; verify the trigger now shows a value.
+ */
+async function pickWorkdayOption(root, triggerLocator, value) {
+  const page = (root && typeof root.page === 'function') ? root.page() : root;
+  try {
+    // Open the dropdown by clicking the trigger. Workday's trigger is often
+    // a button or div with role="combobox" — both respond to .click().
+    await triggerLocator.click({ timeout: 2500 }).catch(async () => {
+      await triggerLocator.click({ force: true, timeout: 1500 });
+    });
+    await page.waitForTimeout(300);
+
+    // Locate the popover. It's appended at document.body and identified by
+    // [data-automation-id="activeListContainer"] (Workday's canonical anchor).
+    const containerSel = '[data-automation-id="activeListContainer"]';
+    const optionSel = '[data-automation-id="promptOption"]';
+    try {
+      await root.locator(containerSel).first().waitFor({ state: 'visible', timeout: 2200 });
+    } catch {
+      return { ok: false, reason: 'workday: activeListContainer never appeared' };
+    }
+
+    // If the trigger also accepts text (searchable combobox), type the value
+    // to filter the list. Speeds up long-list matching dramatically.
+    const typed = String(value).split(/[,;]/)[0].trim();
+    try {
+      const isTextInput = await triggerLocator.evaluate((el) => {
+        const tag = (el.tagName || '').toLowerCase();
+        const type = (el.getAttribute('type') || '').toLowerCase();
+        return tag === 'input' && (type === 'text' || type === 'search' || type === '');
+      }).catch(() => false);
+      if (isTextInput && typed) {
+        await triggerLocator.fill('').catch(() => {});
+        await page.keyboard.type(typed, { delay: 30 });
+        await page.waitForTimeout(450); // let virtualized list re-render filtered set
+      }
+    } catch { /* not a text input — skip filter step */ }
+
+    // Scroll-and-scrape. Snapshot options, scroll, snapshot, repeat until
+    // stable for 2 rounds or we hit the scroll budget.
+    const container = root.locator(containerSel).first();
+    const seen = new Map(); // text → first index seen
+    const MAX_SCROLLS = 30;
+    let stableRounds = 0;
+    let prevSize = 0;
+    for (let i = 0; i < MAX_SCROLLS; i++) {
+      const visible = await root.locator(optionSel).evaluateAll((nodes) => {
+        return nodes.map((n) => (n.innerText || n.textContent || '').replace(/\s+/g, ' ').trim()).filter(Boolean);
+      }).catch(() => []);
+      for (const t of visible) { if (!seen.has(t)) seen.set(t, seen.size); }
+      if (seen.size === prevSize) {
+        stableRounds += 1;
+        if (stableRounds >= 2) break; // list exhausted
+      } else {
+        stableRounds = 0;
+        prevSize = seen.size;
+      }
+      // Scroll the container to materialize more entries.
+      await container.evaluate((el) => { el.scrollTop = el.scrollTop + el.clientHeight; }).catch(() => {});
+      await page.waitForTimeout(180);
+    }
+
+    const options = Array.from(seen.keys());
+    if (options.length === 0) {
+      return { ok: false, reason: 'workday: scrolled but no promptOption text found' };
+    }
+
+    // Fuzzy match: exact → starts-with → contains → token overlap.
+    const v = String(value).toLowerCase().trim();
+    let pickText = options.find((t) => t.toLowerCase() === v)
+      || options.find((t) => t.toLowerCase().startsWith(v))
+      || options.find((t) => t.toLowerCase().includes(v) || v.includes(t.toLowerCase()));
+    if (!pickText) {
+      const vTokens = v.split(/\s+/).filter((t) => t.length > 2);
+      pickText = options.find((t) => {
+        const tt = t.toLowerCase();
+        return vTokens.some((vt) => tt.includes(vt));
+      });
+    }
+    if (!pickText) {
+      await page.keyboard.press('Escape').catch(() => {});
+      return { ok: false, reason: `workday: no option matched "${value}" (had ${options.length}: ${options.slice(0, 4).join(' / ')}${options.length > 4 ? '…' : ''})` };
+    }
+
+    // Click by visible text — scoped to the popover so we don't accidentally
+    // hit a same-named link elsewhere on the page.
+    const target = root.locator(`${containerSel} ${optionSel}`).filter({ hasText: pickText }).first();
+    await target.scrollIntoViewIfNeeded({ timeout: 1500 }).catch(() => {});
+    await target.click({ timeout: 1500 }).catch(async () => {
+      await target.click({ force: true, timeout: 1500 });
+    });
+    await page.waitForTimeout(200);
+
+    // Verify: the popover should have closed and the trigger should reflect
+    // the selection. If neither holds, the click silently failed.
+    const stillOpen = await root.locator(containerSel).first().isVisible({ timeout: 400 }).catch(() => false);
+    if (stillOpen) {
+      // One more try with a keyboard Enter (Workday sometimes needs that on the
+      // highlighted option).
+      await page.keyboard.press('Enter').catch(() => {});
+      await page.waitForTimeout(150);
+    }
+    return { ok: true, reason: `workday picked: ${pickText}` };
+  } catch (e) {
+    return { ok: false, reason: `workday option picker threw: ${e.message}` };
+  }
+}
+
 async function openAndPickOption(root, triggerLocator, value, llmCtx) {
   // root: Page or Frame. .locator works on both; keyboard/waitForTimeout
   // need the Page. For in-frame fields, option menus render inside the
@@ -547,6 +675,26 @@ async function openAndPickOption(root, triggerLocator, value, llmCtx) {
     }
   } catch {}
 
+  try {
+    // Workday combobox / multi-select. Workday wraps every form widget in a
+    // [data-automation-id^="formField-"] container and its dropdowns mount a
+    // popover with [data-automation-id="activeListContainer"], whose options
+    // are [data-automation-id="promptOption"] entries. Long lists (country,
+    // state, university) are virtualized: scrolling triggers more entries to
+    // render. We borrow the scroll-and-scrape pattern from the public
+    // shanjilcoding/resume-tailor-public/src/lib/workday.js bookmarklet.
+    const isWorkdayCombo = await triggerLocator.evaluate((el) => {
+      const inside = !!el.closest('[data-automation-id^="formField-"]');
+      const onWorkday = /myworkdayjobs\.com|workday\.com/i.test(window.location.href);
+      return inside || onWorkday;
+    }).catch(() => false);
+    if (isWorkdayCombo) {
+      const r = await pickWorkdayOption(root, triggerLocator, value);
+      if (r && r.ok) return r;
+      // If it failed (not actually a Workday combobox after all), fall through.
+    }
+  } 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
@@ -795,13 +943,33 @@ async function typeAndPickSuggestion(root, locator, value) {
  * @returns {Promise<{filled, skipped, failed, askUserReasons, planned}>}
  */
 async function smartFillPage(page, aep, options) {
-  const { config, jobId, resumePath, coverLetterPath, ctx } = options;
+  const { config, jobId, resumePath, coverLetterPath, ctx, ats } = options;
 
-  // 1. Scan via AX tree
-  const fields = await scanAccessibility(page).catch((e) => {
-    console.warn(`[smartFill] scanAccessibility failed: ${e.message}`);
-    return [];
-  });
+  // 1. Scan via AX tree. For Workday, prefer the DOM-walker that targets
+  // [data-automation-id^="formField-"] — the AX-tree scan returns mostly
+  // nothing on Workday's shadow-DOM React, which is what historically forced
+  // the entire job into vision (expensive). If scanWorkday returns <5 fields
+  // (atypical posting, login wall) we fall through to scanAccessibility so
+  // the orchestrator's downstream vision precision-fill still gets a shot.
+  const isWorkdayAts = (String(ats || '').toLowerCase() === 'workday')
+    || /myworkdayjobs\.com|workday\.com/i.test(page.url());
+  let fields = [];
+  if (isWorkdayAts) {
+    const wd = await scanWorkday(page).catch((e) => {
+      console.warn(`[smartFill] scanWorkday failed: ${e.message}`);
+      return [];
+    });
+    if (wd.length >= 5) {
+      fields = wd;
+      console.log(`[scanWorkday] ${fields.length} fields detected via data-automation-id`);
+    }
+  }
+  if (fields.length === 0) {
+    fields = await scanAccessibility(page).catch((e) => {
+      console.warn(`[smartFill] scanAccessibility failed: ${e.message}`);
+      return [];
+    });
+  }
   if (fields.length === 0) {
     console.warn('[smartFill] no fields detected on page');
     return { filled: 0, skipped: 0, failed: 0, askUserReasons: [], planned: 0, fallback: false };
@@ -846,6 +1014,30 @@ async function smartFillPage(page, aep, options) {
 
   console.log(`[smartFill] planner returned ${plan.length} actions for ${fields.length} fields`);
 
+  // Phase 4 of the Workday end-to-end fix: dry-run preview, Workday only.
+  // Workday forms are LONG (often 30+ fields across multiple pages) and the
+  // cost of a wrong fill — especially on demographic / sponsorship / clearance
+  // fields where the form rejects misclicks — is high. We render every
+  // planned action as a single readable line and hold 8 seconds before
+  // touching the DOM, letting the user Ctrl-C if anything looks off.
+  // Off-switch: config.workdayDryRun = false in ~/.halo-agent/config.json.
+  // Greenhouse / Lever / Ashby do NOT get this gate — their forms are short
+  // enough that the existing post-fill REVIEWING gate covers it.
+  if (isWorkdayAts && config?.workdayDryRun !== false) {
+    console.log('');
+    console.log(`[dry-run] Workday — about to fill ${plan.length} fields. Ctrl-C in the next 8s to cancel.`);
+    const planByMmidPreview = new Map(plan.map((p) => [String(p.mmid), p]));
+    for (const f of fields) {
+      const it = planByMmidPreview.get(String(f.mmid));
+      if (!it || it.action === 'skip') continue;
+      const labelShort = (f.label || f.selectorHint || '?').slice(0, 50);
+      const valShort = String(it.value || '').slice(0, 60).replace(/\s+/g, ' ');
+      console.log(`  · ${it.action.padEnd(13)} ${labelShort.padEnd(50)}  ${valShort}`);
+    }
+    console.log('');
+    await page.waitForTimeout(8000);
+  }
+
   // 4. Execute the plan in DOM order (planner doesn't dictate order; we
   // mirror the field scan order so dependent fields fill after their parents).
   const fieldByMmid = new Map(fields.map((f) => [String(f.mmid), f]));