@duckmind/dm-windows-x64 0.63.0 → 0.63.4

package/extensions/dm-web-access/brightdata.js

@@ -0,0 +1,334 @@
+import { existsSync, readFileSync } from "node:fs";
+import { activityMonitor } from "./activity.js";
+import { hasCredentialSource, redactCredential, resolveCredential } from "./credential-source.js";
+import { getWebSearchConfigPath } from "./utils.js";
+const BRIGHTDATA_API_URL = "https://api.brightdata.com/request";
+const CONFIG_PATH = getWebSearchConfigPath();
+const SEARCH_TIMEOUT_MS = 60000;
+const ZONE_PATTERN = /^[A-Za-z0-9_-]+$/;
+const RECENCY_TBS = {
+  day: "qdr:d",
+  week: "qdr:w",
+  month: "qdr:m",
+  year: "qdr:y"
+};
+let cachedConfig = null;
+function configParseDetail(err) {
+  const position = errorMessage(err).match(/at position \d+(?: \(line \d+ column \d+\))?/i);
+  return position ? `not valid JSON, ${position[0]}` : "not valid JSON";
+}
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH)) {
+    cachedConfig = {};
+    return cachedConfig;
+  }
+  const raw = readFileSync(CONFIG_PATH, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${configParseDetail(err)}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Invalid config in ${CONFIG_PATH}: expected a JSON object`);
+  }
+  cachedConfig = parsed;
+  return cachedConfig;
+}
+async function getApiKey(signal) {
+  return resolveCredential({
+    provider: "Bright Data",
+    configuredValue: loadConfig().brightdataApiKey,
+    environmentValue: process.env.BRIGHTDATA_API_KEY,
+    signal
+  });
+}
+async function requireApiKey(signal) {
+  const apiKey = await getApiKey(signal);
+  if (!apiKey) {
+    throw new Error(`Bright Data API key not found. Either:
+` + `  1. Create ${CONFIG_PATH} with { "brightdataApiKey": "your-key" }
+` + `  2. Set BRIGHTDATA_API_KEY environment variable
+` + "Get a key at https://brightdata.com/cp/setting/users");
+  }
+  return apiKey;
+}
+function normalizeZone(value) {
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return null;
+  return ZONE_PATTERN.test(trimmed) ? trimmed : null;
+}
+function serpZoneSetting() {
+  const fromEnv = process.env.BRIGHTDATA_SERP_ZONE;
+  if (typeof fromEnv === "string" && fromEnv.trim()) {
+    return { raw: fromEnv.trim(), label: "BRIGHTDATA_SERP_ZONE" };
+  }
+  const configured = loadConfig().brightdataSerpZone;
+  if (typeof configured === "string" && configured.trim()) {
+    return { raw: configured.trim(), label: `brightdataSerpZone in ${CONFIG_PATH}` };
+  }
+  return null;
+}
+function getSerpZone() {
+  const setting = serpZoneSetting();
+  return setting ? normalizeZone(setting.raw) : null;
+}
+function requireSerpZone() {
+  const setting = serpZoneSetting();
+  const zone = setting ? normalizeZone(setting.raw) : null;
+  if (zone)
+    return zone;
+  if (setting) {
+    throw new Error(`Bright Data SERP zone is invalid: ${setting.label} must be a zone name of letters, digits, "-", or "_" ` + `(got "${untrustedText(setting.raw, 60)}").
+` + "The zone must be of Bright Data type `serp`; a Web Unlocker zone (type `unblocker`) is a different product and does not return SERP JSON.\n" + "Create or rename one at https://brightdata.com/cp/zones");
+  }
+  throw new Error(`Bright Data SERP zone is invalid or missing. Either:
+` + `  1. Create ${CONFIG_PATH} with { "brightdataSerpZone": "your_serp_zone" }
+` + `  2. Set BRIGHTDATA_SERP_ZONE environment variable
+` + "The zone must be of Bright Data type `serp`; a Web Unlocker zone is a different product and does not return SERP JSON.\n" + "Create one at https://brightdata.com/cp/zones");
+}
+function normalizeCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return 5;
+  return Math.max(1, Math.min(Math.floor(value), 20));
+}
+function normalizeDomain(value) {
+  let input = value.trim().toLowerCase();
+  if (!input)
+    return null;
+  if (input.startsWith("-"))
+    input = input.slice(1).trim();
+  if (!input)
+    return null;
+  try {
+    const parsed = input.includes("://") ? new URL(input) : new URL(`https://${input}`);
+    input = parsed.hostname;
+  } catch {
+    input = input.split("/")[0]?.split(":")[0] ?? "";
+  }
+  input = input.replace(/^\.+|\.+$/g, "");
+  return /^[a-z0-9][a-z0-9.-]*\.[a-z]{2,}$/i.test(input) ? input : null;
+}
+function parseDomainFilter(domainFilter) {
+  const filters = { include: [], exclude: [] };
+  if (!domainFilter?.length)
+    return filters;
+  for (const raw of domainFilter) {
+    const domain = normalizeDomain(raw);
+    if (!domain)
+      continue;
+    const target = raw.trim().startsWith("-") ? filters.exclude : filters.include;
+    if (!target.includes(domain))
+      target.push(domain);
+  }
+  return filters;
+}
+function buildSearchQuery(query, filters) {
+  const parts = [query];
+  if (filters.include.length === 1) {
+    parts.push(`site:${filters.include[0]}`);
+  } else if (filters.include.length > 1) {
+    parts.push(filters.include.map((domain) => `site:${domain}`).join(" OR "));
+  }
+  for (const domain of filters.exclude) {
+    parts.push(`-site:${domain}`);
+  }
+  return parts.join(" ");
+}
+function buildSerpUrl(searchQuery, numResults, recencyFilter) {
+  const params = new URLSearchParams({ q: searchQuery });
+  params.set("num", String(Math.min(numResults + 5, 20)));
+  const tbs = recencyFilter ? RECENCY_TBS[recencyFilter] : undefined;
+  if (tbs)
+    params.set("tbs", tbs);
+  params.set("brd_json", "1");
+  return `https://www.google.com/search?${params.toString()}`;
+}
+function domainMatches(hostname, domain) {
+  return hostname === domain || hostname.endsWith(`.${domain}`);
+}
+function passesDomainFilters(url, filters) {
+  if (filters.include.length === 0 && filters.exclude.length === 0)
+    return true;
+  let hostname;
+  try {
+    hostname = new URL(url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  if (filters.exclude.some((domain) => domainMatches(hostname, domain)))
+    return false;
+  if (filters.include.length === 0)
+    return true;
+  return filters.include.some((domain) => domainMatches(hostname, domain));
+}
+function requestSignal(signal) {
+  const timeout = AbortSignal.timeout(SEARCH_TIMEOUT_MS);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+const STATUS_SHAPED_PATTERN = /\b(?:error|status|http)[\s:=-]{1,4}(\d{3})\b/gi;
+const QUOTA_SHAPED_PATTERN = /rate limit|quota|too many requests/gi;
+function untrustedText(text, limit = 300) {
+  return text.replace(/\s+/g, " ").trim().slice(0, limit).replace(STATUS_SHAPED_PATTERN, "upstream $1").replace(QUOTA_SHAPED_PATTERN, "upstream rate-limit notice");
+}
+function invalidResponse(zone, message) {
+  return new Error(`Bright Data API returned invalid response for zone ${zone}: ${message}`);
+}
+function envelopeError(envelope, apiKey) {
+  const parts = [];
+  const { error, errors } = envelope;
+  if (typeof error === "string" && error.trim())
+    parts.push(error.trim());
+  else if (error && typeof error === "object")
+    parts.push(JSON.stringify(error));
+  if (Array.isArray(errors) && errors.length > 0)
+    parts.push(JSON.stringify(errors));
+  else if (typeof errors === "string" && errors.trim())
+    parts.push(errors.trim());
+  if (parts.length === 0)
+    return null;
+  for (const key of ["code", "error_code"]) {
+    const code = envelope[key];
+    if (typeof code === "string" && code.trim())
+      parts.push(`${key} ${code.trim()}`);
+    else if (typeof code === "number")
+      parts.push(`${key} ${code}`);
+  }
+  return untrustedText(redactCredential(parts.join(", "), apiKey), 200);
+}
+function parseSerpResponse(value, zone, apiKey) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw invalidResponse(zone, "expected an object envelope");
+  }
+  const envelope = value;
+  const upstreamError = envelopeError(envelope, apiKey);
+  if (upstreamError) {
+    throw invalidResponse(zone, `Bright Data reported an error instead of a SERP: ${upstreamError}`);
+  }
+  if (envelope.organic === undefined || envelope.organic === null) {
+    throw invalidResponse(zone, "expected an organic array and the envelope carried none. A `serp` zone queried with brd_json=1 " + "returns { organic: [...] }; a zone of type `unblocker`, or a missing brd_json=1, is the usual cause");
+  }
+  if (!Array.isArray(envelope.organic))
+    throw invalidResponse(zone, "expected organic array");
+  const organic = [];
+  for (const [index, entry] of envelope.organic.entries()) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw invalidResponse(zone, `expected organic[${index}] object`);
+    }
+    organic.push(entry);
+  }
+  return { organic };
+}
+function mapResults(organic, numResults, filters) {
+  if (!Array.isArray(organic))
+    return [];
+  const mapped = [];
+  for (const item of organic) {
+    const url = typeof item.link === "string" ? item.link.trim() : "";
+    if (!url || !passesDomainFilters(url, filters))
+      continue;
+    const title = typeof item.title === "string" ? item.title.trim() : "";
+    mapped.push({
+      title: title || `Source ${mapped.length + 1}`,
+      url,
+      snippet: typeof item.description === "string" ? item.description.replace(/\s+/g, " ").trim() : ""
+    });
+    if (mapped.length >= numResults)
+      break;
+  }
+  return mapped;
+}
+function buildAnswer(results) {
+  return results.map((result) => result.snippet ? `${result.snippet}
+Source: ${result.title} (${result.url})` : `Source: ${result.title} (${result.url})`).join(`
+
+`);
+}
+export function isBrightDataAvailable() {
+  try {
+    if (getSerpZone() === null)
+      return false;
+    return hasCredentialSource({
+      provider: "Bright Data",
+      configuredValue: loadConfig().brightdataApiKey,
+      environmentValue: process.env.BRIGHTDATA_API_KEY
+    });
+  } catch {
+    return false;
+  }
+}
+export async function searchWithBrightData(query, options = {}) {
+  const zone = requireSerpZone();
+  const apiKey = await requireApiKey(options.signal);
+  const numResults = normalizeCount(options.numResults);
+  const filters = parseDomainFilter(options.domainFilter);
+  const searchQuery = buildSearchQuery(query, filters);
+  const body = {
+    url: buildSerpUrl(searchQuery, numResults, options.recencyFilter),
+    zone,
+    format: "raw",
+    data_format: "parsed_light"
+  };
+  const activityId = activityMonitor.logStart({ type: "api", query: searchQuery });
+  let response;
+  try {
+    response = await fetch(BRIGHTDATA_API_URL, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: requestSignal(options.signal)
+    });
+  } catch (err) {
+    const message = errorMessage(err);
+    const redactedMessage = redactCredential(message, apiKey);
+    if (redactedMessage.toLowerCase().includes("abort"))
+      activityMonitor.logComplete(activityId, 0);
+    else
+      activityMonitor.logError(activityId, redactedMessage);
+    if (redactedMessage === message)
+      throw err;
+    const redactedError = new Error(redactedMessage);
+    if (err instanceof Error)
+      redactedError.name = err.name;
+    throw redactedError;
+  }
+  if (!response.ok) {
+    activityMonitor.logComplete(activityId, response.status);
+    const errorText = untrustedText(redactCredential(await response.text(), apiKey));
+    throw new Error(`Bright Data API error ${response.status} for zone ${zone}: ${errorText}`);
+  }
+  const raw = await response.text();
+  if (!raw.trim()) {
+    activityMonitor.logComplete(activityId, response.status);
+    throw new Error(`Bright Data API returned empty response for zone ${zone}`);
+  }
+  let rawData;
+  try {
+    rawData = JSON.parse(raw);
+  } catch (err) {
+    activityMonitor.logComplete(activityId, response.status);
+    const body = untrustedText(redactCredential(raw, apiKey));
+    throw new Error(`Bright Data API returned invalid JSON for zone ${zone}: ${body}`);
+  }
+  let data;
+  try {
+    data = parseSerpResponse(rawData, zone, apiKey);
+  } catch (err) {
+    activityMonitor.logComplete(activityId, response.status);
+    throw err;
+  }
+  activityMonitor.logComplete(activityId, response.status);
+  const results = mapResults(data.organic, numResults, filters);
+  return { answer: buildAnswer(results), results };
+}