dsh-provider-proxy 0.2.1 → 0.4.0

package/lib/index.js

@@ -4,10 +4,24 @@ var __export = (target, all) => {
     __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 
+// src/index.ts
+import { fetch as undiciFetch2 } from "undici";
+
 // src/fetch-router.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 import { fetch as undiciFetch } from "undici";
 var STATE_KEY = /* @__PURE__ */ Symbol.for("dsh-provider-proxy.fetch-router.v1");
+function requestHost(input) {
+  try {
+    if (typeof input === "string") return new URL(input).hostname;
+    if (input instanceof URL) return input.hostname;
+    const url = input?.url;
+    if (typeof url === "string") return new URL(url).hostname;
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
 function installSharedRouter() {
   const current = globalThis[STATE_KEY];
   if (current !== void 0) {
@@ -26,6 +40,10 @@ function installSharedRouter() {
     if (init !== void 0 && init !== null && init.dispatcher !== void 0) {
       return originalFetch.call(globalThis, input, init);
     }
+    if (active.decide !== void 0 && active.decide(requestHost(input)) === "direct") {
+      return originalFetch.call(globalThis, input, init);
+    }
+    active.onHit?.();
     return undiciFetch(input, {
       ...init,
       dispatcher: active.dispatcher
@@ -81,11 +99,11 @@ function acquireFetchRouter() {
   const state = installSharedRouter();
   let released = false;
   return {
-    run(dispatcher, callback) {
-      return state.storage.run({ dispatcher }, callback);
+    run(store, callback) {
+      return state.storage.run(store, callback);
     },
-    wrap(dispatcher, factory) {
-      return contextualIterable(state.storage, { dispatcher }, factory);
+    wrap(store, factory) {
+      return contextualIterable(state.storage, store, factory);
     },
     release() {
       if (released) return;
@@ -103,7 +121,7 @@ function acquireFetchRouter() {
 }
 
 // src/proxy-table.ts
-import { ProxyAgent } from "undici";
+import { ProxyAgent, Socks5ProxyAgent } from "undici";
 
 // src/config.ts
 import { createRequire } from "node:module";
@@ -1010,17 +1028,32 @@ var ProviderProxyRoute = z.object({
   port: z.number().default(0),
   /** Optional proxy username. */
   username: z.string().default(""),
-  /** NAME of the credentials-service record holding the proxy password. Never the password. */
-  passwordRef: z.string().default("")
+  /** SOCKS5 proxy password. Only used when `protocol` is `socks5`. */
+  password: z.string().default(""),
+  /**
+   * Comma/space-separated TARGET hosts that must go through the proxy. Empty
+   * means "no restriction" (every target is proxied). Suffix match.
+   */
+  onlyHosts: z.string().default(""),
+  /** Comma/space-separated TARGET hosts that bypass the proxy; takes priority over `onlyHosts`. */
+  bypassHosts: z.string().default("")
 });
 var Config = z.object({
   /** Per-provider proxy routes, keyed by provider route id (e.g. `sensenova`). */
-  providers: vol(z.dict(ProviderProxyRoute).default({}))
+  providers: vol(z.dict(ProviderProxyRoute).default({})),
+  /**
+   * URL the per-provider connection self-check requests THROUGH the proxy.
+   * Volatile, so a settings write does not remount the plugin; the default is an
+   * IP echo service, which lets the check report the exit address.
+   */
+  testUrl: vol(z.string().default("https://api.ipify.org?format=json"))
 });
 function normalizeRoute(provider, raw) {
   const route = ProviderProxyRoute(raw ?? {});
   const value = typeof route.get === "function" ? route.get() : route;
-  if (!value.enabled) return { ...value, port: value.port || 0 };
+  const onlyHosts = value.onlyHosts.trim().toLowerCase();
+  const bypassHosts = value.bypassHosts.trim().toLowerCase();
+  if (!value.enabled) return { ...value, port: value.port || 0, onlyHosts, bypassHosts };
   const host = value.host.trim();
   if (host.length === 0) {
     throw new TypeError(`dsh-provider-proxy: provider "${provider}" \u542F\u7528\u4E86\u4EE3\u7406\uFF0C\u4F46\u672A\u586B\u5199\u4EE3\u7406\u5730\u5740`);
@@ -1033,16 +1066,50 @@ function normalizeRoute(provider, raw) {
       `dsh-provider-proxy: provider "${provider}" \u7684\u4EE3\u7406\u7AEF\u53E3\u65E0\u6548\uFF08\u9700\u4E3A 1-65535 \u7684\u6574\u6570\uFF09`
     );
   }
-  return { ...value, host, username: value.username.trim() };
+  return { ...value, host, username: value.username.trim(), onlyHosts, bypassHosts };
 }
 
 // src/proxy-table.ts
 function proxyUrl(route) {
-  const auth = route.username.length === 0 ? "" : `${encodeURIComponent(route.username).replace(/%3A/gi, ":")}@`;
+  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;
-  return `${route.protocol}://${auth}${host}:${route.port}`;
+  return `${route.protocol}://${credentials}${host}:${route.port}`;
+}
+function displayOrigin(route, url) {
+  if (route.protocol !== "socks5") return new URL(url).origin;
+  const host = route.host.includes(":") && !route.host.startsWith("[") ? `[${route.host}]` : route.host;
+  return `${route.protocol}://${host}:${route.port}`;
+}
+function createDispatcher(route, url, password) {
+  if (route.protocol === "socks5") {
+    const auth = {};
+    if (route.username.length > 0) auth.username = route.username;
+    if (password.length > 0) auth.password = password;
+    return new Socks5ProxyAgent(url, auth);
+  }
+  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;
 }
-async function createProxyTable(config, options = {}) {
+function buildDecide(route) {
+  const only = parseHostList(route.onlyHosts);
+  const bypass = parseHostList(route.bypassHosts);
+  return (host) => {
+    if (host === void 0) return "proxy";
+    if (hostMatches(host, bypass)) return "direct";
+    if (only.length > 0 && !hostMatches(host, only)) return "direct";
+    return "proxy";
+  };
+}
+function createProxyTable(config) {
   const entries = /* @__PURE__ */ new Map();
   const problems = /* @__PURE__ */ new Map();
   for (const [provider, raw] of Object.entries(config ?? {})) {
@@ -1054,21 +1121,34 @@ async function createProxyTable(config, options = {}) {
       continue;
     }
     if (!route.enabled) continue;
-    if (route.protocol === "socks5") {
-      problems.set(provider, "dsh-provider-proxy: socks5 \u6682\u672A\u5B9E\u73B0\uFF0C\u8BF7\u6539\u7528 http \u6216 https");
+    if (route.protocol === "socks5" && route.username.length > 0 && route.password.length === 0) {
+      problems.set(
+        provider,
+        "dsh-provider-proxy: SOCKS5 \u914D\u7F6E\u4E86\u7528\u6237\u540D\u4F46\u6CA1\u6709\u5BC6\u7801\uFF1B\u8BF7\u8865\u5168\u5BC6\u7801\u6216\u6E05\u7A7A\u7528\u6237\u540D"
+      );
+      continue;
+    }
+    if (route.protocol !== "socks5" && route.password.length > 0 && route.username.length === 0) {
+      problems.set(
+        provider,
+        "dsh-provider-proxy: \u914D\u7F6E\u4E86\u4EE3\u7406\u5BC6\u7801\u4F46\u6CA1\u6709\u7528\u6237\u540D\uFF1B\u8BF7\u8865\u5168\u7528\u6237\u540D\u6216\u6E05\u7A7A\u5BC6\u7801"
+      );
       continue;
     }
-    const password = options.resolvePassword?.(provider, route.passwordRef);
-    void password;
     const url = proxyUrl(route);
     let dispatcher;
     try {
-      dispatcher = new ProxyAgent({ uri: url });
+      dispatcher = createDispatcher(route, url, route.password);
     } catch (error) {
       problems.set(provider, error instanceof Error ? error.message : String(error));
       continue;
     }
-    entries.set(provider, { provider, proxyOrigin: new URL(url).origin, dispatcher });
+    entries.set(provider, {
+      provider,
+      proxyOrigin: displayOrigin(route, url),
+      dispatcher,
+      decide: buildDecide(route)
+    });
   }
   return { entries, problems };
 }
@@ -1081,6 +1161,7 @@ async function closeTable(entries) {
 // src/index.ts
 var name = "dsh-provider-proxy";
 var inject = ["llm"];
+var WEB_SEARCH_KEY = "web-search";
 function plainProviders(config) {
   const raw = config?.providers;
   if (raw === void 0) return {};
@@ -1093,12 +1174,92 @@ function apply(ctx, config) {
   let current = /* @__PURE__ */ new Map();
   let problems = /* @__PURE__ */ new Map();
   let closed = false;
+  let webAvailable = false;
+  const hits = /* @__PURE__ */ new Map();
+  const bump = (provider) => {
+    hits.set(provider, (hits.get(provider) ?? 0) + 1);
+  };
+  const DEFAULT_TEST_URL = "https://api.ipify.org?format=json";
+  const TEST_TIMEOUT_MS = 1e4;
+  const selfChecks = /* @__PURE__ */ new Map();
+  const plainTestUrl = () => {
+    const raw = config?.testUrl;
+    const snapshot2 = raw?.get;
+    const value = typeof snapshot2 === "function" ? snapshot2.call(raw) : raw;
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : DEFAULT_TEST_URL;
+  };
+  const causesOf = (error) => {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    const queue = [error];
+    while (queue.length > 0) {
+      const node = queue.shift();
+      if (node === null || typeof node !== "object" || seen.has(node)) continue;
+      seen.add(node);
+      out.push(node);
+      const cause = node.cause;
+      if (cause !== void 0 && cause !== null) queue.push(cause);
+      const errors = node.errors;
+      if (Array.isArray(errors)) queue.push(...errors);
+    }
+    return out;
+  };
+  const classifyTestError = (error) => {
+    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 message = error instanceof Error ? error.message : String(error);
+    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` };
+    }
+    const connectivity = ["ECONNREFUSED", "ENOTFOUND", "EHOSTUNREACH", "ENETUNREACH", "ECONNRESET", "EAI_AGAIN"];
+    const code = connectivity.find((candidate) => codes.includes(candidate));
+    if (code !== void 0) {
+      return { kind: "proxy-unreachable", error: `\u4EE3\u7406\u4E0D\u53EF\u8FBE\uFF08${code}\uFF09\uFF1A${message}` };
+    }
+    if (names.includes("ProxyAuthentication") || message.includes("407")) {
+      return { kind: "proxy-auth", error: `\u4EE3\u7406\u8981\u6C42\u8BA4\u8BC1\uFF08HTTP 407\uFF09\uFF1A${message}` };
+    }
+    return { kind: "target", error: `\u8BF7\u6C42\u5931\u8D25\uFF1A${message}` };
+  };
+  const runSelfCheck = async (provider) => {
+    const route = current.get(provider);
+    if (route === void 0) {
+      return { ok: false, kind: "no-route", error: `provider "${provider}" \u672A\u542F\u7528\u4EE3\u7406` };
+    }
+    const started = performance.now();
+    try {
+      const response = await undiciFetch2(plainTestUrl(), {
+        dispatcher: route.dispatcher,
+        signal: AbortSignal.timeout(TEST_TIMEOUT_MS)
+      });
+      const ms = Math.round(performance.now() - started);
+      if (response.status === 407) {
+        return { ok: false, ms, status: 407, kind: "proxy-auth", error: "\u4EE3\u7406\u8981\u6C42\u8BA4\u8BC1\uFF08HTTP 407\uFF09" };
+      }
+      let exitIp;
+      try {
+        const body = await response.json();
+        if (typeof body?.ip === "string" && body.ip.length > 0) exitIp = body.ip;
+      } catch {
+      }
+      return {
+        ok: response.ok === true,
+        ms,
+        status: response.status,
+        ...exitIp === void 0 ? {} : { exitIp },
+        kind: response.ok === true ? "ok" : "target"
+      };
+    } catch (error) {
+      return { ok: false, ms: Math.round(performance.now() - started), ...classifyTestError(error) };
+    }
+  };
   try {
     ctx.logger.info("dsh-provider-proxy mounted (pid %d)", process.pid);
   } catch {
   }
   const rebuild = async () => {
-    const next = await createProxyTable(plainProviders(config));
+    const next = createProxyTable(plainProviders(config));
     const previous = current;
     current = next.entries;
     problems = next.problems;
@@ -1132,6 +1293,9 @@ function apply(ctx, config) {
       }
     } catch {
     }
+    if (webAvailable && out.every((row) => row.id !== WEB_SEARCH_KEY)) {
+      out.push({ id: WEB_SEARCH_KEY, name: "Web \u641C\u7D22", live: true });
+    }
     out.sort((a, b) => a.name.localeCompare(b.name));
     return { providers: out };
   };
@@ -1142,7 +1306,11 @@ function apply(ctx, config) {
         path: "/dsh-provider-proxy/providers",
         handler: (_req, res) => {
           try {
-            const text = JSON.stringify({ ...catalog(), problems: Object.fromEntries(problems) });
+            const text = JSON.stringify({
+              ...catalog(),
+              problems: Object.fromEntries(problems),
+              hits: Object.fromEntries(hits)
+            });
             res.writeHead(200, {
               "content-type": "application/json; charset=utf-8",
               "cache-control": "no-store",
@@ -1155,10 +1323,87 @@ function apply(ctx, config) {
           }
         }
       });
+      wctx?.webServer?.register?.({
+        kind: "exact",
+        path: "/dsh-provider-proxy/test",
+        handler: (req, res) => {
+          const send = (status, payload) => {
+            const text = JSON.stringify(payload);
+            res.writeHead(status, {
+              "content-type": "application/json; charset=utf-8",
+              "cache-control": "no-store",
+              "content-length": Buffer.byteLength(text)
+            });
+            res.end(text);
+          };
+          if (req?.method !== "POST") {
+            send(405, { ok: false, kind: "method", error: "\u81EA\u68C0\u7AEF\u70B9\u53EA\u63A5\u53D7 POST" });
+            return;
+          }
+          if (typeof req.on !== "function") {
+            send(400, { ok: false, kind: "body", error: "\u65E0\u6CD5\u8BFB\u53D6\u8BF7\u6C42\u4F53" });
+            return;
+          }
+          const chunks = [];
+          req.on("data", (chunk) => chunks.push(chunk));
+          req.on("error", () => send(400, { ok: false, kind: "body", error: "\u8BFB\u53D6\u8BF7\u6C42\u4F53\u5931\u8D25" }));
+          req.on("end", () => {
+            void (async () => {
+              let provider;
+              try {
+                const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
+                provider = parsed?.provider;
+              } catch {
+                send(400, { ok: false, kind: "body", error: "\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5 JSON" });
+                return;
+              }
+              if (typeof provider !== "string" || provider.length === 0) {
+                send(400, { ok: false, kind: "body", error: "\u7F3A\u5C11 provider" });
+                return;
+              }
+              let pending = selfChecks.get(provider);
+              if (pending === void 0) {
+                pending = runSelfCheck(provider);
+                selfChecks.set(provider, pending);
+                void pending.finally(() => {
+                  if (selfChecks.get(provider) === pending) selfChecks.delete(provider);
+                });
+              }
+              send(200, await pending);
+            })().catch((error) => {
+              send(500, { ok: false, kind: "internal", error: String(error) });
+            });
+          });
+        }
+      });
     } catch (error) {
       void error;
     }
   });
+  ctx.inject?.(["web"], (wctx) => {
+    const web = wctx?.web;
+    if (web === void 0 || typeof web.search !== "function") return;
+    webAvailable = true;
+    const original = web.search;
+    const patched = function(request, signal) {
+      const route = current.get(WEB_SEARCH_KEY);
+      if (route === void 0) return original.call(this, request, signal);
+      return router.run(
+        {
+          dispatcher: route.dispatcher,
+          provider: WEB_SEARCH_KEY,
+          onHit: () => bump(WEB_SEARCH_KEY),
+          decide: route.decide
+        },
+        () => original.call(this, request, signal)
+      );
+    };
+    web.search = patched;
+    const registerEffect = typeof wctx?.effect === "function" ? wctx.effect.bind(wctx) : ctx.effect?.bind(ctx);
+    registerEffect?.(() => () => {
+      if (web.search === patched) web.search = original;
+    });
+  });
   ctx.effect(() => {
     const stop = ctx.on(
       "llm/stream",
@@ -1167,7 +1412,15 @@ function apply(ctx, config) {
         if (typeof provider !== "string") return next();
         const route = current.get(provider);
         if (route === void 0) return next();
-        return router.wrap(route.dispatcher, next);
+        return router.wrap(
+          {
+            dispatcher: route.dispatcher,
+            provider,
+            onHit: () => bump(provider),
+            decide: route.decide
+          },
+          next
+        );
       },
       { global: true }
     );
@@ -1192,7 +1445,8 @@ function apply(ctx, config) {
         provider: entry.provider,
         proxyOrigin: entry.proxyOrigin
       })),
-      problems: Object.fromEntries(problems)
+      problems: Object.fromEntries(problems),
+      hits: Object.fromEntries(hits)
     })
   });
 }
@@ -1200,6 +1454,7 @@ export {
   Config,
   PROTOCOLS,
   ProviderProxyRoute,
+  WEB_SEARCH_KEY,
   acquireFetchRouter,
   apply,
   closeTable,