halo-agent 1.3.3 → 1.3.5

package/filler.js

@@ -17,22 +17,11 @@ function jitter(base) {
  * Fires the full event sequence that frameworks listen for.
  */
 async function setFieldValue(page, selector, value) {
+  // Wrapper that delegates to the React-aware locator variant.
   try {
-    await page.locator(selector).first().waitFor({ timeout: 3000 });
-    await page.evaluate(({ sel, val }) => {
-      const el = document.querySelector(sel);
-      if (!el) return;
-      el.focus();
-      // React's synthetic event system requires using the native setter
-      const nativeInputValueSetter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set
-        || Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value')?.set;
-      if (nativeInputValueSetter) nativeInputValueSetter.call(el, val);
-      el.dispatchEvent(new Event('focus', { bubbles: true }));
-      el.dispatchEvent(new Event('input', { bubbles: true }));
-      el.dispatchEvent(new Event('change', { bubbles: true }));
-      el.dispatchEvent(new Event('blur', { bubbles: true }));
-    }, { sel: selector, val: value });
-    return true;
+    const loc = page.locator(selector).first();
+    await loc.waitFor({ timeout: 3000 });
+    return await setFieldValueByHandle(page, loc, value);
   } catch {
     return false;
   }
@@ -41,23 +30,53 @@ async function setFieldValue(page, selector, value) {
 /**
  * Set a field value by Playwright element handle (used after semantic matching).
  */
-async function setFieldValueByHandle(page, elementHandle, value) {
+async function setFieldValueByHandle(page, elementOrLocator, value) {
+  // Strategy ladder, hardest-React-friendly first.
+  // The Reddit-Greenhouse run proved everything below the FIRST strategy
+  // fired but the field still appeared empty: React's controlled-input
+  // validator rejects programmatic value writes that don't go through a
+  // real event pipeline. Playwright's locator.fill() simulates a real
+  // user typing (pointerdown → focus → keystroke events → blur) and IS
+  // the only thing modern React forms (Greenhouse, Ashby, Lever, Workday)
+  // reliably accept. We try it first and fall back to native-setter only
+  // if Playwright's path fails (rare; mostly when the element isn't a
+  // standard input).
+
+  // 1. Playwright native fill — works for >99% of React forms
+  try {
+    await elementOrLocator.fill(String(value), { timeout: 5000 });
+    // Verify the value actually stuck (React might have rejected it)
+    const got = await elementOrLocator.inputValue({ timeout: 1000 }).catch(() => null);
+    if (got && got.trim()) return true;
+    // If empty after fill, React rejected it — fall through to manual setter
+  } catch {
+    // Locator may not support .fill() (custom div pretending to be input).
+    // Fall through.
+  }
+
+  // 2. Click + keyboard.type — slower but bullets through React harder
+  try {
+    await elementOrLocator.click({ timeout: 2000 });
+    await elementOrLocator.fill('', { timeout: 2000 }).catch(() => {});
+    await page.keyboard.type(String(value), { delay: 20 });
+    const got = await elementOrLocator.inputValue({ timeout: 1000 }).catch(() => null);
+    if (got && got.trim()) return true;
+  } catch {}
+
+  // 3. Native setter dance — last resort for non-standard elements
   try {
-    await page.evaluate(({ val }) => {
-      const el = arguments[0]; // handled via elementHandle approach below
-    }, { val: value });
-    // Use evaluate with the handle directly
-    await elementHandle.evaluate((el, val) => {
+    await elementOrLocator.evaluate((el, val) => {
       el.focus();
-      const nativeInputValueSetter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set
-        || Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value')?.set;
-      if (nativeInputValueSetter) nativeInputValueSetter.call(el, val);
-      el.dispatchEvent(new Event('focus', { bubbles: true }));
+      const proto = el.tagName === 'TEXTAREA' ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+      const setter = Object.getOwnPropertyDescriptor(proto, 'value')?.set;
+      if (setter) setter.call(el, val); else el.value = val;
       el.dispatchEvent(new Event('input', { bubbles: true }));
       el.dispatchEvent(new Event('change', { bubbles: true }));
-      el.dispatchEvent(new Event('blur', { bubbles: true }));
-    }, value);
-    return true;
+      el.blur();
+    }, String(value));
+    // Verify
+    const got = await elementOrLocator.inputValue({ timeout: 1000 }).catch(() => null);
+    return !!(got && got.trim());
   } catch {
     return false;
   }
@@ -252,7 +271,35 @@ async function fillLocator(page, locator, value, label) {
       isContentEditable: el.isContentEditable,
       hasOptions: el.tagName === 'SELECT',
       optionCount: el.tagName === 'SELECT' ? el.options.length : 0,
-    })).catch(() => ({ tag: 'input', type: 'text', role: '', isContentEditable: false, hasOptions: false, optionCount: 0 }));
+      // Typeahead heuristics: any of these signals means "type then pick a
+      // suggestion." Greenhouse Location, Lever City, Workday locations all
+      // use this pattern — a plain text input that mounts a <ul role=listbox>
+      // of city matches as you type. Plain .fill() leaves the field
+      // visually populated but React clears it on blur because no
+      // suggestion was committed.
+      isTypeahead: !!(
+        el.getAttribute('aria-autocomplete') === 'list' ||
+        el.getAttribute('aria-autocomplete') === 'both' ||
+        el.getAttribute('aria-haspopup') === 'listbox' ||
+        el.getAttribute('aria-haspopup') === 'true' ||
+        el.getAttribute('autocomplete') === 'off' && el.getAttribute('aria-expanded') !== null ||
+        // Greenhouse + Lever wrap their typeahead in role=combobox parent
+        el.closest('[role="combobox"]') ||
+        // "Locate me" sibling button is a strong Greenhouse Location signal
+        Array.from((el.closest('div') || el.parentElement || document).querySelectorAll('button, a')).some(b => /locate\s*me/i.test(b.textContent || ''))
+      ),
+    })).catch(() => ({ tag: 'input', type: 'text', role: '', isContentEditable: false, hasOptions: false, optionCount: 0, isTypeahead: false }));
+
+    // ── Typeahead text input (Greenhouse Location, Lever City) ──
+    // Check BEFORE the generic combobox path so a plain <input> with
+    // typeahead-flagged ancestors still gets the type-then-pick treatment
+    // (those inputs aren't role=combobox themselves).
+    if (meta.isTypeahead && (meta.tag === 'input' || meta.tag === 'textarea')) {
+      const ok = await fillTypeahead(page, locator, value);
+      if (ok) return true;
+      // Fall through to default text-input path if typeahead pick failed —
+      // some forms accept the typed value even without selecting a suggestion.
+    }
 
     // ── Native <select> ──
     if (meta.tag === 'select' || meta.hasOptions) {
@@ -343,6 +390,65 @@ async function fillLocator(page, locator, value, label) {
  * Strategy: click trigger → wait for option list → find closest matching option → click it.
  * Handles React Select, Ashby custom select, Lever, Greenhouse custom dropdowns.
  */
+/**
+ * Type-and-pick handler for autocomplete/typeahead inputs (Greenhouse
+ * Location, Lever City, Workday location pickers). Strategy:
+ *
+ *   1. Click the input to focus
+ *   2. Clear any existing text
+ *   3. Type the value SLOWLY, character-by-character (suggestions fire
+ *      on each keystroke; typing too fast can race the network)
+ *   4. Wait for a listbox/option container to render
+ *   5. Pick the best matching option (exact > startsWith > first)
+ *   6. Verify the input now shows a committed value
+ *
+ * Returns false if no suggestion list appears — caller can fall back to
+ * a plain fill.
+ */
+async function fillTypeahead(page, locator, value) {
+  try {
+    await locator.click({ timeout: 2000 });
+    // Clear via select-all + delete (more reliable than .fill('') for
+    // autocompletes that have their own state)
+    await locator.press('Meta+A').catch(() => locator.press('Control+A')).catch(() => {});
+    await locator.press('Delete').catch(() => {});
+    // Type the FIRST PART (city name only) — typing "San Francisco, CA"
+    // when the typeahead expects "San Francisco" can suppress matches.
+    const firstChunk = String(value).split(/[,;]/)[0].trim();
+    await page.keyboard.type(firstChunk, { delay: 60 });
+    // Wait briefly for suggestions to render
+    await page.waitForTimeout(700);
+    // Look for a listbox / option container — multiple common patterns
+    const optionSel = [
+      '[role="option"]',
+      '[role="listbox"] li',
+      '[role="listbox"] [role="option"]',
+      '[class*="option"][class*="select"]',
+      '[class*="suggestion"]',
+      'ul[class*="autocomplete"] li',
+      // Greenhouse-specific
+      '.select__option',
+      '.select__menu [role="option"]',
+    ].join(', ');
+    const options = page.locator(optionSel);
+    const count = await options.count().catch(() => 0);
+    if (count === 0) return false;
+    // Prefer exact-match option; fall back to "starts with"; else first.
+    const allTexts = await options.allTextContents().catch(() => []);
+    const v = firstChunk.toLowerCase();
+    let pickIdx = allTexts.findIndex(t => t.toLowerCase().trim() === v);
+    if (pickIdx === -1) pickIdx = allTexts.findIndex(t => t.toLowerCase().trim().startsWith(v));
+    if (pickIdx === -1) pickIdx = 0;
+    await options.nth(pickIdx).click({ timeout: 2000 });
+    await page.waitForTimeout(200);
+    // Verify the input now shows a real value
+    const got = await locator.inputValue({ timeout: 1000 }).catch(() => null);
+    return !!(got && got.trim());
+  } catch {
+    return false;
+  }
+}
+
 async function fillCustomDropdown(page, triggerLocator, value) {
   try {
     await triggerLocator.click();
@@ -646,8 +752,37 @@ async function fillFields(page, aep, options = {}) {
       continue;
     }
 
-    // File uploads — handled separately by uploadResume() in orchestrator
-    if (source === 'file_upload') continue;
+    // File uploads — resume is handled separately by uploadResume() in the
+    // gate handler. Cover letter is its own thing: ATSes like Greenhouse and
+    // Ashby render a dedicated cover-letter file input alongside the resume
+    // one. When the user compiled a cover letter PDF (in PacketPrep studio),
+    // upload it here against the matching field.
+    if (source === 'file_upload') {
+      if (field.category === 'file:cover_letter' && aep.__coverLetterLocalPath) {
+        try {
+          // setInputFiles works directly on hidden <input type=file>; no need
+          // to traverse to a sibling button when we already have the input.
+          const inputLoc = field.selector ? page.locator(field.selector).first() : null;
+          if (inputLoc) {
+            // Some forms hide the input via CSS — unhide briefly so Playwright
+            // doesn't reject the setInputFiles call on a 0x0 element.
+            await inputLoc.evaluate(el => {
+              el.style.display = 'block'; el.style.opacity = '1'; el.style.visibility = 'visible';
+              el.style.width = '1px'; el.style.height = '1px';
+            }).catch(() => {});
+            await inputLoc.setInputFiles(aep.__coverLetterLocalPath, { timeout: 5000 });
+            console.log(`[filler] filled (file): "${labelShort}" = cover-letter.pdf`);
+            filled++;
+            if (ctx && trackKey) ctx.answeredFields.set(trackKey, { value: 'cover-letter.pdf', pageIndex: ctx.currentPageIndex, source: 'file' });
+            await delay();
+            continue;
+          }
+        } catch (e) {
+          console.warn(`[filler] cover-letter upload failed for "${labelShort}": ${e.message}`);
+        }
+      }
+      continue;
+    }
 
     // EEO / consent — skip silently (vision handles EEO, user handles consent)
     if (source === 'skip') continue;

package/orchestrator.js

@@ -68,6 +68,18 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       tempResumeFile = await downloadResume(aep.recommended_resume.pdf_presigned_url);
     }
 
+    // Download cover-letter PDF too — separate file because Greenhouse/Ashby
+    // have separate file inputs for each. Only present when the user
+    // compiled it in PacketPrep (cover_letter_pdf_status='ready').
+    let tempCoverLetterFile = null;
+    if (aep.cover_letter_pdf?.pdf_presigned_url) {
+      tempCoverLetterFile = await downloadResume(aep.cover_letter_pdf.pdf_presigned_url);
+      if (tempCoverLetterFile) console.log('[orchestrator] Cover letter PDF downloaded');
+    }
+    // Expose to fillFields via aep so the file:cover_letter category resolver
+    // can hand it to the uploader.
+    aep.__coverLetterLocalPath = tempCoverLetterFile;
+
     // Check for an existing checkpoint — if a previous run got past page 1
     // before crashing, resume from where it stopped. The fillFields path uses
     // ctx.answeredFields to skip already-completed labels, so restoring the

package/package.json

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

package/scanPage.js

@@ -597,8 +597,57 @@ function resolveFieldValues(fields, aep) {
       return { field, value: null, source: 'file_upload' };
     }
 
-    // EEO/consent — skip (handled by vision or user)
-    if (cat === 'eeo' || cat === 'consent') {
+    // Consent checkboxes — user-only (we don't auto-accept terms).
+    if (cat === 'consent') {
+      return { field, value: null, source: 'skip' };
+    }
+
+    // EEO — answer from profile self-ID when set, OR infer common
+    // implications from what IS set. The profile already collects
+    // gender_self_id / race / veteran / disability. We hand those back
+    // directly for matching dropdown labels, plus do a small amount of
+    // inference for derived questions ("transgender experience?" → No
+    // when user is cisgender, "veteran?" → No is the safe default the
+    // user can override). Anything we can't infer falls through to
+    // 'skip' so it gets reviewed.
+    if (cat === 'eeo') {
+      const label = (field.label || '').toLowerCase();
+      const pf = aep.profile_fill || {};
+      // Direct mapping by question text
+      if (/gender|sex/.test(label) && !/transgender|trans\s*experience/.test(label)) {
+        if (pf.gender) return { field, value: pf.gender, source: 'profile:eeo' };
+      }
+      if (/race|ethnicit|hispanic/.test(label)) {
+        if (pf.race) return { field, value: pf.race, source: 'profile:eeo' };
+      }
+      if (/veteran|military/.test(label)) {
+        if (pf.veteran) return { field, value: pf.veteran, source: 'profile:eeo' };
+        // Inference: most users are non-veterans; safer default is "No"
+        // (recruiters expect this field answered; blank → required-field
+        // error). User can change in profile.
+        return { field, value: 'I am not a protected veteran', source: 'profile:eeo-default' };
+      }
+      if (/disabilit/.test(label)) {
+        if (pf.disability) return { field, value: pf.disability, source: 'profile:eeo' };
+        return { field, value: "I don't wish to answer", source: 'profile:eeo-default' };
+      }
+      // Transgender / trans experience: cisgender implication when gender
+      // is set to non-trans. Cisgender users almost never want to
+      // accidentally self-ID as trans; defaulting to "No" when gender is
+      // explicit is safer than skipping (which causes a required-field
+      // error). Don't infer when gender is unset — that becomes 'skip'.
+      if (/transgender|trans\s*experience/.test(label)) {
+        if (pf.gender) return { field, value: 'No', source: 'profile:eeo-inferred' };
+      }
+      // Sexual orientation — never infer. User must self-ID.
+      if (/sexual\s*orientation|orientation\b/.test(label)) {
+        return { field, value: "I don't wish to answer", source: 'profile:eeo-default' };
+      }
+      // Pronouns — derivable from gender
+      if (/pronoun/.test(label)) {
+        if (pf.gender && /female|woman/i.test(pf.gender)) return { field, value: 'she/her', source: 'profile:eeo-inferred' };
+        if (pf.gender && /male|man/i.test(pf.gender)) return { field, value: 'he/him', source: 'profile:eeo-inferred' };
+      }
       return { field, value: null, source: 'skip' };
     }