dsh-provider-proxy 0.5.1 → 0.6.0

package/lib/index.js

@@ -1167,6 +1167,41 @@ function normalizeRoute(provider, raw, options) {
   return { ...value, host, username: value.username.trim(), onlyHosts, bypassHosts, testTarget };
 }
 
+// src/host-rules.ts
+function splitHostRules(raw) {
+  return raw.split(/[,\s]+/).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function normalizeHostRule(raw) {
+  return raw.trim().replace(/^\*?\./, "").toLowerCase();
+}
+function parseHostList(raw) {
+  return splitHostRules(raw).map(normalizeHostRule).filter((entry) => entry.length > 0);
+}
+function hostMatches(host, rules) {
+  for (const rule of rules) {
+    if (rule === "*") return true;
+    if (host === rule || host.endsWith(`.${rule}`)) return true;
+  }
+  return false;
+}
+function isBracketedIpv6(token) {
+  return /^\[[0-9a-f:.]+\]$/i.test(token);
+}
+function hostRuleProblem(raw) {
+  const token = raw.trim();
+  if (token.length === 0) return void 0;
+  if (token === "*." || normalizeHostRule(token).length === 0) return "\u7A7A\u901A\u914D\u7B26";
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(token)) return "\u5E26\u534F\u8BAE\u524D\u7F00";
+  if (token.includes("/")) return "\u5E26\u8DEF\u5F84";
+  if (token.includes(":") && !isBracketedIpv6(token)) return "\u5E26\u7AEF\u53E3\u6216\u975E\u6CD5\u5192\u53F7";
+  const withoutLeadingWildcard = token.replace(/^\*\./, "");
+  if (withoutLeadingWildcard.includes("*") && token !== "*") return "\u6742\u6563\u901A\u914D\u7B26";
+  return void 0;
+}
+function deadRuleEntries(raw) {
+  return splitHostRules(raw).filter((entry) => hostRuleProblem(entry) !== void 0);
+}
+
 // src/proxy-table.ts
 function proxyUrl(route) {
   const credentials = route.username.length === 0 ? "" : route.password.length > 0 && route.protocol !== "socks5" ? `${encodeURIComponent(route.username)}:${encodeURIComponent(route.password)}@` : `${encodeURIComponent(route.username)}@`;
@@ -1187,16 +1222,6 @@ function createDispatcher(route, url, password) {
   }
   return new ProxyAgent({ uri: url });
 }
-function parseHostList(raw) {
-  return raw.split(/[,\s]+/).map((entry) => entry.trim().replace(/^\*?\./, "")).filter((entry) => entry.length > 0);
-}
-function hostMatches(host, rules) {
-  for (const rule of rules) {
-    if (rule === "*") return true;
-    if (host === rule || host.endsWith(`.${rule}`)) return true;
-  }
-  return false;
-}
 function isLocalHost(host) {
   const bare = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
   if (bare === "localhost" || bare.endsWith(".localhost")) return true;
@@ -1426,12 +1451,15 @@ function apply(ctx, config) {
     }
     return out;
   };
-  const classifyTestError = (error, viaProxy) => {
+  const classifyTestError = (error, viaProxy, rawTarget) => {
     const chain = causesOf(error);
     const names = chain.map((node) => node.name).filter((name2) => typeof name2 === "string");
     const codes = chain.map((node) => node.code).filter((code2) => typeof code2 === "string");
     const messages = chain.map((node) => node.message).filter((text) => typeof text === "string");
-    const message = error instanceof Error ? error.message : String(error);
+    const message = redactTargetFromText(
+      error instanceof Error ? error.message : String(error),
+      rawTarget
+    );
     if (names.includes("TimeoutError") || names.includes("AbortError")) {
       return { kind: "timeout", error: `\u8D85\u65F6\uFF08${TEST_TIMEOUT_MS / 1e3}s\uFF09\uFF1A\u4EE3\u7406\u6216\u76EE\u6807\u65E0\u54CD\u5E94` };
     }
@@ -1445,6 +1473,28 @@ function apply(ctx, config) {
     }
     return { kind: "target", error: `\u8BF7\u6C42\u5931\u8D25\uFF1A${message}` };
   };
+  const sanitizeTargetForDisplay = (target) => {
+    const raw = String(target ?? "");
+    try {
+      const url = new URL(raw);
+      return `${url.protocol}//${url.host}${url.pathname}`;
+    } catch {
+      const withoutUserinfo = raw.replace(
+        /^([a-z][a-z0-9+.-]*:\/\/)[^/@\s]+@/i,
+        "$1"
+      );
+      const withoutQuery = withoutUserinfo.split(/[?#]/, 1)[0] ?? "";
+      const bounded = withoutQuery.length > 160 ? `${withoutQuery.slice(0, 160)}\u2026` : withoutQuery;
+      return bounded;
+    }
+  };
+  const redactTargetFromText = (text, rawTarget) => {
+    let safe = text;
+    if (rawTarget.length > 0) safe = safe.split(rawTarget).join("[\u76EE\u6807\u5DF2\u8131\u654F]");
+    safe = safe.replace(/\b([a-z][a-z0-9+.-]*:\/\/)[^/@\s]+@/gi, "$1");
+    safe = safe.replace(/([?&#])[^\s"'<>]*/g, "$1");
+    return safe.length > 500 ? `${safe.slice(0, 500)}\u2026` : safe;
+  };
   const failureCodeOf = (error) => {
     const chain = causesOf(error);
     const names = chain.map((node) => node.name).filter((name2) => typeof name2 === "string");
@@ -1457,24 +1507,45 @@ function apply(ctx, config) {
     return "ERROR";
   };
   const probeTarget = async (target, route) => {
+    const displayTarget = sanitizeTargetForDisplay(target);
     let host;
     try {
       host = new URL(target).hostname;
     } catch {
-      return { ok: false, kind: "target", error: `\u81EA\u68C0\u76EE\u6807\u4E0D\u662F\u5408\u6CD5 URL\uFF1A${target}` };
+      return {
+        ok: false,
+        kind: "target",
+        target: displayTarget,
+        error: `\u81EA\u68C0\u76EE\u6807\u4E0D\u662F\u5408\u6CD5 URL\uFF1A${displayTarget}`
+      };
     }
     const viaProxy = route.decide(host) === "proxy";
     const started = performance.now();
     try {
-      const response = await undiciFetch2(target, {
+      const requestTarget = (() => {
+        const url = new URL(target);
+        url.username = "";
+        url.password = "";
+        return url.toString();
+      })();
+      const response = await undiciFetch2(requestTarget, {
         // A direct probe must NOT carry the dispatcher, or undici would force it
         // through the proxy anyway.
         ...viaProxy ? { dispatcher: route.dispatcher } : {},
         signal: AbortSignal.timeout(TEST_TIMEOUT_MS)
       });
       const ms = Math.round(performance.now() - started);
+      const targetField = { target: displayTarget };
       if (viaProxy && response.status === 407) {
-        return { ok: false, ms, status: 407, kind: "proxy-auth", viaProxy, error: "\u4EE3\u7406\u8981\u6C42\u8BA4\u8BC1\uFF08HTTP 407\uFF09" };
+        return {
+          ok: false,
+          ms,
+          status: 407,
+          kind: "proxy-auth",
+          viaProxy,
+          ...targetField,
+          error: `\u4EE3\u7406\u8981\u6C42\u8BA4\u8BC1\uFF08HTTP 407\uFF09\uFF1A${displayTarget}`
+        };
       }
       let exitIp;
       try {
@@ -1489,6 +1560,7 @@ function apply(ctx, config) {
           ms,
           status: response.status,
           viaProxy,
+          ...targetField,
           ...exitIp === void 0 ? {} : { exitIp },
           kind: "ok"
         };
@@ -1498,24 +1570,28 @@ function apply(ctx, config) {
         ms,
         status: response.status,
         viaProxy,
+        ...targetField,
         kind: "target",
-        error: `\u76EE\u6807\u8FD4\u56DE HTTP ${response.status}\uFF085xx\uFF0C\u4E0A\u6E38\u6216\u94FE\u8DEF\u5F02\u5E38\uFF09`
+        // The status travels in its own field; the reason text must not repeat
+        // it, or the page shows the same code twice in different colours.
+        error: `\u76EE\u6807\u8FD4\u56DE 5xx\uFF08\u4E0A\u6E38\u6216\u94FE\u8DEF\u5F02\u5E38\uFF09\uFF1A${displayTarget}`
       };
     } catch (error) {
       return {
         ok: false,
         ms: Math.round(performance.now() - started),
         viaProxy,
-        ...classifyTestError(error, viaProxy)
+        ...classifyTestError(error, viaProxy, target),
+        target: displayTarget
       };
     }
   };
-  const selfCheckTargets = (provider, testTarget) => {
+  const selfCheckTargetsOf = (provider, testTarget) => {
     const own = (testTarget ?? "").trim();
-    if (own.length > 0) return [own];
+    if (own.length > 0) return { targets: [own], source: "route" };
     const upstream = upstreamOf(provider);
-    if (upstream !== void 0) return [upstream];
-    return plainTestUrls();
+    if (upstream !== void 0) return { targets: [upstream], source: "upstream" };
+    return { targets: plainTestUrls(), source: "testUrl" };
   };
   const selfCheckKey = (provider) => {
     const raw = plainProviders(config)[provider] ?? {};
@@ -1531,7 +1607,7 @@ function apply(ctx, config) {
       raw.onlyHosts ?? "",
       raw.bypassHosts ?? "",
       plainLocalDirect(config),
-      selfCheckTargets(provider, raw.testTarget)
+      selfCheckTargetsOf(provider, raw.testTarget).targets
     ]);
   };
   const runSelfCheck = async (provider) => {
@@ -1559,13 +1635,14 @@ function apply(ctx, config) {
     }
     try {
       let last;
-      for (const target of selfCheckTargets(provider, route.testTarget)) {
+      const { targets, source } = selfCheckTargetsOf(provider, route.testTarget);
+      for (const target of targets) {
         const outcome = await probeTarget(target, route);
-        if (outcome.ok === true) return outcome;
+        if (outcome.ok === true) return { ...outcome, targetSource: source };
         last = outcome;
         if (outcome.kind === "proxy-auth") break;
       }
-      return last ?? { ok: false, kind: "target", error: "\u6CA1\u6709\u53EF\u7528\u7684\u81EA\u68C0\u76EE\u6807" };
+      return last === void 0 ? { ok: false, kind: "target", target: "", targetSource: source, error: "\u6CA1\u6709\u53EF\u7528\u7684\u81EA\u68C0\u76EE\u6807" } : { ...last, targetSource: source };
     } finally {
       if (temporary) await route.dispatcher.close().catch(() => void 0);
     }
@@ -1809,12 +1886,17 @@ export {
   buildRouteEntry,
   closeTable,
   createProxyTable,
+  deadRuleEntries,
   defaultProxyProblem,
+  hostMatches,
+  hostRuleProblem,
   inject,
   name,
   normalizeDefaultProxy,
   normalizeRoute,
+  parseHostList,
   proxyHostProblem,
-  proxyUrl
+  proxyUrl,
+  splitHostRules
 };
 //# sourceMappingURL=index.js.map