dsh-plugin 1.4.6 → 1.4.8

package/src/client/components/views/SettingsView.tsx

@@ -94,6 +94,8 @@ export function SettingsView({ t, settings, update, reset, env, onCopy, openSect
   // —— HTTP 代理连通性：输入停笔后防抖实时探测（服务端 /proxy-check 用该代理打 github.com）。
   // 结果只作提示、绝不阻断保存 —— 用户可能是先填地址后开代理，保存后再去开代理完全合法。
   const [proxyProbe, setProxyProbe] = useState<'idle' | 'checking' | 'ok' | 'fail'>('idle')
+  // 失败细分原因（如 'tlsRevocation'）：证书吊销受阻时提示「不是代理地址不通」，避免误导排查方向
+  const [proxyProbeReason, setProxyProbeReason] = useState<string | null>(null)
   const proxyProbeTimer = useRef<number | null>(null)
   const proxyProbeSeq = useRef(0)
   // 卸载时清掉未触发的防抖计时器，避免卸载后 setState
@@ -103,25 +105,31 @@ export function SettingsView({ t, settings, update, reset, env, onCopy, openSect
   }, [])
   // 设置被外部重置（恢复默认/清空代理）时同步清掉探测状态，避免残留过期的「不通」提示
   useEffect(() => {
-    if (settings.proxy === '') setProxyProbe('idle')
+    if (settings.proxy === '') { setProxyProbe('idle'); setProxyProbeReason(null) }
   }, [settings.proxy])
 
   const probeProxyNow = (value: string) => {
     const v = value.trim()
-    if (v === '') { setProxyProbe('idle'); return }
+    if (v === '') { setProxyProbe('idle'); setProxyProbeReason(null); return }
     const seq = ++proxyProbeSeq.current
     setProxyProbe('checking')
+    setProxyProbeReason(null)
     void fetch('/dsh-plugin-hub/proxy-check', {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
       body: JSON.stringify({ proxy: v }),
       cache: 'no-store',
     }).then((res) => res.json())
-      .then((data: { ok?: boolean }) => {
+      .then((data: { ok?: boolean; reason?: string | null }) => {
         if (seq !== proxyProbeSeq.current) return
         setProxyProbe(data.ok ? 'ok' : 'fail')
+        setProxyProbeReason(typeof data.reason === 'string' ? data.reason : null)
+      })
+      .catch(() => {
+        if (seq !== proxyProbeSeq.current) return
+        setProxyProbe('fail')
+        setProxyProbeReason(null)
       })
-      .catch(() => { if (seq === proxyProbeSeq.current) setProxyProbe('fail') })
   }
 
   const onProxyChange = (e: ChangeEvent<HTMLInputElement>) => {
@@ -191,7 +199,8 @@ export function SettingsView({ t, settings, update, reset, env, onCopy, openSect
           : proxyProbe === 'ok'
             ? h('div', { className: `${styles.proxyHint} ${styles.proxyHintOk}` }, t('proxyCheckOk'))
             : proxyProbe === 'fail'
-              ? h('div', { className: `${styles.proxyHint} ${styles.proxyHintFail}` }, t('proxyCheckFail'))
+              ? h('div', { className: `${styles.proxyHint} ${styles.proxyHintFail}` },
+                proxyProbeReason === 'tlsRevocation' ? t('proxyCheckRevocation') : t('proxyCheckFail'))
               : null,
       ),
     }),

package/src/client/locales.ts

@@ -116,6 +116,8 @@ export const zh = {
   proxyCheckChecking: '正在测试该代理地址…',
   proxyCheckOk: '测试可达，安装与目录请求将统一走该代理',
   proxyCheckFail: '此地址测试不通，仍可保存；请确认代理已开启、地址与端口无误',
+  // 失败细分原因：Windows Schannel 必须取到证书吊销信息，取不到即中断握手 —— 不是代理地址不通
+  proxyCheckRevocation: '证书吊销检查受阻（Windows Schannel 取不到 CRL/OCSP），握手被中断；属本机 TLS 环境问题，非代理地址不通',
   settingsMirror: 'npm 镜像源',
   settingsMirrorDesc: '默认跟随本机 npm 配置；官方源慢可换国内镜像',
   mirrorNone: '未配置（跟随本机 npm 配置）',
@@ -203,6 +205,9 @@ export const zh = {
   diagSummaryRunning: '正在检测通道…',
   diagSummaryOk: '全部通道正常',
   diagSummaryFail: '存在不可达通道，点击对应行可重测',
+  // 失败细分原因：Windows Schannel 必须取到证书吊销信息才能握手，取不到即中断（易被误当成网络不通）
+  diagFailRevocation: '证书校验受阻',
+  diagFailRevocationHint: '系统 curl 取不到证书吊销信息（Windows Schannel 必需 CRL/OCSP），TLS 握手被中断 —— 这不是网络不通，npm/git 可能照常可用。升级 curl 到 7.70+ 可自动按「尽力而为」处理，或换一个能访问吊销服务的网络。',
   settingsEnvSnapshot: '系统版本',
   settingsEnvSnapshotDesc: '复制宿主版本与系统信息，提交 Issue 时粘贴到正文便于复现',
   settingsEnvCopy: '复制',
@@ -483,6 +488,8 @@ export const en = {
   proxyCheckChecking: 'Testing this proxy address…',
   proxyCheckOk: 'Reachable — installs and catalog requests will route through it',
   proxyCheckFail: 'Unreachable, but you can still save it; make sure the proxy is running and the address and port are correct',
+  // Failure reason: Windows Schannel aborts the handshake when revocation info (CRL/OCSP) is unreachable — not a bad proxy address
+  proxyCheckRevocation: 'Certificate revocation check blocked (Windows Schannel could not fetch CRL/OCSP), so the handshake was aborted — a local TLS issue, not a bad proxy address',
   settingsMirror: 'npm mirror',
   settingsMirrorDesc: 'Unset by default — follows local npm config; pick a domestic mirror if slow',
   mirrorNone: 'Unset (follow local npm config)',
@@ -570,6 +577,9 @@ export const en = {
   diagSummaryRunning: 'Checking channels…',
   diagSummaryOk: 'All channels reachable',
   diagSummaryFail: 'Unreachable channel(s) — click a row to re-check',
+  // Failure reason: Windows Schannel aborts the handshake when revocation info (CRL/OCSP) is unreachable (easily mistaken for a network outage)
+  diagFailRevocation: 'Cert check blocked',
+  diagFailRevocationHint: 'The system curl cannot fetch certificate revocation info (CRL/OCSP, required by Windows Schannel), so the TLS handshake is aborted — this is not a network outage, and npm/git may still work. curl 7.70+ downgrades the check to best-effort, or switch to a network that can reach the revocation service.',
   settingsEnvSnapshot: 'System version',
   settingsEnvSnapshotDesc: 'Copy host version and system info for pasting into issue reports',
   settingsEnvCopy: 'Copy',

package/src/server/http/routes.ts

@@ -107,12 +107,13 @@ function catalogCacheFile(profile: string, key: string): string {
   return join(profileDirectory(profile), 'cache', `catalog-${key}.json`)
 }
 
-/** 读缓存：文件存在、JSON 合法、未过期 → 返回原始响应字符串；否则 null（视为 miss）。 */
-function readCatalogCache(file: string): string | null {
+/** 读缓存：文件存在、JSON 合法、未超过 maxAgeMs → 返回原始响应字符串；否则 null（视为 miss）。
+ *  maxAgeMs 传 Infinity 即「任意年龄的缓存」，供实时拉取失败时兜底使用。 */
+function readCatalogCache(file: string, maxAgeMs: number): string | null {
   try {
     const entry = JSON.parse(readFileSync(file, 'utf8')) as CatalogCacheEntry
     if (entry && typeof entry.at === 'number' && typeof entry.body === 'string'
-      && Date.now() - entry.at < CATALOG_CACHE_TTL_MS) {
+      && Date.now() - entry.at < maxAgeMs) {
       return entry.body
     }
   } catch {
@@ -494,13 +495,18 @@ export function mountPluginHubRoutes(webServer: WebServerService, profile: strin
           const child = spawn(bin, args)
           let out = ''
           child.stdout.on('data', (d) => { out += String(d) })
-          child.on('error', () => sendJson(response, 500, { error: 'directory picker unavailable' }))
-          child.on('close', (code) => {
+          // spawn 失败（如 Linux 无 zenity）会先触发 error 再触发 close（code=-2）：
+          // 只允许第一个事件应答，否则第二次 sendJson 对已结束的响应再 writeHead，
+          // 抛 ERR_HTTP_HEADERS_SENT 成为宿主进程内的未捕获异常。
+          let done = false
+          const finish = (reply: () => void) => { if (!done) { done = true; reply() } }
+          child.on('error', () => finish(() => sendJson(response, 500, { error: 'directory picker unavailable' })))
+          child.on('close', (code) => finish(() => {
             // macOS osascript 输出带引号（如 "/Users/x"），统一剥掉首尾空白与引号
             const picked = out.trim().replace(/^"|"$/g, '')
             if (code === 0 && picked !== '') sendJson(response, 200, { path: picked })
             else sendJson(response, 200, { cancelled: true })
-          })
+          }))
         } catch {
           sendJson(response, 500, { error: 'directory picker unavailable' })
         }
@@ -567,8 +573,16 @@ export function mountPluginHubRoutes(webServer: WebServerService, profile: strin
             ? await gitLsRemote(c.url, c.proxy ?? effectiveProxy, 6000)
             : await probe(c.url, c.proxy)
           results.push({ key: c.key, ok: r.ok })
-          // git 行的 status 是退出码，客户端 git 行只显示 OK / 不可达，不显示成 HTTP 码
-          send({ type: r.ok ? 'ok' : 'fail', key: c.key, display: c.display, ms: r.ms, status: c.git ? null : r.status })
+          // git 行的 status 是退出码，客户端 git 行只显示 OK / 不可达，不显示成 HTTP 码。
+          // reason 透出失败细分原因（如 Windows 证书吊销受阻），客户端据此给对症提示而非笼统「不可达」。
+          send({
+            type: r.ok ? 'ok' : 'fail',
+            key: c.key,
+            display: c.display,
+            ms: r.ms,
+            status: c.git ? null : r.status,
+            reason: r.ok ? null : (r.reason ?? null),
+          })
         }
         send({ type: 'end', at: Date.now() })
         response.end()
@@ -609,9 +623,10 @@ export function mountPluginHubRoutes(webServer: WebServerService, profile: strin
           sendJson(response, 200, { ok: false, ms: null, status: null, target, reason: 'empty' })
           return
         }
-        // 探测走该代理本身（不是 effectiveProxy）：验证的就是用户填的这个地址
+        // 探测走该代理本身（不是 effectiveProxy）：验证的就是用户填的这个地址。
+        // reason 带上失败细分原因（如证书吊销受阻），设置页才能提示「不是代理地址的问题」。
         const r = await probeUrl(target, proxy, 6000)
-        sendJson(response, 200, { ok: r.ok, ms: r.ms, status: r.status, target })
+        sendJson(response, 200, { ok: r.ok, ms: r.ms, status: r.status, target, reason: r.reason ?? null })
       },
     }),
     webServer.register({
@@ -635,7 +650,7 @@ export function mountPluginHubRoutes(webServer: WebServerService, profile: strin
           : `https://api.dsh-plugin.org/plugins.${lang}.json`
         // 1 小时本地缓存：命中直接返回（跨重启生效，插件市场秒开），未命中才走 curl 拉远程
         const cacheFile = catalogCacheFile(profile, isStats ? 'stats' : `plugins-${lang}`)
-        const cached = readCatalogCache(cacheFile)
+        const cached = readCatalogCache(cacheFile, CATALOG_CACHE_TTL_MS)
         if (cached !== null) {
           try {
             sendJson(response, 200, JSON.parse(cached))
@@ -646,6 +661,17 @@ export function mountPluginHubRoutes(webServer: WebServerService, profile: strin
         }
         const r = await fetchViaCurl(target, proxy, 20000)
         if (!r.ok || r.body === '') {
+          // 实时拉取失败：退回任意年龄的本地缓存（上次成功数据），
+          // 避免证书吊销受阻 / 网络抖动时整个插件市场打不开 —— 数据可能过期，但好过空白。
+          const stale = readCatalogCache(cacheFile, Number.POSITIVE_INFINITY)
+          if (stale !== null) {
+            try {
+              sendJson(response, 200, JSON.parse(stale))
+              return
+            } catch {
+              // 兜底缓存也损坏：落到下面的 502
+            }
+          }
           sendJson(response, 502, { error: 'catalog fetch failed' })
           return
         }

package/src/server/services/install/npm-resolve.ts

@@ -13,7 +13,7 @@
  */
 import { get } from 'node:https'
 
-/** 反查缓存：repo 小写 → npm 包名（null 表示已确认无对应 npm 包）。 */
+/** 反查缓存：repo 小写 → npm 包名（null 表示已确认无对应 npm 包；网络异常不缓存）。 */
 const cache = new Map<string, string | null>()
 
 /** 单次 registry 查询超时（ms）：慢网络下失败返回 null，不阻塞安装流程。 */
@@ -22,7 +22,9 @@ const REQUEST_TIMEOUT_MS = 8000
 /**
  * 反查 repo（`owner/repo`）对应的官方 npm 包名；未命中、网络异常或超时返回 null。
  * 返回 null 不代表仓库一定没有 npm 包，只代表本次未能确认 —— 调用方应保留
- * 原有错误路径，反查只是额外的一次尝试。
+ * 原有错误路径，反查只是额外的一次尝试。只有「已确认」的结果（包名，或 200
+ * 响应下确认无匹配）会进缓存；网络异常/超时/解析失败不缓存，同一会话内下次
+ * 安装仍会重试反查，避免一次瞬时故障把整个会话锁死在 git 通道。
  * registry 参数：npm 镜像源地址，空串 = 官方源；与安装通道吃同一 registry，
  * 保证「配置了镜像」时反查和安装走同一个源（镜像节点同步完整时结果一致）。
  * 慢网络下失败不阻塞安装。
@@ -31,12 +33,15 @@ export function resolveNpmPackage(repo: string, registry = ''): Promise<string |
   const key = repo.toLowerCase()
   if (cache.has(key)) return Promise.resolve(cache.get(key) ?? null)
   const name = searchRepo(repo, registry)
-  name.then((found) => cache.set(key, found)).catch(() => cache.set(key, null))
-  return name
+  void name.then((found) => {
+    if (found !== undefined) cache.set(key, found)
+  })
+  return name.then((found) => found ?? null)
 }
 
-/** 用 npm search 接口按 repository 地址反查，并做铁证校验（包元数据必须指向该仓库）。 */
-function searchRepo(repo: string, registry: string): Promise<string | null> {
+/** 用 npm search 接口按 repository 地址反查，并做铁证校验（包元数据必须指向该仓库）。
+ * 返回：包名 = 命中；null = 200 响应下确认无匹配；undefined = 本次未能确认（网络/超时/解析失败）。 */
+function searchRepo(repo: string, registry: string): Promise<string | null | undefined> {
   const [owner, name] = repo.split('/')
   if (owner === undefined || name === undefined || name === '') return Promise.resolve(null)
   const base = registry === '' ? 'https://registry.npmjs.org' : registry.replace(/\/+$/, '')
@@ -45,7 +50,7 @@ function searchRepo(repo: string, registry: string): Promise<string | null> {
     const req = get(url, { timeout: REQUEST_TIMEOUT_MS }, (res) => {
       if (res.statusCode !== 200) {
         res.resume()
-        resolve(null)
+        resolve(undefined)
         return
       }
       let body = ''
@@ -65,11 +70,11 @@ function searchRepo(repo: string, registry: string): Promise<string | null> {
           }
           resolve(null)
         } catch {
-          resolve(null)
+          resolve(undefined)
         }
       })
     })
     req.on('timeout', () => req.destroy())
-    req.on('error', () => resolve(null))
+    req.on('error', () => resolve(undefined))
   })
 }

package/src/server/services/install/package-entry.ts

@@ -0,0 +1,41 @@
+/**
+ * DSH-Plugin Hub — the community plugin marketplace for DeepSeek Harness.
+ * Website: https://dsh-plugin.org
+ * GitHub: https://github.com/dshplugin/dsh-plugin-hub
+ *
+ * 包入口解析：从 package.json 的 exports["."] / main 推出用于校验的入口文件。
+ * git 通道（tar 预检）与 npm 通道（装后 statSync 校验）共用，保证两条通道
+ * 对同一个包判定一致。
+ */
+
+/** exports 条件对象里按优先级尝试的键；Node 语义下 default 最宽，import/require 次之。 */
+const EXPORT_CONDITION_KEYS = ['default', 'import', 'require'] as const
+
+/**
+ * 解析包的入口文件（相对包根，不带 `./` 前缀）。
+ *
+ * Node 的 exports 规范要求字符串 target 以 `./` 开头（如 `"./lib/index.js"`），
+ * 而 tar 成员名与磁盘路径都不带该前缀，因此统一剥掉；条件对象
+ * （`{ "import": ..., "require": ... }`）按 default → import → require 取第一
+ * 个字符串值。无 exports 时回退 main，再回退 index.js。
+ */
+export function resolvePackageEntry(meta: { main?: unknown; exports?: unknown }): string {
+  const dot = (meta.exports as Record<string, unknown> | undefined)?.['.']
+  const fromExports = typeof dot === 'string'
+    ? dot
+    : dot !== null && typeof dot === 'object'
+      ? firstStringOf(dot as Record<string, unknown>)
+      : undefined
+  const candidate = typeof fromExports === 'string' ? fromExports
+    : typeof meta.main === 'string' ? meta.main
+      : 'index.js'
+  return candidate.replace(/^\.\//u, '')
+}
+
+function firstStringOf(conditions: Record<string, unknown>): string | undefined {
+  for (const key of EXPORT_CONDITION_KEYS) {
+    const value = conditions[key]
+    if (typeof value === 'string' && value !== '') return value
+  }
+  return undefined
+}

package/src/server/services/install/preflight.ts

@@ -18,6 +18,7 @@ import { join } from 'node:path'
 import { pipeline } from 'node:stream/promises'
 import { promisify } from 'node:util'
 import { githubRepoOf } from '../profile/profile.ts'
+import { resolvePackageEntry } from './package-entry.ts'
 
 const execFileAsync = promisify(execFile)
 
@@ -56,13 +57,7 @@ export async function preflightTarget(target: string): Promise<PreflightResult>
     await download(`https://codeload.github.com/${owner}/${repo}/tar.gz/${commit}`, tar)
     const meta = await readTarJson(tar, 'package/package.json')
     if (meta === null) return { ok: true, missing: null, name: null }
-    const dot = (meta.exports as Record<string, unknown> | undefined)?.['.']
-    const resolved = typeof dot === 'string'
-      ? dot
-      : dot !== null && typeof dot === 'object'
-        ? (dot as Record<string, unknown>).default
-        : undefined
-    const entry = typeof resolved === 'string' ? resolved : typeof meta.main === 'string' ? meta.main : 'index.js'
+    const entry = resolvePackageEntry(meta)
     const inTar = await hasTarEntry(tar, `package/${entry}`)
     return { ok: inTar, missing: inTar ? null : entry, name: typeof meta.name === 'string' ? meta.name : null }
   } catch {

package/src/server/services/install/task-queue.ts

@@ -8,6 +8,7 @@
  * 输出流式收集到任务上；卸载成功时尝试从运行中 loader 即时停用（见 loader.ts）。
  */
 import { spawn, spawnSync } from 'node:child_process'
+import { resolvePackageEntry } from './package-entry.ts'
 import { readFileSync, statSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
 import type { InstallResult, InstallTask, Invocation, QueueItem } from './install-types.ts'
@@ -258,7 +259,19 @@ function pumpQueue(): void {
   if (!item) return
   const { task, options } = item
   task.status = 'running'
-  void runPluginMutation({ ...options, task }).finally(() => {
+  void runPluginMutation({ ...options, task })
+    .catch((error) => {
+      // runPluginMutation 的恢复路径（如 allowBuilds 写回 pnpm-workspace.yaml）
+      // 可能抛出；落到 failed 终态并留痕，否则该 Promise 链成为未处理 rejection
+      //（Node >= 15 默认直接终止进程），而队列自身却在 finally 里继续 pump。
+      if (task.status !== 'cancelled') {
+        task.status = 'failed'
+        task.exitCode = null
+        task.progress = 0
+        pushLine(task, `[internal] ${error instanceof Error ? error.message : String(error)}`)
+      }
+    })
+    .finally(() => {
     runningChildren.delete(task.id)
     // 系统日志：任务终态（成功/失败/取消），按动作归类安装/卸载/更新日志
     const show = task.displayTarget ?? task.target
@@ -547,12 +560,7 @@ export function verifyInstalledEntry(profile: string, target: string): { name: s
       main?: unknown
       exports?: unknown
     }
-    const dot = (meta.exports as Record<string, unknown> | undefined)?.['.']
-    const resolved = typeof dot === 'string' ? dot
-      : dot !== null && typeof dot === 'object'
-        ? (dot as Record<string, unknown>).default
-        : undefined
-    entry = typeof resolved === 'string' ? resolved : typeof meta.main === 'string' ? meta.main : 'index.js'
+    entry = resolvePackageEntry(meta)
   } catch {
     return { name, missing: null }
   }

package/src/server/services/probe.ts

@@ -21,10 +21,53 @@ export interface ProbeResult {
   ms: number | null
   /** HTTP 状态码；失败为 null */
   status: number | null
+  /** 失败细分原因：仅当能确认为环境侧 TLS 问题时才有值，普通不可达为 null */
+  reason?: ProbeFailReason | null
 }
 
+/**
+ * 不可达的细分原因。把「证书吊销检查被挡」这类本机环境问题与「网络不通」分开，
+ * 诊断列表才能给出对症提示，而不是笼统显示不可达。
+ */
+export type ProbeFailReason = 'tlsRevocation'
+
 const probeFail = (): ProbeResult => ({ ok: false, ms: null, status: null })
 
+/**
+ * Windows 的 curl 走 Schannel 做 TLS：握手阶段强制获取证书吊销信息（CRL/OCSP），
+ * 代理受限或吊销服务不可达时整个握手直接失败（CRYPT_E_NO_REVOCATION_CHECK），
+ * 表现为 `curl: (35) schannel: next InitializeSecurityContext failed` —— 而 Node/npm/
+ * 浏览器各有自己的 TLS 实现，照常可用，用户只会看到「插件市场打不开」。
+ * --ssl-revoke-best-effort（curl ≥ 7.70）把吊销检查降级为尽力而为，握手不再被它拦死；
+ * 其它平台后端（SecureTransport / OpenSSL）没有这个强制行为，不加参数。
+ * 运行时读 process.platform（而非模块级常量），便于测试覆盖两条分支。
+ */
+export function curlTlsArgs(): string[] {
+  return process.platform === 'win32' ? ['--ssl-revoke-best-effort'] : []
+}
+
+/** 本机 curl 太老、不认识 --ssl-revoke-best-effort（curl < 7.70）：退出码 2 + stderr 指向该参数。 */
+export function curlRevokeFlagUnsupported(code: number | null, stderr: string): boolean {
+  return code === 2 && /ssl-revoke-best-effort/i.test(stderr) && /unknown|unrecognized/i.test(stderr)
+}
+
+/** stderr 是否指向 Schannel 取不到证书吊销信息（据此归因为环境 TLS 问题，而非网络不通）。 */
+export function tlsRevocationBlocked(stderr: string): boolean {
+  return /CRYPT_E_NO_REVOCATION_CHECK|CRYPT_E_REVOCATION_OFFLINE|0x80092012/i.test(stderr)
+}
+
+/** 探测/安装同一套代理口径：curl 与 git 子进程都读 HTTP(S)_PROXY 环境变量。 */
+function proxyEnv(proxy: string): NodeJS.ProcessEnv {
+  if (proxy === '') return { ...process.env }
+  return {
+    ...process.env,
+    HTTP_PROXY: proxy,
+    HTTPS_PROXY: proxy,
+    http_proxy: proxy,
+    https_proxy: proxy,
+  }
+}
+
 /** macOS 系统代理：scutil --proxy 输出里的 HTTP(S) 代理；未开启返回 null。 */
 function macSystemProxy(): string | null {
   try {
@@ -74,46 +117,72 @@ export function systemProxy(): string | null {
   return null
 }
 
-/**
- * curl 子进程探测：spawn curl -s -w '%{http_code}' 并注入代理 env。
- * curl 读 HTTP_PROXY/HTTPS_PROXY 是原生行为，与 pnpm/git 安装通道同一套代理口径；
- * 失败（curl 不存在 / 连接失败 / 超时）都归为不可达，全程不抛错。
- */
-function curlProbe(url: string, proxy: string, timeoutMs: number): Promise<ProbeResult> {
+/** curl 一次调用的原始结果：退出码（进程没起来 / 超时被杀为 null）+ 两路输出。 */
+interface CurlRun {
+  code: number | null
+  stdout: string
+  stderr: string
+}
+
+/** 跑一次 curl 子进程，收集 stdout 与 stderr（stderr 是识别 Schannel 类 TLS 失败的唯一线索）。 */
+function runCurl(args: string[], env: NodeJS.ProcessEnv, timeoutMs: number): Promise<CurlRun> {
   return new Promise((resolve) => {
-    const started = Date.now()
-    const env: NodeJS.ProcessEnv = { ...process.env }
-    if (proxy !== '') {
-      env.HTTP_PROXY = proxy
-      env.HTTPS_PROXY = proxy
-      env.http_proxy = proxy
-      env.https_proxy = proxy
-    }
-    const discard = process.platform === 'win32' ? 'NUL' : '/dev/null'
-    const child = spawn('curl', [
-      '-s', '-o', discard, '-w', '%{http_code}',
-      '--max-time', String(Math.max(1, Math.round(timeoutMs / 1000))),
-      url,
-    ], { env })
-    let code = ''
-    child.stdout.on('data', (c: Buffer) => { code += c.toString() })
+    let stdout = ''
+    let stderr = ''
     let done = false
-    const finish = (r: ProbeResult) => {
+    const finish = (code: number | null) => {
       if (done) return
       done = true
       clearTimeout(timer)
-      resolve(r)
+      resolve({ code, stdout, stderr })
     }
-    child.on('error', () => finish(probeFail()))
-    child.on('close', () => {
-      const status = /^\d+$/.test(code.trim()) ? Number(code.trim()) : null
-      finish({ ok: status !== null && status >= 100 && status < 400, ms: Date.now() - started, status })
-    })
+    const child = spawn('curl', args, { env })
+    child.stdout.on('data', (c: Buffer) => { stdout += c.toString() })
+    child.stderr.on('data', (c: Buffer) => { stderr += c.toString() })
+    child.on('error', () => finish(null))
+    child.on('close', (code) => finish(code))
     // 超时兜底：curl --max-time 到点自行退出，此处再设一个进程级超时防止悬挂
-    const timer = setTimeout(() => { child.kill(); finish(probeFail()) }, timeoutMs + 1000)
+    const timer = setTimeout(() => { child.kill(); finish(null) }, timeoutMs + 1000)
   })
 }
 
+/** 带 TLS 兜底的 curl 调用：先按平台参数跑（Windows 带吊销检查降级），
+ *  若本机 curl 不认这个参数（curl < 7.70）则去掉参数重跑一次，保证老版本不因此直接失败。 */
+async function curlWithTlsFallback(args: string[], env: NodeJS.ProcessEnv, timeoutMs: number): Promise<CurlRun> {
+  const tlsArgs = curlTlsArgs()
+  const first = await runCurl([...tlsArgs, ...args], env, timeoutMs)
+  if (tlsArgs.length === 0 || !curlRevokeFlagUnsupported(first.code, first.stderr)) return first
+  return runCurl(args, env, timeoutMs)
+}
+
+/**
+ * curl 子进程探测：spawn curl -s -w '%{http_code}' 并注入代理 env。
+ * curl 读 HTTP_PROXY/HTTPS_PROXY 是原生行为，与 pnpm/git 安装通道同一套代理口径；
+ * 失败（curl 不存在 / 连接失败 / 超时）都归为不可达，全程不抛错。
+ * 证书吊销检查受阻（Windows Schannel）另记 reason，供诊断给出对症提示。
+ */
+async function curlProbe(url: string, proxy: string, timeoutMs: number): Promise<ProbeResult> {
+  const started = Date.now()
+  const discard = process.platform === 'win32' ? 'NUL' : '/dev/null'
+  // -sS（而非仅 -s）：silent 会把连接/TLS 错误一并吞掉，而识别证书吊销受阻正需要 stderr；
+  // 子进程 stderr 由我们收集、不会回显给用户，所以补 -S 不产生噪音。
+  const r = await curlWithTlsFallback([
+    '-sS', '-o', discard, '-w', '%{http_code}',
+    '--max-time', String(Math.max(1, Math.round(timeoutMs / 1000))),
+    url,
+  ], proxyEnv(proxy), timeoutMs)
+  // 子进程没起来 / 超时被杀：没有任何可诊断信息，按不可达处理
+  if (r.code === null) return probeFail()
+  const status = /^\d+$/.test(r.stdout.trim()) ? Number(r.stdout.trim()) : null
+  const ok = status !== null && status >= 100 && status < 400
+  return {
+    ok,
+    ms: Date.now() - started,
+    status,
+    reason: !ok && tlsRevocationBlocked(r.stderr) ? 'tlsRevocation' : null,
+  }
+}
+
 /**
  * 探测一个 HTTPS 目标：proxy 非空注入给 curl 子进程走代理，否则直连。
  * 供系统诊断 /diagnostics 使用；目标 URL 非法返回不可达。
@@ -137,13 +206,7 @@ export function probeUrl(url: string, proxy: string, timeoutMs: number): Promise
 export function gitLsRemote(url: string, proxy: string, timeoutMs: number): Promise<ProbeResult> {
   return new Promise((resolve) => {
     const started = Date.now()
-    const env: NodeJS.ProcessEnv = { ...process.env, GIT_TERMINAL_PROMPT: '0' }
-    if (proxy !== '') {
-      env.HTTP_PROXY = proxy
-      env.HTTPS_PROXY = proxy
-      env.http_proxy = proxy
-      env.https_proxy = proxy
-    }
+    const env: NodeJS.ProcessEnv = { ...proxyEnv(proxy), GIT_TERMINAL_PROMPT: '0' }
     const child = spawn('git', ['ls-remote', '--exit-code', url, 'HEAD'], { env })
     let out = ''
     child.stdout.on('data', (c: Buffer) => { out += c.toString() })
@@ -168,33 +231,20 @@ export function gitLsRemote(url: string, proxy: string, timeoutMs: number): Prom
 }
 
 /**
- * curl 子进程抓取响应体（与 probeUrl 同一套代理 env 注入）。
+ * curl 子进程抓取响应体（与 probeUrl 同一套代理 env 注入与 TLS 参数兜底）。
  * 供服务端 /catalog 代理路由使用：目录/统计数据经此拉到服务端再转给浏览器，
  * 使「目录数据请求走设置里的代理」与 npm / git 安装通道口径一致。
- * 失败（curl 不存在 / 连接失败 / 超时 / 非零退出）时 ok=false，全程不抛错。
+ * 失败（curl 不存在 / 连接失败 / 超时 / 非零退出）时 ok=false，全程不抛错；
+ * reason 区分「证书吊销受阻」这类环境 TLS 问题，供调用方决定兜底策略。
  */
-export function fetchViaCurl(url: string, proxy: string, timeoutMs: number): Promise<{ ok: boolean; body: string }> {
-  return new Promise((resolve) => {
-    const env: NodeJS.ProcessEnv = { ...process.env }
-    if (proxy !== '') {
-      env.HTTP_PROXY = proxy
-      env.HTTPS_PROXY = proxy
-      env.http_proxy = proxy
-      env.https_proxy = proxy
-    }
-    const child = spawn('curl', ['-s', '--max-time', String(Math.max(1, Math.round(timeoutMs / 1000))), url], { env })
-    let body = ''
-    child.stdout.on('data', (c: Buffer) => { body += c.toString() })
-    let done = false
-    const finish = (ok: boolean) => {
-      if (done) return
-      done = true
-      clearTimeout(timer)
-      resolve({ ok, body })
-    }
-    child.on('error', () => finish(false))
-    child.on('close', (code) => finish(code === 0))
-    // 超时兜底：curl --max-time 到点自行退出，此处再设一个进程级超时防止悬挂
-    const timer = setTimeout(() => { child.kill(); finish(false) }, timeoutMs + 1000)
-  })
+export function fetchViaCurl(
+  url: string, proxy: string, timeoutMs: number,
+): Promise<{ ok: boolean; body: string; reason: ProbeFailReason | null }> {
+  // 同样用 -sS：正文之外还要 stderr 里的 TLS 失败线索（被 stderr 收集，不外泄给用户）
+  const args = ['-sS', '--max-time', String(Math.max(1, Math.round(timeoutMs / 1000))), url]
+  return curlWithTlsFallback(args, proxyEnv(proxy), timeoutMs).then((r) => ({
+    ok: r.code === 0,
+    body: r.stdout,
+    reason: r.code !== 0 && tlsRevocationBlocked(r.stderr) ? 'tlsRevocation' : null,
+  }))
 }