agentlinkops 0.5.0 → 0.6.0

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

@@ -0,0 +1,321 @@
+import { runPageDomOp } from "./domOps.js";
+class PlaywrightWorkerCompat {
+  constructor(worker) {
+    this.worker = worker;
+  }
+  worker;
+  async evaluate(script) {
+    return await this.worker.evaluate(script);
+  }
+}
+class PlaywrightLocatorCompat {
+  constructor(locator) {
+    this.locator = locator;
+  }
+  locator;
+  wrap(next) {
+    return new PlaywrightLocatorCompat(next);
+  }
+  count() {
+    return this.locator.count();
+  }
+  nth(index) {
+    return this.wrap(this.locator.nth(index));
+  }
+  first() {
+    return this.wrap(this.locator.first());
+  }
+  last() {
+    return this.wrap(this.locator.last());
+  }
+  filter(options) {
+    return this.wrap(this.locator.filter({ hasText: options.hasText }));
+  }
+  getByText(text) {
+    return this.wrap(this.locator.getByText(text));
+  }
+  isVisible(options) {
+    return this.locator.isVisible(options);
+  }
+  isEnabled() {
+    return this.locator.isEnabled();
+  }
+  focus() {
+    return this.locator.focus();
+  }
+  boundingBox() {
+    return this.locator.boundingBox();
+  }
+  scrollIntoViewIfNeeded() {
+    return this.locator.scrollIntoViewIfNeeded();
+  }
+  click(options) {
+    return this.locator.click(options);
+  }
+  press(key, options) {
+    return this.locator.press(key, options);
+  }
+  waitFor(options) {
+    return this.locator.waitFor({
+      timeout: options?.timeout,
+      state: options?.state
+    });
+  }
+  async readInputValue() {
+    return await this.locator.evaluate((element) => {
+      if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+        return element.value;
+      }
+      if (element instanceof HTMLElement) {
+        return element.innerText || element.textContent || "";
+      }
+      return "";
+    });
+  }
+  async setInputValue(value) {
+    await this.locator.evaluate((element, nextValue) => {
+      if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+        const proto = Object.getPrototypeOf(element);
+        const descriptor = Object.getOwnPropertyDescriptor(proto, "value");
+        if (descriptor?.set) {
+          descriptor.set.call(element, nextValue);
+        } else {
+          element.value = nextValue;
+        }
+        element.dispatchEvent(new Event("input", { bubbles: true }));
+        element.dispatchEvent(new Event("change", { bubbles: true }));
+        return;
+      }
+      if (element instanceof HTMLElement) {
+        element.focus();
+        element.innerText = nextValue;
+        element.dispatchEvent(new Event("input", { bubbles: true }));
+        element.dispatchEvent(new Event("change", { bubbles: true }));
+      }
+    }, value);
+  }
+  async getEditableState() {
+    return await this.locator.evaluate((element) => {
+      function hasHiddenAncestor(target) {
+        let current = target;
+        while (current) {
+          if (current.hidden || current.getAttribute("aria-hidden") === "true" || current.hasAttribute("inert")) {
+            return true;
+          }
+          const style = window.getComputedStyle(current);
+          if (style.display === "none" || style.visibility === "hidden" || style.visibility === "collapse" || style.opacity === "0" || style.pointerEvents === "none") {
+            return true;
+          }
+          current = current.parentElement;
+        }
+        return false;
+      }
+      function acceptsTextInput(target) {
+        if (target instanceof HTMLTextAreaElement) {
+          return true;
+        }
+        if (target instanceof HTMLInputElement) {
+          const blockedTypes = /* @__PURE__ */ new Set([
+            "hidden",
+            "button",
+            "checkbox",
+            "color",
+            "file",
+            "image",
+            "radio",
+            "range",
+            "reset",
+            "submit"
+          ]);
+          return !blockedTypes.has(target.type);
+        }
+        return target.isContentEditable || target.getAttribute("contenteditable") === "true";
+      }
+      function isEnabled(target) {
+        if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) {
+          return !target.disabled && !target.readOnly;
+        }
+        return target.getAttribute("aria-disabled") !== "true" && !target.hasAttribute("disabled") && target.getAttribute("contenteditable") !== "false";
+      }
+      if (!(element instanceof HTMLElement)) {
+        return {
+          connected: false,
+          visible: false,
+          editable: false,
+          enabled: false,
+          acceptsTextInput: false
+        };
+      }
+      const rect = element.getBoundingClientRect();
+      const clientRects = element.getClientRects();
+      const visibleByBrowser = typeof element.checkVisibility === "function" ? element.checkVisibility({
+        checkOpacity: true,
+        checkVisibilityCSS: true
+      }) : true;
+      const visible = element.isConnected && visibleByBrowser && !hasHiddenAncestor(element) && clientRects.length > 0 && rect.width > 0 && rect.height > 0;
+      const enabled = isEnabled(element);
+      const textInput = acceptsTextInput(element);
+      return {
+        connected: element.isConnected,
+        visible,
+        editable: visible && enabled && textInput,
+        enabled,
+        acceptsTextInput: textInput
+      };
+    });
+  }
+  async dispatchClick() {
+    await this.locator.evaluate((element) => {
+      if (!(element instanceof HTMLElement)) return;
+      element.dispatchEvent(
+        new MouseEvent("click", {
+          bubbles: true,
+          cancelable: true,
+          composed: true,
+          view: window
+        })
+      );
+    });
+  }
+}
+class PlaywrightBrowserContextCompat {
+  constructor(context) {
+    this.context = context;
+    const existingPages = this.context.pages();
+    this.initialPage = existingPages.length === 1 && existingPages[0]?.url() === "about:blank" ? existingPages[0] : null;
+  }
+  context;
+  pageMap = /* @__PURE__ */ new WeakMap();
+  initialPage;
+  wrapPage(page) {
+    const existing = this.pageMap.get(page);
+    if (existing) return existing;
+    const wrapped = new PlaywrightPageCompat(page, this);
+    this.pageMap.set(page, wrapped);
+    return wrapped;
+  }
+  getRawContext() {
+    return this.context;
+  }
+  getBrowser() {
+    const browser = this.context.browser();
+    if (browser) return browser;
+    return {
+      version: () => "Camoufox",
+      close: () => this.context.close()
+    };
+  }
+  async newPage() {
+    if (this.initialPage) {
+      const page = this.initialPage;
+      this.initialPage = null;
+      return this.wrapPage(page);
+    }
+    return this.wrapPage(await this.context.newPage());
+  }
+  async close() {
+    await this.context.close();
+  }
+  async storageState(options) {
+    await this.context.storageState(options);
+  }
+  async addInitScript(script) {
+    await this.context.addInitScript(script);
+  }
+  on(event, listener) {
+    this.context.on(event, (page) => {
+      listener(this.wrapPage(page));
+    });
+  }
+}
+class PlaywrightPageCompat {
+  constructor(page, owner) {
+    this.page = page;
+    this.owner = owner;
+    this.mouse = this.page.mouse;
+    this.keyboard = this.page.keyboard;
+  }
+  page;
+  owner;
+  mouse;
+  keyboard;
+  getRawPage() {
+    return this.page;
+  }
+  async goto(url, options) {
+    await this.page.goto(url, options);
+  }
+  async evaluate(pageFunction, arg) {
+    return await this.page.evaluate(pageFunction, arg);
+  }
+  url() {
+    return this.page.url();
+  }
+  async getUrl() {
+    return this.page.url();
+  }
+  waitForTimeout(ms) {
+    return this.page.waitForTimeout(ms);
+  }
+  waitForLoadState(state, options) {
+    return this.page.waitForLoadState(state, options);
+  }
+  async waitForSelector(selector, options) {
+    await this.page.waitForSelector(selector, options ?? {});
+  }
+  locator(selector) {
+    return new PlaywrightLocatorCompat(this.page.locator(selector));
+  }
+  close() {
+    return this.page.close();
+  }
+  setDefaultTimeout(ms) {
+    this.page.setDefaultTimeout(ms);
+  }
+  setDefaultNavigationTimeout(ms) {
+    this.page.setDefaultNavigationTimeout(ms);
+  }
+  on(event, listener) {
+    if (event === "console") {
+      this.page.on(event, listener);
+      return;
+    }
+    this.page.on(event, (worker) => {
+      listener(
+        new PlaywrightWorkerCompat(worker)
+      );
+    });
+  }
+  context() {
+    return this.owner;
+  }
+  viewportSize() {
+    return this.page.viewportSize();
+  }
+  async runDomOp(operation, params) {
+    return await runPageDomOp(
+      this.page,
+      operation,
+      params ?? {}
+    );
+  }
+  async ping() {
+    try {
+      await Promise.race([
+        this.page.evaluate(() => true),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("page ping timeout")), 5e3)
+        )
+      ]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async screenshot(options) {
+    return await this.page.screenshot(options ?? {});
+  }
+}
+export {
+  PlaywrightBrowserContextCompat
+};

package/src/citations/browser/gen/lib/browser/proxy/forwarder.js

@@ -0,0 +1,251 @@
+import {
+  request as httpRequest
+} from "node:http";
+import { request as httpsRequest } from "node:https";
+import { connect as netConnect } from "node:net";
+import { connect as tlsConnect } from "node:tls";
+const SOCKET_TIMEOUT_MS = 3e4;
+function buildBasicAuthHeader(proxy) {
+  if (!proxy.username && !proxy.password) return null;
+  const token = Buffer.from(
+    `${proxy.username ?? ""}:${proxy.password ?? ""}`
+  ).toString("base64");
+  return `Basic ${token}`;
+}
+function sanitizeHeaders(headers) {
+  const nextHeaders = { ...headers };
+  delete nextHeaders["proxy-authorization"];
+  delete nextHeaders["proxy-connection"];
+  delete nextHeaders["Proxy-Authorization"];
+  delete nextHeaders["Proxy-Connection"];
+  return nextHeaders;
+}
+function formatHttpTarget(request) {
+  if (!request.url) {
+    throw new Error("Proxy request missing URL");
+  }
+  if (/^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(request.url)) {
+    return new URL(request.url);
+  }
+  if (!request.headers.host) {
+    throw new Error("Proxy request missing Host header");
+  }
+  return new URL(`http://${request.headers.host}${request.url}`);
+}
+function parseAuthority(authority) {
+  if (authority.startsWith("[")) {
+    const closingBracket = authority.indexOf("]");
+    if (closingBracket === -1) {
+      throw new Error(`Invalid authority: ${authority}`);
+    }
+    const host2 = authority.slice(1, closingBracket);
+    const portPart = authority.slice(closingBracket + 1);
+    const port2 = portPart.startsWith(":") ? Number(portPart.slice(1)) : 443;
+    if (!Number.isFinite(port2)) {
+      throw new Error(`Invalid authority port: ${authority}`);
+    }
+    return { host: host2, port: port2 };
+  }
+  const separator = authority.lastIndexOf(":");
+  if (separator === -1) {
+    return { host: authority, port: 443 };
+  }
+  const host = authority.slice(0, separator);
+  const port = Number(authority.slice(separator + 1));
+  if (!host || !Number.isFinite(port)) {
+    throw new Error(`Invalid authority: ${authority}`);
+  }
+  return { host, port };
+}
+function connectTcp(host, port) {
+  return new Promise((resolve, reject) => {
+    const socket = netConnect({ host, port });
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const onConnect = () => {
+      cleanup();
+      socket.setNoDelay(true);
+      socket.setTimeout(SOCKET_TIMEOUT_MS, () => {
+        socket.destroy(new Error("socket timeout"));
+      });
+      resolve(socket);
+    };
+    const cleanup = () => {
+      socket.off("error", onError);
+      socket.off("connect", onConnect);
+    };
+    socket.once("error", onError);
+    socket.once("connect", onConnect);
+  });
+}
+function connectTls(host, port) {
+  return new Promise((resolve, reject) => {
+    const socket = tlsConnect({
+      host,
+      port,
+      servername: host,
+      // Proxy providers (e.g. BrightData) may use custom CA certs.
+      // rejectUnauthorized applies only to the proxy TLS hop, not to the
+      // end-to-end TLS inside the CONNECT tunnel (which the browser validates).
+      rejectUnauthorized: false
+    });
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const onSecureConnect = () => {
+      cleanup();
+      socket.setNoDelay(true);
+      socket.setTimeout(SOCKET_TIMEOUT_MS, () => {
+        socket.destroy(new Error("socket timeout"));
+      });
+      resolve(socket);
+    };
+    const cleanup = () => {
+      socket.off("error", onError);
+      socket.off("secureConnect", onSecureConnect);
+    };
+    socket.once("error", onError);
+    socket.once("secureConnect", onSecureConnect);
+  });
+}
+function readUntilAny(socket, ...delimiters) {
+  return new Promise((resolve, reject) => {
+    const delimiterBuffers = delimiters.map((d) => Buffer.from(d));
+    const chunks = [];
+    let total = 0;
+    const onData = (chunk) => {
+      chunks.push(chunk);
+      total += chunk.length;
+      const payload = Buffer.concat(chunks, total);
+      for (const delimiterBuffer of delimiterBuffers) {
+        const index = payload.indexOf(delimiterBuffer);
+        if (index === -1) continue;
+        cleanup();
+        const end = index + delimiterBuffer.length;
+        const head = payload.subarray(0, end);
+        const tail = payload.subarray(end);
+        if (tail.length > 0) {
+          socket.unshift(tail);
+        }
+        resolve(head);
+        return;
+      }
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const onClose = () => {
+      cleanup();
+      reject(new Error("socket closed before response headers were received"));
+    };
+    const cleanup = () => {
+      socket.off("data", onData);
+      socket.off("error", onError);
+      socket.off("close", onClose);
+    };
+    socket.on("data", onData);
+    socket.once("error", onError);
+    socket.once("close", onClose);
+  });
+}
+async function createTunnelSocket(proxy, targetHost, targetPort) {
+  const socket = proxy.scheme === "https" ? await connectTls(proxy.host, proxy.port) : await connectTcp(proxy.host, proxy.port);
+  const authHeader = buildBasicAuthHeader(proxy);
+  const requestLines = [
+    `CONNECT ${targetHost}:${targetPort} HTTP/1.1`,
+    `Host: ${targetHost}:${targetPort}`,
+    "Proxy-Connection: Keep-Alive"
+  ];
+  if (authHeader) {
+    requestLines.push(`Proxy-Authorization: ${authHeader}`);
+  }
+  requestLines.push("", "");
+  socket.write(requestLines.join("\r\n"));
+  const responseHead = await readUntilAny(socket, "\r\n\r\n", "\n\n");
+  const statusLine = responseHead.toString("latin1").split(/\r?\n/, 1)[0] ?? "";
+  if (!/^HTTP\/1\.[01] 200\b/i.test(statusLine)) {
+    socket.destroy();
+    throw new Error(`Proxy CONNECT failed: ${statusLine || "no response"}`);
+  }
+  return socket;
+}
+function handleProxyError(response, statusCode, error) {
+  if (response.headersSent) {
+    response.destroy(error instanceof Error ? error : void 0);
+    return;
+  }
+  response.writeHead(statusCode, { "Content-Type": "text/plain" });
+  response.end(error instanceof Error ? error.message : "proxy error");
+}
+async function handleHttpProxyRequest(request, response, proxy, trackSocket) {
+  const target = formatHttpTarget(request);
+  const proxyAuthHeader = buildBasicAuthHeader(proxy);
+  const transport = proxy.scheme === "https" ? httpsRequest : httpRequest;
+  const upstreamRequest = transport(
+    {
+      host: proxy.host,
+      port: proxy.port,
+      method: request.method,
+      path: target.toString(),
+      headers: {
+        ...sanitizeHeaders(request.headers),
+        ...proxyAuthHeader ? { "Proxy-Authorization": proxyAuthHeader } : {}
+      },
+      agent: false,
+      // Proxy providers may use custom CA certs; only disable for proxy hop.
+      rejectUnauthorized: false
+    },
+    (upstreamResponse) => {
+      response.writeHead(
+        upstreamResponse.statusCode ?? 502,
+        upstreamResponse.statusMessage,
+        upstreamResponse.headers
+      );
+      upstreamResponse.pipe(response);
+    }
+  );
+  upstreamRequest.on("socket", (socket) => {
+    trackSocket(socket);
+  });
+  upstreamRequest.on("error", (error) => {
+    handleProxyError(response, 502, error);
+  });
+  request.pipe(upstreamRequest);
+}
+function relaySockets(clientSocket, upstreamSocket) {
+  const destroyPair = () => {
+    clientSocket.destroy();
+    upstreamSocket.destroy();
+  };
+  clientSocket.on("error", destroyPair);
+  upstreamSocket.on("error", destroyPair);
+  clientSocket.on("close", () => upstreamSocket.destroy());
+  upstreamSocket.on("close", () => clientSocket.destroy());
+  clientSocket.pipe(upstreamSocket);
+  upstreamSocket.pipe(clientSocket);
+}
+function checkProxyReachable(host, port, timeoutMs = 2e3) {
+  return new Promise((resolve) => {
+    const socket = netConnect({ host, port });
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, timeoutMs);
+    socket.once("connect", () => {
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(true);
+    });
+    socket.once("error", () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
+}
+export {
+  checkProxyReachable
+};

package/src/citations/browser/gen/lib/extraction/sourceUtils.js

@@ -0,0 +1,71 @@
+import { getDomain, getFaviconUrls } from "../../../shims/utils.js";
+const PROVIDER_OWNED_SOURCE_DOMAINS = {
+  chatgpt: ["chatgpt.com", "openai.com"],
+  perplexity: ["perplexity.ai"],
+  gemini: ["gemini.google.com", "google.com"],
+  claude: ["claude.ai", "anthropic.com"],
+  "ai-overview": ["google.com"]
+};
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeSourceTitle(rawTitle, url) {
+  const normalized = rawTitle.replace(/\s+/g, " ").trim();
+  if (!normalized) return normalized;
+  const domain = getDomain(url)?.replace(/^www\./i, "") || "";
+  const hostLabel = domain.split(".")[0] || "";
+  const prefixes = [domain, hostLabel].filter(Boolean);
+  let title = normalized;
+  for (const prefix of prefixes) {
+    title = title.replace(
+      new RegExp(`^${escapeRegExp(prefix)}(?:\\s+|(?=[A-Z]))`, "i"),
+      ""
+    );
+  }
+  return title.trim() || normalized;
+}
+function isProviderOwnedSource(provider, url) {
+  if (!provider) return false;
+  const hostname = (() => {
+    try {
+      return new URL(url).hostname.toLowerCase();
+    } catch {
+      return "";
+    }
+  })();
+  if (!hostname) return false;
+  return (PROVIDER_OWNED_SOURCE_DOMAINS[provider] || []).some(
+    (domain) => hostname === domain || hostname.endsWith(`.${domain}`)
+  );
+}
+function buildSources(rawSources, options) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { rawHref, title: rawTitle, citedText } of rawSources) {
+    const url = rawHref.replace(/#.*$/, "");
+    if (!url) continue;
+    if (isProviderOwnedSource(options?.provider, url)) continue;
+    const domain = getDomain(url) || null;
+    const title = normalizeSourceTitle(rawTitle || "", url) || domain || url;
+    const favicon = getFaviconUrls(domain ?? "")?.[0] ?? null;
+    const source = { title, cited_text: citedText, url, domain, favicon };
+    const dedupeKey = JSON.stringify({
+      domain: source.domain ?? null,
+      url: source.url,
+      title: source.title,
+      cited_text: source.cited_text ?? ""
+    });
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    results.push(source);
+  }
+  return results;
+}
+async function clickButtonViaDispatch(_page, button) {
+  await button.dispatchClick();
+  return true;
+}
+export {
+  buildSources,
+  clickButtonViaDispatch
+};

package/src/citations/browser/gen/lib/input/editor/assertNotBlocked.js

@@ -0,0 +1,54 @@
+import { ExternalServiceError } from "../../../../shims/errors.js";
+async function detectEditorBlocker(page, input) {
+  const box = await input.boundingBox().catch(() => null);
+  if (!box || box.width < 8 || box.height < 8) {
+    return { blocked: false, reason: null };
+  }
+  const insetX = Math.max(6, Math.min(24, box.width * 0.12));
+  const insetY = Math.max(6, Math.min(18, box.height * 0.2));
+  const points = [
+    { x: box.x + box.width / 2, y: box.y + box.height / 2 },
+    { x: box.x + insetX, y: box.y + insetY },
+    { x: box.x + box.width - insetX, y: box.y + insetY }
+  ];
+  return await page.evaluate((samples) => {
+    const isEditorLike = (element) => Boolean(
+      element?.closest(
+        '[contenteditable="true"], textarea, input, [role="textbox"], [role="combobox"]'
+      )
+    );
+    for (const sample of samples) {
+      const top = document.elementFromPoint(sample.x, sample.y);
+      if (!top) continue;
+      if (isEditorLike(top)) continue;
+      const blocker = top.closest(
+        '[role="dialog"], [aria-modal="true"], [popover], [data-state="open"]'
+      ) || top;
+      if (!(blocker instanceof HTMLElement)) continue;
+      const style = window.getComputedStyle(blocker);
+      if (style.display === "none" || style.visibility === "hidden" || style.pointerEvents === "none") {
+        continue;
+      }
+      const rect = blocker.getBoundingClientRect();
+      if (rect.width < 120 || rect.height < 40) continue;
+      const text = (blocker.textContent || "").replace(/\s+/g, " ").trim();
+      const label = blocker.getAttribute("aria-label") || blocker.getAttribute("role") || blocker.tagName.toLowerCase();
+      return {
+        blocked: true,
+        reason: `${label}:${text.slice(0, 120)}`
+      };
+    }
+    return { blocked: false, reason: null };
+  }, points);
+}
+async function ensureEditorNotBlocked(page, input, provider) {
+  const result = await detectEditorBlocker(page, input);
+  if (!result.blocked) return;
+  throw new ExternalServiceError(
+    provider,
+    `Editor blocked by overlay: ${result.reason ?? "unknown blocker"}`
+  );
+}
+export {
+  ensureEditorNotBlocked
+};