halo-agent 1.3.2 → 1.3.4

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 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.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 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;
   }
@@ -637,6 +656,8 @@ async function fillFields(page, aep, options = {}) {
 
   // ── Pass 3: fill each field ───────────────────────────────────────────────
   for (const { field, value, source } of resolved) {
+    const labelShort = (field.label || field.selector || '?').slice(0, 50);
+
     // Skip if already answered on a previous page
     const trackKey = field.label || field.selector;
     if (ctx && trackKey && ctx.answeredFields.has(trackKey)) {
@@ -660,8 +681,15 @@ async function fillFields(page, aep, options = {}) {
       continue;
     }
 
-    // No value for a profile field — missing from profile, skip
-    if (!value) { skipped++; continue; }
+    // No value for a profile field — missing from profile, skip.
+    // Log this loudly: it's almost always the actual cause of "the agent
+    // didn't fill anything." profile_fill missing a value the user definitely
+    // entered means the AEP builder isn't sending it from strategic_profile.
+    if (!value) {
+      console.warn(`[filler] no-value ${source}: "${labelShort}" (category=${field.category}) — value missing from AEP`);
+      skipped++;
+      continue;
+    }
 
     // Locate the element — use the scanner's selector first, then fall back to semantic finder
     let locator = null;
@@ -690,7 +718,10 @@ async function fillFields(page, aep, options = {}) {
       locator = await semanticFindField(page, { field_id: field.id || field.name, label: field.label }).catch(() => null);
     }
 
-    if (!locator) { skipped++; continue; }
+    if (!locator) {
+      console.warn(`[filler] no-locator: "${labelShort}" (selector="${(field.selector || '').slice(0,60)}") — element not visible / selector dead`);
+      skipped++; continue;
+    }
 
     // Special case: cover letter — type character by character
     if (field.category === 'cover_letter' && field.tag === 'textarea') {
@@ -739,11 +770,19 @@ async function fillFields(page, aep, options = {}) {
     try {
       const ok = await fillLocator(page, locator, value, field.label);
       if (ok) {
+        const valShort = String(value).slice(0, 40).replace(/\n/g, ' ');
+        console.log(`[filler] filled (${source}): "${labelShort}" = "${valShort}${String(value).length > 40 ? '...' : ''}"`);
         filled++;
         if (ctx && trackKey) ctx.answeredFields.set(trackKey, { value, pageIndex: ctx.currentPageIndex, source });
         await delay();
-      } else { failed++; }
-    } catch { failed++; }
+      } else {
+        console.warn(`[filler] fill-failed: "${labelShort}" — fillLocator returned false`);
+        failed++;
+      }
+    } catch (e) {
+      console.warn(`[filler] fill-threw: "${labelShort}" — ${e.message}`);
+      failed++;
+    }
   }
 
   // ── Legacy fallback: also run old profile map + semantic matcher ──────────

package/orchestrator.js

@@ -402,30 +402,47 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       console.warn(`[orchestrator] verify-submit unavailable: ${e.message}`);
     }
 
-    if (!verdict.submitted) {
+    // Three-way verdict:
+    //   submitted: true  → real success, mark DONE
+    //   submitted: false → real failure, NEEDS_ATTENTION with the error
+    //   submitted: null  → could not verify (Firecrawl down/missing).
+    //                     Bounce to REVIEWING so the user eyeballs the
+    //                     screenshot — never silently mark DONE on
+    //                     unverified submits (that was the Chalk bug).
+    if (verdict.submitted === false) {
       const reason = verdict.error_message || 'Submission did not confirm — form may still have errors';
       console.warn(`[orchestrator] Submission NOT verified. Reason: ${reason}`);
       await reportStatus('NEEDS_ATTENTION', {
         review_screenshot_r2_key: confirmKey || null,
-        needs_attention_reason: `Submit clicked but not confirmed: ${reason}`,
+        needs_attention_reason: `Submit clicked but Ashby/ATS rejected it: ${reason}`,
         intervention_type: 'submit_failed',
         step: 'VERIFY',
         step_detail: reason.slice(0, 200),
         fields_filled: cumulativeFilled,
       });
-      // Do NOT clearCheckpoint — user may dismiss + re-queue, and a stale
-      // checkpoint would resume into the same failed state. The dismiss flow
-      // clears it (DELETE /apply-queue/:id sets form_checkpoint_json = NULL).
       throw new Error(`Submission failed verification: ${reason}`);
     }
 
+    if (verdict.submitted === null) {
+      console.warn(`[orchestrator] Could not verify submission (source: ${verdict.source}). Sending to REVIEWING for your eyeball.`);
+      await reportStatus('REVIEWING', {
+        review_screenshot_r2_key: confirmKey || null,
+        step: 'REVIEWING',
+        step_detail: 'Could not auto-verify — please confirm the submit',
+        fields_filled: cumulativeFilled,
+      });
+      // Stop here; user clicks Submit on dashboard → /apply-queue/submit/:id
+      // will flip to DONE. Don't return — let the function return naturally.
+      return;
+    }
+
     await reportStatus('DONE', {
       confirmation_screenshot_r2_key: confirmKey || null,
       fields_filled: cumulativeFilled,
     });
     await clearCheckpoint(config, queueId);
 
-    console.log(`[orchestrator] Done (verified): ${queueItem.company} - ${queueItem.title}${verdict.source === 'firecrawl' ? ' · firecrawl-verified' : ' · unverified'}`);
+    console.log(`[orchestrator] Done (verified): ${queueItem.company} - ${queueItem.title} · firecrawl-verified`);
 
     // Post fill session data to backend for learning loop
     await postFillSession(config, {

package/package.json

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

package/scanPage.js

@@ -339,10 +339,17 @@ async function scanAshby(page) {
     if (f.name && f.name.startsWith('_systemfield_')) {
       const sfField = f.name.replace('_systemfield_', '');
       const profileMap = { name: 'full_name', email: 'email', phone: 'phone', linkedin: 'linkedin', website: 'portfolio', resume: null };
-      if (sfField === 'resume' || f.inputType === 'file') return { ...f, category: 'file:resume' };
+      if (sfField === 'resume') return { ...f, category: 'file:resume' };
       if (profileMap[sfField] !== undefined) return { ...f, category: 'profile:' + profileMap[sfField] };
     }
-    if (f.inputType === 'file') return { ...f, category: 'file:resume' };
+    // File inputs: distinguish resume vs cover-letter vs other by the visible
+    // label. Without this, Ashby's separate cover-letter file input was being
+    // shadowed by 'file:resume' and uploadResume() only handles one resume.
+    if (f.inputType === 'file') {
+      const lbl = (f.label || '').toLowerCase();
+      if (/cover\s*letter/.test(lbl)) return { ...f, category: 'file:cover_letter' };
+      return { ...f, category: 'file:resume' };
+    }
     // Modern Ashby uses UUID names for ALL fields (Name, Email, Phone, custom).
     // Classify by LABEL first — that's the only signal that distinguishes
     // a profile field from a custom question when the name attr is opaque.
@@ -525,6 +532,12 @@ async function scanPage(page, ats) {
   });
 
   console.log(`[scanPage] ${platform}: found ${out.length} fields (${out.filter(f => f.category.startsWith('profile')).length} profile, ${out.filter(f => f.category === 'custom').length} custom, ${out.filter(f => f.category === 'eeo').length} eeo)`);
+  // Per-field breakdown so we can SEE why a "Name" field ended up classified
+  // as 'custom' instead of 'profile:full_name' — without this, every fill
+  // failure is a guessing game.
+  for (const f of out) {
+    console.log(`[scanPage]   - ${f.category.padEnd(22)} | ${(f.label || '(no label)').slice(0, 60)} | ${f.tag}/${f.inputType}`);
+  }
   return out;
 }