halo-agent 2.5.0 → 2.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "halo-agent",
-  "version": "2.5.0",
+  "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 };