tianshu-harness 3.23.0

package/dist/chunk-J4U4AW46.js

@@ -0,0 +1,440 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  resolveProxyForUrl
+} from "./chunk-2HDP7RMR.js";
+import {
+  require_undici
+} from "./chunk-O5VZQKCB.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/tools/web-search/build-backends.ts
+init_esm_shims();
+
+// src/tools/web-search/duckduckgo.ts
+init_esm_shims();
+function parseDuckDuckGoResults(html, maxCount) {
+  const results = [];
+  const titleBlocks = html.split('<h2 class="result__title">');
+  for (let i = 1; i < titleBlocks.length && results.length < maxCount; i++) {
+    const block = titleBlocks[i];
+    const linkMatch = block.match(/<a[^>]+class="result__a"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/i);
+    if (!linkMatch) continue;
+    const url = decodeHtmlEntities(linkMatch[1]);
+    const title = decodeHtmlEntities(stripHtml(linkMatch[2])).trim();
+    if (!title || !url) continue;
+    const snippetMatch = block.match(/<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/i);
+    const snippet = snippetMatch ? decodeHtmlEntities(stripHtml(snippetMatch[1])).trim() : "";
+    const actualUrl = extractActualUrl(url);
+    results.push({ title, url: actualUrl, snippet });
+  }
+  return results;
+}
+function stripHtml(text) {
+  return text.replace(/<[^>]+>/g, "").trim();
+}
+function decodeHtmlEntities(text) {
+  return text.replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos|#39|nbsp|ensp|emsp|thinsp|rsaquo|lsaquo);/g, (m, e) => {
+    switch (e) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return '"';
+      case "apos":
+      case "#39":
+        return "'";
+      case "nbsp":
+        return "\xA0";
+      case "ensp":
+        return "\u2002";
+      case "emsp":
+        return "\u2003";
+      case "thinsp":
+        return "\u2009";
+      case "rsaquo":
+        return "\u203A";
+      case "lsaquo":
+        return "\u2039";
+    }
+    const code = e[1] === "x" || e[1] === "X" ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10);
+    return Number.isFinite(code) && code > 0 ? String.fromCodePoint(code) : m;
+  });
+}
+function extractActualUrl(ddgUrl) {
+  try {
+    const parsed = new URL(ddgUrl.replace(/^\/\//, "https://"));
+    const uddg = parsed.searchParams.get("uddg");
+    if (uddg) {
+      const decoded = decodeURIComponent(uddg);
+      return /^https?:\/\//i.test(decoded) ? decoded : ddgUrl;
+    }
+    const u = parsed.searchParams.get("u");
+    if (u) {
+      const decoded = decodeURIComponent(u);
+      return /^https?:\/\//i.test(decoded) ? decoded : ddgUrl;
+    }
+  } catch {
+  }
+  return ddgUrl;
+}
+var DuckDuckGoBackend = class {
+  constructor(fetchImpl) {
+    this.fetchImpl = fetchImpl;
+  }
+  fetchImpl;
+  name = "duckduckgo";
+  isAvailable() {
+    return true;
+  }
+  async search(query, count, signal) {
+    const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+    const response = await this.fetchImpl(url, {
+      signal,
+      headers: { "User-Agent": "terminal-coding-agent/1.0" },
+      redirect: "manual"
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const html = await response.text();
+    return parseDuckDuckGoResults(html, count);
+  }
+};
+
+// src/tools/web-search/bing.ts
+init_esm_shims();
+var BING_ENDPOINT = "https://cn.bing.com/search";
+var BING_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+function parseBingResults(html, maxCount) {
+  const results = [];
+  const blocks = html.split('<li class="b_algo');
+  for (let i = 1; i < blocks.length && results.length < maxCount; i++) {
+    const block = blocks[i];
+    const linkMatch = extractTitleLink(block);
+    if (!linkMatch) continue;
+    const rawUrl = decodeHtmlEntities(linkMatch.url);
+    const url = decodeCkAUrl(rawUrl);
+    const title = decodeHtmlEntities(stripHtml2(linkMatch.title)).replace(/\s+/g, " ").trim();
+    if (!title || !url || !/^https?:\/\//i.test(url)) continue;
+    const snippetMatch = block.match(/<p[^>]+class="b_lineclamp\d"[^>]*>([\s\S]*?)<\/p>/i);
+    const snippet = snippetMatch ? decodeHtmlEntities(stripHtml2(snippetMatch[1])).replace(/\s+/g, " ").trim() : "";
+    results.push({ title, url, snippet });
+  }
+  return results;
+}
+function extractTitleLink(block) {
+  const h2 = block.match(/<h2[^>]*>([\s\S]*?)<\/h2>/i);
+  if (h2) {
+    const m2 = h2[1].match(/<a[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/i);
+    if (m2) return { url: m2[1], title: m2[2] };
+  }
+  const head = block.slice(0, 4096);
+  const anchorRe = /<a[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+  let m;
+  while ((m = anchorRe.exec(head)) !== null) {
+    const href = m[1];
+    if (!/^https?:\/\//i.test(href)) continue;
+    if (isBingInternalUrl(href)) continue;
+    return { url: href, title: m[2] };
+  }
+  return void 0;
+}
+function isBingInternalUrl(url) {
+  try {
+    const host = new URL(url).hostname.toLowerCase();
+    return host.endsWith(".bing.com") || host.endsWith(".microsoft.com") || host === "go.microsoft.com" || host === "r.bing.com";
+  } catch {
+    return false;
+  }
+}
+function stripHtml2(text) {
+  return text.replace(/<[^>]+>/g, "");
+}
+function decodeCkAUrl(rawUrl) {
+  if (!rawUrl.includes("/ck/a")) return rawUrl;
+  try {
+    const parsed = new URL(rawUrl);
+    const u = parsed.searchParams.get("u");
+    if (!u) return rawUrl;
+    const b64 = u.slice(2).replace(/-/g, "+").replace(/_/g, "/");
+    const padded = b64 + "===".slice((b64.length + 3) % 4);
+    const decoded = Buffer.from(padded, "base64").toString("utf8");
+    return /^https?:\/\//i.test(decoded) ? decoded : rawUrl;
+  } catch {
+    return rawUrl;
+  }
+}
+var BingBackend = class {
+  constructor(fetchImpl) {
+    this.fetchImpl = fetchImpl;
+  }
+  fetchImpl;
+  name = "bing";
+  isAvailable() {
+    return true;
+  }
+  async search(query, count, signal) {
+    const url = `${BING_ENDPOINT}?q=${encodeURIComponent(query)}`;
+    const response = await this.fetchImpl(url, {
+      signal,
+      headers: {
+        "User-Agent": BING_UA,
+        "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.5"
+      },
+      redirect: "manual"
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const html = await response.text();
+    return parseBingResults(html, count);
+  }
+};
+
+// src/tools/web-search/brave.ts
+init_esm_shims();
+var BRAVE_ENDPOINT = "https://api.search.brave.com/res/v1/web/search";
+var BraveBackend = class {
+  constructor(fetchImpl, apiKey, region) {
+    this.fetchImpl = fetchImpl;
+    this.apiKey = apiKey;
+    this.region = region;
+  }
+  fetchImpl;
+  apiKey;
+  region;
+  name = "brave";
+  isAvailable() {
+    return typeof this.apiKey === "string" && this.apiKey.length > 0;
+  }
+  async search(query, count, signal) {
+    const params = new URLSearchParams({ q: query, count: String(count) });
+    if (this.region) params.set("country", this.region);
+    const response = await this.fetchImpl(`${BRAVE_ENDPOINT}?${params.toString()}`, {
+      signal,
+      headers: {
+        Accept: "application/json",
+        "Accept-Encoding": "gzip",
+        "X-Subscription-Token": this.apiKey ?? ""
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    const raw = data.web?.results ?? [];
+    const results = [];
+    for (const r of raw) {
+      if (!r.url || !r.title) continue;
+      results.push({ title: r.title, url: r.url, snippet: r.description ?? "" });
+      if (results.length >= count) break;
+    }
+    return results;
+  }
+};
+
+// src/tools/web-search/tavily.ts
+init_esm_shims();
+var TAVILY_ENDPOINT = "https://api.tavily.com/search";
+var TavilyBackend = class {
+  constructor(fetchImpl, apiKey) {
+    this.fetchImpl = fetchImpl;
+    this.apiKey = apiKey;
+  }
+  fetchImpl;
+  apiKey;
+  name = "tavily";
+  isAvailable() {
+    return typeof this.apiKey === "string" && this.apiKey.length > 0;
+  }
+  async search(query, count, signal) {
+    const response = await this.fetchImpl(TAVILY_ENDPOINT, {
+      signal,
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey ?? ""}`
+      },
+      body: JSON.stringify({ query, max_results: count })
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    const raw = data.results ?? [];
+    const results = [];
+    for (const r of raw) {
+      if (!r.url || !r.title) continue;
+      results.push({ title: r.title, url: r.url, snippet: r.content ?? "" });
+      if (results.length >= count) break;
+    }
+    return results;
+  }
+};
+
+// src/tools/web-search/bocha.ts
+init_esm_shims();
+var BOCHA_ENDPOINT = "https://api.bochaai.com/v1/web-search";
+var BochaBackend = class {
+  constructor(fetchImpl, apiKey) {
+    this.fetchImpl = fetchImpl;
+    this.apiKey = apiKey;
+  }
+  fetchImpl;
+  apiKey;
+  name = "bocha";
+  isAvailable() {
+    return typeof this.apiKey === "string" && this.apiKey.length > 0;
+  }
+  async search(query, count, signal) {
+    const response = await this.fetchImpl(BOCHA_ENDPOINT, {
+      signal,
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey ?? ""}`
+      },
+      body: JSON.stringify({ query, count, summary: true })
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    if (data.code && data.code !== 200) {
+      throw new Error(`bocha ${data.code}: ${data.msg ?? "unknown error"}`);
+    }
+    const raw = data.data?.webPages?.value ?? [];
+    const results = [];
+    for (const r of raw) {
+      if (!r.url || !r.name) continue;
+      const snippet = r.summary || r.snippet || "";
+      const result = { title: r.name, url: r.url, snippet };
+      if (r.siteName) result.siteName = r.siteName;
+      if (r.datePublished) result.publishedAt = r.datePublished;
+      results.push(result);
+      if (results.length >= count) break;
+    }
+    return results;
+  }
+};
+
+// src/tools/web-search/proxy-fetch.ts
+init_esm_shims();
+var import_undici = __toESM(require_undici(), 1);
+
+// src/tools/web-search/bounded-fetch.ts
+init_esm_shims();
+var DEFAULT_MAX_SEARCH_BYTES = 8 * 1024 * 1024;
+function boundedSearchFetch(fetchImpl, maxBytes = DEFAULT_MAX_SEARCH_BYTES) {
+  return async (url, init) => {
+    const res = await fetchImpl(url, init);
+    if (!res.body) return res;
+    const reader = res.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value && value.byteLength > 0) {
+          total += value.byteLength;
+          if (total > maxBytes) {
+            await reader.cancel().catch(() => {
+            });
+            throw new Error(`search response body exceeded ${maxBytes}-byte cap`);
+          }
+          chunks.push(Buffer.from(value));
+        }
+      }
+    } finally {
+      try {
+        reader.releaseLock();
+      } catch {
+      }
+    }
+    const headers = new Headers(res.headers);
+    headers.delete("content-encoding");
+    headers.delete("content-length");
+    return new Response(Buffer.concat(chunks, total), {
+      status: res.status,
+      statusText: res.statusText,
+      headers
+    });
+  };
+}
+
+// src/tools/web-search/proxy-fetch.ts
+function createProxyAwareFetch(proxyOpts, fetchImpl = import_undici.fetch) {
+  const bounded = boundedSearchFetch(fetchImpl);
+  return async (url, init) => {
+    const proxyUrl = resolveProxyForUrl(url, proxyOpts);
+    if (!proxyUrl) return bounded(url, init);
+    const merged = { ...init };
+    merged.dispatcher = new import_undici.ProxyAgent({ uri: proxyUrl });
+    return bounded(url, merged);
+  };
+}
+
+// src/tools/web-search/build-backends.ts
+function resolveSearchKey(config, env, backend) {
+  const s = config.search;
+  const inlineKey = s[`${backend}ApiKey`];
+  if (typeof inlineKey === "string" && inlineKey.length > 0) return inlineKey;
+  const envName = s[`${backend}ApiKeyEnv`];
+  if (typeof envName === "string" && envName.length > 0) {
+    const v = env[envName];
+    if (v) return v;
+  }
+  return env[`${backend.toUpperCase()}_API_KEY`];
+}
+function buildSearchBackends(config, deps = {}) {
+  const fetchImpl = deps.fetch ?? createProxyAwareFetch(deps.proxy);
+  const env = deps.env ?? process.env;
+  const backends = [];
+  for (const name of config.search.backends) {
+    switch (name) {
+      case "bing":
+        backends.push(new BingBackend(fetchImpl));
+        break;
+      case "duckduckgo":
+        backends.push(new DuckDuckGoBackend(fetchImpl));
+        break;
+      case "brave":
+        backends.push(new BraveBackend(fetchImpl, resolveSearchKey(config, env, "brave"), config.search.region));
+        break;
+      case "tavily":
+        backends.push(new TavilyBackend(fetchImpl, resolveSearchKey(config, env, "tavily")));
+        break;
+      case "bocha":
+        backends.push(new BochaBackend(fetchImpl, resolveSearchKey(config, env, "bocha")));
+        break;
+      default:
+        break;
+    }
+  }
+  if (backends.length === 0) {
+    backends.push(new DuckDuckGoBackend(fetchImpl));
+  }
+  return backends;
+}
+
+export {
+  parseDuckDuckGoResults,
+  decodeHtmlEntities,
+  DuckDuckGoBackend,
+  createProxyAwareFetch,
+  BingBackend,
+  BraveBackend,
+  TavilyBackend,
+  resolveSearchKey,
+  buildSearchBackends
+};