halo-agent 1.3.5 → 1.3.6

package/filler.js

@@ -259,7 +259,7 @@ async function uploadFile(page, triggerSelector, filePath) {
  *
  * Returns true if fill succeeded.
  */
-async function fillLocator(page, locator, value, label) {
+async function fillLocator(page, locator, value, label, dropdownCtx = null) {
   if (!value) return false;
 
   try {
@@ -321,13 +321,50 @@ async function fillLocator(page, locator, value, label) {
         );
         if (fuzzy) ok = await locator.selectOption(fuzzy.v).then(() => true).catch(() => false);
       }
+      // 5. AI synonym pick — "Straight" → "Heterosexual", "Asian" →
+      // "South Asian" etc. We hand the LLM the user's literal answer
+      // plus the EXACT option list and let it pick the equivalent.
+      if (!ok && dropdownCtx && opts.length > 0) {
+        try {
+          const optionTexts = opts.map(o => o.t).filter(Boolean);
+          const res = await fetch(`${dropdownCtx.config.apiUrl}/smartfill/field-answer`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${dropdownCtx.config.token}` },
+            body: JSON.stringify({
+              job_id: dropdownCtx.jobId,
+              field_label: label || '',
+              field_type: 'select',
+              options: optionTexts,
+              previously_answered: [{ label: 'user intent', value: String(value) }],
+            }),
+          });
+          if (res.ok) {
+            const { value: picked } = await res.json();
+            if (picked && picked !== 'SKIP') {
+              const pickedV = picked.toLowerCase().trim();
+              const match = opts.find(o => o.t.toLowerCase().trim() === pickedV)
+                || opts.find(o => o.t.toLowerCase().includes(pickedV) || pickedV.includes(o.t.toLowerCase()));
+              if (match) {
+                ok = await locator.selectOption(match.v).then(() => true).catch(() => false);
+                if (ok) console.log(`[filler] AI-picked select: "${label}" "${value}" → "${match.t}"`);
+              }
+            }
+          }
+        } catch (e) {
+          console.warn(`[filler] AI native-select pick failed for "${label}": ${e.message}`);
+        }
+      }
       return ok;
     }
 
     // ── Custom dropdown / combobox (React Select, Ashby, Lever custom selects) ──
     if (meta.role === 'combobox' || meta.role === 'listbox' ||
         meta.tag === 'div' || meta.tag === 'button') {
-      return await fillCustomDropdown(page, locator, value);
+      return await fillCustomDropdown(page, locator, value, dropdownCtx ? {
+        config: dropdownCtx.config,
+        jobId: dropdownCtx.jobId,
+        label,
+      } : {});
     }
 
     // ── Radio group (native) ──
@@ -449,49 +486,85 @@ async function fillTypeahead(page, locator, value) {
   }
 }
 
-async function fillCustomDropdown(page, triggerLocator, value) {
+async function fillCustomDropdown(page, triggerLocator, value, options = {}) {
   try {
     await triggerLocator.click();
     await page.waitForTimeout(350);
 
-    // Look for an open listbox, menu, or option list
-    const optionSelectors = [
-      `[role="option"]:has-text("${value}")`,
-      `[role="menuitem"]:has-text("${value}")`,
-      `li:has-text("${value}")`,
-      `.Select-option:has-text("${value}")`,
-      `[class*="option"]:has-text("${value}")`,
-    ];
-
-    for (const sel of optionSelectors) {
-      try {
-        const opt = page.locator(sel).first();
-        if (await opt.isVisible({ timeout: 800 })) {
-          await opt.click();
-          return true;
-        }
-      } catch {}
+    // STEP 1: Discover ALL available options (visible after opening). We
+    // need this for two reasons:
+    //   a) substring/exact match locally (cheap, no LLM round trip)
+    //   b) if no local match, ask the LLM to pick from this exact list —
+    //      that's how "Straight" maps to "Heterosexual" without us having
+    //      to hardcode a synonym table for every form
+    // We collect texts BEFORE any click attempts so the LLM has the same
+    // option universe the user would see.
+    const optionLocators = page.locator('[role="option"], [role="menuitem"], .select__option, li[class*="option"]');
+    const optionCount = await optionLocators.count().catch(() => 0);
+    const optionTexts = [];
+    for (let i = 0; i < Math.min(optionCount, 40); i++) {
+      const t = (await optionLocators.nth(i).textContent().catch(() => '')).trim();
+      if (t) optionTexts.push(t);
     }
 
-    // Fuzzy: get all visible options and find closest match
-    const allOptions = await page.locator('[role="option"], [role="menuitem"]').all();
-    let bestMatch = null;
-    let bestScore = 0;
-    for (const opt of allOptions) {
-      const text = (await opt.textContent().catch(() => '')).trim().toLowerCase();
-      const target = value.toLowerCase();
-      const score = text === target ? 1 :
-                    text.includes(target) ? 0.8 :
-                    target.includes(text) ? 0.7 : 0;
-      if (score > bestScore) { bestScore = score; bestMatch = opt; }
+    // STEP 2: Local exact match (case-insensitive)
+    const v = String(value).toLowerCase().trim();
+    let pickIdx = optionTexts.findIndex(t => t.toLowerCase().trim() === v);
+
+    // STEP 3: Local substring match (either direction)
+    if (pickIdx === -1) {
+      pickIdx = optionTexts.findIndex(t => {
+        const tt = t.toLowerCase().trim();
+        return tt.includes(v) || v.includes(tt);
+      });
     }
-    if (bestMatch && bestScore >= 0.7) {
-      await bestMatch.click();
+
+    if (pickIdx !== -1) {
+      await optionLocators.nth(pickIdx).click({ timeout: 2000 });
       return true;
     }
 
-    // Nothing found — press Escape to close the dropdown
-    await page.keyboard.press('Escape');
+    // STEP 4: LLM picks from the option universe — the smart-fill path.
+    // Sends user's intent ("Straight") + question text + the EXACT list
+    // of options Greenhouse is rendering ("Heterosexual", "Gay or
+    // Lesbian", "Bisexual", "Prefer not to say"). Backend already has
+    // the /smartfill/field-answer endpoint with options[] support.
+    if (optionTexts.length > 0 && options.config && options.jobId && options.label) {
+      try {
+        const res = await fetch(`${options.config.apiUrl}/smartfill/field-answer`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${options.config.token}` },
+          body: JSON.stringify({
+            job_id: options.jobId,
+            field_label: options.label,
+            field_type: 'select',
+            options: optionTexts,
+            // Pass user's stated intent so the LLM picks the closest
+            // option that REPRESENTS that intent, not just text similarity.
+            previously_answered: [{ label: 'user intent', value: String(value) }],
+          }),
+        });
+        if (res.ok) {
+          const { value: picked } = await res.json();
+          if (picked && picked !== 'SKIP') {
+            // Match the picked text back to an option locator
+            const pickedV = picked.toLowerCase().trim();
+            const aiIdx = optionTexts.findIndex(t => t.toLowerCase().trim() === pickedV)
+              ?? optionTexts.findIndex(t => t.toLowerCase().includes(pickedV) || pickedV.includes(t.toLowerCase()));
+            if (aiIdx !== -1 && aiIdx >= 0) {
+              await optionLocators.nth(aiIdx).click({ timeout: 2000 });
+              console.log(`[filler] AI-picked dropdown: "${options.label}" "${value}" → "${optionTexts[aiIdx]}"`);
+              return true;
+            }
+          }
+        }
+      } catch (e) {
+        console.warn(`[filler] AI dropdown pick failed for "${options.label}": ${e.message}`);
+      }
+    }
+
+    // Nothing matched — close dropdown gracefully so the next field can fill
+    await page.keyboard.press('Escape').catch(() => {});
     return false;
   } catch {
     return false;
@@ -729,6 +802,12 @@ async function fillFields(page, aep, options = {}) {
   const speed = options.speed || 'normal';
   const ctx = options.ctx || null;
   const ats = options.ats || 'generic';
+  // dropdownCtx flows to fillLocator → fillCustomDropdown so custom selects
+  // can call the backend's /smartfill/field-answer with the question text +
+  // available options. That's the "Straight" → "Heterosexual" synonym fix.
+  const dropdownCtx = options.config && options.jobId
+    ? { config: options.config, jobId: options.jobId }
+    : null;
   const delay = () => new Promise(r => setTimeout(r, jitter(100 + Math.random() * 150)));
 
   let filled = 0, skipped = 0, failed = 0;
@@ -862,7 +941,7 @@ async function fillFields(page, aep, options = {}) {
         await delay();
       } else {
         // Try clicking the locator directly (custom styled radio)
-        const ok2 = await fillLocator(page, locator, value, field.label);
+        const ok2 = await fillLocator(page, locator, value, field.label, dropdownCtx);
         if (ok2) { filled++; if (ctx && trackKey) ctx.answeredFields.set(trackKey, { value, pageIndex: ctx.currentPageIndex, source }); await delay(); }
         else { skipped++; }
       }
@@ -884,7 +963,7 @@ async function fillFields(page, aep, options = {}) {
 
     // All other types — use universal fillLocator
     try {
-      const ok = await fillLocator(page, locator, value, field.label);
+      const ok = await fillLocator(page, locator, value, field.label, dropdownCtx);
       if (ok) {
         const valShort = String(value).slice(0, 40).replace(/\n/g, ' ');
         console.log(`[filler] filled (${source}): "${labelShort}" = "${valShort}${String(value).length > 40 ? '...' : ''}"`);

package/orchestrator.js

@@ -130,7 +130,7 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       console.log(`[orchestrator] Using vision fallback for ${ats_type}`);
       fillResult = await visionFill(page, aep, anthropicKey, { alreadyFilled: ctx.answeredFields });
     } else {
-      fillResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type });
+      fillResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
     }
 
     // Fetch AI answers for any fields that scanPage identified as needing AI
@@ -157,7 +157,7 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
         }
       }
       // Second fill pass with newly fetched answers
-      const retryResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type });
+      const retryResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
       fillResult.filled += retryResult.filled;
       fillResult.skipped = retryResult.skipped;
       console.log(`[orchestrator] Retry fill: +${retryResult.filled} fields filled`);
@@ -280,7 +280,7 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       ctx.currentPageIndex++;
 
       // Fill any new fields that appeared on this page
-      const pageResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type });
+      const pageResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
       cumulativeFilled += pageResult.filled || 0;
 
       // Fetch AI answers for custom fields scanPage identified on this page
@@ -297,7 +297,7 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
             }
           } catch {}
         }
-        const retryPage = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type });
+        const retryPage = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
         cumulativeFilled += retryPage.filled || 0;
       }
 
@@ -436,6 +436,22 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
     }
 
     if (verdict.submitted === null) {
+      // Auto-submit mode means "don't ask me, just submit." If we can't
+      // verify but the user opted into hands-off, trust the click and
+      // mark DONE (the screenshot is the receipt; user can audit later).
+      // Without this, autoSubmit was silently being ignored every time
+      // Firecrawl was slow/down — exactly the case user hit.
+      const autoSubmit = config.autoSubmit || aep.agent_config?.auto_submit;
+      if (autoSubmit) {
+        console.log(`[orchestrator] Could not verify (source: ${verdict.source}) — auto-submit ON, trusting click.`);
+        await reportStatus('DONE', {
+          confirmation_screenshot_r2_key: confirmKey || null,
+          fields_filled: cumulativeFilled,
+        });
+        await clearCheckpoint(config, queueId);
+        console.log(`[orchestrator] Done (auto-submit, unverified): ${queueItem.company} - ${queueItem.title}`);
+        return;
+      }
       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,
@@ -1030,7 +1046,7 @@ async function runExtensionFill({
     log(`Vision fill for ${ats_type}`);
     fillResult = await visionFill(page, aep, anthropicKey, { alreadyFilled: ctx.answeredFields });
   } else {
-    fillResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type });
+    fillResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
   }
 
   reportFillStatus('FILLING', { fieldsFilled: fillResult.filled || 0, message: `Filled ${fillResult.filled || 0} fields...` });
@@ -1055,7 +1071,7 @@ async function runExtensionFill({
         }
       } catch (e) { log(`AI answer failed for "${f.label}": ${e.message}`); }
     }
-    const retry = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type });
+    const retry = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
     fillResult.filled += retry.filled;
     fillResult.skipped = retry.skipped;
   }
@@ -1119,7 +1135,7 @@ async function runExtensionFill({
     }
 
     ctx.currentPageIndex++;
-    const pageResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type });
+    const pageResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
     cumulativeFilled += pageResult.filled || 0;
 
     if (anthropicKey && !useVisionForThis && (pageResult.skipped > 2 || pageResult.failed > 0)) {

package/package.json

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

package/scanPage.js

@@ -268,6 +268,21 @@ async function scanGreenhouse(page) {
     if (f.id && ghSystemIds[f.id]) {
       return { ...f, category: f.id === 'resume' || f.id === 'cover_letter' ? 'file:' + f.id : 'profile:' + ghSystemIds[f.id] };
     }
+    // File inputs — Greenhouse's modern job-boards UI labels both file
+    // inputs as "Attach" (the visible button text), not "Resume" or
+    // "Cover Letter". Distinguish by name= attribute instead.
+    // resume:    name="resume"        or name="job_application[resume]"
+    // cover ltr: name="cover_letter"  or name="job_application[cover_letter]"
+    if (f.inputType === 'file') {
+      const n = (f.name || '').toLowerCase();
+      if (n.includes('cover_letter') || n.includes('coverletter')) return { ...f, category: 'file:cover_letter' };
+      if (n.includes('resume') || n.includes('cv')) return { ...f, category: 'file:resume' };
+      // Order on the page: first file input is resume, second is cover letter.
+      // Without name/id signals, fall back to ordering. We mark unknowns
+      // 'file:resume' here and re-tag the second occurrence below after
+      // the map (where we have the whole list).
+      return { ...f, category: 'file:unknown' };
+    }
     // Custom question fields: id like question_12345678
     if (f.id && /^question_\d+$/.test(f.id)) {
       return { ...f, category: 'custom' };
@@ -281,7 +296,17 @@ async function scanGreenhouse(page) {
       return { ...f, category: 'profile:' + f.id.split('--')[0] };
     }
     return { ...f, category: classifyField(f) };
-  }).filter(f => f.category !== 'ignore' && f.inputType !== 'hidden');
+  }).reduce((acc, f) => {
+    // Position-based resolution for ambiguous file inputs: first unknown
+    // file → resume, second → cover_letter. Greenhouse always renders
+    // resume above cover letter; the DOM walk preserves that order.
+    if (f.category === 'file:unknown') {
+      const sawResume = acc.some(p => p.category === 'file:resume');
+      f.category = sawResume ? 'file:cover_letter' : 'file:resume';
+    }
+    acc.push(f);
+    return acc;
+  }, []).filter(f => f.category !== 'ignore' && f.inputType !== 'hidden');
 }
 
 /**