agentlinkops 0.6.1 → 0.6.3

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

@@ -1,251 +0,0 @@
-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/input/editor/assertNotBlocked.js

@@ -1,54 +0,0 @@
-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
-};

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

@@ -1,21 +0,0 @@
-import { PROVIDER_SUBMIT_BTN_SELECTORS } from "../../../../shims/utils.js";
-async function findEnabledSendButton(page, provider) {
-  const selectors = PROVIDER_SUBMIT_BTN_SELECTORS[provider] || [];
-  for (const selector of selectors) {
-    const buttons = page.locator(selector);
-    const count = await buttons.count();
-    for (let i = 0; i < count; i++) {
-      const btn = buttons.nth(i);
-      try {
-        if (await btn.isVisible() && await btn.isEnabled()) {
-          return btn;
-        }
-      } catch {
-      }
-    }
-  }
-  return null;
-}
-export {
-  findEnabledSendButton
-};

package/src/citations/browser/gen/lib/input/response/getText.js

@@ -1,10 +0,0 @@
-import { PROVIDER_MODEL_RESPONSE_SELECTORS } from "../../../../shims/utils.js";
-async function getText(page, provider) {
-  return await page.runDomOp("response-text", {
-    provider,
-    selectors: PROVIDER_MODEL_RESPONSE_SELECTORS[provider] || []
-  });
-}
-export {
-  getText
-};

package/src/citations/fixtures/dataforseo-aio.json

@@ -1,82 +0,0 @@
-{
-  "version": "0.0.0",
-  "status_code": 20000,
-  "status_message": "Ok.",
-  "cost": 0.0012,
-  "tasks_count": 1,
-  "tasks_error": 0,
-  "tasks": [
-    {
-      "id": "09211815-1535-0067-0000-7b8e2b4e5c91",
-      "status_code": 20000,
-      "status_message": "Ok.",
-      "cost": 0.0012,
-      "result_count": 1,
-      "result": [
-        {
-          "keyword": "what is backlink monitoring",
-          "type": "organic",
-          "se_domain": "google.com",
-          "location_code": 2840,
-          "language_code": "en",
-          "check_url": "https://www.google.com/search?q=what%20is%20backlink%20monitoring&num=10&hl=en&gl=us&gws_rd=cr",
-          "datetime": "2026-09-18 18:15:03 +00:00",
-          "item_types": ["ai_overview", "organic", "featured_snippet", "people_also_ask"],
-          "se_results_count": 12400000,
-          "items": [
-            {
-              "type": "ai_overview",
-              "rank_group": 1,
-              "rank_absolute": 1,
-              "position": "top",
-              "xpath": "/html[1]/body[1]/div[6]/div[2]/div[9]/div[1]/div[2]/div[2]/div[1]/div[1]",
-              "text": "Backlink monitoring is the process of regularly tracking and analyzing the links pointing to your website from other sites. It involves checking whether your existing backlinks are still active, identifying new backlinks as they appear, and analyzing the quality and relevance of those links. Effective backlink monitoring helps you maintain a healthy link profile, identify potentially harmful links, and find opportunities for new link building. Common tools for backlink monitoring include Ahrefs, Semrush, and Moz, which provide comprehensive dashboards for tracking your link profile over time.",
-              "items": [
-                {
-                  "type": "ai_overview_item",
-                  "source": "backlinkmonitoring.ai",
-                  "domain": "backlinkmonitoring.ai",
-                  "title": "What Is Backlink Monitoring and Why It Matters",
-                  "url": "https://backlinkmonitoring.ai/blog/what-is-backlink-monitoring",
-                  "snippet": "Backlink monitoring is the practice of regularly tracking and analyzing inbound links to your website..."
-                },
-                {
-                  "type": "ai_overview_item",
-                  "source": "adaptify.ai",
-                  "domain": "adaptify.ai",
-                  "title": "What is Backlink Monitoring and Why Your SEO Needs It",
-                  "url": "https://adaptify.ai/blog/what-is-backlink-monitoring-and-why-your-seo-needs-it",
-                  "snippet": "Effective backlink monitoring helps you maintain a healthy link profile and identify harmful links..."
-                },
-                {
-                  "type": "ai_overview_item",
-                  "source": "lynkdog.com",
-                  "domain": "lynkdog.com",
-                  "title": "Backlink Monitoring: A Complete Beginner's Guide",
-                  "url": "https://lynkdog.com/blog/backlink-monitoring-beginners-guide",
-                  "snippet": "Backlink monitoring involves checking whether your existing backlinks are still active..."
-                },
-                {
-                  "type": "ai_overview_item",
-                  "source": "brand24.com",
-                  "domain": "brand24.com",
-                  "title": "Backlinks Monitoring 101: Tools, Tips, and Best Practices",
-                  "url": "https://brand24.com/blog/backlinks-monitoring-101/",
-                  "snippet": "Common tools for backlink monitoring include Ahrefs, Semrush, and Moz..."
-                }
-              ]
-            },
-            {
-              "type": "organic",
-              "rank_group": 1,
-              "rank_absolute": 2,
-              "url": "https://backlinko.com/hub/seo/backlinks",
-              "domain": "backlinko.com",
-              "title": "What Are Backlinks in SEO & Why You Need Them"
-            }
-          ]
-        }
-      ]
-    }
-  ]
-}