halo-agent 2.0.6 → 2.0.9

package/captcha.js

@@ -16,10 +16,43 @@ const CAPSOLVER_API = 'https://api.capsolver.com';
  * Detect if a CAPTCHA is present anywhere on the page (including nested iframes).
  * Returns { detected, type, sitekey, pageUrl }
  */
+// ATS domains that EMBED their form (and its reCAPTCHA) in an iframe on a
+// company-branded careers page. When the captcha lives in one of these
+// frames, the sitekey is registered to THIS domain — so CapSolver must be
+// told the frame URL, not the wrapper page URL. (The Orion case:
+// orioninnovation.com/careers embeds job-boards.greenhouse.io; sending the
+// orioninnovation.com URL → "Invalid domain for site key".)
+const EMBEDDED_ATS_HOSTS = /(greenhouse\.io|lever\.co|ashbyhq\.com|myworkdayjobs\.com|icims\.com|smartrecruiters\.com|jobvite\.com|workable\.com)/i;
+
+/**
+ * Pick the URL to hand CapSolver for a given reCAPTCHA. The sitekey is
+ * domain-locked, so the URL must match the domain the widget actually runs
+ * on. If the form is embedded in a known-ATS iframe, that frame's URL wins
+ * over the top-level page URL.
+ */
+function resolveCaptchaPageUrl(page) {
+  const topUrl = page.url();
+  // If the top URL is itself an ATS domain, use it directly.
+  if (EMBEDDED_ATS_HOSTS.test(topUrl)) return topUrl;
+  // Otherwise, look for an ATS iframe — its URL is where the sitekey lives.
+  for (const frame of page.frames()) {
+    if (frame === page.mainFrame()) continue;
+    const fUrl = frame.url();
+    if (fUrl && EMBEDDED_ATS_HOSTS.test(fUrl)) {
+      // Strip the recaptcha frame itself — we want the FORM's frame, not
+      // google's. recaptcha frames are on google.com so they won't match
+      // EMBEDDED_ATS_HOSTS anyway, but be defensive.
+      if (!/google\.com|gstatic\.com/i.test(fUrl)) return fUrl;
+    }
+  }
+  return topUrl;
+}
+
 async function detectCaptcha(page) {
-  // The pageUrl CapSolver wants is the top-level URL the user sees, not an
-  // inner iframe URL. Anchor it here so every branch returns the same thing.
-  const pageUrl = page.url();
+  // The URL CapSolver needs is the domain the sitekey is registered to —
+  // the embedded ATS frame's URL when the form is iframed into a branded
+  // careers page, otherwise the top-level URL.
+  const pageUrl = resolveCaptchaPageUrl(page);
 
   // First try the top-level frame via evaluate
   const topResult = await page.evaluate(() => {

package/detectFormErrors.js

@@ -150,18 +150,28 @@ async function detectFormErrors(page) {
       // 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;
+        // Walk up to the React-Select CONTROL specifically (not the inner
+        // value-container — we want the whole control so single-value is
+        // in scope). react-select structure:
+        //   .select__control > .select__value-container > .select__single-value
+        //                                               > .select__input-container > input[role=combobox]
+        // The aria-invalid lands on the inner input, so we MUST climb to
+        // .select__control to see the rendered value chip.
+        let wrap = el.closest('[class*="select__control"]');
+        if (!wrap) {
+          // Climb manually for class variants
+          let p = el;
+          for (let i = 0; i < 8 && p; i++, p = p.parentElement) {
+            if (/select__control|select-control|\bSelect\b.*control/i.test(p.className || '')) { wrap = p; break; }
+          }
+        }
+        if (!wrap) wrap = el.closest('[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"]'
+            '[class*="chip"], [class*="tag"]'
           );
           if (valueEl && (valueEl.innerText || valueEl.textContent || '').trim()) return false;
           // Also: the control's own text, minus the placeholder. If the

package/orchestrator.js

@@ -87,6 +87,11 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
 
   let page = null;
   let tempResumeFile = null;
+  // When the run ends in a terminal SUCCESS (DONE), we leave the tab open
+  // so the user sees the confirmation page — visual loop-closure. Only
+  // close the tab on errors/cleanup. Set true right before each successful
+  // DONE return/fall-through.
+  let leaveTabOpen = false;
 
   // Initialize cross-page context tracker
   const ctx = createFormContext();
@@ -246,6 +251,7 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
         const currentUrl = page.url();
         const looksLikeConfirmation = /thank|confirm|success|applied|submitted/i.test(currentUrl);
         if (looksLikeConfirmation) {
+          leaveTabOpen = true;
           await reportStatus('DONE', { fields_filled: cumulativeFilled });
           await clearCheckpoint(config, queueId);
           console.log(`[orchestrator] Detected confirmation page by URL: ${currentUrl}`);
@@ -388,6 +394,7 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
           if (vRes.ok) vVerdict = await vRes.json();
         } catch {}
         if (vVerdict.submitted === true) {
+          leaveTabOpen = true;
           await reportStatus('DONE', { confirmation_screenshot_r2_key: confirmKey || null, fields_filled: cumulativeFilled });
           await clearCheckpoint(config, queueId);
           console.log(`[orchestrator] Done via vision (verified): ${queueItem.company} - ${queueItem.title}`);
@@ -613,6 +620,7 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
         fields_filled: cumulativeFilled,
       });
     } else {
+      leaveTabOpen = true;
       await reportStatus('DONE', {
         confirmation_screenshot_r2_key: confirmKey || null,
         fields_filled: cumulativeFilled,
@@ -668,9 +676,16 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
     if (tempResumeFile) {
       try { fs.unlinkSync(tempResumeFile); } catch {}
     }
-    // Close the tab (leave other tabs untouched)
-    if (page) {
+    // Close the tab on failure/cleanup — but on a successful submit, LEAVE
+    // it open so the user sees the confirmation page (visual loop-closure).
+    // The next job opens its own new tab, so leaving this one doesn't block
+    // anything; sequential processing is enforced by the poller (one job at
+    // a time). Stale success tabs accumulate, but that's the user's call to
+    // close — they asked for the satisfaction of seeing it land.
+    if (page && !leaveTabOpen) {
       try { await page.close(); } catch {}
+    } else if (page && leaveTabOpen) {
+      console.log('[orchestrator] Leaving confirmation tab open for your review.');
     }
   }
 }

package/package.json

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

package/smartFill.js

@@ -293,14 +293,125 @@ async function tryIntlTelCountry(page, triggerLocator, value) {
   }
 }
 
+/**
+ * React-Select handler. Greenhouse migrated its ENTIRE form to react-select
+ * (.select__control / .select__input / .select__menu / .select__option,
+ * with remix-css-* emotion classes). The diagnostic dump confirmed every
+ * failing dropdown — Country, Location — is this widget.
+ *
+ * The reason a plain click+look-for-options failed: react-select renders
+ * its .select__menu ONLY after the input is focused, and for long lists
+ * (countries) it filters by typed text. So the flow is:
+ *   1. click the .select__control to focus + open
+ *   2. type the value to filter the menu (react-select narrows as you type)
+ *   3. wait for .select__option to appear
+ *   4. click the best-matching option (or press Enter to take the highlight)
+ *
+ * For Location it's the same widget but backed by an async (Google Places)
+ * option source — typing triggers a network fetch, options arrive ~700ms
+ * later as .select__option. Same handler covers it.
+ *
+ * Returns null if this isn't a react-select field (so other handlers run).
+ */
+async function tryReactSelect(page, triggerLocator, value) {
+  try {
+    // Detect: the trigger or an ancestor carries a .select__ class.
+    const info = await triggerLocator.evaluate((el) => {
+      const control = el.closest('[class*="select__control"]')
+        || el.closest('[class*="select__value-container"]')?.closest('[class*="select__control"]')
+        || (el.className && /select__/.test(el.className) ? el.closest('[class*="select__"]')?.closest('[class*="control"]') : null)
+        // Last resort: walk up to any node whose class has select__control
+        || (() => { let p = el; for (let i = 0; i < 8 && p; i++, p = p.parentElement) { if (/select__control/.test(p.className || '')) return p; } return null; })();
+      if (!control) return null;
+      // The real text input inside the control:
+      const input = control.querySelector('input.select__input, input[class*="select__input"], input[role="combobox"]') || el;
+      // Tag both with a temp id so Playwright can target them precisely.
+      const cid = 'halo-rs-control-' + Math.random().toString(36).slice(2, 8);
+      control.setAttribute('data-halo-rs', cid);
+      if (input) input.setAttribute('data-halo-rs-input', cid);
+      return { cid };
+    }).catch(() => null);
+    if (!info) return null;
+
+    const control = page.locator(`[data-halo-rs="${info.cid}"]`).first();
+    const input = page.locator(`[data-halo-rs-input="${info.cid}"]`).first();
+
+    // 1. Open: click the control. react-select opens the menu on control click.
+    await control.click({ timeout: 2500 }).catch(() => {});
+    await page.waitForTimeout(250);
+
+    // 2. Type the value to filter. Strip "+1" / parens noise from country
+    //    values ("United States +1" → "United States"). For location, type
+    //    the city ("Tempe").
+    const typed = String(value).replace(/\s*\+\d+\s*$/, '').split(/[,;]/)[0].trim();
+    // Focus the input then type char-by-char so react-select's onChange fires.
+    await input.click({ timeout: 1500 }).catch(() => {});
+    await input.fill('').catch(() => {});
+    await page.keyboard.type(typed, { delay: 50 });
+
+    // 3. Wait for options. react-select menu is .select__menu containing
+    //    .select__option. Async (Places) options take longer — wait up to 2s.
+    const optSel = '.select__option, [class*="select__option"], [id*="react-select"][id*="option"]';
+    try {
+      await page.locator(optSel).first().waitFor({ state: 'visible', timeout: 2200 });
+    } catch {
+      // No options appeared. For react-select, pressing Enter on a typed
+      // value sometimes commits a free-text/create option. Try it, then
+      // verify the control now shows a value.
+      await page.keyboard.press('Enter').catch(() => {});
+      await page.waitForTimeout(200);
+      const filled = await control.evaluate((c) => {
+        const v = c.querySelector('[class*="single-value"], [class*="multi-value"]');
+        return v ? (v.textContent || '').trim() : '';
+      }).catch(() => '');
+      if (filled) return { ok: true, reason: `react-select (enter-commit): ${filled}` };
+      await page.keyboard.press('Escape').catch(() => {});
+      return { ok: false, reason: 'react-select menu showed no options after typing' };
+    }
+
+    // 4. Pick best option.
+    const opts = page.locator(optSel);
+    const texts = await opts.allTextContents().catch(() => []);
+    const tl = typed.toLowerCase();
+    let idx = texts.findIndex((t) => t.toLowerCase().trim() === tl);
+    if (idx === -1) idx = texts.findIndex((t) => t.toLowerCase().trim().startsWith(tl));
+    if (idx === -1) idx = texts.findIndex((t) => t.toLowerCase().includes(tl) || tl.includes(t.toLowerCase().trim()));
+    if (idx === -1) idx = 0; // react-select already filtered; first is best
+    await opts.nth(idx).click({ timeout: 2000 }).catch(async () => {
+      // react-select options sometimes need Enter on the highlighted item
+      await page.keyboard.press('Enter');
+    });
+    await page.waitForTimeout(150);
+    // Verify a value chip rendered
+    const got = await control.evaluate((c) => {
+      const v = c.querySelector('[class*="single-value"], [class*="multi-value"]');
+      return v ? (v.textContent || '').trim() : '';
+    }).catch(() => '');
+    if (got) return { ok: true, reason: `react-select picked: ${got}` };
+    return { ok: true, reason: `react-select clicked option: ${texts[idx] || typed}` };
+  } catch (e) {
+    return { ok: false, reason: `react-select handler threw: ${e.message}` };
+  }
+}
+
 async function openAndPickOption(page, triggerLocator, value, llmCtx) {
+  // React-Select FIRST — Greenhouse uses it for every dropdown. The
+  // diagnostic confirmed Country + Location are both .select__ widgets.
+  // Returns null if not react-select, so other handlers still run.
+  try {
+    const rs = await tryReactSelect(page, triggerLocator, value);
+    if (rs !== null) {
+      if (rs.ok) return rs;
+      // react-select detected but pick failed — log + fall through to the
+      // generic path as a last resort (rare).
+      console.warn(`[smartFill] react-select pick failed: ${rs.reason}`);
+    }
+  } catch {}
+
   try {
-    // First: intl-tel-input special case. The Country dial-code picker on
-    // Greenhouse is a non-standard widget that ignores clicks to its
-    // input — has to click the flag button. tryIntlTelCountry returns
-    // null when the field isn't intl-tel, so other dropdowns continue.
+    // intl-tel-input special case (kept for forms that genuinely use it).
     const itlResult = await tryIntlTelCountry(page, triggerLocator, value);
-    if (itlResult !== null) return itlResult;
+    if (itlResult !== null && itlResult.ok) return itlResult;
   } catch {}
 
   // Second: Google Places typeahead. The Greenhouse Location field is