halo-agent 2.2.3 → 2.2.6

package/browser.js

@@ -135,7 +135,7 @@ async function connectToChrome(retries = 10, opts = {}) {
               ctx = fresh.contexts()[0] || await fresh.newContext();
               conn.context = ctx;
             }
-            const page = await ctx.newPage();
+            let page = await ctx.newPage();
             if (url) {
               try {
                 await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 60000 });
@@ -153,6 +153,39 @@ async function connectToChrome(retries = 10, opts = {}) {
                   await page.waitForTimeout(8000);
                 }
               }
+
+              // VERIFY-AFTER-GOTO. connectOverCDP against the user's REAL Chrome
+              // has a tab-handle race: ctx.newPage() may hand back a different
+              // tab than the one that actually navigated (e.g. Chrome already
+              // had a restored New Tab open). Symptom: the agent then scans
+              // about:blank / chrome://newtab forever while the target URL is
+              // loaded in a sibling tab. Self-correct: if our handle isn't on
+              // the target host, find the tab that IS and adopt it.
+              try {
+                const here = page.url();
+                const targetHost = new URL(url).hostname;
+                const onTarget = (u) => { try { return new URL(u).hostname === targetHost; } catch { return false; } };
+                if (!onTarget(here)) {
+                  // Look across all pages in this context for the one that navigated.
+                  const pages = ctx.pages();
+                  const match = pages.find((p) => onTarget(p.url()));
+                  if (match && match !== page) {
+                    console.warn(`[halo-agent] newPage handle was on "${here.slice(0, 40)}" but target loaded in another tab — adopting it.`);
+                    // Close the stray blank tab we opened so it doesn't litter.
+                    if (/^about:blank$|^chrome:\/\/newtab/i.test(here)) {
+                      try { await page.close(); } catch {}
+                    }
+                    page = match;
+                    await page.bringToFront().catch(() => {});
+                  } else if (/^about:blank$|^chrome:\/\/newtab/i.test(here)) {
+                    // Our tab is genuinely blank and nothing else navigated —
+                    // the goto silently no-op'd. Retry the navigation on THIS tab.
+                    console.warn('[halo-agent] Tab still blank after goto — retrying navigation on this handle...');
+                    await page.goto(url, { waitUntil: 'commit', timeout: 30000 }).catch(() => {});
+                    await page.waitForTimeout(4000);
+                  }
+                }
+              } catch { /* best-effort self-correction; fall through */ }
             }
             return page;
           },

package/index.js

@@ -479,7 +479,7 @@ async function runStart() {
 
   let version = '';
   try { version = require('./package.json').version; } catch {}
-  ui.banner(version);
+  ui.bigBanner(version); // hero frame — the one you'd screenshot
 
   // The agent runs its own isolated Chrome instance (separate --user-data-dir
   // at ~/.halo-agent/chrome-profile) so it never collides with the user's

package/orchestrator.js

@@ -48,6 +48,7 @@ async function fillFields(page, aep, opts) {
     plannedActions: result.planned || 0,
     fellBackToLegacy: !!result.fallback,
     resumeUploaded: !!result.resumeUploaded,
+    coverLetterUploaded: !!result.coverLetterUploaded,
   };
 }
 const { detectCaptcha, solveCaptcha, injectCaptchaToken } = require('./captcha');
@@ -684,12 +685,45 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
     }
 
     if (finalState === 'REVIEWING') {
+      // CRITICAL: keep the Chrome tab OPEN and the agent ALIVE so the user can
+      // actually take over. Previously this branch reported REVIEWING then
+      // fell through → the `finally` closed the tab and the agent moved on,
+      // leaving a REVIEWING row with no open tab and nothing listening — a
+      // dead-end the user couldn't resolve. Now: leave the tab open, tell the
+      // user what's blank, and wait for them to finish in Chrome + click
+      // Submit (which the agent's waitForSubmitConfirmation is parked on).
+      leaveTabOpen = true;
+      // Re-check exactly which required fields are still empty so the message
+      // names them (the user is staring at the form; tell them what to fix).
+      const stillEmpty = await detectRequiredEmpties(page, {
+        excludeLabels: (ctx.skippedFields || []).map((s) => s.label),
+        resumeUploaded: !!fillResult.resumeUploaded,
+      }).catch(() => ({ emptyFields: [] }));
+      const emptyList = stillEmpty.emptyFields.map((f) => f.label).slice(0, 8).join(', ');
+      const reason = emptyList
+        ? `${stillEmpty.emptyFields.length} field(s) need you: ${emptyList}. Fill them in the open Chrome tab, then click Submit.`
+        : `Couldn't auto-confirm this submit. Eyeball the open Chrome tab, then click Submit.`;
       await reportStatus('REVIEWING', {
         review_screenshot_r2_key: confirmKey || null,
         step: 'REVIEWING',
-        step_detail: `Submit clicked at ${verdictUrl.slice(0, 100)} — verifier unavailable, please confirm`,
+        step_detail: reason.slice(0, 200),
+        needs_attention_reason: reason,
         fields_filled: cumulativeFilled,
       });
+      console.log(`[orchestrator] REVIEWING — tab left open. ${reason}`);
+      // Park here until the user clicks Submit on the dashboard. The tab stays
+      // open the whole time so they can fill the blanks in their own Chrome.
+      await waitForSubmitConfirmation(config, queueId);
+      // They filled the blanks and clicked Submit — click the form's submit.
+      const finishBtn = await findSubmitButton(page).catch(() => null);
+      if (finishBtn) {
+        console.log('[orchestrator] User confirmed — clicking submit on the finished form.');
+        await finishBtn.click().catch(() => {});
+        await page.waitForTimeout(2500);
+      }
+      await reportStatus('DONE', { confirmation_screenshot_r2_key: confirmKey || null, fields_filled: cumulativeFilled });
+      await clearCheckpoint(config, queueId);
+      console.log(`[orchestrator] Done (user-completed): ${queueItem.company} - ${queueItem.title}`);
     } else {
       leaveTabOpen = true;
       await reportStatus('DONE', {
@@ -724,8 +758,13 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       filled_actions: filledActions,
       // Pass through which actual files were uploaded — backend writes to
       // submissions.resume_pdf_r2_key / cover_letter_pdf_r2_key for receipt.
-      resume_pdf_r2_key: aep?.recommended_resume?.pdf_r2_key || null,
-      cover_letter_pdf_r2_key: aep?.cover_letter_pdf?.pdf_r2_key || null,
+      // ONLY report a file key if the agent ACTUALLY uploaded it. Previously
+      // the cover-letter key was sent whenever the packet HAD one, even when
+      // the upload FAILED ("no cover_letter file available") — so the receipt
+      // claimed a cover letter that was never submitted. The receipt must
+      // reflect what landed on the form, not what the packet contained.
+      resume_pdf_r2_key: (fillResult.resumeUploaded || tempResumeFile) ? (aep?.recommended_resume?.pdf_r2_key || null) : null,
+      cover_letter_pdf_r2_key: fillResult.coverLetterUploaded ? (aep?.cover_letter_pdf?.pdf_r2_key || null) : null,
     }).catch(() => {}); // non-critical
 
   } catch (err) {

package/package.json

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

package/smartFill.js

@@ -188,14 +188,61 @@ async function executePlanItem(page, item, fieldByMmid, ctx) {
             }
           }
         }
-        // Strategy 2: just click the labeled option directly (custom radios).
+        // Strategy 2: custom radios (Ashby etc) — click the labeled option,
+        // but SCOPED to THIS field's own radiogroup. The old code matched
+        // `[role="radio"]:has-text("Yes")` across the WHOLE page via .first(),
+        // so on a form with several Yes/No questions it clicked the first
+        // "Yes" on the page (or nothing) instead of the one for this field —
+        // the Gen Digital bug where sponsorship + office-commitment radios
+        // ended up blank. Anchor on the scanned element's group container.
         const v = String(item.value);
-        const opt = root.locator(`[role="radio"]:has-text("${v}"), label:has-text("${v}")`).first();
-        if (await opt.isVisible({ timeout: 800 }).catch(() => false)) {
-          await opt.click({ timeout: 1500 });
-          return { ok: true, reason: `radio (label): ${v}` };
+        // Tag the field's enclosing radiogroup so we can scope option lookup.
+        const groupId = await locator.evaluate((el) => {
+          // Walk up to the nearest radiogroup / fieldset / Ashby field entry.
+          let p = el;
+          for (let i = 0; i < 8 && p; i++, p = p.parentElement) {
+            const role = p.getAttribute && p.getAttribute('role');
+            const cls = String(p.className || '');
+            if (role === 'radiogroup' || p.tagName === 'FIELDSET'
+                || /_fieldEntry_|ashby-application-form-field-entry|radio.?group/i.test(cls)) {
+              const gid = 'halo-rg-' + Math.random().toString(36).slice(2, 8);
+              p.setAttribute('data-halo-rg', gid);
+              return gid;
+            }
+          }
+          return null;
+        }).catch(() => null);
+
+        const groupRoot = groupId ? root.locator(`[data-halo-rg="${groupId}"]`) : root;
+        // Within the group, find the option whose visible label matches value.
+        // Try role=radio, label, and a generic clickable row with the text.
+        const optInGroup = groupRoot.locator(
+          `[role="radio"]:has-text("${v}"), label:has-text("${v}"), ` +
+          `[class*="option"]:has-text("${v}"), [class*="radio"]:has-text("${v}")`
+        ).first();
+        if (await optInGroup.isVisible({ timeout: 1000 }).catch(() => false)) {
+          await optInGroup.click({ timeout: 1500 }).catch(async () => {
+            await optInGroup.click({ force: true, timeout: 1500 });
+          });
+          // Verify it registered: the matched radio should now be checked /
+          // aria-checked. Ashby toggles aria-checked on the role=radio element.
+          await page.waitForTimeout(150);
+          const stuck = await optInGroup.evaluate((el) => {
+            const r = el.querySelector('[role="radio"]') || el.closest('[role="radio"]') || el;
+            return r.getAttribute('aria-checked') === 'true'
+              || (r.querySelector && r.querySelector('input:checked') != null)
+              || (r.tagName === 'INPUT' && r.checked);
+          }).catch(() => true); // if we can't tell, assume click worked
+          if (stuck) return { ok: true, reason: `radio (scoped label): ${v}` };
+          // Didn't register — click the input inside the option as a fallback.
+          const innerInput = optInGroup.locator('input[type="radio"]').first();
+          if (await innerInput.count().catch(() => 0)) {
+            await innerInput.check({ force: true, timeout: 1500 }).catch(() => {});
+            return { ok: true, reason: `radio (scoped input): ${v}` };
+          }
+          return { ok: true, reason: `radio (clicked, unverified): ${v}` };
         }
-        return { ok: false, reason: `radio option "${item.value}" not found` };
+        return { ok: false, reason: `radio option "${item.value}" not found in group` };
       } catch (e) {
         return { ok: false, reason: `radio failed: ${e.message}` };
       }
@@ -477,6 +524,29 @@ async function openAndPickOption(root, triggerLocator, value, llmCtx) {
     if (itlResult !== null && itlResult.ok) return itlResult;
   } catch {}
 
+  try {
+    // Ashby async typeahead. Ashby's Location field is role="combobox" with
+    // aria-haspopup="listbox" and an input class like `_input_v5ami_28`. It
+    // renders NO options until you type, then fetches matches over the
+    // network (~700ms) and shows them as [role="option"]. The generic
+    // open-and-look path opened it, saw an empty menu, and bailed — that's
+    // the Gen Digital "dropdown opened but no visible options found" failure.
+    // Detect Ashby's widget and route to type-then-wait-for-async-options.
+    const isAshbyCombo = await triggerLocator.evaluate((el) => {
+      const role = el.getAttribute('role');
+      const hasPopup = el.getAttribute('aria-haspopup');
+      const cls = String(el.className || '');
+      // Ashby's emotion-hashed input class, or the generic combobox+listbox shape.
+      const ashbyClass = /_input_/.test(cls) && !!el.closest('[class*="_fieldEntry_"], .ashby-application-form-field-entry');
+      return (role === 'combobox' && (hasPopup === 'listbox' || hasPopup === 'true')) || ashbyClass;
+    }).catch(() => false);
+    if (isAshbyCombo) {
+      const r = await typeAndPickSuggestion(root, triggerLocator, value);
+      if (r.ok) return r;
+      // If typeahead didn't land, fall through to the generic path below.
+    }
+  } 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
@@ -781,7 +851,8 @@ async function smartFillPage(page, aep, options) {
   const fieldByMmid = new Map(fields.map((f) => [String(f.mmid), f]));
   const planByMmid = new Map(plan.map((p) => [String(p.mmid), p]));
   let filled = 0, skipped = 0, failed = 0;
-  let resumeUploaded = false; // so the orchestrator can skip its blanket fallback
+  let resumeUploaded = false;      // so the orchestrator can skip its blanket fallback
+  let coverLetterUploaded = false; // so the receipt only claims a cover letter if one actually went in
   const askUserReasons = [];
 
   for (const f of fields) {
@@ -820,11 +891,14 @@ async function smartFillPage(page, aep, options) {
       } else {
         console.log(`[smartFill] ${item.action} "${labelShort}" — ${result.reason}${item.reasoning ? ` (why: ${item.reasoning.slice(0, 80)})` : ''}`);
         filled += 1;
-        // Note a successful resume upload so the orchestrator doesn't run its
-        // legacy blanket "upload resume to the first file input" fallback,
-        // which was dumping the resume into the COVER-LETTER slot too.
-        if (item.action === 'upload_file' && String(item.value).toLowerCase().trim() !== 'cover_letter') {
-          resumeUploaded = true;
+        // Track which files actually went in. resumeUploaded gates the
+        // orchestrator's blanket fallback; coverLetterUploaded gates whether
+        // the RECEIPT is allowed to claim a cover letter was submitted (it was
+        // lying before — packet had a cover-letter key, upload FAILED, receipt
+        // still showed it).
+        if (item.action === 'upload_file') {
+          if (String(item.value).toLowerCase().trim() === 'cover_letter') coverLetterUploaded = true;
+          else resumeUploaded = true;
         }
         // Track in ctx for cross-page dedup
         if (ctx && ctx.answeredFields) {
@@ -843,7 +917,7 @@ async function smartFillPage(page, aep, options) {
     }
   }
 
-  return { filled, skipped, failed, askUserReasons, planned: plan.length, fallback: false, resumeUploaded };
+  return { filled, skipped, failed, askUserReasons, planned: plan.length, fallback: false, resumeUploaded, coverLetterUploaded };
 }
 
 module.exports = { smartFillPage };

package/ui.js

@@ -73,6 +73,26 @@ function banner(version) {
   console.log('');
 }
 
+// Big block-letter wordmark for the hero moment (`start`) — the frame you'd
+// screenshot for a LinkedIn post. Five-row ASCII HALO in ember, tagline +
+// version underneath. Falls back to the compact boxed banner when color is
+// off (logs/CI) so the auto-start service log doesn't get a wall of blocks.
+const HALO_ART = [
+  '██   ██  █████  ██      ██████ ',
+  '██   ██ ██   ██ ██      ██  ██ ',
+  '███████ ███████ ██      ██  ██ ',
+  '██   ██ ██   ██ ██      ██  ██ ',
+  '██   ██ ██   ██ ███████ ██████ ',
+];
+function bigBanner(version) {
+  if (!useColor) { banner(version); return; }
+  const ver = version ? gray('· agent v' + version) : gray('· agent');
+  console.log('');
+  for (const row of HALO_ART) console.log('  ' + ember(row));
+  console.log('  ' + gray('auto-apply, in your own Chrome') + '   ' + ver);
+  console.log('');
+}
+
 // Affordance helper: the obvious next command, rendered consistently so the
 // user always knows what to type next. Shown after pair/init/etc.
 function nextStep(cmd, note) {
@@ -123,5 +143,5 @@ function spinner(message) {
 module.exports = {
   bold, dim, red, green, yellow, blue, magenta, cyan, gray, ember,
   sym, success, fail, info, warn, muted, step,
-  banner, spinner, nextStep, hint, commandTable, visLen,
+  banner, bigBanner, spinner, nextStep, hint, commandTable, visLen,
 };