dsh-provider-proxy 0.7.0 → 0.9.0

package/lib/index.js

@@ -1073,6 +1073,15 @@ var DefaultProxy = z.object({
 var ProviderProxyRoute = z.object({
   /** Whether this provider's calls are routed through the proxy below. */
   enabled: z.boolean().default(false),
+  /**
+   * A named preset from the top-level `proxyProfiles` dictionary.
+   *
+   * Non-empty wins over `useDefault`: the route's TRANSPORT fields come from
+   * that preset. Empty (the default) keeps the 0.8.0 behaviour, where
+   * `useDefault` may borrow the top-level `defaultProxy`. Target-host rules and
+   * the self-check target are always the route's own.
+   */
+  profileId: z.string().default(""),
   /**
    * When true, this route's TRANSPORT fields (protocol/host/port/username/
    * password) come from the top-level `defaultProxy` instead of its own, so the
@@ -1109,6 +1118,12 @@ var ProviderProxyRoute = z.object({
 var Config = z.object({
   /** Per-provider proxy routes, keyed by provider route id (e.g. `sensenova`). */
   providers: vol(z.dict(ProviderProxyRoute).default({})),
+  /**
+   * Named proxy endpoints, keyed by a user-chosen name. A route opts into one
+   * with `profileId`; the top-level `defaultProxy` remains the implicit
+   * "default preset" so an old configuration keeps working unchanged.
+   */
+  proxyProfiles: vol(z.dict(DefaultProxy).default({})),
   /**
    * Shared endpoint for every route that sets `useDefault`. Volatile for the
    * same reason as `providers`: a settings write is committed into the running
@@ -1149,8 +1164,9 @@ function normalizeRoute(provider, raw, options) {
   const onlyHosts = value.onlyHosts.trim().toLowerCase();
   const bypassHosts = value.bypassHosts.trim().toLowerCase();
   const testTarget = value.testTarget.trim();
+  const profileId = value.profileId.trim();
   if (!value.enabled && options?.requireEnabled !== false) {
-    return { ...value, port: value.port || 0, onlyHosts, bypassHosts, testTarget };
+    return { ...value, profileId, port: value.port || 0, onlyHosts, bypassHosts, testTarget };
   }
   const host = value.host.trim();
   const hostProblem = proxyHostProblem(host);
@@ -1164,7 +1180,15 @@ function normalizeRoute(provider, raw, options) {
       `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(), onlyHosts, bypassHosts, testTarget };
+  return {
+    ...value,
+    profileId,
+    host,
+    username: value.username.trim(),
+    onlyHosts,
+    bypassHosts,
+    testTarget
+  };
 }
 
 // src/host-rules.ts
@@ -1201,6 +1225,107 @@ function hostRuleProblem(raw) {
 function deadRuleEntries(raw) {
   return splitHostRules(raw).filter((entry) => hostRuleProblem(entry) !== void 0);
 }
+var PROVIDER_HOST_TEMPLATES = {
+  openai: { label: "OpenAI", hosts: "api.openai.com, *.openai.com" },
+  anthropic: { label: "Anthropic", hosts: "api.anthropic.com" },
+  google: { label: "Google", hosts: "generativelanguage.googleapis.com" },
+  deepseek: { label: "DeepSeek", hosts: "api.deepseek.com" }
+};
+function providerHostTemplate(providerId) {
+  const key = providerId.trim().toLowerCase().split(/[-_/:.]/)[0] ?? "";
+  const template = PROVIDER_HOST_TEMPLATES[key];
+  return template === void 0 ? void 0 : { id: key, ...template };
+}
+function appendHostRules(raw, hosts) {
+  const existing = new Set(parseHostList(raw));
+  const additions = [];
+  for (const token of splitHostRules(hosts)) {
+    const normalized = normalizeHostRule(token);
+    if (normalized.length === 0 || existing.has(normalized)) continue;
+    existing.add(normalized);
+    additions.push(token);
+  }
+  if (additions.length === 0) return raw.trim();
+  const prefix = raw.trim();
+  return prefix.length === 0 ? additions.join(", ") : `${prefix}, ${additions.join(", ")}`;
+}
+
+// src/presets.ts
+var DEFAULT_PROFILE_LABEL = "\u9ED8\u8BA4\u9884\u8BBE (Default)";
+var DEFAULT_PROFILE_BINDING = "__default__";
+function routeBindingOf(route) {
+  const profileId = (route?.profileId ?? "").trim();
+  if (profileId.length > 0) return { kind: "profile", profileId };
+  if (route?.useDefault === true) return { kind: "default" };
+  return { kind: "own" };
+}
+function bindingFields(binding) {
+  switch (binding.kind) {
+    case "profile":
+      return { profileId: binding.profileId, useDefault: false };
+    case "default":
+      return { profileId: "", useDefault: true };
+    case "own":
+      return { profileId: "", useDefault: false };
+  }
+}
+function resolveEndpoint(provider, route, defaultProxy, profiles) {
+  const binding = routeBindingOf(route);
+  if (binding.kind === "own") return { ok: true, binding };
+  if (binding.kind === "default") return { ok: true, binding, endpoint: defaultProxy ?? {} };
+  const preset = profiles?.[binding.profileId];
+  if (preset === void 0) {
+    return {
+      ok: false,
+      binding,
+      problem: `dsh-provider-proxy: provider "${provider}" \u7ED1\u5B9A\u7684\u9884\u8BBE\u300C${binding.profileId}\u300D\u4E0D\u5B58\u5728\uFF1B\u8BF7\u9009\u62E9\u4E00\u4E2A\u73B0\u6709\u9884\u8BBE\u6216\u6539\u7528\u81EA\u5B9A\u4E49\u914D\u7F6E`
+    };
+  }
+  return { ok: true, binding, endpoint: preset };
+}
+function profileNameProblem(raw) {
+  const name2 = raw.trim();
+  if (name2.length === 0) return "\u9884\u8BBE\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+  if (name2.length > 40) return "\u9884\u8BBE\u540D\u79F0\u4E0D\u80FD\u8D85\u8FC7 40 \u4E2A\u5B57\u7B26";
+  if (/[\u0000-\u001f\u007f]/.test(name2)) return "\u9884\u8BBE\u540D\u79F0\u4E0D\u80FD\u5305\u542B\u63A7\u5236\u5B57\u7B26";
+  if (name2 === DEFAULT_PROFILE_LABEL) return "\u8BE5\u540D\u79F0\u7531\u5185\u7F6E\u9ED8\u8BA4\u9884\u8BBE\u4FDD\u7559\uFF0C\u8BF7\u6362\u4E00\u4E2A\u540D\u79F0";
+  if (name2 === DEFAULT_PROFILE_BINDING) return "\u8BE5\u540D\u79F0\u7531\u63D2\u4EF6\u4FDD\u7559\uFF0C\u8BF7\u6362\u4E00\u4E2A\u540D\u79F0";
+  return void 0;
+}
+function withEndpoint(route, endpoint) {
+  return {
+    ...route,
+    protocol: endpoint.protocol ?? "http",
+    host: endpoint.host ?? "",
+    port: endpoint.port ?? 0,
+    username: endpoint.username ?? "",
+    password: endpoint.password ?? ""
+  };
+}
+function effectiveRoute(route, defaultProxy, profiles) {
+  const base = route ?? {};
+  const binding = routeBindingOf(base);
+  if (binding.kind === "own") return base;
+  const resolved = resolveEndpoint("", base, defaultProxy, profiles);
+  if (!resolved.ok || resolved.endpoint === void 0) return base;
+  return withEndpoint(base, resolved.endpoint);
+}
+function profileNames(profiles) {
+  return Object.keys(profiles ?? {}).sort((a, b) => a.localeCompare(b));
+}
+function routesBoundTo(routes, profileId) {
+  const out = [];
+  for (const [id, route] of Object.entries(routes ?? {})) {
+    if ((route?.profileId ?? "").trim() === profileId) out.push(id);
+  }
+  return out.sort();
+}
+function endpointSummary(endpoint) {
+  const protocol = endpoint?.protocol ?? "http";
+  const host = (endpoint?.host ?? "").trim() || "\u2014";
+  const port = endpoint?.port ?? 0;
+  return `${protocol}://${host}:${port === 0 ? "\u2014" : port}`;
+}
 
 // src/proxy-table.ts
 function normalizedRuleSet(raw) {
@@ -1270,19 +1395,21 @@ function buildDecide(route, localDirect) {
     return "proxy";
   };
 }
-function withDefaultProxy(route, defaultProxy) {
-  return {
-    ...route,
-    protocol: defaultProxy.protocol,
-    host: defaultProxy.host,
-    port: defaultProxy.port,
-    username: defaultProxy.username,
-    password: defaultProxy.password
-  };
-}
 function buildRouteEntry(provider, raw, options) {
   let effective = raw;
-  if (raw?.useDefault === true) {
+  const resolved = resolveEndpoint(provider, raw, options.defaultProxy, options.profiles);
+  if (!resolved.ok) return { ok: false, problem: resolved.problem };
+  if (resolved.binding.kind === "profile") {
+    const preset = resolved.endpoint ?? {};
+    const why = defaultProxyProblem(preset);
+    if (why !== void 0) {
+      return {
+        ok: false,
+        problem: `dsh-provider-proxy: provider "${provider}" \u7ED1\u5B9A\u7684\u9884\u8BBE\u300C${resolved.binding.profileId}\u300D\u4E0D\u53EF\u7528\uFF1A${why}`
+      };
+    }
+    effective = withEndpoint(raw, normalizeDefaultProxy(preset));
+  } else if (resolved.binding.kind === "default") {
     const why = defaultProxyProblem(options.defaultProxy);
     if (why !== void 0) {
       return {
@@ -1290,7 +1417,7 @@ function buildRouteEntry(provider, raw, options) {
         problem: `dsh-provider-proxy: provider "${provider}" \u542F\u7528\u4E86\u300C\u4F7F\u7528\u9ED8\u8BA4\u4EE3\u7406\u300D\uFF0C\u4F46\u9876\u5C42\u9ED8\u8BA4\u4EE3\u7406\u4E0D\u53EF\u7528\uFF1A${why}`
       };
     }
-    effective = withDefaultProxy(raw, options.defaultProxy);
+    effective = withEndpoint(raw, options.defaultProxy);
   }
   let route;
   try {
@@ -1345,6 +1472,7 @@ function createProxyTable(config, options = {}) {
   const problems = /* @__PURE__ */ new Map();
   const buildOptions = {
     defaultProxy: normalizeDefaultProxy(options.defaultProxy),
+    profiles: options.profiles,
     requireEnabled: true,
     localDirect: options.localDirect !== false
   };
@@ -1362,16 +1490,260 @@ async function closeTable(entries) {
   entries.clear();
 }
 
+// src/proxy-env.ts
+var SOURCES = ["HTTPS_PROXY", "HTTP_PROXY", "ALL_PROXY"];
+function explicitPortOf(text) {
+  const authority = text.slice(text.indexOf("://") + 3).split(/[/?#]/, 1)[0] ?? "";
+  const hostPort = authority.slice(authority.lastIndexOf("@") + 1);
+  const match = /^\[[^\]]+\]:(\d+)$/.exec(hostPort) ?? /^[^:]+:(\d+)$/.exec(hostPort);
+  if (match === null) return 0;
+  const parsed = Number.parseInt(match[1], 10);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+function parseProxyEnvValue(raw) {
+  const text = (raw ?? "").trim();
+  if (text.length === 0) return void 0;
+  const first = text.split(",")[0]?.trim() ?? "";
+  if (first.length === 0) return void 0;
+  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(first) ? first : `http://${first}`;
+  let url;
+  try {
+    url = new URL(withScheme);
+  } catch {
+    return void 0;
+  }
+  const scheme = url.protocol.slice(0, -1).toLowerCase();
+  const protocol = scheme === "socks" ? "socks5" : scheme === "http" || scheme === "https" || scheme === "socks5" ? scheme : void 0;
+  if (protocol === void 0) return void 0;
+  const host = url.hostname.startsWith("[") && url.hostname.endsWith("]") ? url.hostname.slice(1, -1) : url.hostname;
+  if (host.length === 0) return void 0;
+  const port = url.port.length > 0 ? Number.parseInt(url.port, 10) : explicitPortOf(withScheme);
+  return {
+    protocol,
+    host,
+    port: Number.isNaN(port) ? 0 : port,
+    hadCredentials: url.username.length > 0 || url.password.length > 0
+  };
+}
+function detectProxyEnv(env = process.env) {
+  for (const source of SOURCES) {
+    const parsed = parseProxyEnvValue(env[source]);
+    if (parsed === void 0) continue;
+    if (parsed.port < 1 || parsed.port > 65535) continue;
+    return { source, ...parsed };
+  }
+  return void 0;
+}
+
+// src/proxy-clients.ts
+var PROXY_CLIENT_PRESETS = [
+  { id: "clash", label: "Clash / Mihomo (127.0.0.1:7890)", protocol: "http", host: "127.0.0.1", port: 7890 },
+  { id: "clash-verge", label: "Clash Verge / Meta (127.0.0.1:7897)", protocol: "http", host: "127.0.0.1", port: 7897 },
+  { id: "v2ray-http", label: "V2Ray / Xray HTTP (127.0.0.1:10809)", protocol: "http", host: "127.0.0.1", port: 10809 },
+  { id: "v2ray-socks", label: "V2Ray / Xray SOCKS5 (127.0.0.1:10808)", protocol: "socks5", host: "127.0.0.1", port: 10808 }
+];
+function proxyClientPreset(id) {
+  return PROXY_CLIENT_PRESETS.find((preset) => preset.id === id);
+}
+
+// src/backup.ts
+var PROTOCOLS2 = ["http", "https", "socks5"];
+function normalizeEndpoint(raw) {
+  const value = raw ?? {};
+  return {
+    protocol: PROTOCOLS2.includes(value.protocol) ? value.protocol : "http",
+    host: typeof value.host === "string" ? value.host.trim() : "",
+    port: typeof value.port === "number" && Number.isFinite(value.port) ? value.port : 0,
+    username: typeof value.username === "string" ? value.username.trim() : "",
+    password: typeof value.password === "string" ? value.password : ""
+  };
+}
+var FALLBACK_TEST_URL = "https://api.ipify.org?format=json";
+function fillRoute(raw) {
+  const value = raw ?? {};
+  return {
+    enabled: value.enabled === true,
+    profileId: typeof value.profileId === "string" ? value.profileId.trim() : "",
+    useDefault: value.useDefault === true,
+    protocol: PROTOCOLS2.includes(value.protocol) ? value.protocol : "http",
+    host: typeof value.host === "string" ? value.host.trim() : "",
+    port: typeof value.port === "number" && Number.isFinite(value.port) ? value.port : 0,
+    username: typeof value.username === "string" ? value.username.trim() : "",
+    password: typeof value.password === "string" ? value.password : "",
+    onlyHosts: typeof value.onlyHosts === "string" ? value.onlyHosts : "",
+    bypassHosts: typeof value.bypassHosts === "string" ? value.bypassHosts : "",
+    testTarget: typeof value.testTarget === "string" ? value.testTarget : ""
+  };
+}
+function buildBackup(source, options = { includePasswords: false }) {
+  const include = options.includePasswords === true;
+  const hide = (password) => include ? password : "";
+  const providers = {};
+  for (const [id, raw] of Object.entries(source.providers ?? {})) {
+    const filled = fillRoute(raw);
+    providers[id] = { ...filled, password: hide(filled.password) };
+  }
+  const proxyProfiles = {};
+  for (const [name2, raw] of Object.entries(source.proxyProfiles ?? {})) {
+    const filled = normalizeEndpoint(raw);
+    proxyProfiles[name2] = { ...filled, password: hide(filled.password) };
+  }
+  const defaultProxy = normalizeEndpoint(source.defaultProxy);
+  return {
+    version: 1,
+    exportedAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    providers,
+    proxyProfiles,
+    defaultProxy: { ...defaultProxy, password: hide(defaultProxy.password) },
+    localDirect: source.localDirect !== false,
+    testUrl: typeof source.testUrl === "string" && source.testUrl.trim().length > 0 ? source.testUrl : FALLBACK_TEST_URL
+  };
+}
+function backupFileName(now = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `dsh-proxy-backup-${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}.json`;
+}
+function isPlainObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseBackup(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    return {
+      ok: false,
+      error: `\u4E0D\u662F\u5408\u6CD5\u7684 JSON\uFF1A${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  if (!isPlainObject2(parsed)) return { ok: false, error: "\u5907\u4EFD\u6587\u4EF6\u7684\u9876\u5C42\u5FC5\u987B\u662F\u4E00\u4E2A\u5BF9\u8C61" };
+  const root = parsed;
+  if (root.providers === void 0 && root.defaultProxy === void 0 && root.proxyProfiles === void 0) {
+    return {
+      ok: false,
+      error: "\u5907\u4EFD\u6587\u4EF6\u7F3A\u5C11 providers / proxyProfiles / defaultProxy\uFF0C\u65E0\u6CD5\u8BC6\u522B\u4E3A\u4EE3\u7406\u914D\u7F6E"
+    };
+  }
+  if (root.providers !== void 0 && !isPlainObject2(root.providers)) {
+    return { ok: false, error: "providers \u5FC5\u987B\u662F\u4E00\u4E2A\u5BF9\u8C61" };
+  }
+  if (root.proxyProfiles !== void 0 && !isPlainObject2(root.proxyProfiles)) {
+    return { ok: false, error: "proxyProfiles \u5FC5\u987B\u662F\u4E00\u4E2A\u5BF9\u8C61" };
+  }
+  if (root.defaultProxy !== void 0 && !isPlainObject2(root.defaultProxy)) {
+    return { ok: false, error: "defaultProxy \u5FC5\u987B\u662F\u4E00\u4E2A\u5BF9\u8C61" };
+  }
+  if (root.localDirect !== void 0 && typeof root.localDirect !== "boolean") {
+    return { ok: false, error: "localDirect \u5FC5\u987B\u662F\u5E03\u5C14\u503C" };
+  }
+  if (root.testUrl !== void 0 && typeof root.testUrl !== "string") {
+    return { ok: false, error: "testUrl \u5FC5\u987B\u662F\u5B57\u7B26\u4E32" };
+  }
+  const endpoint = (value, label) => {
+    if (value.protocol !== void 0 && !PROTOCOLS2.includes(value.protocol)) {
+      return `${label}.protocol \u5FC5\u987B\u662F ${PROTOCOLS2.join(" / ")}`;
+    }
+    for (const key of ["host", "username", "password"]) {
+      if (value[key] !== void 0 && typeof value[key] !== "string") {
+        return `${label}.${key} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`;
+      }
+    }
+    if (value.port !== void 0 && (typeof value.port !== "number" || !Number.isFinite(value.port))) {
+      return `${label}.port \u5FC5\u987B\u662F\u6570\u5B57`;
+    }
+    return void 0;
+  };
+  const providers = {};
+  for (const [id, value] of Object.entries(root.providers ?? {})) {
+    if (!isPlainObject2(value)) return { ok: false, error: `providers.${id} \u5FC5\u987B\u662F\u4E00\u4E2A\u5BF9\u8C61` };
+    const why = endpoint(value, `providers.${id}`);
+    if (why !== void 0) return { ok: false, error: why };
+    for (const key of ["enabled", "useDefault"]) {
+      if (value[key] !== void 0 && typeof value[key] !== "boolean") {
+        return { ok: false, error: `providers.${id}.${key} \u5FC5\u987B\u662F\u5E03\u5C14\u503C` };
+      }
+    }
+    for (const key of ["profileId", "onlyHosts", "bypassHosts", "testTarget"]) {
+      if (value[key] !== void 0 && typeof value[key] !== "string") {
+        return { ok: false, error: `providers.${id}.${key} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32` };
+      }
+    }
+    providers[id] = fillRoute(value);
+  }
+  const proxyProfiles = {};
+  for (const [name2, value] of Object.entries(
+    root.proxyProfiles ?? {}
+  )) {
+    if (!isPlainObject2(value)) return { ok: false, error: `proxyProfiles.${name2} \u5FC5\u987B\u662F\u4E00\u4E2A\u5BF9\u8C61` };
+    const why = endpoint(value, `proxyProfiles.${name2}`);
+    if (why !== void 0) return { ok: false, error: why };
+    proxyProfiles[name2] = normalizeEndpoint(value);
+  }
+  if (root.defaultProxy !== void 0) {
+    const why = endpoint(root.defaultProxy, "defaultProxy");
+    if (why !== void 0) return { ok: false, error: why };
+  }
+  const document = {
+    version: 1,
+    exportedAt: typeof root.exportedAt === "string" ? root.exportedAt : "",
+    providers,
+    proxyProfiles,
+    defaultProxy: normalizeEndpoint(root.defaultProxy ?? {}),
+    localDirect: root.localDirect !== false,
+    testUrl: typeof root.testUrl === "string" && root.testUrl.trim().length > 0 ? root.testUrl : FALLBACK_TEST_URL
+  };
+  return { ok: true, document };
+}
+function backupOps(document) {
+  return [
+    { op: "set", path: ["providers"], value: document.providers },
+    { op: "set", path: ["proxyProfiles"], value: document.proxyProfiles },
+    { op: "set", path: ["defaultProxy"], value: document.defaultProxy },
+    { op: "set", path: ["localDirect"], value: document.localDirect },
+    { op: "set", path: ["testUrl"], value: document.testUrl }
+  ];
+}
+function backupCounts(document) {
+  return {
+    providers: Object.keys(document.providers).length,
+    profiles: Object.keys(document.proxyProfiles).length,
+    enabled: Object.values(document.providers).filter((route) => route.enabled).length
+  };
+}
+function validateEnabledRoutes(document) {
+  for (const [id, route] of Object.entries(document.providers)) {
+    if (!route.enabled) continue;
+    if (route.profileId.length > 0 || route.useDefault) continue;
+    const hostProblem = proxyHostProblem(route.host);
+    if (hostProblem !== void 0) {
+      return {
+        provider: id,
+        problem: hostProblem === "\u672A\u586B\u5199\u4EE3\u7406\u5730\u5740" ? `provider "${id}" \u542F\u7528\u4E86\u4EE3\u7406\uFF0C\u4F46\u672A\u586B\u5199\u4EE3\u7406\u5730\u5740` : `provider "${id}" \u7684${hostProblem}`
+      };
+    }
+    if (!Number.isInteger(route.port) || route.port < 1 || route.port > 65535) {
+      return { provider: id, problem: `provider "${id}" \u7684\u4EE3\u7406\u7AEF\u53E3\u65E0\u6548\uFF08\u9700\u4E3A 1-65535 \u7684\u6574\u6570\uFF09` };
+    }
+  }
+  return void 0;
+}
+
 // 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 {};
+  return plainDict(config?.providers, {});
+}
+function plainDict(field, fallback) {
+  const raw = field;
+  if (raw === void 0) return fallback;
   const snapshot2 = raw.get;
   const value = typeof snapshot2 === "function" ? snapshot2.call(raw) : raw;
-  return value ?? {};
+  return value ?? fallback;
+}
+function plainProfiles(config) {
+  return plainDict(config?.proxyProfiles, {});
 }
 function plainDefaultProxy(config) {
   const raw = config?.defaultProxy;
@@ -1674,7 +2046,7 @@ function apply(ctx, config) {
   };
   const selfCheckKey = (provider) => {
     const raw = plainProviders(config)[provider] ?? {};
-    const endpoint = raw.useDefault === true ? plainDefaultProxy(config) : raw;
+    const endpoint = effectiveRoute(raw, plainDefaultProxy(config), plainProfiles(config));
     return JSON.stringify([
       provider,
       endpoint.protocol ?? "http",
@@ -1692,20 +2064,25 @@ function apply(ctx, config) {
   const runSelfCheck = async (provider) => {
     let route = current.get(provider);
     let temporary = false;
-    if (route === void 0) {
-      const problem = problems.get(provider);
-      if (problem !== void 0) {
-        return { ok: false, kind: "route-rejected", error: bareMessage(problem) };
+    const saved = plainProviders(config)[provider];
+    const buildOptions = {
+      defaultProxy: normalizeDefaultProxy(plainDefaultProxy(config)),
+      profiles: plainProfiles(config),
+      requireEnabled: false,
+      localDirect: plainLocalDirect(config)
+    };
+    if (route !== void 0) {
+      const expected = saved === void 0 || saved.enabled !== true ? void 0 : buildRouteEntry(provider, saved, buildOptions);
+      if (expected === void 0 || !expected.ok || expected.entry.proxyOrigin !== route.proxyOrigin) {
+        route = void 0;
       }
-      const configured = plainProviders(config)[provider];
-      if (configured === void 0 || configured.enabled === true) {
+    }
+    if (route === void 0) {
+      const configured = saved;
+      if (configured === void 0) {
         return { ok: false, kind: "no-route", error: `provider "${provider}" \u672A\u542F\u7528\u4EE3\u7406` };
       }
-      const built = buildRouteEntry(provider, configured, {
-        defaultProxy: normalizeDefaultProxy(plainDefaultProxy(config)),
-        requireEnabled: false,
-        localDirect: plainLocalDirect(config)
-      });
+      const built = buildRouteEntry(provider, configured, buildOptions);
       if (!built.ok) {
         return { ok: false, kind: "route-rejected", error: bareMessage(built.problem) };
       }
@@ -1733,8 +2110,9 @@ function apply(ctx, config) {
   const rebuild = () => {
     const providers = plainProviders(config);
     const defaultProxy = plainDefaultProxy(config);
+    const profiles = plainProfiles(config);
     const localDirect = plainLocalDirect(config);
-    const next = createProxyTable(providers, { defaultProxy, localDirect });
+    const next = createProxyTable(providers, { defaultProxy, profiles, localDirect });
     const previous = current;
     current = next.entries;
     problems = next.problems;
@@ -1746,7 +2124,7 @@ function apply(ctx, config) {
       forgetChecks(provider);
     }
     for (const [provider, raw] of Object.entries(providers)) {
-      const effective = raw?.useDefault === true ? { ...raw, ...defaultProxy } : raw;
+      const effective = effectiveRoute(raw, defaultProxy, profiles);
       const fingerprint = routeFingerprint({
         ...effective,
         localDirect
@@ -1813,6 +2191,15 @@ function apply(ctx, config) {
     out.sort((a, b) => a.name.localeCompare(b.name));
     return { providers: out };
   };
+  let environmentDetected = false;
+  let environmentProxy;
+  const environmentProxyOf = () => {
+    if (!environmentDetected) {
+      environmentProxy = detectProxyEnv();
+      environmentDetected = true;
+    }
+    return environmentProxy;
+  };
   ctx.inject?.(["webServer"], (wctx) => {
     try {
       wctx?.webServer?.register?.({
@@ -1822,6 +2209,7 @@ function apply(ctx, config) {
           try {
             const text = JSON.stringify({
               ...catalog(),
+              environment: { proxy: environmentProxyOf() ?? null },
               problems: Object.fromEntries(
                 [...problems].map(([id, message]) => [id, bareMessage(message)])
               ),
@@ -2023,27 +2411,50 @@ function apply(ctx, config) {
 }
 export {
   Config,
+  DEFAULT_PROFILE_LABEL,
   PROTOCOLS,
+  PROVIDER_HOST_TEMPLATES,
+  PROXY_CLIENT_PRESETS,
   ProviderProxyRoute,
   WEB_SEARCH_KEY,
   acquireFetchRouter,
+  appendHostRules,
   apply,
+  backupCounts,
+  backupFileName,
+  backupOps,
+  bindingFields,
+  buildBackup,
   buildRouteEntry,
   closeTable,
   createProxyTable,
   deadRuleEntries,
   defaultProxyProblem,
+  detectProxyEnv,
+  effectiveRoute,
+  endpointSummary,
   hostMatches,
   hostRuleProblem,
   inject,
   name,
   normalizeDefaultProxy,
   normalizeRoute,
+  parseBackup,
   parseHostList,
+  parseProxyEnvValue,
+  profileNameProblem,
+  profileNames,
+  providerHostTemplate,
+  proxyClientPreset,
   proxyHostProblem,
   proxyUrl,
+  resolveEndpoint,
+  routeBindingOf,
   routeFingerprint,
   routeStateDecision,
-  splitHostRules
+  routesBoundTo,
+  splitHostRules,
+  validateEnabledRoutes,
+  withEndpoint
 };
 //# sourceMappingURL=index.js.map