@yanglaofish/dsh-proxy-pro 1.0.7 → 1.0.8

package/docs/LESSONS.md

@@ -780,4 +780,38 @@ API 端点就这样被误判。**404 从来不是「网络不可达」的证据*
 
 **教训**：① 探测方法本身就是误判来源——HEAD「轻量」不等于「等价」；② 把 404 当「不存在」
 之前先问「服务器认不认这个方法」；③ 状态码是二手的，链路层结论只能由「是否拿到 HTTP
-应答」给出。
+应答」给出。
+
+---
+
+## 28. 发布铁律：每次 npm publish 后必须主动强制触发淘宝源同步（用户定案，2026-09-18）
+
+**用户的规矩（说了两次，不可违背）**：每次我们更新 npm 包（publish 成功）后，**必须手动
+主动触发淘宝源（npmmirror）更新，不许等待**——用户原话「每次更新了 npm，都请你手动强制
+触发淘宝源更新」「不要等待，就是走淘宝的主动同步」。
+
+**为什么**：npmmirror 自己拉取官方源有队列延迟，干等（只 PUT 一次 syncs 然后 poll）会 stuck
+几分钟甚至更久，导致 `dsh plugin add <新版本>` 在淘宝源上解析不到。**主动循环触发**（每轮
+先 PUT syncs、再 poll）实测 1.0.5=11 轮、1.0.6=13 轮、1.0.7=33 轮（约 2-4 分钟）必定拉到。
+
+**标准流程（每一步都要做）**：
+1. `npm publish --access=public --registry=https://registry.npmjs.org --replace-registry-host=never` 成功；
+2. 循环最多 60 轮：`PUT https://registry.npmmirror.com/-/package/@yanglaofish%2Fdsh-proxy-pro/syncs`
+   带 body `{"version":"<新版本>"}`（ContentType application/json），随后
+   `GET https://registry.npmmirror.com/@yanglaofish%2Fdsh-proxy-pro` 看 `dist-tags.latest`；
+   每轮间隔 8-10s，**一直循环到 latest == 新版本**（不许提前放弃）；
+3. latest 到位后立即：`dsh plugin --profile test add '@yanglaofish/dsh-proxy-pro@^<新版本>'`
+   与 `dsh plugin --profile web add ...`，并验证两个 profile 的 node_modules 版本。
+
+**教训**：① 「PUT syncs 返回 201」只是入队确认，不是同步完成——以 `dist-tags.latest` 为准；
+② 官方 registry 先可见不代表淘宝可见，淘宝拉取是独立队列；③ 用户规则优先于"省事"——主动
+触发是默认动作，不是可选优化。
+
+**补充：git push 的代理必须与「被暖窗的代理」一致（2026-09-18 实测）**：git 全局配置里写死的
+`http.proxy=http://proxyhk.huawei.com:8080` 是历史遗留——当前网络环境该代理已 407 失效，
+而系统代理是 `proxyza`（南非）。正确姿势：push 前用 `Invoke-WebRequest https://github.com`
+暖**当前系统代理**（.NET 自动 NTLM），然后 `git -c http.proxy=http://<当前系统代理> push`
+（用 `-c` 临时覆盖写死的 config）。若暖窗对象与 git 实际走的代理不一致，必然 407 CONNECT
+tunnel failed（proxyhk 暖窗 407、proxyza 暖窗 200 → 只有后者能推成功）。长期可选：
+`git config --global --unset http.proxy` 让 git 走插件写入的 `http_proxy` 环境变量（动态跟随
+当前系统代理），注意 CLI 环境无插件时需手动 `-c` 指定。

package/lib/client.js

@@ -74,9 +74,15 @@ window.__ModuleLoader__.load({
       ".dsxprx-diagwhy{font-size:12px;line-height:17px;color:var(--dsw-alias-label-secondary)}",
       ".dsxprx-diagfix{font-size:12px;line-height:17px;color:var(--dsw-alias-label-primary)}",
       ".dsxprx-diagnote{font-size:11px;line-height:16px;color:var(--dsw-alias-label-caption)}",
+      ".dsxprx-verdict{display:inline-flex;align-items:center;gap:6px;padding:2px 10px;border-radius:999px;font-weight:600;font-size:12px;line-height:18px}",
+      ".dsxprx-verdict[data-tone=ok]{background:rgba(16,185,129,.12);color:var(--dsw-alias-state-success-primary,#10b981)}",
+      ".dsxprx-verdict[data-tone=warn]{background:rgba(245,158,11,.14);color:#f59e0b}",
+      ".dsxprx-verdict[data-tone=bad]{background:rgba(239,68,68,.12);color:var(--dsw-alias-state-error-primary,#ef4444)}",
+      ".dsxprx-diagprobe{display:flex;align-items:center;gap:8px;flex-wrap:wrap}",
+      ".dsxprx-diotag{flex:none;min-width:44px;font-size:12px;line-height:17px;color:var(--dsw-alias-label-caption)}",
+      ".dsxprx-verdictlarge{font-size:13px;font-weight:600;line-height:19px;color:var(--dsw-alias-label-primary)}",
+      ".dsxprx-diagverdict{display:flex;flex-direction:column;gap:3px;padding:6px 0 2px;border-top:1px dashed var(--dsw-alias-border-l1)}",
       ".dsxprx-title{font-size:16px;font-weight:700;line-height:22px;color:var(--dsw-alias-label-primary)}",
-      ".dsxprx-diagcheck{flex:none;display:flex;align-items:center;gap:5px;font-size:12px;line-height:16px;color:var(--dsw-alias-label-secondary);cursor:pointer;white-space:nowrap}",
-      ".dsxprx-diagcheck input{width:14px;height:14px;accent-color:#4d6bfe;margin:0}",
       ".dsxprx-hdr{display:flex;align-items:center;gap:6px;max-width:180px;height:26px;padding:0 10px;border:1px solid var(--dsw-alias-border-l1);border-radius:999px;background:transparent;color:var(--dsw-alias-label-primary);font:inherit;font-size:12px;line-height:16px;cursor:pointer;white-space:nowrap;overflow:hidden}",
       ".dsxprx-hdr:hover{background:var(--dsw-alias-state-hover)}",
       ".dsxprx-hdr .dsxprx-dot{width:8px;height:8px}",
@@ -296,26 +302,29 @@ window.__ModuleLoader__.load({
           });
         };
       }
-      var diagUseProxy = useState(true);
-      var setDiagUseProxy = diagUseProxy[1];
-      /** Three-state headline for one probe verdict (usable / degraded / unusable). */
-      function probeHeadline(probe) {
-        if (!probe) return "未知";
-        if (probe.verdict === "usable") return "可用" + (probe.status === undefined ? "" : "（HTTP " + probe.status + "）");
-        if (probe.verdict === "degraded") return "降级：" + (probe.short || "未知");
-        if (probe.verdict === "unusable") return "不可用：" + (probe.short || "未知");
-        return probe.ok ? "可用" : (probe.short || "未知");
-      }
+      // 诊断双通道并行（走代理 + 直连），由 host 一次给出两侧徽章和推荐，
+      // 不再让用户手动勾选通道（2026-09-18：单侧探针分不清被拒者是谁）
       function runDiag() {
         var target = diagUrl.trim();
         if (!target) return;
         setDiagBusy(true);
         setDiagResult(null);
-        fetchJson("/route?url=" + encodeURIComponent(target) + "&useProxy=" + (diagUseProxy[0] ? "1" : "0")).then(function (data) {
+        fetchJson("/route?url=" + encodeURIComponent(target)).then(function (data) {
           setDiagResult(data === null ? { error: "诊断接口不可用" } : data);
         }).finally(function () { setDiagBusy(false); });
       }
       var diag = diagResult[0];
+      /** 通道徽章：优先用 host 的 proxyBadge/directBadge（人话+色），缺失时回退旧判定。 */
+      function channelBadge(name) {
+        var b = diag && typeof diag[name] === "object" && diag[name] !== null ? diag[name] : null;
+        if (b && b.text && b.tone) return b;
+        var fallback = name === "proxyBadge" ? diag?.proxy : diag?.direct;
+        if (!fallback) return { text: "未知", tone: "warn" };
+        if (fallback.verdict === "usable") return { text: "链路通 · 目标正常响应", tone: "ok" };
+        if (fallback.verdict === "degraded") return { text: "链路通 · 这次请求被目标拒绝", tone: "warn" };
+        if (fallback.verdict === "unusable") return { text: "链路不通 · 网络/代理问题", tone: "bad" };
+        return fallback.ok ? { text: "链路通", tone: "ok" } : { text: "链路不通", tone: "bad" };
+      }
 
       return react.createElement("div", { className: "dsxprx", "data-proxy-settings": true },
 
@@ -402,27 +411,29 @@ window.__ModuleLoader__.load({
               onChange: function (event) { setDiagUrl(event.target.value); },
               onKeyDown: function (event) { if (event.key === "Enter") runDiag(); },
             }),
-            react.createElement("label", { className: "dsxprx-diagcheck" },
-              react.createElement("input", {
-                type: "checkbox",
-                checked: diagUseProxy[0],
-                onChange: function (event) { setDiagUseProxy(event.target.checked); },
-              }),
-              "使用代理"),
             react.createElement("button", { type: "button", className: "dsxprx-diagbtn", onClick: runDiag, disabled: diagBusy[0] || !diagUrl.trim() }, "测试路由")
           ),
-          react.createElement("span", { className: "dsxprx-hint" }, "勾选「使用代理」= 强制走代理测通不通；不勾 = 强制直连测。对比可判断该域名该不该加进 NO_PROXY。"),
+          react.createElement("span", { className: "dsxprx-hint" }, "同时测「走代理」与「直连」两条通道并给出推荐，可判断该域名该不该加进 NO_PROXY。"),
           diag !== null
             ? react.createElement("div", { className: "dsxprx-diagout" },
               diag.error
                 ? react.createElement("span", null, "诊断失败：" + diag.error)
                 : [
-                  react.createElement("span", { key: "c" }, "测试通道： " + (diag.channel === "proxy" ? "经代理（强制）" : diag.channel === "direct" ? "直连（强制绕过）" : "按当前策略")),
                   react.createElement("span", { key: "r" }, "策略判定： " + diag.route + (diag.bypassed ? "（NO_PROXY 命中）" : "")),
-                  react.createElement("span", { key: "p" }, "连通探测： " + probeHeadline(diag.probe)),
-                  diag.probe && diag.probe.why ? react.createElement("span", { key: "w", className: "dsxprx-diagwhy" }, "可能原因： " + diag.probe.why) : null,
-                  diag.probe && diag.probe.fix ? react.createElement("span", { key: "f", className: "dsxprx-diagfix" }, "挽救措施： " + diag.probe.fix) : null,
-                  diag.probe && diag.probe.note ? react.createElement("span", { key: "n", className: "dsxprx-diagnote" }, "备注： " + diag.probe.note) : null,
+                  react.createElement("span", { key: "px", className: "dsxprx-diagprobe" },
+                    react.createElement("span", { className: "dsxprx-diotag" }, "走代理"),
+                    react.createElement("span", { className: "dsxprx-verdict", "data-tone": channelBadge("proxyBadge").tone }, channelBadge("proxyBadge").text)
+                  ),
+                  react.createElement("span", { key: "dx", className: "dsxprx-diagprobe" },
+                    react.createElement("span", { className: "dsxprx-diotag" }, "直连"),
+                    react.createElement("span", { className: "dsxprx-verdict", "data-tone": channelBadge("directBadge").tone }, channelBadge("directBadge").text)
+                  ),
+                  diag.verdict ? react.createElement("span", { key: "v", className: "dsxprx-diagverdict" },
+                    react.createElement("span", { className: "dsxprx-verdictlarge" }, "推荐： " + (diag.short || "未知")),
+                    diag.why ? react.createElement("span", { className: "dsxprx-diagwhy" }, "可能原因： " + diag.why) : null,
+                    diag.fix ? react.createElement("span", { className: "dsxprx-diagfix" }, "挽救措施： " + diag.fix) : null
+                  ) : null,
+                  diag.proxy && diag.proxy.note ? react.createElement("span", { key: "n", className: "dsxprx-diagnote" }, "备注： " + diag.proxy.note) : null,
                   diag.hint ? react.createElement("span", { key: "h" }, "提示： " + diag.hint) : null,
                 ]
             )

package/lib/index.js

@@ -32,6 +32,7 @@ import { promisify } from 'node:util'
 import {
   classifyProbeStatus,
   classifyTargetFailure,
+  combineDualProbe,
   headNeedsGetRetry,
   keepaliveHint,
   makeSystemProxyReader,
@@ -267,18 +268,25 @@ async function policyProbe(target) {
 }
 
 /**
- * 按 web_fetch 的方式探测一个目标：先给路由判定，再用策略通道发真实请求
- * （app undici 的 fetch + 全局 dispatcher，见 policyProbe）。`channel` 选择
- * 探测路径：'policy'（默认）、'proxy'（强制走代理）、'direct'（强制绕过）。
+ * 按 web_fetch 的方式探测一个目标，**同时**强制走代理 + 强制直连两个通道，
+ * 再把两侧结果综合成一条人话推荐（combineDualProbe）。
+ *
+ * 单侧探测无法判断被拒是谁干的（目标 or 代理?）——只有两侧对比才能得出
+ * 方向性结论（直连通+代理失败 → 问题在代理一侧；代理通+直连失败 → 代理是
+ * 唯一通路）。`channel` 保留兼容：'policy'/'proxy'/'direct' 仍是旧的单通道
+ * 探测（HTTP API 的历史 useProxy 参数使用），默认 'dual' 走双通道并行。
  */
-async function probeTarget(url, snapshot, channel = 'policy') {
+async function probeTarget(url, snapshot, channel = 'dual') {
   let parsed
   try {
     parsed = new URL(url)
   } catch {
-    return { url, route: 'invalid', bypassed: false,
-      probe: { ok: false, verdict: 'unusable', kind: 'invalid', short: 'URL 无效 — 需要 http(s)://主机/路径',
-        why: '输入不是可解析的绝对 URL。', fix: '用完整形式，如 https://github.com/foo/bar。' } }
+    return { url, route: 'invalid', bypassed: false, channel,
+      proxy: { ok: false, verdict: 'unusable', kind: 'invalid', short: 'URL 无效 — 需要 http(s)://主机/路径',
+        why: '输入不是可解析的绝对 URL。', fix: '用完整形式，如 https://github.com/foo/bar。' },
+      direct: { ok: false, verdict: 'unusable', kind: 'invalid', short: 'URL 无效 — 需要 http(s)://主机/路径',
+        why: '输入不是可解析的绝对 URL。', fix: '用完整形式，如 https://github.com/foo/bar。' },
+      verdict: 'both-bad', short: 'URL 无效', why: '输入不是可解析的绝对 URL。', fix: '用完整形式，如 https://github.com/foo/bar。' }
   }
   let routeName = 'DIRECT'
   try {
@@ -292,6 +300,8 @@ async function probeTarget(url, snapshot, channel = 'policy') {
     const host = entry.trim().replace(/^\*?\./, '').toLowerCase()
     return host.length > 0 && (host === parsed.hostname.toLowerCase() || parsed.hostname.toLowerCase().endsWith(`.${host}`))
   })
+
+  // 兼容旧单通道调用（HTTP API 历史 useProxy 参数）
   if (channel === 'proxy' || channel === 'direct') {
     const proxyUrl = channel === 'proxy' ? (snapshot?.effective?.url ?? '') : ''
     const probe = proxyUrl === '' && channel === 'proxy'
@@ -301,8 +311,27 @@ async function probeTarget(url, snapshot, channel = 'policy') {
       : await forceChannelProbe(parsed, channel, proxyUrl)
     return { url, route: routeName, bypassed, channel, probe }
   }
-  const probe = await policyProbe(parsed)
-  return { url, route: routeName, bypassed, probe }
+  if (channel === 'policy') {
+    const probe = await policyProbe(parsed)
+    return { url, route: routeName, bypassed, channel, probe }
+  }
+
+  // 双通道并行：强制走代理 + 强制直连，各自独立探测（互不干扰）
+  const proxyUrl = snapshot?.effective?.url ?? ''
+  const proxyProbe = proxyUrl === ''
+    ? { ok: false, verdict: 'unusable', kind: 'bad-proxy', short: '当前快照里没有可用的代理地址',
+      why: '代理开关处于关闭（或 Windows 系统代理关闭），没有可强制走代理的对象。',
+      fix: '打开代理，或在「代理配置」里修复地址/模式。' }
+    : await forceChannelProbe(parsed, 'proxy', proxyUrl)
+  const directProbe = await forceChannelProbe(parsed, 'direct', '')
+  const combined = combineDualProbe(proxyProbe, directProbe)
+  return {
+    url, route: routeName, bypassed, channel: 'dual',
+    proxy: proxyProbe, direct: directProbe,
+    verdict: combined.verdict, short: combined.short,
+    why: combined.why, fix: combined.fix,
+    proxyBadge: combined.proxyBadge, directBadge: combined.directBadge,
+  }
 }
 
 // ---- browser-trust fence (mirrors dsh's /api fence) ------------------------
@@ -532,18 +561,16 @@ function apply(ctx, config) {
     output: {
       schema: PROXY_TEST_SCHEMA,
       render: (_args, value) => {
-        const p = value.probe ?? {}
-        const head = p.verdict === 'usable'
-          ? `可用${p.status === undefined ? '' : `（HTTP ${p.status}）`}`
-          : `${p.verdict === 'degraded' ? '降级' : '不可用'} — ${p.short ?? '未知'}`
+        const badge = (b) => (b?.tone === 'ok' ? '🟢' : b?.tone === 'warn' ? '🟡' : '🔴') + ' ' + (b?.text ?? '未知')
         const lines = [
           `路由: ${value.route}`,
           `NO_PROXY 命中: ${value.bypassed}`,
-          `连通探测: ${head}`,
+          `走代理: ${badge(value.proxyBadge)}`,
+          `直连:   ${badge(value.directBadge)}`,
+          `结论: ${value.short ?? '未知'}`,
         ]
-        if (p.why) lines.push(`可能原因: ${p.why}`)
-        if (p.fix) lines.push(`挽救措施: ${p.fix}`)
-        if (p.note) lines.push(`备注: ${p.note}`)
+        if (value.why) lines.push(`可能原因: ${value.why}`)
+        if (value.fix) lines.push(`挽救措施: ${value.fix}`)
         if (value.hint) lines.push(`提示: ${value.hint}`)
         return [{ type: 'text', text: lines.join('\n') }]
       },
@@ -551,7 +578,7 @@ function apply(ctx, config) {
     execute: async (args) => {
       await requestSync()
       const result = await probeTarget(String(args.url ?? ''), snapshot)
-      result.hint = keepaliveHint(result.probe?.short ?? '', snapshot?.effective?.url ?? '')
+      result.hint = keepaliveHint(`${result.proxy?.short ?? ''} ${result.direct?.short ?? ''}`, snapshot?.effective?.url ?? '')
       return result
     },
     presentCall: (args) => ({
@@ -668,10 +695,14 @@ function apply(ctx, config) {
             }
             if (is('/route', 'GET')) {
               const target = url.searchParams.get('url') ?? ''
+              // useProxy 保留兼容：'1'/'0' 走旧的单通道强制；无参数（新版面板）走双通道
               const useProxy = url.searchParams.get('useProxy')
-              const channel = useProxy === '1' ? 'proxy' : useProxy === '0' ? 'direct' : 'policy'
+              const channel = useProxy === '1' ? 'proxy' : useProxy === '0' ? 'direct' : 'dual'
               const result = await probeTarget(target, snapshot, channel)
-              result.hint = keepaliveHint(result.probe?.short ?? '', snapshot?.effective?.url ?? '')
+              result.hint = keepaliveHint(
+                `${result.proxy?.short ?? ''} ${result.direct?.short ?? ''}`.trim(),
+                snapshot?.effective?.url ?? ''
+              )
               sendJson(res, 200, { ok: true, ...result })
               return
             }

package/lib/proxy-core.js

@@ -416,3 +416,82 @@ export function classifyTargetFailure(error) {
     why: '请求失败，探测器无法归类原因。',
     fix: '对比直连/代理两侧并重试；用 proxy_status 查看生效路由。' }
 }
+
+/**
+ * 双通道综合判定：把「强制走代理」与「强制直连」两次探测合成为一份可给人
+ * 看的结果：两条徽章（各自带 tone 色）+ 一条推荐。
+ *
+ * 单侧探针拿不到应答者身份，因此「代理策略拦截」只能靠两侧对比得到方向性
+ * 结论（LESSONS §30：直连通+代理失败 → 问题在代理一侧；代理通+直连失败 →
+ * 代理是唯一通路；都失败 → 环境/服务端问题；都通 → 保持现状）。
+ *
+ * @param proxyProbe - 强制走代理通道的探测结果（classify 输出形态）。
+ * @param directProbe - 强制直连通道的探测结果。
+ * @returns `{ verdict, short, why, fix, proxyBadge, directBadge }`，
+ *   badge = { text, tone: 'ok'|'warn'|'bad' }。
+ */
+export function combineDualProbe(proxyProbe, directProbe) {
+  const proxyOk = proxyProbe?.ok === true
+  const directOk = directProbe?.ok === true
+  const proxyAuth = proxyProbe?.kind === 'auth'
+    || (proxyProbe?.verdict === 'unusable' && /NTLM|407/.test(String(proxyProbe?.short ?? '')))
+
+  const notReachable = (probe, label) => {
+    const detail = (probe?.short ?? '未知原因').replace(/^HTTP \d+ — /, '')
+    return `${label}：${detail}`
+  }
+
+  // 都通 → 都可以
+  if (proxyOk && directOk) {
+    return {
+      verdict: 'both-ok',
+      short: '代理与直连均通',
+      why: '两条通道都拿到了正常应答，目标本身可用。',
+      fix: '保持当前策略即可；无需改 NO_PROXY。',
+      proxyBadge: { text: '链路通 · 目标正常响应', tone: 'ok' },
+      directBadge: { text: '链路通 · 目标正常响应', tone: 'ok' },
+    }
+  }
+
+  // 只有代理通 → 走代理
+  if (proxyOk && !directOk) {
+    return {
+      verdict: 'proxy-only',
+      short: '只有走代理能通',
+      why: `直连 ${notReachable(directProbe, '失败')}；走代理正常——该目标在当前网络需经代理访问。`,
+      fix: '确认该域名不在 NO_PROXY 直连名单里；保持代理开启。',
+      proxyBadge: { text: '链路通 · 目标正常响应', tone: 'ok' },
+      directBadge: { text: '链路不通 · 直连失败', tone: 'bad' },
+    }
+  }
+
+  // 只有直连通 → 问题在代理一侧（可能是策略拦截/认证/代理故障）
+  if (!proxyOk && directOk) {
+    const base = proxyAuth
+      ? {
+          why: '代理要求 NTLM 认证（407），而直连正常——该目标不值得绕代理。',
+          fix: '该域名走代理会被认证卡住：把它加入 NO_PROXY 直连名单即可；无需打开认证窗口。',
+        }
+      : {
+          why: '经代理失败而直连正常——问题最可能在代理一侧：访问策略拦截、代理故障，或代理到目标之间的链路异常。',
+          fix: '先重试排除临时故障；仍失败则检查代理可用性或联系管理员。若确认是策略拦截，把该域名加入 NO_PROXY 直连名单。',
+        }
+    return {
+      verdict: proxyAuth ? 'direct-only-auth' : 'direct-only',
+      short: proxyAuth ? '直连可通 · 代理需认证' : '直连可通 · 代理被拦',
+      ...base,
+      proxyBadge: { text: proxyAuth ? '链路不通 · 代理要求认证' : '链路不通 · 经代理访问失败', tone: 'bad' },
+      directBadge: { text: '链路通 · 目标正常响应', tone: 'ok' },
+    }
+  }
+
+  // 都失败 → 环境/服务端问题
+  return {
+    verdict: 'both-bad',
+    short: '代理与直连均失败',
+    why: `两条通道都没拿到正常应答：代理 ${notReachable(proxyProbe, '失败')}；直连 ${notReachable(directProbe, '失败')}。`,
+    fix: '是环境或服务端问题，与代理开关无关：检查网络/目标服务，或稍后重试。',
+    proxyBadge: { text: `链路不通 · ${notReachable(proxyProbe, '代理失败')}`, tone: 'bad' },
+    directBadge: { text: `链路不通 · ${notReachable(directProbe, '直连失败')}`, tone: 'bad' },
+  }
+}

package/lib/tool-schemas.js

@@ -54,7 +54,28 @@ export const PROXY_TEST_PARAMETERS = {
   },
 }
 
-/** Output schema of `proxy_test`. */
+/** Reusable per-channel probe result (a classifyProbeStatus / classifyTargetFailure
+ *  output). Schema DSL has no $ref, so this inlines into PROXY_TEST_SCHEMA. */
+const PROBE_RESULT_SCHEMA = {
+  type: 'object',
+  additionalProperties: false,
+  required: true,
+  properties: {
+    ok: { type: 'boolean', required: true },
+    verdict: { type: 'string' },
+    status: { type: 'number' },
+    kind: { type: 'string' },
+    short: { type: 'string' },
+    why: { type: 'string' },
+    fix: { type: 'string' },
+    note: { type: 'string' },
+  },
+}
+
+/** Output schema of `proxy_test`. Dual-channel: forces both legs in parallel
+ * (走代理 / 直连), then combines them into one human verdict + recommendation
+ * (2026-09-18: single-side probes cannot tell WHO answered, so a strategy
+ * block can only be inferred by comparing both sides — LESSONS §30). */
 export const PROXY_TEST_SCHEMA = {
   type: 'object',
   additionalProperties: false,
@@ -62,25 +83,13 @@ export const PROXY_TEST_SCHEMA = {
     url: { type: 'string', required: true },
     route: { type: 'string', required: true },
     bypassed: { type: 'boolean', required: true },
-    probe: {
-      type: 'object',
-      additionalProperties: false,
-      required: true,
-      properties: {
-        ok: { type: 'boolean', required: true },
-        // Three-state verdict plus the actionable pair the panel and the tool
-        // render (2026-09-17: a 504 used to print as "reachable"). Every field
-        // must be listed here — the object is additionalProperties:false, so an
-        // undeclared field fails schema validation.
-        verdict: { type: 'string' },
-        status: { type: 'number' },
-        kind: { type: 'string' },
-        short: { type: 'string' },
-        why: { type: 'string' },
-        fix: { type: 'string' },
-        note: { type: 'string' },
-      },
-    },
+    channel: { type: 'string', required: true },
+    proxy: PROBE_RESULT_SCHEMA,
+    direct: PROBE_RESULT_SCHEMA,
+    verdict: { type: 'string', required: true },
+    short: { type: 'string', required: true },
+    why: { type: 'string', required: true },
+    fix: { type: 'string', required: true },
     hint: { type: 'string' },
   },
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanglaofish/dsh-proxy-pro",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "DSH proxy manager: route model requests, web fetches and spawned tools through the Windows system proxy or a custom address; per-URL route diagnosis, one-click toggle from the conversation header, a dedicated Settings page, and keepalive-aware 407 hints.",
   "type": "module",
   "main": "./lib/index.js",