agentlinkops 0.5.0 → 0.5.1

package/src/citations/browser/gen/lib/browser/display.js

@@ -0,0 +1,147 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { access } from "node:fs/promises";
+import { release } from "node:os";
+const XVFB_CANDIDATES = ["/usr/bin/Xvfb", "/usr/local/bin/Xvfb"];
+const XVFB_START_TIMEOUT_MS = 5e3;
+const DEFAULT_SCREEN_WIDTH = 1920;
+const DEFAULT_SCREEN_HEIGHT = 1080;
+const DEFAULT_SCREEN_DEPTH = 24;
+const DEFAULT_CAMOUFOX_HEADLESS_MODE = "virtual";
+function findXvfbBinary() {
+  for (const candidate of XVFB_CANDIDATES) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function detectDisplay() {
+  return process.env.DISPLAY?.trim() || null;
+}
+function isWsl() {
+  if (process.platform !== "linux") return false;
+  const kernelRelease = release().toLowerCase();
+  return kernelRelease.includes("microsoft") || kernelRelease.includes("wsl");
+}
+function parseScreenSpec() {
+  const raw = process.env.CAMOUFOX_XVFB_SCREEN?.trim();
+  if (!raw) {
+    return {
+      width: DEFAULT_SCREEN_WIDTH,
+      height: DEFAULT_SCREEN_HEIGHT,
+      depth: DEFAULT_SCREEN_DEPTH
+    };
+  }
+  const match = raw.match(/^(\d+)x(\d+)x(\d+)$/i);
+  if (!match) {
+    throw new Error(
+      "CAMOUFOX_XVFB_SCREEN must use WIDTHxHEIGHTxDEPTH, for example 1920x1080x24."
+    );
+  }
+  return {
+    width: Number(match[1]),
+    height: Number(match[2]),
+    depth: Number(match[3])
+  };
+}
+async function waitForDisplaySocket(displayNumber, child, timeoutMs = XVFB_START_TIMEOUT_MS) {
+  const socketPath = `/tmp/.X11-unix/X${displayNumber}`;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (child.exitCode !== null) {
+      throw new Error(`Xvfb exited before display :${displayNumber} was ready`);
+    }
+    try {
+      await access(socketPath);
+      return;
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  child.kill("SIGTERM");
+  throw new Error(
+    `Xvfb display :${displayNumber} was not ready within ${timeoutMs}ms`
+  );
+}
+async function ensureDisplay(options) {
+  if ((process.env.CAMOUFOX_HEADLESS_MODE ?? DEFAULT_CAMOUFOX_HEADLESS_MODE) === "headless") {
+    return null;
+  }
+  const existingDisplay = detectDisplay();
+  if ((options?.allowExistingDisplay ?? true) && existingDisplay) {
+    return {
+      display: existingDisplay,
+      cleanup: async () => {
+      }
+    };
+  }
+  if (process.platform !== "linux") {
+    return null;
+  }
+  if ((process.env.CAMOUFOX_HEADLESS_MODE ?? DEFAULT_CAMOUFOX_HEADLESS_MODE) === "headful") {
+    throw new Error(
+      "CAMOUFOX_HEADLESS_MODE=headful requires DISPLAY to already be set."
+    );
+  }
+  const xvfbBinary = findXvfbBinary();
+  if (!xvfbBinary) {
+    throw new Error("No DISPLAY or Xvfb available for headful Camoufox.");
+  }
+  let lastError = null;
+  const preferredDisplay = process.env.CAMOUFOX_XVFB_DISPLAY?.trim() || null;
+  const screen = parseScreenSpec();
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    const display = preferredDisplay ?? `:${100 + Math.floor(Math.random() * 800)}`;
+    const displayNumber = Number(display.replace(/^:/, ""));
+    if (!Number.isInteger(displayNumber)) {
+      throw new Error(
+        `Invalid CAMOUFOX_XVFB_DISPLAY value "${display}". Expected format like :99.`
+      );
+    }
+    const xvfb = spawn(
+      xvfbBinary,
+      [
+        display,
+        "-screen",
+        "0",
+        `${screen.width}x${screen.height}x${screen.depth}`,
+        "-ac",
+        "-nolisten",
+        "tcp"
+      ],
+      { stdio: "ignore" }
+    );
+    try {
+      await waitForDisplaySocket(displayNumber, xvfb);
+      return {
+        display,
+        cleanup: async () => {
+          try {
+            xvfb.kill("SIGTERM");
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            if (xvfb.exitCode === null) {
+              xvfb.kill("SIGKILL");
+            }
+          } catch {
+          }
+        }
+      };
+    } catch (error) {
+      lastError = error;
+      try {
+        xvfb.kill("SIGTERM");
+      } catch {
+      }
+      if (preferredDisplay) {
+        break;
+      }
+    }
+  }
+  throw new Error(
+    `Failed to bootstrap Xvfb: ${lastError instanceof Error ? lastError.message : "unknown error"}`
+  );
+}
+export {
+  detectDisplay,
+  ensureDisplay,
+  isWsl
+};

package/src/citations/browser/gen/lib/browser/domOps.js

@@ -0,0 +1,339 @@
+import { PROVIDER_RAW_SOURCES_DOM_EXTRACTORS } from "../../core/providers/_shared/rawSourcesDom.js";
+async function runPageDomOp(page, operation, params) {
+  const nextParams = { ...params ?? {} };
+  if (operation === "raw-sources") {
+    const provider = String(nextParams.provider || "");
+    nextParams.providerRawSourcesExtractor = PROVIDER_RAW_SOURCES_DOM_EXTRACTORS[provider] ?? "";
+  }
+  return await page.evaluate(
+    ({ operation: currentOperation, params: currentParams }) => {
+      function splitTopLevelSelectors(selector) {
+        const parts = [];
+        let current = "";
+        let parenDepth = 0;
+        let bracketDepth = 0;
+        let quote = null;
+        for (const char of selector) {
+          if (quote) {
+            current += char;
+            if (char === quote) {
+              quote = null;
+            }
+            continue;
+          }
+          if (char === "'" || char === '"') {
+            quote = char;
+            current += char;
+            continue;
+          }
+          if (char === "(") parenDepth += 1;
+          if (char === ")") parenDepth = Math.max(0, parenDepth - 1);
+          if (char === "[") bracketDepth += 1;
+          if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+          if (char === "," && parenDepth === 0 && bracketDepth === 0) {
+            if (current.trim()) parts.push(current.trim());
+            current = "";
+            continue;
+          }
+          current += char;
+        }
+        if (current.trim()) parts.push(current.trim());
+        return parts;
+      }
+      function parseHasTextSelector(selector) {
+        const textFilters = [];
+        let baseSelector = selector;
+        const regex = /:has-text\((["'])(.*?)\1\)/g;
+        baseSelector = baseSelector.replace(
+          regex,
+          (_full, _quote, value) => {
+            textFilters.push(value);
+            return "";
+          }
+        );
+        baseSelector = baseSelector.trim() || "*";
+        return { baseSelector, textFilters };
+      }
+      function elementText(element) {
+        if (element instanceof HTMLElement) {
+          return (element.innerText || element.textContent || "").trim();
+        }
+        return (element.textContent || "").trim();
+      }
+      function isVisible(element) {
+        if (!(element instanceof HTMLElement)) return false;
+        if (!element.isConnected) return false;
+        const style = window.getComputedStyle(element);
+        if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") {
+          return false;
+        }
+        const rect = element.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      }
+      function dedupeElements(elements) {
+        return Array.from(new Set(elements));
+      }
+      function resolveSelectorWithin(root, selector) {
+        const elements = [];
+        for (const part of splitTopLevelSelectors(selector)) {
+          const { baseSelector, textFilters } = parseHasTextSelector(part);
+          const matches = Array.from(
+            root.querySelectorAll(baseSelector)
+          ).filter(
+            (el) => textFilters.every(
+              (filter) => elementText(el).toLowerCase().includes(filter.toLowerCase())
+            )
+          );
+          elements.push(...matches);
+        }
+        return dedupeElements(elements);
+      }
+      function isResponsePlaceholder(element) {
+        return element.getAttribute("aria-busy") === "true" || (element.getAttribute("data-message-id") || "").startsWith(
+          "request-placeholder"
+        );
+      }
+      function findLatestResponseElement(selectors) {
+        const selector = (selectors || []).join(", ");
+        if (!selector.trim()) return null;
+        const element = Array.from(document.querySelectorAll(selector)).filter(
+          (el) => el instanceof HTMLElement && isVisible(el) && !isResponsePlaceholder(el) && el.innerText.trim().length > 50
+        ).pop() ?? null;
+        return element ? { selector, element } : null;
+      }
+      function getCachedRawSources(key) {
+        const cache = window.__oneglanseRawSourcesCache;
+        return cache?.[key] ?? null;
+      }
+      function setCachedRawSources(key, rawSources) {
+        const state = window;
+        state.__oneglanseRawSourcesCache ||= {};
+        state.__oneglanseRawSourcesCache[key] = rawSources;
+      }
+      function extractClaudeRawSourcesFromResponseElement(responseEl) {
+        const normalize = (text) => text.replace(/\s+/g, " ").trim();
+        const getTextBeforeAnchor = (anchor) => {
+          let text = "";
+          let node = anchor;
+          while (node) {
+            if (node.previousSibling) {
+              node = node.previousSibling;
+              while (node && node.lastChild) {
+                node = node.lastChild;
+              }
+            } else {
+              node = node.parentNode;
+            }
+            if (!node) break;
+            if (node.nodeType === Node.TEXT_NODE) {
+              const content = node.textContent || "";
+              text = `${content} ${text}`;
+              if (/[.!?]\s*$/.test(content)) break;
+            }
+          }
+          return normalize(text);
+        };
+        return Array.from(responseEl.querySelectorAll('a[href^="http"]')).map((anchor) => {
+          const link = anchor;
+          const anchorElement = anchor instanceof HTMLElement ? anchor : null;
+          return {
+            rawHref: link.href,
+            title: (anchor.textContent || "").trim() || link.href,
+            citedText: anchorElement ? getTextBeforeAnchor(anchorElement) : ""
+          };
+        }).filter((source) => source.rawHref);
+      }
+      function runProviderRawSourcesExtractor(extractorSource, selectors) {
+        if (!extractorSource.trim()) return [];
+        const extractor = Function(
+          `return (${extractorSource});`
+        )();
+        return extractor(
+          {
+            getCachedRawSources,
+            setCachedRawSources,
+            findLatestResponseElement,
+            extractClaudeRawSourcesFromResponseElement
+          },
+          selectors
+        );
+      }
+      function readResponseText(_provider, selectors) {
+        return findLatestResponseElement(selectors)?.element.innerText.trim() || "";
+      }
+      function isCitationAnchor(anchor) {
+        const text = anchor.textContent?.trim() || "";
+        if (!text || text.length > 40) return false;
+        if (/^\+?\d+$/.test(text)) return true;
+        if (/^[a-z0-9.\-+]+$/i.test(text) && text.includes(".") && text.length < 40) return true;
+        return false;
+      }
+      function formatCitationAnchors(root) {
+        const cleanCitationText = (text) => text.replace(/\+\d+$/, "").trim();
+        for (const anchor of Array.from(root.querySelectorAll("a[href]"))) {
+          if (!(anchor instanceof HTMLAnchorElement)) continue;
+          if (!isCitationAnchor(anchor)) continue;
+          const rawText = anchor.textContent?.trim();
+          if (!rawText) continue;
+          const cleaned = cleanCitationText(rawText);
+          if (!cleaned) {
+            anchor.remove();
+            continue;
+          }
+          const strong = document.createElement("strong");
+          strong.textContent = `[${cleaned}]`;
+          anchor.replaceWith(
+            document.createTextNode(" "),
+            strong,
+            document.createTextNode(" ")
+          );
+        }
+      }
+      function readResponseHtml(provider, selectors) {
+        if (provider === "ai-overview") {
+          const root = document.querySelector('[data-container-id="main-col"]');
+          if (!root) return "";
+          const clone2 = root.cloneNode(true);
+          formatCitationAnchors(clone2);
+          clone2.querySelectorAll(
+            '[data-src-id], button, [role="button"], svg, img, style, script'
+          ).forEach((el) => el.remove());
+          return clone2.innerHTML.trim();
+        }
+        const latestResponse = findLatestResponseElement(selectors);
+        if (!latestResponse) return "";
+        if (provider === "claude") {
+          setCachedRawSources(
+            "claude",
+            extractClaudeRawSourcesFromResponseElement(latestResponse.element)
+          );
+        }
+        const clone = latestResponse.element.cloneNode(true);
+        formatCitationAnchors(clone);
+        const noiseSelectors = [
+          "button",
+          "[role='button']",
+          "svg",
+          "script",
+          "style",
+          "noscript",
+          "iframe",
+          "sup",
+          "[aria-live]",
+          "[data-testid='copy-turn-action-button']",
+          "[data-testid='voice-play-turn-action-button']",
+          "[data-testid='thumbs-up-button']",
+          "[data-testid='thumbs-down-button']",
+          "[aria-hidden='true']"
+        ];
+        for (const sel of noiseSelectors) {
+          for (const el of Array.from(clone.querySelectorAll(sel))) {
+            el.remove();
+          }
+        }
+        return clone.innerHTML.trim();
+      }
+      function captureVisibleHtml(selectors, fallbackSelectors) {
+        const latestResponse = findLatestResponseElement(selectors);
+        if (latestResponse) {
+          const html = latestResponse.element.outerHTML.trim();
+          if (html) return { selector: latestResponse.selector, html };
+        }
+        for (const selector of fallbackSelectors || []) {
+          const element = resolveSelectorWithin(document, selector)[0] ?? null;
+          if (!isVisible(element)) continue;
+          const html = element.outerHTML.trim();
+          if (html) return { selector, html };
+        }
+        return { selector: "none", html: "" };
+      }
+      function detectBotPageState() {
+        const bodyText = (document.body?.innerText || "").replace(/\s+/g, " ").trim();
+        const title = (document.title || "").trim();
+        const url = window.location.href;
+        const signals = [
+          {
+            matched: /sorry/i.test(url) || /our systems have detected unusual traffic/i.test(bodyText),
+            reason: "bot detection: unusual traffic / sorry page"
+          },
+          {
+            matched: /captcha|recaptcha|turnstile|verify you are human/i.test(
+              bodyText
+            ),
+            reason: "bot detection: captcha or human verification challenge"
+          },
+          {
+            matched: Boolean(
+              document.querySelector(
+                'form#captcha-form, iframe[src*="recaptcha"]'
+              )
+            ) || /challenge/i.test(title),
+            reason: "bot detection: challenge UI present"
+          },
+          {
+            matched: /\/login|\/log-in|\/signin|\/sign-in|\/sign-up|\/signup|\/auth(?:\/|$)|accounts\.google\.com|auth\.openai\.com/.test(
+              url
+            ),
+            reason: "session expired: redirected to login page"
+          },
+          {
+            matched: /sign in to continue|you('ve| have) been signed out|create a free account|log in to continue|sign in to (?:chat|use|access)|please (?:sign|log) in/i.test(
+              bodyText
+            ),
+            reason: "session expired: login wall detected"
+          }
+        ];
+        const hit = signals.find((signal) => signal.matched);
+        return {
+          botDetected: Boolean(hit),
+          reason: hit?.reason ?? null
+        };
+      }
+      function getPlatformName() {
+        const uaDataPlatform = navigator.userAgentData?.platform || "";
+        return String(uaDataPlatform || navigator.platform || "").toLowerCase();
+      }
+      switch (currentOperation) {
+        case "ping":
+          return true;
+        case "window-metrics":
+          return {
+            outerHeight: window.outerHeight,
+            innerHeight: window.innerHeight,
+            outerWidth: window.outerWidth,
+            innerWidth: window.innerWidth
+          };
+        case "detect-bot-page":
+          return detectBotPageState();
+        case "platform-name":
+          return getPlatformName();
+        case "response-text":
+          return readResponseText(
+            String(currentParams?.provider || ""),
+            currentParams?.selectors || []
+          );
+        case "response-html":
+          return readResponseHtml(
+            String(currentParams?.provider || ""),
+            currentParams?.selectors || []
+          );
+        case "capture-visible-html":
+          return captureVisibleHtml(
+            currentParams?.selectors || [],
+            currentParams?.fallbackSelectors || []
+          );
+        case "raw-sources":
+          return runProviderRawSourcesExtractor(
+            String(currentParams?.providerRawSourcesExtractor || ""),
+            currentParams?.selectors || []
+          );
+        default:
+          throw new Error(`unknown page operation: ${currentOperation}`);
+      }
+    },
+    { operation, params: nextParams }
+  );
+}
+export {
+  runPageDomOp
+};

package/src/citations/browser/gen/lib/browser/humanBehavior.js

@@ -0,0 +1,121 @@
+const CAMOUFOX_HUMANIZE = true;
+function canUseOsLevelInput(_page) {
+  return false;
+}
+async function clickLocatorLikeUser(_page, target, options) {
+  await target.click({
+    timeout: options?.timeout,
+    delay: options?.delay,
+    force: options?.force
+  });
+  return true;
+}
+async function pressKeyLikeUser(page, key, options) {
+  await page.keyboard.press(key, { delay: options?.delay });
+  return true;
+}
+async function getBrowserPrimaryModifier(page) {
+  try {
+    const platform = await page.runDomOp("platform-name");
+    return platform.includes("mac") ? "Meta" : "Control";
+  } catch {
+    return "Control";
+  }
+}
+function randomBetween(min, max) {
+  return min + Math.floor(Math.random() * (max - min + 1));
+}
+const graphemeSegmenter = typeof Intl !== "undefined" && "Segmenter" in Intl ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : null;
+function bezierPoint(t, p0, p1, p2, p3) {
+  const u = 1 - t;
+  return u * u * u * p0 + 3 * u * u * t * p1 + 3 * u * t * t * p2 + t * t * t * p3;
+}
+async function moveMouseToElement(page, target) {
+  if (CAMOUFOX_HUMANIZE) return;
+  const box = await target.boundingBox().catch(() => null);
+  if (!box) return;
+  const viewport = page.viewportSize() ?? { width: 1920, height: 1080 };
+  const startX = randomBetween(viewport.width * 0.1, viewport.width * 0.9);
+  const startY = randomBetween(viewport.height * 0.1, viewport.height * 0.9);
+  const endX = box.x + box.width * (0.3 + Math.random() * 0.4);
+  const endY = box.y + box.height * (0.3 + Math.random() * 0.4);
+  const cp1x = startX + (endX - startX) * (0.2 + Math.random() * 0.3);
+  const cp1y = startY + (Math.random() - 0.5) * 100;
+  const cp2x = endX - (endX - startX) * (0.2 + Math.random() * 0.3);
+  const cp2y = endY + (Math.random() - 0.5) * 100;
+  const steps = randomBetween(6, 12);
+  for (let i = 0; i <= steps; i++) {
+    const t = i / steps;
+    const x = bezierPoint(t, startX, cp1x, cp2x, endX);
+    const y = bezierPoint(t, startY, cp1y, cp2y, endY);
+    await page.mouse.move(x, y);
+    await page.waitForTimeout(randomBetween(3, 12));
+  }
+}
+async function preInteractionIdle(page) {
+  await page.waitForTimeout(
+    CAMOUFOX_HUMANIZE ? randomBetween(80, 180) : randomBetween(300, 700)
+  );
+}
+async function smallScroll(page) {
+  if (CAMOUFOX_HUMANIZE) return;
+  const amount = randomBetween(50, 200);
+  await page.mouse.wheel(0, amount);
+  await page.waitForTimeout(randomBetween(200, 600));
+}
+async function typeTextWithCadence(page, text) {
+  const units = graphemeSegmenter ? Array.from(graphemeSegmenter.segment(text), (segment) => segment.segment) : Array.from(text);
+  for (const unit of units) {
+    await page.keyboard.type(unit);
+    await page.waitForTimeout(randomBetween(12, 28));
+  }
+  return units.length;
+}
+async function pastePrompt(page, text) {
+  const segments = graphemeSegmenter ? Array.from(graphemeSegmenter.segment(text), (segment) => segment.segment) : Array.from(text);
+  let cursor = 0;
+  let charsSinceLongPause = 0;
+  while (cursor < segments.length) {
+    const nextChunkSize = randomBetween(3, 8);
+    const chunk = segments.slice(cursor, cursor + nextChunkSize).join("");
+    cursor += nextChunkSize;
+    if (chunk === "\n") {
+      await page.keyboard.press("Shift+Enter");
+      charsSinceLongPause = 0;
+      await page.waitForTimeout(randomBetween(60, 140));
+      continue;
+    }
+    if (chunk.includes("\n")) {
+      const parts = chunk.split("\n");
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part) {
+          charsSinceLongPause += await typeTextWithCadence(page, part);
+        }
+        if (i < parts.length - 1) {
+          await page.keyboard.press("Shift+Enter");
+          charsSinceLongPause = 0;
+          await page.waitForTimeout(randomBetween(70, 160));
+        }
+      }
+    } else {
+      charsSinceLongPause += await typeTextWithCadence(page, chunk);
+    }
+    await page.waitForTimeout(randomBetween(35, 110));
+    if (charsSinceLongPause >= randomBetween(22, 40)) {
+      charsSinceLongPause = 0;
+      await page.waitForTimeout(randomBetween(120, 260));
+    }
+  }
+}
+export {
+  canUseOsLevelInput,
+  clickLocatorLikeUser,
+  getBrowserPrimaryModifier,
+  moveMouseToElement,
+  pastePrompt,
+  preInteractionIdle,
+  pressKeyLikeUser,
+  randomBetween,
+  smallScroll
+};

package/src/citations/browser/gen/lib/browser/navigate.js

@@ -0,0 +1,46 @@
+import { ExternalServiceError, toErrorMessage } from "../../../shims/errors.js";
+import { RETRYABLE_ERRORS, logger } from "../../../shims/utils.js";
+function jitter(baseMs, factor = 0.3) {
+  const delta = Math.round(baseMs * factor);
+  const min = Math.max(0, baseMs - delta);
+  const max = baseMs + delta;
+  return Math.round(min + Math.random() * (max - min));
+}
+async function navigateWithRetry(page, url, options = {}, maxRetries = 3, delayMs = 2e3) {
+  let referer = options?.referer;
+  if (referer === void 0) {
+    try {
+      const currentUrl = page.url();
+      if (currentUrl && currentUrl !== "about:blank") {
+        referer = currentUrl;
+      }
+    } catch {
+    }
+  }
+  const gotoOptions = referer !== void 0 ? { ...options, referer } : options;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      await page.goto(url, gotoOptions);
+      return;
+    } catch (err) {
+      const message = toErrorMessage(err);
+      const isRetryable = RETRYABLE_ERRORS.some((e) => message.includes(e));
+      if (!isRetryable || attempt === maxRetries) {
+        throw new ExternalServiceError(
+          "navigation",
+          toErrorMessage(err),
+          502,
+          { url, attempt },
+          err
+        );
+      }
+      logger.warn(
+        `navigation failed (attempt ${attempt}/${maxRetries}): ${message} \u2014 retrying in ${Math.round(jitter(delayMs) / 100) / 10}s`
+      );
+      await page.waitForTimeout(jitter(delayMs));
+    }
+  }
+}
+export {
+  navigateWithRetry
+};