job-application-agent 3.4.2 → 3.6.0

package/job-application-agent/scripts/attention-runner-poll.mjs

@@ -0,0 +1,328 @@
+#!/usr/bin/env node
+/**
+ * GCP / Antigravity hosted-runner poll loop for attention resume signals.
+ *
+ * Polls GET /api/internal/attention-signals/:id with ATTENTION_NOTIFY_SECRET.
+ * Exit codes are stable for shell loops / Antigravity task graphs:
+ *
+ *   0  resume_requested — renew lease, re-inspect ATS, submit only on visible confirm
+ *  10  skipped          — resolve attention, no submit, continue round
+ *  11  aborted          — release lease, end round
+ *  20  timeout          — still waiting when --timeout elapsed
+ *   1  hard error       — missing env, HTTP/auth failure, invalid args
+ *
+ * Env:
+ *   ATTENTION_NOTIFY_SECRET  (required) Bearer for internal poll
+ *   PUBLIC_SITE_URL          site origin, default https://jobappagent.com
+ *   ATTENTION_NOTIFY_URL     optional; origin derived if PUBLIC_SITE_URL unset
+ *
+ * Usage:
+ *   node scripts/attention-runner-poll.mjs --attention-id attention-…
+ *   node scripts/attention-runner-poll.mjs --attention-id attention-… --interval 5 --timeout 3600
+ */
+
+import { pathToFileURL } from "node:url";
+
+export const EXIT = Object.freeze({
+  RESUME: 0,
+  ERROR: 1,
+  SKIPPED: 10,
+  ABORTED: 11,
+  TIMEOUT: 20,
+});
+
+/**
+ * @param {string[]} argv
+ */
+export function parseArgs(argv) {
+  const args = { attentionId: "", intervalSec: 5, timeoutSec: 3600, once: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const flag = argv[i];
+    const next = argv[i + 1];
+    if (flag === "--attention-id" || flag === "--id") {
+      args.attentionId = String(next ?? "").trim();
+      i += 1;
+    } else if (flag === "--interval") {
+      args.intervalSec = Number(next);
+      i += 1;
+    } else if (flag === "--timeout") {
+      args.timeoutSec = Number(next);
+      i += 1;
+    } else if (flag === "--once") {
+      args.once = true;
+    } else if (flag === "--help" || flag === "-h") {
+      args.help = true;
+    } else if (flag.startsWith("-")) {
+      throw new Error(`Unknown flag: ${flag}`);
+    }
+  }
+  return args;
+}
+
+/**
+ * @param {NodeJS.ProcessEnv} env
+ */
+export function resolvePollConfig(env = process.env) {
+  const secret = String(env.ATTENTION_NOTIFY_SECRET ?? "").trim();
+  let siteUrl = String(env.PUBLIC_SITE_URL ?? env.ATTENTION_SITE_URL ?? "").trim();
+  if (!siteUrl && env.ATTENTION_NOTIFY_URL) {
+    try {
+      siteUrl = new URL(env.ATTENTION_NOTIFY_URL).origin;
+    } catch {
+      siteUrl = "";
+    }
+  }
+  if (!siteUrl) siteUrl = "https://jobappagent.com";
+  return { secret, siteUrl };
+}
+
+/**
+ * @param {string} siteUrl
+ * @param {string} attentionId
+ */
+export function buildSignalPollUrl(siteUrl, attentionId) {
+  const origin = new URL(siteUrl).origin;
+  return new URL(`/api/internal/attention-signals/${encodeURIComponent(attentionId)}`, origin).toString();
+}
+
+/**
+ * @param {object} poll
+ */
+export function interpretPoll(poll) {
+  if (!poll || typeof poll !== "object") {
+    return { done: false, waiting: true, action: "wait", message: "Empty poll body; keep waiting." };
+  }
+  if (poll.resumeRequested || poll.signal === "resume_requested") {
+    return {
+      done: true,
+      exitCode: EXIT.RESUME,
+      signal: "resume_requested",
+      action: "resume",
+      message: [
+        "Signal: resume_requested",
+        "Next: renew cloud lease → load session binding (same tab / DISPLAY=:99 / VNC 5900) →",
+        "re-inspect the filled ATS page → submit if possible → wait for visible confirmation →",
+        "ledger intent-confirm. filled ≠ applied.",
+        "Helper: node scripts/attention-resume-submit.mjs --attention-id … --checklist",
+        "If unsure or still blocked, re-open attention honestly.",
+      ].join(" "),
+    };
+  }
+  if (poll.skipped || poll.signal === "skipped") {
+    return {
+      done: true,
+      exitCode: EXIT.SKIPPED,
+      signal: "skipped",
+      action: "skip",
+      message: [
+        "Signal: skipped",
+        "Next: attention resolve (no submit) → continue the round on other roles.",
+      ].join(" "),
+    };
+  }
+  if (poll.aborted || poll.signal === "aborted") {
+    return {
+      done: true,
+      exitCode: EXIT.ABORTED,
+      signal: "aborted",
+      action: "abort",
+      message: [
+        "Signal: aborted",
+        "Next: cloud lease-release → end the round. Do not submit.",
+      ].join(" "),
+    };
+  }
+  return {
+    done: false,
+    waiting: true,
+    action: "wait",
+    message: "No candidate signal yet (pending/null). Keep polling while lease held.",
+  };
+}
+
+/**
+ * @param {{
+ *   attentionId: string,
+ *   siteUrl: string,
+ *   secret: string,
+ *   intervalSec?: number,
+ *   timeoutSec?: number,
+ *   once?: boolean,
+ *   fetchImpl?: typeof fetch,
+ *   sleep?: (ms: number) => Promise<void>,
+ *   now?: () => number,
+ *   log?: (line: string) => void,
+ * }} options
+ */
+export async function pollAttentionSignal(options) {
+  const {
+    attentionId,
+    siteUrl,
+    secret,
+    intervalSec = 5,
+    timeoutSec = 3600,
+    once = false,
+    fetchImpl = fetch,
+    sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    now = () => Date.now(),
+    log = console.log,
+  } = options;
+
+  if (!attentionId) return { ok: false, exitCode: EXIT.ERROR, error: "attention_id_required" };
+  if (!secret) return { ok: false, exitCode: EXIT.ERROR, error: "ATTENTION_NOTIFY_SECRET missing" };
+
+  let pollUrl;
+  try {
+    pollUrl = buildSignalPollUrl(siteUrl, attentionId);
+  } catch {
+    return { ok: false, exitCode: EXIT.ERROR, error: "site_url_invalid" };
+  }
+
+  const started = now();
+  const deadline = started + Math.max(1, timeoutSec) * 1000;
+  const intervalMs = Math.max(1, intervalSec) * 1000;
+
+  log(`[attention-poll] watching ${attentionId}`);
+  log(`[attention-poll] GET ${pollUrl} every ${intervalSec}s (timeout ${timeoutSec}s)`);
+
+  while (true) {
+    let response;
+    try {
+      response = await fetchImpl(pollUrl, {
+        method: "GET",
+        headers: {
+          authorization: `Bearer ${secret}`,
+          accept: "application/json",
+        },
+      });
+    } catch (error) {
+      return {
+        ok: false,
+        exitCode: EXIT.ERROR,
+        error: `poll_request_failed: ${error instanceof Error ? error.message : "unknown"}`,
+      };
+    }
+
+    if (response.status === 401) {
+      return { ok: false, exitCode: EXIT.ERROR, error: "unauthorized — check ATTENTION_NOTIFY_SECRET" };
+    }
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      return {
+        ok: false,
+        exitCode: EXIT.ERROR,
+        error: `poll_http_${response.status}${body ? `: ${body.slice(0, 200)}` : ""}`,
+      };
+    }
+
+    const poll = await response.json().catch(() => null);
+    const interpreted = interpretPoll(poll);
+    if (interpreted.done) {
+      log(`[attention-poll] ${interpreted.message}`);
+      return {
+        ok: true,
+        exitCode: interpreted.exitCode,
+        signal: interpreted.signal,
+        action: interpreted.action,
+        poll,
+        message: interpreted.message,
+      };
+    }
+
+    log(`[attention-poll] waiting… (${poll?.signal ?? "null"})`);
+    if (once) {
+      return {
+        ok: true,
+        exitCode: EXIT.TIMEOUT,
+        action: "wait",
+        poll,
+        message: "No signal on --once poll.",
+      };
+    }
+    if (now() >= deadline) {
+      log("[attention-poll] timeout — still no resume/skip/abort signal");
+      return {
+        ok: false,
+        exitCode: EXIT.TIMEOUT,
+        error: "timeout",
+        message: "Timeout waiting for candidate signal. Renew lease or re-notify.",
+      };
+    }
+    await sleep(intervalMs);
+  }
+}
+
+function printHelp() {
+  console.log(`Usage: node scripts/attention-runner-poll.mjs --attention-id <id> [options]
+
+Options:
+  --interval <sec>   Poll interval (default 5)
+  --timeout <sec>    Max wait (default 3600)
+  --once             Single poll then exit 20 if still waiting
+
+Exit codes:
+  0  resume_requested
+ 10  skipped
+ 11  aborted
+ 20  timeout / still waiting
+  1  error
+
+Env: ATTENTION_NOTIFY_SECRET, PUBLIC_SITE_URL (or ATTENTION_NOTIFY_URL origin)
+`);
+}
+
+async function main(argv = process.argv.slice(2)) {
+  let args;
+  try {
+    args = parseArgs(argv);
+  } catch (error) {
+    console.error(`[attention-poll] ${error instanceof Error ? error.message : error}`);
+    process.exitCode = EXIT.ERROR;
+    return;
+  }
+  if (args.help) {
+    printHelp();
+    return;
+  }
+  if (!args.attentionId) {
+    console.error("[attention-poll] --attention-id is required");
+    printHelp();
+    process.exitCode = EXIT.ERROR;
+    return;
+  }
+  if (!Number.isFinite(args.intervalSec) || args.intervalSec <= 0) {
+    console.error("[attention-poll] --interval must be a positive number");
+    process.exitCode = EXIT.ERROR;
+    return;
+  }
+  if (!Number.isFinite(args.timeoutSec) || args.timeoutSec <= 0) {
+    console.error("[attention-poll] --timeout must be a positive number");
+    process.exitCode = EXIT.ERROR;
+    return;
+  }
+
+  const { secret, siteUrl } = resolvePollConfig(process.env);
+  const result = await pollAttentionSignal({
+    attentionId: args.attentionId,
+    siteUrl,
+    secret,
+    intervalSec: args.intervalSec,
+    timeoutSec: args.timeoutSec,
+    once: args.once,
+  });
+
+  if (!result.ok && result.error) {
+    console.error(`[attention-poll] ${result.error}`);
+  }
+  process.exitCode = result.exitCode;
+}
+
+const isDirect = import.meta.url === pathToFileURL(process.argv[1] ?? "").href
+  || process.argv[1]?.endsWith("attention-runner-poll.mjs");
+
+if (isDirect) {
+  main().catch((error) => {
+    console.error(`[attention-poll] ${error instanceof Error ? error.message : error}`);
+    process.exitCode = EXIT.ERROR;
+  });
+}

package/job-application-agent/scripts/captcha-vendor.mjs

@@ -0,0 +1,328 @@
+/**
+ * P2 CAPTCHA vendor scaffolding — gated Off by default.
+ *
+ * CAPTCHA_VENDOR=off|capsolver|2captcha (default off)
+ * Never call vendors unless vendor≠off AND api key present AND buyer opt-in.
+ * Fail closed to attention / live panel (complete-captcha).
+ *
+ * No cookie/session theft: solvers get only public page URL + sitekey + type.
+ * Solving CAPTCHA is never "applied" — submit + visible confirm still required.
+ */
+
+export const CAPTCHA_VENDORS = Object.freeze(["off", "capsolver", "2captcha"]);
+
+export const CAPTCHA_FRICTION = Object.freeze({
+  attempt: "captcha_vendor_attempt",
+  success: "captcha_vendor_success",
+  fail: "captcha_vendor_fail",
+  unsupported: "captcha_vendor_unsupported",
+  cap_hit: "captcha_vendor_cap_hit",
+  skipped_off: "captcha_vendor_skipped_off",
+});
+
+/**
+ * @param {NodeJS.ProcessEnv} [env]
+ */
+export function resolveCaptchaVendorConfig(env = process.env) {
+  const vendorRaw = String(env.CAPTCHA_VENDOR ?? "off").trim().toLowerCase();
+  const vendor = CAPTCHA_VENDORS.includes(vendorRaw) ? vendorRaw : "off";
+  const apiKey = String(env.CAPTCHA_VENDOR_API_KEY ?? "").trim();
+  const spendCapUsd = Number(env.CAPTCHA_SPEND_CAP_USD_MONTH ?? 5);
+  const spendMonthUsd = Number(env.CAPTCHA_SPEND_MONTH_USD ?? 0);
+  const buyerOptIn = String(env.CAPTCHA_BUYER_OPT_IN ?? env.CAPTCHA_ASSIST ?? "")
+    .trim()
+    .toLowerCase();
+  const captchaAssist = buyerOptIn === "on" || buyerOptIn === "true" || buyerOptIn === "1";
+  return {
+    vendor,
+    apiKey,
+    spendCapUsd: Number.isFinite(spendCapUsd) && spendCapUsd > 0 ? spendCapUsd : 5,
+    spendMonthUsd: Number.isFinite(spendMonthUsd) && spendMonthUsd >= 0 ? spendMonthUsd : 0,
+    captchaAssist,
+    enabled: vendor !== "off" && Boolean(apiKey) && captchaAssist,
+  };
+}
+
+/**
+ * Hard stop when monthly spend would exceed the cap.
+ * @param {{ spendMonthUsd?: number, spendCapUsd?: number, additionalUsd?: number }} input
+ */
+export function checkCaptchaSpendCap(input = {}) {
+  const spent = Number(input.spendMonthUsd ?? 0);
+  const cap = Number(input.spendCapUsd ?? 5);
+  const additional = Number(input.additionalUsd ?? 0);
+  const safeSpent = Number.isFinite(spent) ? Math.max(0, spent) : 0;
+  const safeCap = Number.isFinite(cap) && cap > 0 ? cap : 5;
+  const safeAdditional = Number.isFinite(additional) ? Math.max(0, additional) : 0;
+  if (safeSpent + safeAdditional > safeCap) {
+    return {
+      ok: false,
+      error: "spend_cap_hit",
+      friction: CAPTCHA_FRICTION.cap_hit,
+      message: "CAPTCHA assist spend cap reached. Fall back to live panel (complete-captcha).",
+      spendMonthUsd: safeSpent,
+      spendCapUsd: safeCap,
+    };
+  }
+  return {
+    ok: true,
+    spendMonthUsd: safeSpent,
+    spendCapUsd: safeCap,
+    remainingUsd: Math.max(0, safeCap - safeSpent),
+  };
+}
+
+/**
+ * Detect common challenge widgets from a page snapshot (no network).
+ * @param {{
+ *   pageUrl?: string,
+ *   pageHtml?: string,
+ *   pageText?: string,
+ *   sitekey?: string,
+ *   challengeType?: string,
+ *   matchedBlockerSelectors?: string[],
+ * }} snapshot
+ */
+export function detectChallenge(snapshot = {}) {
+  const html = String(snapshot.pageHtml ?? snapshot.pageText ?? "");
+  const selectors = Array.isArray(snapshot.matchedBlockerSelectors)
+    ? snapshot.matchedBlockerSelectors.join(" ")
+    : "";
+  const haystack = `${html}\n${selectors}`;
+  const explicit = String(snapshot.challengeType ?? "").trim().toLowerCase();
+
+  let type = "unknown";
+  if (explicit) type = explicit;
+  else if (/cf-turnstile|turnstile/i.test(haystack)) type = "turnstile";
+  else if (/recaptcha\/enterprise|google\.com\/recaptcha\/enterprise/i.test(haystack)) type = "recaptcha_v2";
+  else if (/recaptcha|g-recaptcha|grecaptcha/i.test(haystack)) type = "recaptcha_v2";
+  else if (/hcaptcha/i.test(haystack)) type = "hcaptcha";
+  else if (/captcha/i.test(haystack)) type = "unknown";
+  else {
+    return { present: false, type: null, sitekey: null, pageurl: snapshot.pageUrl ?? null };
+  }
+
+  const sitekey = String(
+    snapshot.sitekey
+      ?? haystack.match(/data-sitekey=["']([^"']+)["']/i)?.[1]
+      ?? "",
+  ).trim() || null;
+
+  return {
+    present: true,
+    type,
+    sitekey,
+    pageurl: snapshot.pageUrl ?? null,
+  };
+}
+
+/**
+ * CapSolver adapter stub — refuses unless fully enabled.
+ * @param {object} task
+ * @param {ReturnType<typeof resolveCaptchaVendorConfig>} config
+ * @param {{ fetchImpl?: typeof fetch }} [options]
+ */
+export async function capsolverCreateTask(task, config, options = {}) {
+  if (config.vendor !== "capsolver") {
+    return { ok: false, error: "vendor_mismatch", friction: CAPTCHA_FRICTION.skipped_off };
+  }
+  if (!config.enabled) {
+    return {
+      ok: false,
+      error: config.apiKey ? "buyer_opt_in_required" : "api_key_missing",
+      friction: CAPTCHA_FRICTION.fail,
+      message: "CapSolver refuse: vendor enabled only with API key + buyer captchaAssist=on.",
+    };
+  }
+  // Scaffold only — no real network in this slice.
+  void options.fetchImpl;
+  void task;
+  return {
+    ok: false,
+    error: "adapter_stub",
+    friction: CAPTCHA_FRICTION.unsupported,
+    message: "CapSolver adapter is scaffolded Off. Spike implementation gated until explicit go.",
+  };
+}
+
+/**
+ * 2Captcha adapter stub — refuses unless fully enabled.
+ * @param {object} task
+ * @param {ReturnType<typeof resolveCaptchaVendorConfig>} config
+ * @param {{ fetchImpl?: typeof fetch }} [options]
+ */
+export async function twocaptchaCreateTask(task, config, options = {}) {
+  if (config.vendor !== "2captcha") {
+    return { ok: false, error: "vendor_mismatch", friction: CAPTCHA_FRICTION.skipped_off };
+  }
+  if (!config.enabled) {
+    return {
+      ok: false,
+      error: config.apiKey ? "buyer_opt_in_required" : "api_key_missing",
+      friction: CAPTCHA_FRICTION.fail,
+      message: "2Captcha refuse: vendor enabled only with API key + buyer captchaAssist=on.",
+    };
+  }
+  void options.fetchImpl;
+  void task;
+  return {
+    ok: false,
+    error: "adapter_stub",
+    friction: CAPTCHA_FRICTION.unsupported,
+    message: "2Captcha adapter is scaffolded Off. Spike implementation gated until explicit go.",
+  };
+}
+
+/**
+ * Poll stub — always fail-closed (no network).
+ * @param {string} taskId
+ * @param {ReturnType<typeof resolveCaptchaVendorConfig>} config
+ */
+export async function pollCaptchaTask(taskId, config) {
+  void taskId;
+  if (!config.enabled) {
+    return { ok: false, error: "vendor_off", friction: CAPTCHA_FRICTION.skipped_off };
+  }
+  return {
+    ok: false,
+    error: "adapter_stub",
+    friction: CAPTCHA_FRICTION.unsupported,
+    message: "CAPTCHA poll stub — no vendor calls until spike is approved.",
+  };
+}
+
+/**
+ * Token inject guidance — never runs when vendor off.
+ * @param {{ token?: string, type?: string }} result
+ * @param {ReturnType<typeof resolveCaptchaVendorConfig>} config
+ */
+export function injectCaptchaToken(result, config) {
+  if (!config.enabled) {
+    return {
+      ok: false,
+      error: "vendor_off",
+      friction: CAPTCHA_FRICTION.skipped_off,
+      message: "CAPTCHA vendor Off — use attention complete-captcha / live panel.",
+    };
+  }
+  if (!result?.token) {
+    return { ok: false, error: "token_missing", friction: CAPTCHA_FRICTION.fail };
+  }
+  return {
+    ok: false,
+    error: "adapter_stub",
+    friction: CAPTCHA_FRICTION.unsupported,
+    message: "Token inject stubbed. Fail closed to live panel.",
+    guidance: {
+      note: "When implemented: set textarea/input for g-recaptcha-response / cf-turnstile-response; never store token in cloud state.",
+      type: result.type ?? null,
+    },
+  };
+}
+
+/**
+ * Single call-site helper for resume / re-inspect.
+ * When Off (default): identical to today — needs human complete-captcha.
+ *
+ * @param {{
+ *   snapshot?: object,
+ *   env?: NodeJS.ProcessEnv,
+ *   fetchImpl?: typeof fetch,
+ * }} [input]
+ */
+export async function tryCaptchaVendorAssist(input = {}) {
+  const config = resolveCaptchaVendorConfig(input.env ?? process.env);
+  const challenge = detectChallenge(input.snapshot ?? {});
+
+  if (!challenge.present) {
+    return { ok: true, assisted: false, reason: "no_challenge", challenge };
+  }
+
+  if (config.vendor === "off") {
+    return {
+      ok: false,
+      assisted: false,
+      reason: "vendor_off",
+      friction: CAPTCHA_FRICTION.skipped_off,
+      challenge,
+      fallback: "complete-captcha",
+      message: "CAPTCHA_VENDOR=off (default). Use live panel / attention complete-captcha.",
+    };
+  }
+
+  if (!config.apiKey) {
+    return {
+      ok: false,
+      assisted: false,
+      reason: "api_key_missing",
+      friction: CAPTCHA_FRICTION.fail,
+      challenge,
+      fallback: "complete-captcha",
+      message: "CAPTCHA vendor key missing — fail closed to human.",
+    };
+  }
+
+  if (!config.captchaAssist) {
+    return {
+      ok: false,
+      assisted: false,
+      reason: "buyer_opt_in_required",
+      friction: CAPTCHA_FRICTION.fail,
+      challenge,
+      fallback: "complete-captcha",
+      message: "Buyer captchaAssist is off — fail closed to human.",
+    };
+  }
+
+  const cap = checkCaptchaSpendCap({
+    spendMonthUsd: config.spendMonthUsd,
+    spendCapUsd: config.spendCapUsd,
+    additionalUsd: 0.01,
+  });
+  if (!cap.ok) {
+    return {
+      ok: false,
+      assisted: false,
+      reason: "spend_cap_hit",
+      friction: CAPTCHA_FRICTION.cap_hit,
+      challenge,
+      fallback: "complete-captcha",
+      message: cap.message,
+    };
+  }
+
+  const supported = new Set(["recaptcha_v2", "turnstile"]);
+  if (!supported.has(challenge.type)) {
+    return {
+      ok: false,
+      assisted: false,
+      reason: "unsupported_type",
+      friction: CAPTCHA_FRICTION.unsupported,
+      challenge,
+      fallback: "complete-captcha",
+      message: `Unsupported challenge type: ${challenge.type}. Fall back to live panel.`,
+    };
+  }
+
+  const task = {
+    type: challenge.type,
+    sitekey: challenge.sitekey,
+    pageurl: challenge.pageurl,
+  };
+
+  const created = config.vendor === "2captcha"
+    ? await twocaptchaCreateTask(task, config, { fetchImpl: input.fetchImpl })
+    : await capsolverCreateTask(task, config, { fetchImpl: input.fetchImpl });
+
+  return {
+    ok: false,
+    assisted: false,
+    reason: created.error ?? "adapter_stub",
+    friction: created.friction ?? CAPTCHA_FRICTION.fail,
+    challenge,
+    fallback: "complete-captcha",
+    message: created.message ?? "CAPTCHA vendor assist failed closed.",
+    // Network was not used by stubs; keep this explicit for tests.
+    networkCalled: false,
+  };
+}