halo-agent 2.4.8 → 2.6.0

package/orchestrator.js

@@ -272,6 +272,15 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       const retryResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
       fillResult.filled += retryResult.filled;
       fillResult.skipped = retryResult.skipped;
+      // Preserve sticky upload flags. If pass 1 uploaded resume / cover letter,
+      // pass 2's smartFill won't redo it (the file slot is already filled and
+      // smartFill skips), so retryResult.resumeUploaded reads false — but the
+      // file IS in the slot. ORing keeps the truth across passes; without this
+      // the orchestrator's blanket fallback uploader (below) re-uploads resume
+      // into whatever file input it finds next, which on Greenhouse is the
+      // cover-letter slot. That's the Robinhood corruption bug.
+      fillResult.resumeUploaded = fillResult.resumeUploaded || retryResult.resumeUploaded;
+      fillResult.coverLetterUploaded = fillResult.coverLetterUploaded || retryResult.coverLetterUploaded;
       console.log(`[orchestrator] Retry fill: +${retryResult.filled} fields filled`);
     }
 
@@ -292,9 +301,33 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
     // the cover-letter slot too. smartFill now reports resumeUploaded, so we
     // only fall back when the planner genuinely missed the resume field.
     if (tempResumeFile && !fillResult.resumeUploaded) {
-      console.log('[orchestrator] smartFill did not upload a resume — running fallback uploader.');
-      const uploaded = await uploadFile(page, 'input[type="file"], [data-testid*="resume"], button:has-text("Upload")', tempResumeFile);
-      if (uploaded) fillResult.filled = (fillResult.filled || 0) + 1;
+      console.log('[orchestrator] smartFill did not upload a resume — running fallback uploader (resume-scoped).');
+      // Scoped selectors. Only match file inputs that are CLEARLY resume slots:
+      // - aria-label / name / id mentions "resume" or "cv"
+      // - dedicated [data-testid*="resume"]
+      // - inputs inside a section/fieldset/div whose nearest heading text
+      //   contains "Resume" or "CV" (Greenhouse pattern — uses a sibling
+      //   <h3>Resume/CV*</h3>). We use Playwright's :has() to chain.
+      //
+      // Critically we EXCLUDE selectors that would match the cover-letter slot.
+      // If no resume-scoped match exists, we don't upload anywhere — better to
+      // surface a real failure than silently corrupt the cover-letter slot.
+      const resumeOnlySelectors = [
+        'input[type="file"][aria-label*="resume" i]',
+        'input[type="file"][aria-label*="cv" i]',
+        'input[type="file"][name*="resume" i]',
+        'input[type="file"][id*="resume" i]',
+        '[data-testid*="resume" i]',
+      ].join(', ');
+      const uploaded = await uploadFile(page, resumeOnlySelectors, tempResumeFile);
+      if (uploaded) {
+        fillResult.filled = (fillResult.filled || 0) + 1;
+        fillResult.resumeUploaded = true;
+      } else {
+        console.warn('[orchestrator] Fallback uploader found no resume-scoped slot. Refusing to upload to generic file inputs to avoid cover-letter corruption.');
+      }
+    } else if (tempResumeFile && fillResult.resumeUploaded) {
+      console.log('[orchestrator] Skipping fallback uploader — smartFill already uploaded resume.');
     }
 
     await reportStatus('IN_PROGRESS', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "halo-agent",
-  "version": "2.4.8",
+  "version": "2.6.0",
   "description": "HALO local apply agent — auto-fills job applications using your real Chrome session",
   "main": "index.js",
   "bin": {
@@ -30,6 +30,7 @@
     "vision.js",
     "manusAutomate.js",
     "ui.js",
+    "resolveLinkedIn.js",
     "README.md"
   ],
   "keywords": [

package/poller.js

@@ -31,6 +31,43 @@ async function startPolling(chromeConn, config) {
     const item = await fetchNextJob(config);
     if (!item) continue;
 
+    // ── resolve_linkedin task branch ──────────────────────────────────
+    // Quick (<5s) URL-read tasks live alongside apply tasks. The agent's
+    // Chrome is already authenticated to LinkedIn, so we read the offsite
+    // "Apply on company website" URL from the live DOM and POST it back.
+    // No tab churn, no full apply flow.
+    if (item.intent === 'resolve_linkedin') {
+      active = true;
+      try {
+        const linkedinUrl = item.step_detail || item.apply_url || item.url;
+        ui.info(`${ui.gray('//')} resolving ${ui.bold(item.company)} ${ui.gray('on linkedin')}`);
+        const { resolveLinkedInOnPage } = require('./resolveLinkedIn');
+        const result = await resolveLinkedInOnPage(chromeConn, linkedinUrl).catch((e) => ({
+          resolved_url: null, reason: e?.message || 'resolve threw',
+        }));
+        await fetch(`${config.apiUrl}/apply-queue/${item.id}/resolved`, {
+          method: 'POST',
+          headers: {
+            Authorization: `Bearer ${config.token}`,
+            'Content-Type': 'application/json',
+            ...cfAccessHeaders(config),
+          },
+          body: JSON.stringify({
+            resolved_url: result.resolved_url || null,
+            reason: result.reason || undefined,
+          }),
+        }).catch(() => {});
+        if (result.resolved_url) {
+          ui.info(`  ${ui.sym.tick} ${ui.gray('→')} ${result.resolved_url}`);
+        } else {
+          ui.warn(`  ${ui.sym.cross} could not resolve · ${result.reason || 'no URL found'}`);
+        }
+      } finally {
+        active = false;
+      }
+      continue;
+    }
+
     active = true;
     console.log('');
     ui.info(`${ui.bold(item.company)} ${ui.gray(ui.sym.dot)} ${item.title}`);

package/resolveLinkedIn.js

@@ -0,0 +1,161 @@
+// resolveLinkedIn — open a LinkedIn job-view URL in the agent's
+// authenticated Chrome session, read the offsite "Apply on company website"
+// URL from the live DOM, return it. The user is already logged into
+// LinkedIn here, so the offsite URL is actually present (unlike the
+// unauthenticated page Cloudflare Browser Run sees).
+//
+// Strategies, in order:
+//   1. <code id="applyUrl"> JSON-encoded URL
+//   2. <a data-tracking-control-name*="apply-link-offsite"> href
+//   3. Voyager / inline JSON dump with companyApplyUrl / applyMethod
+//   4. Click intercept — click the visible Apply button, capture the
+//      destination URL from a new-tab event (works for the modern UI where
+//      the apply button JS-navigates instead of using an <a href>).
+//
+// Returns { resolved_url: string | null, reason?: string }.
+
+const RESOLVE_TIMEOUT_MS = 15_000;
+
+async function resolveLinkedInOnPage(chromeConn, linkedinUrl) {
+  if (!linkedinUrl || !/linkedin\.com\/jobs\/view/i.test(linkedinUrl)) {
+    return { resolved_url: null, reason: 'not a linkedin job-view url' };
+  }
+
+  let page;
+  try {
+    page = await chromeConn.newPage();
+  } catch (e) {
+    return { resolved_url: null, reason: `couldn't open page: ${e.message}` };
+  }
+
+  // Listen for new-tab events on the same context — this catches the
+  // "Apply on company website" button when it opens the ATS in a new tab.
+  let newTabUrl = null;
+  const onNewPage = async (p) => {
+    try {
+      // The new tab navigates through a LinkedIn redirector first, then
+      // lands on the final ATS URL. We wait briefly, then capture.
+      await new Promise((r) => setTimeout(r, 1200));
+      const u = p.url();
+      if (u && /^https?:\/\//i.test(u) && !/linkedin\.com/i.test(u)) {
+        newTabUrl = u;
+      }
+      // Close the new tab — we have what we need, no point loading it.
+      try { await p.close(); } catch {}
+    } catch {}
+  };
+  try { chromeConn.context.on('page', onNewPage); } catch {}
+
+  try {
+    await Promise.race([
+      page.goto(linkedinUrl, { waitUntil: 'domcontentloaded', timeout: RESOLVE_TIMEOUT_MS }),
+      new Promise((_, reject) => setTimeout(() => reject(new Error('navigation timeout')), RESOLVE_TIMEOUT_MS)),
+    ]);
+    // Let LinkedIn's JS render the apply button (lazy-loaded).
+    await page.waitForSelector('#applyUrl, [data-tracking-control-name*="apply"], button[aria-label*="Apply" i], a[aria-label*="Apply" i]', { timeout: 6000 }).catch(() => {});
+
+    // Run the 1-3 strategies inline.
+    const found = await page.evaluate(() => {
+      const isExt = (u) =>
+        !!u && typeof u === 'string' && /^https?:\/\//i.test(u) && !/linkedin\.com/i.test(u);
+
+      // 1. <code id="applyUrl">
+      try {
+        const code = document.getElementById('applyUrl');
+        if (code && code.textContent) {
+          let raw = code.textContent.trim();
+          try { const p = JSON.parse(raw); if (isExt(p)) return p; } catch (e) {}
+          raw = raw.replace(/^"+|"+$/g, '');
+          if (isExt(raw)) return raw;
+        }
+      } catch (e) {}
+
+      // 2. data-tracking-control-name=apply-link-offsite anchors.
+      try {
+        const sel = [
+          'a[data-tracking-control-name*="apply-link-offsite"]',
+          'a[data-tracking-control-name*="apply_unify"]',
+          'a[data-tracking-control-name*="apply-link"]',
+        ].join(', ');
+        const els = Array.from(document.querySelectorAll(sel));
+        for (const el of els) {
+          const href = el.getAttribute('href') || '';
+          if (isExt(href)) return new URL(href, document.baseURI).href;
+        }
+      } catch (e) {}
+
+      // 3. Inline JSON dumps in <code> elements.
+      try {
+        const codes = Array.from(document.querySelectorAll('code'));
+        for (const c of codes) {
+          const txt = c.textContent || '';
+          if (!txt.includes('companyApplyUrl') && !txt.includes('applyMethod')) continue;
+          try {
+            const obj = JSON.parse(txt);
+            const stack = [obj];
+            while (stack.length) {
+              const cur = stack.pop();
+              if (!cur || typeof cur !== 'object') continue;
+              if (isExt(cur.companyApplyUrl)) return cur.companyApplyUrl;
+              if (isExt(cur.applyUrl)) return cur.applyUrl;
+              if (isExt(cur.url) && cur.applyMethod) return cur.url;
+              for (const k of Object.keys(cur)) {
+                if (typeof cur[k] === 'object') stack.push(cur[k]);
+              }
+            }
+          } catch (e) {}
+        }
+      } catch (e) {}
+
+      return null;
+    }).catch(() => null);
+
+    if (found) {
+      // Clean up listener and page.
+      try { chromeConn.context.off('page', onNewPage); } catch {}
+      try { await page.close(); } catch {}
+      return { resolved_url: found };
+    }
+
+    // Strategy 4 — click the Apply button and watch for a new tab.
+    try {
+      const clicked = await page.evaluate(() => {
+        const candidates = [
+          'button[data-tracking-control-name*="apply"]',
+          'a[data-tracking-control-name*="apply"]',
+          'button[aria-label*="Apply" i]',
+          'a[aria-label*="Apply" i]',
+        ];
+        for (const sel of candidates) {
+          const el = document.querySelector(sel);
+          if (el) {
+            try { el.click(); return true; } catch (e) {}
+          }
+        }
+        return false;
+      });
+      if (clicked) {
+        // Wait up to 5s for the new tab listener to populate newTabUrl.
+        const start = Date.now();
+        while (Date.now() - start < 5000 && !newTabUrl) {
+          await new Promise((r) => setTimeout(r, 200));
+        }
+        if (newTabUrl) {
+          try { chromeConn.context.off('page', onNewPage); } catch {}
+          try { await page.close(); } catch {}
+          return { resolved_url: newTabUrl };
+        }
+      }
+    } catch {}
+
+    try { chromeConn.context.off('page', onNewPage); } catch {}
+    try { await page.close(); } catch {}
+    return { resolved_url: null, reason: 'no offsite URL found in any strategy' };
+  } catch (e) {
+    try { chromeConn.context.off('page', onNewPage); } catch {}
+    try { await page.close(); } catch {}
+    return { resolved_url: null, reason: e?.message || 'navigation failed' };
+  }
+}
+
+module.exports = { resolveLinkedInOnPage };

package/scanAccessibility.js

@@ -311,6 +311,48 @@ async function enrichFromDom(page, axFields) {
         }
       } catch {}
 
+      // Group-heading disambiguation for file inputs with generic labels.
+      // Greenhouse renders two `<input type="file">` inputs both labeled
+      // "Attach" — one under a `<h3>Resume/CV*</h3>` heading, one under
+      // `<h3>Cover Letter</h3>`. The AX name only sees "Attach" for both,
+      // so the planner can't route resume vs cover_letter deterministically.
+      // Walk up to the nearest heading and capture its text as groupLabel.
+      let groupLabel = '';
+      try {
+        const isFile = (el.tagName === 'INPUT' && String(el.type || '').toLowerCase() === 'file');
+        if (isFile) {
+          // Use the resolved AX/placeholder label if present; else fall back
+          // to the input's textContent / aria-label.
+          const lblForCheck = (el.getAttribute('aria-label') || el.placeholder || '').trim();
+          // Conservative: only fire when the immediate label is a generic
+          // upload verb. We don't want to clobber a real label like "Resume".
+          const generic = /^(attach|attach\s*file|upload|upload\s*file|choose file|select file|browse|add file|file)$/i;
+          // The visible button label is often on a sibling <button>; check that too.
+          let buttonText = '';
+          try {
+            const wrapper = el.closest('div, section, fieldset, [class*="field"], [class*="upload"]');
+            const btn = wrapper && wrapper.querySelector('button, [role="button"]');
+            if (btn) buttonText = safeText(btn.innerText || btn.textContent || '').trim();
+          } catch {}
+          const labelLooksGeneric = !lblForCheck || generic.test(lblForCheck) || generic.test(buttonText || '');
+          if (labelLooksGeneric) {
+            // Walk up to 8 ancestors and look for a heading inside that ancestor.
+            let p = el.parentElement, hops = 0;
+            while (p && hops < 8) {
+              const heading = p.querySelector('h1, h2, h3, h4, h5, h6, legend, [role="heading"]');
+              if (heading && !heading.contains(el)) {
+                const t = safeText(heading.textContent || '').replace(/\s*\*\s*$/, '').trim();
+                if (t && t.length > 0 && t.length < 150) {
+                  groupLabel = t;
+                  break;
+                }
+              }
+              p = p.parentElement; hops++;
+            }
+          }
+        }
+      } catch {}
+
       return {
         mmid,
         tag,
@@ -321,6 +363,7 @@ async function enrichFromDom(page, axFields) {
         ariaLabel: el.getAttribute('aria-label') || '',
         placeholder: el.placeholder || '',
         recoveredLabel,
+        groupLabel,
         selectorHint,
         currentValue,
         options,