luckytri 1.0.0

package/server/core/name-call.js

@@ -0,0 +1,29 @@
+const nameCallBoundary = "\\s,，、。！？!?：:；;（）()\\[\\]";
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const HAIL = "喂哎诶嘿";
+const PARTICLES = "啊呀呢吧哦嘛";
+const AFTER = "你|我|今天|现在|怎么|能|可以|帮|回|看|咋|在|有没有|好累|辛苦|救";
+// Talking about her, not to her. Checked against the text after the name.
+const ABOUT =
+  /^(?:\s*(?:是谁|是个|是一个|的名字|这个名字|这人|那个人|的?头像|在群里|说的是))/i;
+
+function calledBy(value, name) {
+  if (!name) return false;
+  const call = new RegExp(
+    `(?:^|[${nameCallBoundary}]|[${HAIL}])@?${escapeRegExp(name)}(?=$|[${nameCallBoundary}]|[${PARTICLES}]|(?:${AFTER}))`,
+    "gi",
+  );
+  let match;
+  while ((match = call.exec(value))) {
+    const after = value.slice(match.index + match[0].length);
+    if (!ABOUT.test(after)) return true;
+    if (match.index === call.lastIndex) call.lastIndex += 1;
+  }
+  return false;
+}
+
+export function isNameCall(text, names = []) {
+  const value = String(text || "").trim();
+  if (!value) return false;
+  return names.some((raw) => calledBy(value, String(raw || "").trim()));
+}

package/server/core/net-guard.js

@@ -0,0 +1,49 @@
+import { isIP } from "node:net";
+
+// Addresses a plugin or a downloaded image must never reach: the machine
+// itself, the local network, and the cloud metadata range. Shared so a
+// plugin's fetch and a picture download refuse the same places.
+export function blockedAddress(address) {
+  const raw = String(address || "")
+    .toLowerCase()
+    .replace(/^\[|\]$/g, "");
+  const mapped = raw.startsWith("::ffff:") ? raw.slice(7) : raw;
+  if (mapped === "::1" || mapped === "::" || raw === "::1" || raw === "::")
+    return true;
+  if (raw.startsWith("fe80:") || raw.startsWith("fc") || raw.startsWith("fd"))
+    return true;
+  const ip = isIP(mapped) === 4 ? mapped : isIP(raw) === 4 ? raw : "";
+  if (!ip) return isIP(raw) !== 6;
+  const [a, b] = ip.split(".").map(Number);
+  return (
+    a === 0 ||
+    a === 10 ||
+    a === 127 ||
+    (a === 169 && b === 254) ||
+    (a === 172 && b >= 16 && b <= 31) ||
+    (a === 192 && b === 168) ||
+    (a === 100 && b >= 64 && b <= 127)
+  );
+}
+
+export async function assertPublicHost(
+  hostname,
+  lookupHost,
+  deny = "地址不可访问",
+) {
+  const host = String(hostname || "").replace(/^\[|\]$/g, "");
+  if (!host) throw Error(deny);
+  if (isIP(host)) {
+    if (blockedAddress(host)) throw Error(deny);
+    return;
+  }
+  let records;
+  try {
+    records = await lookupHost(host, { all: true });
+  } catch {
+    throw Error(deny);
+  }
+  const list = Array.isArray(records) ? records : [records];
+  if (!list.length || list.some((item) => blockedAddress(item?.address)))
+    throw Error(deny);
+}

package/server/core/network.js

@@ -0,0 +1,157 @@
+const TRANSIENT_NETWORK_CODES = new Set([
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ECONNABORTED",
+  "EPIPE",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "EAI_AGAIN",
+  "ETIMEDOUT",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  "UND_ERR_SOCKET",
+  "UND_ERR_CLOSED",
+]);
+
+export const RETRYABLE_STATUS = new Set([
+  408, 425, 429, 500, 502, 503, 504, 520, 521, 522, 523, 529,
+]);
+
+const TLS_CODE =
+  /^(?:ERR_SSL|ERR_TLS|EPROTO|CERT_|UNABLE_TO_VERIFY|DEPTH_ZERO|SELF_SIGNED)/;
+
+export function isTransientNetworkError(error) {
+  let current = error;
+  for (let depth = 0; current && depth < 6; depth++, current = current.cause) {
+    if (
+      TRANSIENT_NETWORK_CODES.has(current.code) ||
+      TRANSIENT_NETWORK_CODES.has(current.errno)
+    )
+      return true;
+    if (
+      current.name === "TypeError" &&
+      /^(?:fetch failed|network error)$/i.test(String(current.message || ""))
+    )
+      return true;
+  }
+  return false;
+}
+
+export function isTimeoutError(error) {
+  let current = error;
+  for (let depth = 0; current && depth < 6; depth++, current = current.cause)
+    if (current.name === "TimeoutError") return true;
+  return false;
+}
+
+export function sanitizeDetail(text, max = 300) {
+  return String(text || "")
+    .replace(/Bearer\s+[^\s,;]+/gi, "Bearer [已隐藏]")
+    .replace(/((?:api[_ -]?key|token|secret)\s*[:= ]+)[^\s,;]+/gi, "$1[已隐藏]")
+    .replace(/\bsk-[A-Za-z0-9_-]{8,}/g, "sk-[已隐藏]")
+    .replace(/https?:\/\/[^\s"'<>]+/gi, (url) => {
+      try {
+        return new URL(url).origin;
+      } catch {
+        return "[地址]";
+      }
+    })
+    .replace(/[\r\n\t]+/g, " ")
+    .trim()
+    .slice(0, max);
+}
+
+// Walks the fetch cause chain so a proxy tunnel refusal, a TLS failure and a
+// server reset are reported as different problems instead of "fetch failed".
+export function describeNetworkError(error) {
+  const chain = [];
+  for (
+    let current = error, depth = 0;
+    current && depth < 6;
+    depth++, current = current.cause
+  )
+    chain.push(current);
+  if (isTimeoutError(error)) return { code: "TIMEOUT", detail: "" };
+  const messages = chain
+    .map((item) => String(item?.message || ""))
+    .filter(Boolean);
+  let code =
+    chain
+      .map((item) => item?.code || item?.errno)
+      .find((value) => TRANSIENT_NETWORK_CODES.has(value)) || "";
+  const proxy = messages
+    .map((message) => message.match(/Proxy response \((\d{3})\)/i))
+    .find(Boolean);
+  if (!code && proxy) code = `PROXY_${proxy[1]}`;
+  if (!code)
+    code =
+      chain
+        .map((item) => String(item?.code || ""))
+        .find((value) => TLS_CODE.test(value)) || "";
+  if (!code)
+    code =
+      chain
+        .map((item) => item?.code)
+        .find((value) => typeof value === "string" && value) || "";
+  if (!code && isTransientNetworkError(error)) code = "FETCH_FAILED";
+  const deepest =
+    messages.filter((message) => !/^fetch failed$/i.test(message)).at(-1) || "";
+  return { code, detail: sanitizeDetail(deepest, 160) };
+}
+
+export function networkErrorCode(error) {
+  return describeNetworkError(error).code;
+}
+
+export function retryDelayFromResponse(response, fallbackMs = 900) {
+  const value = String(response?.headers?.get?.("retry-after") || "").trim();
+  if (value) {
+    const seconds = Number(value);
+    const dateDelay = Date.parse(value) - Date.now();
+    const delay = Number.isFinite(seconds)
+      ? seconds * 1000
+      : Number.isFinite(dateDelay) && dateDelay > 0
+        ? dateDelay
+        : Number.NaN;
+    if (Number.isFinite(delay)) return Math.max(0, Math.min(delay, 30000));
+  }
+  return Math.max(0, Math.min(Number(fallbackMs) || 900, 30000));
+}
+
+export async function withTransientRequestRetry(
+  operation,
+  {
+    retries = 3,
+    delayMs = 600,
+    maxDelayMs = 8000,
+    deadlineMs = 45000,
+    onRetry,
+    random = Math.random,
+    sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    now = Date.now,
+  } = {},
+) {
+  const started = now();
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await operation(attempt);
+    } catch (error) {
+      if (
+        (!isTransientNetworkError(error) && error?.retryableRequest !== true) ||
+        attempt >= retries
+      )
+        throw error;
+      // Half fixed, half random: bursts of failures spread out instead of
+      // hitting a recovering gateway at the same moment.
+      const ceiling = Math.min(maxDelayMs, delayMs * 2 ** attempt);
+      let wait = ceiling / 2 + random() * (ceiling / 2);
+      const hinted = Number(error?.retryDelayMs);
+      if (Number.isFinite(hinted))
+        wait = Math.max(wait, Math.min(hinted, 30000));
+      if (now() - started + wait > deadlineMs) throw error;
+      onRetry?.(attempt + 1, error, wait);
+      await sleep(wait);
+    }
+  }
+}