dsh-provider-proxy 0.5.1 → 0.6.1

package/lib/index.js

@@ -1167,7 +1167,64 @@ 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 normalizedRuleSet(raw) {
+  const rules = (raw ?? "").split(/[,\s]+/).map(normalizeHostRule).filter((entry) => entry.length > 0);
+  return [...new Set(rules)].sort();
+}
+function routeFingerprint(input) {
+  return JSON.stringify([
+    input.protocol ?? "http",
+    String(input.host ?? "").trim(),
+    input.port ?? 0,
+    String(input.username ?? "").trim(),
+    input.password ?? "",
+    normalizedRuleSet(input.onlyHosts),
+    normalizedRuleSet(input.bypassHosts),
+    input.localDirect !== false
+  ]);
+}
+function routeStateDecision(previous, next) {
+  if (previous === void 0) return { token: "new", clearLastUse: false };
+  if (previous.fingerprint !== next.fingerprint) return { token: "new", clearLastUse: true };
+  if (previous.enabled !== next.enabled) return { token: "new", clearLastUse: false };
+  return { token: "keep", clearLastUse: false };
+}
 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)}@`;
   const host = route.host.includes(":") && !route.host.startsWith("[") ? `[${route.host}]` : route.host;
@@ -1187,16 +1244,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;
@@ -1347,12 +1394,16 @@ function apply(ctx, config) {
   let closed = false;
   let webAvailable = false;
   const hits = /* @__PURE__ */ new Map();
+  const routeStates = /* @__PURE__ */ new Map();
+  let nextRouteToken = 1;
   const lastUse = /* @__PURE__ */ new Map();
-  const bump = (provider) => {
+  const bump = (provider, token) => {
     hits.set(provider, (hits.get(provider) ?? 0) + 1);
+    if (routeStates.get(provider)?.token !== token) return;
     lastUse.set(provider, { ...lastUse.get(provider), startedAt: Date.now() });
   };
-  const settle = (provider) => (ok, detail) => {
+  const settle = (provider, token) => (ok, detail) => {
+    if (routeStates.get(provider)?.token !== token) return;
     const previous = lastUse.get(provider);
     lastUse.set(provider, {
       startedAt: previous?.startedAt ?? Date.now(),
@@ -1368,7 +1419,60 @@ function apply(ctx, config) {
   const MAX_REQUEST_BYTES = 8 * 1024;
   const selfChecks = /* @__PURE__ */ new Map();
   const SELF_CHECK_COOLDOWN_MS = 3e3;
+  const MAX_CHECK_ENTRIES_PER_PROVIDER = 8;
+  const MAX_CHECK_PROVIDERS = 64;
   const lastChecks = /* @__PURE__ */ new Map();
+  const checkKeyOf = (provider, key) => key.slice(provider.length);
+  const pruneCheckCache = (now = Date.now()) => {
+    for (const [provider, entries] of lastChecks) {
+      for (const [key, entry] of entries) {
+        if (now - entry.at >= SELF_CHECK_COOLDOWN_MS) entries.delete(key);
+      }
+      if (entries.size === 0) lastChecks.delete(provider);
+    }
+    while (lastChecks.size > MAX_CHECK_PROVIDERS) {
+      let oldestProvider;
+      let oldestAt = Infinity;
+      for (const [provider, entries] of lastChecks) {
+        let latest = -Infinity;
+        for (const entry of entries.values()) latest = Math.max(latest, entry.at);
+        if (latest < oldestAt) {
+          oldestAt = latest;
+          oldestProvider = provider;
+        }
+      }
+      if (oldestProvider === void 0) break;
+      lastChecks.delete(oldestProvider);
+    }
+  };
+  const rememberCheck = (provider, key, result) => {
+    pruneCheckCache();
+    let entries = lastChecks.get(provider);
+    if (entries === void 0) {
+      entries = /* @__PURE__ */ new Map();
+      lastChecks.set(provider, entries);
+    }
+    entries.set(checkKeyOf(provider, key), { at: Date.now(), result });
+    while (entries.size > MAX_CHECK_ENTRIES_PER_PROVIDER) {
+      let oldestKey;
+      let oldestAt = Infinity;
+      for (const [candidate, entry] of entries) {
+        if (entry.at < oldestAt) {
+          oldestAt = entry.at;
+          oldestKey = candidate;
+        }
+      }
+      if (oldestKey === void 0) break;
+      entries.delete(oldestKey);
+    }
+    pruneCheckCache();
+  };
+  const forgetChecks = (provider) => {
+    lastChecks.delete(provider);
+    for (const key of [...selfChecks.keys()]) {
+      if (key.startsWith(`${provider}\0`)) selfChecks.delete(key);
+    }
+  };
   const plainTestUrls = () => {
     const raw = config?.testUrl;
     const snapshot2 = raw?.get;
@@ -1426,12 +1530,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 +1552,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 +1586,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 +1639,7 @@ function apply(ctx, config) {
           ms,
           status: response.status,
           viaProxy,
+          ...targetField,
           ...exitIp === void 0 ? {} : { exitIp },
           kind: "ok"
         };
@@ -1498,24 +1649,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 +1686,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 +1714,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);
     }
@@ -1574,17 +1730,56 @@ function apply(ctx, config) {
     ctx.logger.info("dsh-provider-proxy mounted (pid %d)", process.pid);
   } catch {
   }
-  const rebuild = async () => {
-    const next = createProxyTable(plainProviders(config), {
-      defaultProxy: plainDefaultProxy(config),
-      localDirect: plainLocalDirect(config)
-    });
+  const rebuild = () => {
+    const providers = plainProviders(config);
+    const defaultProxy = plainDefaultProxy(config);
+    const localDirect = plainLocalDirect(config);
+    const next = createProxyTable(providers, { defaultProxy, localDirect });
     const previous = current;
     current = next.entries;
     problems = next.problems;
+    const configured = new Set(Object.keys(providers));
+    for (const provider of [...routeStates.keys()]) {
+      if (configured.has(provider)) continue;
+      routeStates.delete(provider);
+      lastUse.delete(provider);
+      forgetChecks(provider);
+    }
+    for (const [provider, raw] of Object.entries(providers)) {
+      const effective = raw?.useDefault === true ? { ...raw, ...defaultProxy } : raw;
+      const fingerprint = routeFingerprint({
+        ...effective,
+        localDirect
+      });
+      const decision = routeStateDecision(routeStates.get(provider), {
+        fingerprint,
+        enabled: raw?.enabled === true
+      });
+      const token = decision.token === "new" ? nextRouteToken++ : routeStates.get(provider).token;
+      if (decision.clearLastUse) {
+        lastUse.delete(provider);
+        forgetChecks(provider);
+      }
+      routeStates.set(provider, { fingerprint, enabled: raw?.enabled === true, token });
+    }
+    pruneCheckCache();
     void closeTable(previous);
+    return Promise.resolve();
   };
-  const ready = rebuild();
+  let rebuildQueue = Promise.resolve();
+  const enqueueRebuild = () => {
+    if (closed) return Promise.resolve();
+    try {
+      const done = rebuild();
+      rebuildQueue = rebuildQueue.then(() => done).catch(() => void 0);
+      return done;
+    } catch (error) {
+      const failed = Promise.reject(error);
+      rebuildQueue = failed.catch(() => void 0);
+      return failed;
+    }
+  };
+  enqueueRebuild();
   const catalog = () => {
     const live = /* @__PURE__ */ new Set();
     const out = [];
@@ -1700,16 +1895,20 @@ function apply(ctx, config) {
                 send(400, { ok: false, kind: "body", error: "\u7F3A\u5C11 provider" });
                 return;
               }
-              const key = selfCheckKey(provider);
+              const key = `${provider}\0${selfCheckKey(provider)}`;
               let pending = selfChecks.get(key);
               if (pending === void 0) {
-                const last = lastChecks.get(key);
+                pruneCheckCache();
+                const last = lastChecks.get(provider)?.get(checkKeyOf(provider, key));
                 if (last !== void 0 && Date.now() - last.at < SELF_CHECK_COOLDOWN_MS) {
                   send(200, { ...last.result, cached: true });
                   return;
                 }
+                const checkToken = routeStates.get(provider)?.token;
                 pending = runSelfCheck(provider).then((result) => {
-                  lastChecks.set(key, { at: Date.now(), result });
+                  if (checkToken !== void 0 && routeStates.get(provider)?.token === checkToken) {
+                    rememberCheck(provider, key, result);
+                  }
                   return result;
                 });
                 selfChecks.set(key, pending);
@@ -1736,11 +1935,13 @@ function apply(ctx, config) {
     const patched = function(request, signal) {
       const route = current.get(WEB_SEARCH_KEY);
       if (route === void 0) return original.call(this, request, signal);
+      const token = routeStates.get(WEB_SEARCH_KEY)?.token;
+      if (token === void 0) return original.call(this, request, signal);
       return router.run(
         {
           dispatcher: route.dispatcher,
-          onHit: () => bump(WEB_SEARCH_KEY),
-          onSettle: settle(WEB_SEARCH_KEY),
+          onHit: () => bump(WEB_SEARCH_KEY, token),
+          onSettle: settle(WEB_SEARCH_KEY, token),
           decide: route.decide
         },
         () => original.call(this, request, signal)
@@ -1760,11 +1961,13 @@ function apply(ctx, config) {
         if (typeof provider !== "string") return next();
         const route = current.get(provider);
         if (route === void 0) return next();
+        const token = routeStates.get(provider)?.token;
+        if (token === void 0) return next();
         return router.wrap(
           {
             dispatcher: route.dispatcher,
-            onHit: () => bump(provider),
-            onSettle: settle(provider),
+            onHit: () => bump(provider, token),
+            onSettle: settle(provider, token),
             decide: route.decide
           },
           next
@@ -1773,14 +1976,14 @@ function apply(ctx, config) {
       { global: true }
     );
     const onConfig = () => {
-      void rebuild();
+      void enqueueRebuild();
     };
     ctx.on("loader/volatile-update", onConfig, { global: true });
     return async () => {
       stop();
       if (closed) return;
       closed = true;
-      await ready.catch(() => void 0);
+      await rebuildQueue.catch(() => void 0);
       await closeTable(current);
       current = /* @__PURE__ */ new Map();
       router.release();
@@ -1795,7 +1998,26 @@ function apply(ctx, config) {
       })),
       problems: Object.fromEntries(problems),
       hits: Object.fromEntries(hits),
-      lastUse: Object.fromEntries(lastUse)
+      lastUse: Object.fromEntries(lastUse),
+      selfCheckCache: (() => {
+        let expiredEntries = 0;
+        let maxPerProvider = 0;
+        let totalEntries = 0;
+        for (const entries of lastChecks.values()) {
+          totalEntries += entries.size;
+          maxPerProvider = Math.max(maxPerProvider, entries.size);
+          for (const entry of entries.values()) {
+            if (Date.now() - entry.at >= SELF_CHECK_COOLDOWN_MS) expiredEntries += 1;
+          }
+        }
+        return {
+          providers: lastChecks.size,
+          pending: selfChecks.size,
+          expiredEntries,
+          totalEntries,
+          maxPerProvider
+        };
+      })()
     })
   });
 }
@@ -1809,12 +2031,19 @@ export {
   buildRouteEntry,
   closeTable,
   createProxyTable,
+  deadRuleEntries,
   defaultProxyProblem,
+  hostMatches,
+  hostRuleProblem,
   inject,
   name,
   normalizeDefaultProxy,
   normalizeRoute,
+  parseHostList,
   proxyHostProblem,
-  proxyUrl
+  proxyUrl,
+  routeFingerprint,
+  routeStateDecision,
+  splitHostRules
 };
 //# sourceMappingURL=index.js.map