@tool-bridge/server 0.21.1 → 0.22.1

package/dist/chunk-7ISGFRC6.js

@@ -0,0 +1,161 @@
+import {
+  TBError
+} from "./chunk-HA4BGL6C.js";
+
+// ../plugins/src/_runtime/ipPolicy.ts
+import ipaddr from "ipaddr.js";
+function isStrictIpv4(value) {
+  return ipaddr.IPv4.isValidFourPartDecimal(value) && value.split(".").every((part) => part === "0" || !part.startsWith("0"));
+}
+function parseAddress(value) {
+  let text = value;
+  if (text.startsWith("[") && text.endsWith("]")) text = text.slice(1, -1);
+  const embeddedIpv4 = text.includes(".") ? text.slice(text.lastIndexOf(":") + 1) : void 0;
+  if (embeddedIpv4 !== void 0 && !isStrictIpv4(embeddedIpv4)) return void 0;
+  try {
+    if (isStrictIpv4(text)) return ipaddr.IPv4.parse(text);
+    if (ipaddr.IPv6.isValid(text)) return ipaddr.IPv6.parse(text);
+  } catch {
+  }
+  return void 0;
+}
+function classifyIpv4(octets) {
+  const a = octets[0];
+  const b = octets[1];
+  const c = octets[2];
+  if (a === 0) return "blocked";
+  if (a === 10) return "blocked";
+  if (a === 127) return "blocked";
+  if (a === 169 && b === 254) return "blocked";
+  if (a === 172 && b >= 16 && b <= 31) return "blocked";
+  if (a === 192 && b === 0 && c === 0) return "blocked";
+  if (a === 192 && b === 0 && c === 2) return "blocked";
+  if (a === 192 && b === 168) return "blocked";
+  if (a === 198 && (b === 18 || b === 19)) return "blocked";
+  if (a === 198 && b === 51 && c === 100) return "blocked";
+  if (a === 203 && b === 0 && c === 113) return "blocked";
+  if (a === 100 && b >= 64 && b <= 127) return "blocked";
+  if (a >= 224) return "blocked";
+  return "public";
+}
+function classifyIpv6(bytes) {
+  const isZero = bytes.every((byte) => byte === 0);
+  if (isZero) return "blocked";
+  if (bytes.slice(0, 15).every((byte) => byte === 0) && bytes[15] === 1) return "blocked";
+  const v4Mapped = bytes.slice(0, 10).every((byte) => byte === 0) && (bytes[10] === 255 && bytes[11] === 255 || bytes[10] === 0 && bytes[11] === 0);
+  if (v4Mapped) {
+    return classifyIpv4([bytes[12], bytes[13], bytes[14], bytes[15]]);
+  }
+  const first = bytes[0];
+  if ((first & 254) === 252) return "blocked";
+  if (first === 254 && (bytes[1] & 192) === 128) return "blocked";
+  if (first === 255) return "blocked";
+  if (first === 32 && bytes[1] === 1 && bytes[2] === 13 && bytes[3] === 184) return "blocked";
+  return "public";
+}
+function isIpAddress(value) {
+  return parseAddress(value) !== void 0;
+}
+function classifyIpAddress(address) {
+  const parsed = parseAddress(address);
+  if (parsed === void 0) return "blocked";
+  if (parsed instanceof ipaddr.IPv4) return classifyIpv4(parsed.octets);
+  const bytes = new Uint8Array(parsed.toByteArray());
+  if (parsed.isIPv4MappedAddress()) return classifyIpv4(parsed.toIPv4Address().octets);
+  return classifyIpv6(bytes);
+}
+
+// ../plugins/src/_runtime/guardedFetch.ts
+var MAX_REDIRECTS = 5;
+var CROSS_ORIGIN_STRIPPED_HEADERS = [
+  "authorization",
+  "cookie",
+  "proxy-authorization"
+  // 各家自定义的密钥头没有统一命名,凡是名字里带 key/token/secret 的一律剥掉:
+  // 宁可让跨源跳转少带一个无关头,也不能漏带走一个凭证。
+];
+var REQUEST_BODY_HEADERS = [
+  "content-encoding",
+  "content-language",
+  "content-location",
+  "content-type"
+];
+function looksLikeCredentialHeader(name) {
+  return /(?:^|-)(?:api[-_]?key|key|token|secret|auth)(?:$|-)/i.test(name);
+}
+function stripCredentials(headers, sensitiveHeaders) {
+  const next = new Headers(headers);
+  for (const [name] of headers) {
+    if (CROSS_ORIGIN_STRIPPED_HEADERS.includes(name.toLowerCase()) || looksLikeCredentialHeader(name) || sensitiveHeaders.has(name.toLowerCase())) {
+      next.delete(name);
+    }
+  }
+  return next;
+}
+var EgressBlockedError = class extends TBError {
+  constructor(message) {
+    super("invalid_argument", message);
+    this.name = "EgressBlockedError";
+  }
+};
+function assertPublicHttpUrl(value) {
+  let url;
+  try {
+    url = value instanceof URL ? value : new URL(value);
+  } catch {
+    throw new EgressBlockedError(`\u51FA\u7AD9\u76EE\u6807\u4E0D\u662F\u5408\u6CD5 URL: ${String(value)}`);
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new EgressBlockedError(`\u51FA\u7AD9\u76EE\u6807\u534F\u8BAE\u4E0D\u88AB\u5141\u8BB8: ${url.protocol}`);
+  }
+  const hostname = url.hostname.startsWith("[") && url.hostname.endsWith("]") ? url.hostname.slice(1, -1) : url.hostname;
+  if (hostname === "") throw new EgressBlockedError("\u51FA\u7AD9\u76EE\u6807\u7F3A\u5C11\u4E3B\u673A\u540D");
+  if (isIpAddress(hostname) && classifyIpAddress(hostname) === "blocked") {
+    throw new EgressBlockedError("\u51FA\u7AD9\u76EE\u6807\u6307\u5411\u79C1\u6709\u6216\u4FDD\u7559\u5730\u5740");
+  }
+  return url;
+}
+function createGuardedFetch(options = {}) {
+  const crossOriginRedirect = options.crossOriginRedirect ?? "error";
+  const maxRedirects = options.maxRedirects ?? MAX_REDIRECTS;
+  const sensitiveHeaders = new Set(
+    (options.sensitiveHeaders ?? []).map((name) => name.toLowerCase())
+  );
+  return async function guardedFetch2(input, init) {
+    const transport = options.fetch ?? globalThis.fetch;
+    const initial = input instanceof Request ? input.url : String(input);
+    let url = assertPublicHttpUrl(initial);
+    let request = input instanceof Request ? new Request(url, new Request(input, init)) : new Request(url, { ...init, redirect: "manual" });
+    for (let hop = 0; ; hop += 1) {
+      const response = await transport(new Request(request.clone(), { redirect: "manual" }));
+      const location = response.headers.get("location");
+      if (response.status < 300 || response.status > 399 || location === null) return response;
+      if (hop >= maxRedirects) {
+        throw new EgressBlockedError(`\u51FA\u7AD9\u91CD\u5B9A\u5411\u8D85\u8FC7 ${maxRedirects} \u8DF3`);
+      }
+      const previousOrigin = new URL(request.url).origin;
+      url = assertPublicHttpUrl(new URL(location, url));
+      const crossesOrigin = url.origin !== previousOrigin;
+      if (crossesOrigin && crossOriginRedirect === "error") {
+        throw new EgressBlockedError("\u643A\u5E26\u654F\u611F\u4FE1\u606F\u7684\u51FA\u7AD9\u8BF7\u6C42\u4E0D\u5141\u8BB8\u8DE8\u6E90\u91CD\u5B9A\u5411");
+      }
+      const headers = !crossesOrigin ? request.headers : stripCredentials(request.headers, sensitiveHeaders);
+      const downgrade = (response.status === 301 || response.status === 302) && request.method === "POST" || response.status === 303 && request.method !== "GET" && request.method !== "HEAD";
+      if (downgrade) {
+        const redirectedHeaders = new Headers(headers);
+        for (const name of REQUEST_BODY_HEADERS) redirectedHeaders.delete(name);
+        request = new Request(url, { method: "GET", headers: redirectedHeaders, redirect: "manual" });
+      } else {
+        const redirected = new Request(url, request);
+        request = crossesOrigin ? new Request(redirected, { headers, redirect: "manual" }) : redirected;
+      }
+    }
+  };
+}
+var guardedFetch = createGuardedFetch();
+
+export {
+  assertPublicHttpUrl,
+  createGuardedFetch,
+  guardedFetch
+};

package/dist/{chunk-E6JCVKW6.js → chunk-BNMLA2RC.js}

@@ -1,13 +1,13 @@
 import {
   upstreamError
-} from "./chunk-ATK45BXV.js";
+} from "./chunk-X7ZUTKHR.js";
 import {
   createGuardedFetch
-} from "./chunk-U7B6DS2O.js";
+} from "./chunk-7ISGFRC6.js";
 import {
   TBError,
   isTBError
-} from "./chunk-UZM2RXZH.js";
+} from "./chunk-HA4BGL6C.js";
 
 // ../plugins/src/_runtime/providerHttp.ts
 function credentialLike(name) {