dsh-remote-web 0.6.12 → 0.6.14

package/lib/index.js

@@ -3997,6 +3997,7 @@ function buildConnectDiagnostics(relayDir, conn, log) {
     `bridge 进程: ${conn.bridgeRunning ? "在运行" : "未运行"}（pid=${conn.bridgePids && conn.bridgePids.length ? conn.bridgePids.join(",") : "-"}，launchd state=${conn.launchdState || "-"}，崩溃循环=${conn.launchdCrashLoop ? "是" : "否"}）`,
     `后台守护: ${conn.watcherRunning ? `在运行（pid=${conn.watcherPids.join(",")}${conn.watcherAgeMs ? `，已 ${Math.round(conn.watcherAgeMs / 1000)} 秒` : ""}${conn.watcherWedged ? "，⚠️ 迟迟未拉起 bridge" : ""}${conn.watcherRestarts ? `，已自动重启 ${conn.watcherRestarts} 次` : ""}）` : "未运行"}`,
     `上游 dsh web: ${conn.upstreamUrl}（${conn.upstreamSource}${conn.upstreamReachable === null ? "" : conn.upstreamReachable ? "，可达" : `，⚠️ 不可达：${conn.upstreamError}`}）`,
+    `目录选择器: ${pickerPinState.kind === "native" ? "⚠️ 系统原生（远程时对话框弹在电脑那台机器上 → 手机上点「添加工作区」会像没反应）" : (pickerPinState.kind || "未知")}${pickerPinState.detail ? `（${pickerPinState.detail}）` : ""}`,
     `中继注册: ${conn.registered ? "已注册（" + conn.registerSource + "）" : "未注册"}`,
     `bridge 账号: ${conn.accountCurrent === false ? "⚠️ 仍是上一个账号的身份（需重启 bridge 重新登记）" : "当前账号"}`,
     conn.rateLimitedUntil ? `登录限流: 约 ${Math.ceil((conn.rateLimitedUntil - Date.now()) / 1000)} 秒后自动重试（凭据无误，无需改密码）` : "",
@@ -5894,6 +5895,100 @@ function registerRoutes(ctx, relayDir) {
  * @param ctx - host cordis context（注入 webServer）。
  * @param config - entry config（可选 relayDir）。
  */
+
+// ---------- 目录选择器：远程控制下必须用「浏览器内实现」（0.6.14） ----------
+//
+// 用户实测（Windows）：镜像页里点「添加工作区」**没反应**；同一功能在 Mac 上正常。
+//
+// 根因：官方 `directory-picker-auto` 在**绑定仅回环**且平台是 darwin/win32 时会挂
+// **原生**选择器（macOS 走 osascript，Windows 走一个 koffi + worker.cjs 子进程去弹 Win32
+// 文件夹对话框，还要合成 Alt 抢前台）。对远程控制来说这是双输：
+//   · 对话框弹在**电脑**那块屏上 —— 拿手机的人什么也看不到，表现就是"按钮无效"；
+//   · Windows 那条原生链路依赖 koffi 原生模块 + 子进程，失败点比 macOS 多得多。
+// 而 auto 只在 `webServer.host !== "127.0.0.1"` 时才改选 browse —— DSH Desktop（Electron 壳）
+// 自己持有 webserver 配置（实测监听 43120 / 回环），我们的 LAN 绑定补丁并不生效，于是它一直
+// 用的是原生那条路。**不能把"手机能不能选工作区"押在宿主的绑定地址上。**
+//
+// 做法（官方文档给的"直接合成那一对"的钉法）：在 loader 里先建起 browse 宿主+界面，
+// **成功之后**再摘掉 auto 条目（auto 的 effect 析构会连带卸掉 native 那一对）。
+//
+// 三条护栏，顺序不能改：
+//   ① 只在当前 kind === "native" 时动手；已经是 browse 就完全不碰（多数自建部署就是这样）；
+//   ② 先建 browse、后摘 auto —— browse 建不起来就什么都不做，宁可用原生也不能让选择器消失；
+//   ③ 任何失败只记日志、绝不抛给宿主（插件不能把 dsh web 拖挂）。
+// `DSH_REMOTE_NATIVE_PICKER=1` 可整体退出（想保留系统原生对话框的人）。
+const PICKER_AUTO_ENTRY_ID = "directory-picker";
+const PICKER_BROWSE_PACKAGES = [
+  "@deepseek-ai/dsh-host-directory-picker-browse",
+  "@deepseek-ai/dsh-client-ui-directory-picker-browse"
+];
+/** 最近一次固定的结果（诊断面板会显示：这类"点了没反应"的问题一眼定位）。 */
+let pickerPinState = { kind: "", action: "pending", detail: "" };
+
+/** 当前挂的是哪一路选择器（服务未就绪时返回空串）。 */
+function directoryPickerKind(ctx) {
+  try {
+    const svc = typeof ctx.get === "function" ? ctx.get("directoryPicker") : null;
+    const cap = svc && typeof svc.capability === "function" ? svc.capability() : null;
+    return cap && typeof cap.kind === "string" ? cap.kind : "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * 把目录选择器固定成 browse（幂等）。服务要等 auto 挂完才存在，所以内部带重试窗口。
+ * @returns {Promise<{kind:string, action:string, detail:string}>}
+ */
+async function pinBrowseDirectoryPicker(ctx, { attempts = 6, gapMs = 700 } = {}) {
+  if (String(process.env.DSH_REMOTE_NATIVE_PICKER || "") === "1") {
+    pickerPinState = { kind: directoryPickerKind(ctx), action: "skipped", detail: "DSH_REMOTE_NATIVE_PICKER=1，保留系统原生对话框" };
+    return pickerPinState;
+  }
+  let loader = null;
+  try { loader = typeof ctx.get === "function" ? ctx.get("loader") : null; } catch { loader = null; }
+  if (!loader || typeof loader.create !== "function") {
+    pickerPinState = { kind: directoryPickerKind(ctx), action: "skipped", detail: "没有 loader 服务，无法干预选择器" };
+    return pickerPinState;
+  }
+  for (let i = 0; i < attempts; i += 1) {
+    const kind = directoryPickerKind(ctx);
+    if (kind === "browse") {
+      pickerPinState = { kind, action: "none", detail: "已经是浏览器内选择器" };
+      return pickerPinState;
+    }
+    if (kind === "native") {
+      const created = [];
+      try {
+        for (const name of PICKER_BROWSE_PACKAGES) created.push(await loader.create({ name }));
+      } catch (e) {
+        for (const id of [...created].reverse()) { try { await loader.remove(id); } catch { /* 尽力回滚 */ } }
+        pickerPinState = { kind, action: "kept_native", detail: `浏览器内选择器装不起来，保留原生：${e && e.message ? e.message : e}` };
+        ctx.logger?.warn?.(`dsh-remote-web: 目录选择器固定为 browse 失败，保留原生：${e && e.message ? e.message : e}`);
+        return pickerPinState;
+      }
+      try {
+        const entry = loader.store ? loader.store[PICKER_AUTO_ENTRY_ID] : null;
+        if (entry) await loader.remove(PICKER_AUTO_ENTRY_ID);
+      } catch (e) {
+        // browse 已经起来了，选择器可用；只是 auto 没摘掉（两者并存时 browse 生效即可）
+        pickerPinState = { kind: "browse", action: "pinned", detail: `已切到浏览器内选择器（auto 条目未摘除：${e && e.message ? e.message : e}）` };
+        return pickerPinState;
+      }
+      pickerPinState = {
+        kind: "browse",
+        action: "pinned",
+        detail: "原生对话框在远程时弹在电脑那台屏上（手机上看不到），已改为浏览器内选择器"
+      };
+      ctx.logger?.info?.("dsh-remote-web: 目录选择器已固定为浏览器内实现（原生对话框远程不可见）");
+      return pickerPinState;
+    }
+    await sleep(gapMs); // 服务还没挂上（auto 正在建）→ 下一轮再看
+  }
+  pickerPinState = { kind: directoryPickerKind(ctx), action: "skipped", detail: "启动窗口内未确认到选择器服务" };
+  return pickerPinState;
+}
+
 export function apply(ctx, config = {}) {
   const relayDir = config.relayDir || process.env.DSH_RELAY_DIR || DEFAULT_RELAY_DIR;
   // 记住宿主 ctx：上游地址要问 dsh web 自己的监听端口（见 upstreamUrl）。
@@ -5929,6 +6024,12 @@ export function apply(ctx, config = {}) {
   ctx.effect(() => registerRoutes(ctx, relayDir), "dsh-remote-web: /dsh-remote routes");
   // 0.1.2-rc.1+ 浏览器会话代持：换取 Harness 会话 Cookie 供 bridge 上游携带（手机点设备不再 401 白页）
   ctx.effect(() => scheduleHarnessMint(ctx, relayDir), "dsh-remote-web: harness browser-session mint");
+  // 目录选择器:远程控制下必须用浏览器内实现(否则手机点「添加工作区」像没反应) —— 见上方长注释
+  ctx.effect(() => {
+    let alive = true;
+    void pinBrowseDirectoryPicker(ctx).catch(() => { /* 绝不影响宿主 */ });
+    return () => { alive = false; void alive; };
+  }, "dsh-remote-web: pin browser directory picker");
   // 插件市场一键全功能:缺桌面运行环境则自动安装,登录后自动拉起 bridge(不依赖用户跑 npx)
   ctx.effect(() => scheduleRuntime(relayDir), "dsh-remote-web: runtime self-provision");
   // 匿名遥测：插件停摆（卸载/重载）时停掉发送心跳；磁盘队列留给下次装载补发。
@@ -5946,3 +6047,8 @@ export function apply(ctx, config = {}) {
   maybeReportInstall(relayDir);
   ctx.logger?.info?.(`dsh-remote-web: /dsh-remote routes ready (relayDir=${relayDir})`);
 }
+
+// test hooks：cordis 只读 name/inject/apply，这些导出只给用例（见 test/picker-pin.test.mjs）。
+// 为什么不放进 apply 内部直接测：apply 是"装载即副作用"的同步函数，选择器固定是异步且带重试窗口的，
+// 单独导出才能把「先建 browse、后摘 auto」这个顺序契约钉死。
+export { pinBrowseDirectoryPicker as __pinBrowseDirectoryPicker, pickerPinState as __pickerPinState, directoryPickerKind as __directoryPickerKind, PICKER_AUTO_ENTRY_ID as __PICKER_AUTO_ENTRY_ID, PICKER_BROWSE_PACKAGES as __PICKER_BROWSE_PACKAGES };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-web",
-  "version": "0.6.12",
+  "version": "0.6.14",
   "description": "公网远程控制 DeepSeek Harness（dsh web）：安装即得专属加密地址，人在外面也能用手机访问电脑上的 dsh——无需同一局域网/WiFi、无需公网 IP 与内网穿透，全程加密；手机端 100% 还原电脑体验（对话/工具/审批/设置）。技术用户可选自建服务，流量走自己的服务器。Remote control DeepSeek Harness (dsh web) from anywhere over the public internet — install, get an encrypted URL, use it from your phone on any network (dual-half cordis plugin: Settings panel + same-origin /dsh-remote routes). (2026-09 由 dsh-remote-ui 更名 / renamed from dsh-remote-ui; dsh-remote 的 dsh web 插件半，不是纯 UI/皮肤插件)",
   "type": "module",
   "main": "lib/index.js",

package/runtime/clients/dsh-remote/dsh-bridge.mjs

@@ -76,6 +76,7 @@ import { promisify } from "node:util";
 import { gzip as gzipCb } from "node:zlib";
 // 移动端适配层(经隧道访问的官方 dsh web 窄屏注入;DSH_MOBILE_ADAPTER=0 可关闭,默认开启)
 import { maybeInjectMobileAdapter } from "./mobile-adapter.mjs";
+import { discoverUpstream, resolveUpstreamHint, FALLBACK_UPSTREAM } from "./upstream-discovery.mjs";
 // 镜像页 E2EE 加密 shim(Phase-4):text/html 注入;DSH_E2EE_SHIM=0 可关闭,叠加 e2ee.enabled 灰度门
 import { maybeInjectE2eeShim } from "./e2ee-shim.mjs";
 // E2EE(端到端加密)客户端基建(Phase-2):MK 派生/会话密钥/信封/握手/开关
@@ -114,7 +115,23 @@ const CONFIG_PATH = process.env.DSH_BRIDGE_CONFIG || DEFAULT_CONFIG;
 // 隧道模式(唯一):bridge 主动 WS 连 relay-router 的 /_bridge
 const TUNNEL_URL = (process.env.DSH_BRIDGE_TUNNEL_URL || "").replace(/\/+$/, "");
 const TUNNEL_HEARTBEAT_MS = Math.max(100, Number(process.env.DSH_BRIDGE_HEARTBEAT_MS) || 15_000);
-const UPSTREAM = process.env.DSH_BRIDGE_UPSTREAM || "http://127.0.0.1:3080";
+/**
+ * 上游 dsh web 的地址。
+ *
+ * ⚠️ 这里**不能**只信环境变量 + 写死 3080（2026-09-23 两起用户实测）：
+ *   ① `dsh web --port 8090` / `--port 0`（系统分配）→ 3080 没人听；
+ *   ② **DSH Desktop**（Electron 壳 `dsh-plugin-desktop`）默认 43120，被占用还会 +1。
+ * bridge 与 watcher 共用同一份发现实现（`upstream-discovery.mjs`）：
+ *   显式环境变量 > `<relayDir>/.dsh-upstream`（插件半用 ctx.webServer.port 落盘）> DSH_WEB_URL
+ *   > **动态发现**（本机 dsh 进程实际监听端口 + Desktop 端口区间，且每个候选都做身份校验）。
+ *
+ * 用 `let` 是因为：① 发现发生在启动之后（异步）；② 上游端口变了要能在**不重启 bridge** 的前提下跟上。
+ */
+const RELAY_DIR = path.dirname(CONFIG_PATH);
+let UPSTREAM = (() => {
+  const hint = resolveUpstreamHint({ relayDir: RELAY_DIR });
+  return hint.url || FALLBACK_UPSTREAM;
+})();
 // 微信机器人通道总开关:DSH_WECHAT=0 关闭(默认开启)。控制面只 bind 回环,且必须带 bridge_secret。
 const WECHAT_DISABLED = String(process.env.DSH_WECHAT || "") === "0";
 // 默认云端服务地址（dsh-remote setup 会显式传入；自建模式无需账号 API）
@@ -385,6 +402,37 @@ const STRIP_RES_HEADERS = new Set([
   "connection", "keep-alive", "upgrade"
 ]);
 
+
+/** 上游重新发现的冷却:失败请求可能连成片,不能每个都去 lsof/pgrep + 探端口。 */
+const UPSTREAM_REFRESH_COOLDOWN_MS = 15_000;
+let upstreamRefreshedAt = 0;
+let upstreamRefreshInflight = null;
+/**
+ * 重新解析上游地址(带身份校验;显式 DSH_BRIDGE_UPSTREAM 时是恒等操作)。
+ * 上游端口变了(Desktop 换端口 / dsh web 重启到别的端口)时,靠它自愈而不必重启 bridge。
+ */
+async function refreshUpstream(reason = "") {
+  if (upstreamRefreshInflight) return upstreamRefreshInflight;
+  const now = Date.now();
+  if (now - upstreamRefreshedAt < UPSTREAM_REFRESH_COOLDOWN_MS) return UPSTREAM;
+  upstreamRefreshedAt = now;
+  upstreamRefreshInflight = (async () => {
+    try {
+      const found = await discoverUpstream({ relayDir: RELAY_DIR });
+      if (found.url && found.url !== UPSTREAM) {
+        console.log(`[bridge] 上游地址切换: ${UPSTREAM} → ${found.url}（来源 ${found.source}${reason ? `,${reason}` : ""}）`);
+        UPSTREAM = found.url;
+      }
+      return UPSTREAM;
+    } catch {
+      return UPSTREAM;
+    } finally {
+      upstreamRefreshInflight = null;
+    }
+  })();
+  return upstreamRefreshInflight;
+}
+
 console.log(`[bridge] 设备 ${DEVICE_ID} → 隧道 ${TUNNEL_URL}/_bridge`);
 console.log(`[bridge] 上游 ${UPSTREAM}`);
 
@@ -505,6 +553,15 @@ export async function handleFrame(dchOrSend, frame) {
   if (id === undefined || id === null) return;
   const send = toSender(dchOrSend);
   if (type === "http") return handleHttpFrame(send, frame);
+  if (type === "http-abort") {
+    // 手机侧断开了这条流(切页/锁屏):掐掉上游,别在电脑上留一条永不结束的 SSE 连接。
+    const c = streamAborts.get(id);
+    if (c) {
+      streamAborts.delete(id);
+      try { c.abort(); } catch { /* ignore */ }
+    }
+    return;
+  }
   if (type === "ws-open") return handleWsOpen(send, frame);
   if (type === "ws-msg") return handleWsMessage(send, frame);
   if (type === "ws-close") return handleWsClose(send, frame);
@@ -541,7 +598,10 @@ function headerValue(headers, name) {
  * 保守策略:任一条件不满足都返回 null(原样回传):
  *   - 方法非 HEAD、状态非 204/304;
  *   - buf ≥ 1KB(太小不值得压);
- *   - 上游未编码(contentEncoding 为空;undici 已自动解压 body,这里只看原 header);
+ *   - `contentEncoding` 为空 —— ⚠️ 它指的是**手上这份 buf 的编码**,不是上游响应头的值:
+ *     上游头的 "gzip" 在 undici 解压后依然留着(见下),照抄过来只会让我们白丢压缩收益;
+ *     调用方必须传"buf 是否已编码",dsh-bridge 的 doHttp 因此**固定传空串**。
+ *     若哪天 buf 真是一段未解压的字节流,调用方才应把对应编码传进来(函数会保守放弃压缩)。
  *   - 请求 Accept-Encoding 含 gzip(手机浏览器必带;没有就不压,避免手机不会解压);
  *   - content-type 可压缩(排除 text/event-stream);
  *   - gzip 后确实更小(极小文件/不可压数据 gzip 反而更大,保守判断)。
@@ -565,6 +625,97 @@ export async function maybeCompressResponse({ buf, contentType, contentEncoding,
   return { buf: out, headers: { "content-encoding": "gzip" } };
 }
 
+/**
+ * 进行中的 SSE 流:frameId → AbortController。
+ * 手机侧断开时,中继会发 `http-abort`,这里据此掐掉上游(否则电脑上会留一条永不结束的连接)。
+ */
+const streamAborts = new Map();
+
+/**
+ * 中继在 `tunnel-register-ok` 里声明支持的**追加帧能力**。
+ *
+ * 为什么必须协商:browser→中继→bridge 是两段**独立升级**的链路。
+ * 新 bridge 的流式帧(`http-chunk`/`http-end`)对**旧中继**是不认识的 —— 旧中继会把
+ * "仅头部"帧当成一个完整的空响应直接 `end()`,SSE 于是变成"秒断 + 浏览器狂重连",
+ * 比原来的 120 秒挂起**更糟**。所以能力由中继声明:拿不到 `http-stream` 就老实退回
+ * 旧的整包缓冲行为(慢,但正确)。默认空集合 = 保守(连不上/旧中继都不冒险用新帧)。
+ */
+const routerCaps = new Set();
+
+/**
+ * SSE(`text/event-stream`)流式转发。
+ *
+ * 为什么必须流式:`doHttp` 是「整包 `await res.arrayBuffer()`」的语义,而 SSE **永不结束** ——
+ * 实测 DSH 的 `/plugins/events`(client-hmr 的事件通道)每次页面加载都把这条请求挂满
+ * bridge 的 120s 上游超时,然后报错;浏览器 EventSource 立刻重连,于是手机端 Network 里
+ * **永远有一条转圈的请求**,页面也始终拿不到事件。
+ *
+ * 帧协议(对中继**追加**、与既有 `http` 帧并存;不认识 streaming 的旧中继只会忽略后续
+ * chunk,退化成"空 body 后结束",不会把页面打挂):
+ *   ← { id, type:"http",       status, headers, streaming:true }  仅头部,无 body
+ *   ← { id, type:"http-chunk", seq, body, bodyBase64:true }       0..n 次
+ *   ← { id, type:"http-end",   seq }                              流结束(含出错收尾)
+ *   → { id, type:"http-abort" }                                   手机断开 → 掐上游
+ *
+ * ⚠️ E2EE 路径**不**走这里:信封是"一问一答"的结构,SSE 要逐块封/解需要另立协议;
+ *    而现实里 SSE 由 `EventSource` 发出、shim 不接管它(不带头部信封标记),
+ *    所以密文流根本不存在 —— 真要做时再单独设计,不要在这里偷偷降级成明文。
+ *
+ * @returns {Promise<{status:number, chunks:number, bytes:number, aborted?:boolean}>}
+ */
+async function doHttpStream(send, id, method, path, reqHeaders) {
+  const safe = safePath(path);
+  if (safe === null) throw new Error("非法路径");
+  const reqHdrs = sanitizeRequestHeaders(reqHeaders);
+  const ck = harnessCookieOf(); // 新版 dsh web 的浏览器会话 Cookie(否则 401 白页)
+  if (ck) reqHdrs.Cookie = ck;
+  const controller = new AbortController();
+  streamAborts.set(id, controller);
+
+  let res;
+  try {
+    res = await fetch(`${UPSTREAM}${safe}`, { method, headers: reqHdrs, signal: controller.signal });
+  } catch (e) {
+    streamAborts.delete(id);
+    throw e; // 头部都还没发出去 → 交给调用方回一个普通错误帧
+  }
+
+  const status = res.status;
+  // 头部帧:告诉中继"这是一条流",随后才逐块推 body
+  send({
+    id,
+    type: "http",
+    status,
+    headers: sanitizeResponseHeaders(Object.fromEntries(res.headers.entries())),
+    streaming: true
+  });
+
+  let seq = 0;
+  let bytes = 0;
+  try {
+    const reader = res.body && typeof res.body.getReader === "function" ? res.body.getReader() : null;
+    if (reader) {
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (!value || value.length === 0) continue;
+        bytes += value.length;
+        send({ id, type: "http-chunk", seq: ++seq, body: Buffer.from(value).toString("base64"), bodyBase64: true });
+      }
+    }
+  } catch (e) {
+    // 头部已经发出去了:这里**绝不能**抛(调用方会用普通帧回 502,而中继那边响应头已定,
+    // 再写一次 head 会炸)。统一以 http-end 收尾,让 EventSource 按自己的节奏重连。
+    const aborted = controller.signal.aborted === true;
+    streamAborts.delete(id);
+    send({ id, type: "http-end", seq, ...(aborted ? { aborted: true } : { error: String(e?.message || e) }) });
+    return { status, chunks: seq, bytes, aborted };
+  }
+  streamAborts.delete(id);
+  send({ id, type: "http-end", seq });
+  return { status, chunks: seq, bytes };
+}
+
 async function doHttp(method, path, reqHeaders, body, isB64) {
   const safe = safePath(path);
   if (safe === null) throw new Error("非法路径");
@@ -624,7 +775,14 @@ async function doHttp(method, path, reqHeaders, body, isB64) {
   const compressed = await maybeCompressResponse({
     buf,
     contentType,
-    contentEncoding: res.headers.get("content-encoding") || "",
+    // 🔴 必须传空:这里的 `buf` 是 **undici 已经解压过**的明文,不是上游线速字节。
+    //    以前传的是 `res.headers.get("content-encoding")` —— 而 undici 解压之后**仍会把该头留着**
+    //    (本文件 sanitizeResponseHeaders 的注释正是这么写的:"undici 已自动解压 body,
+    //     content-encoding/length 会误导浏览器")。于是 maybeCompressResponse 看到 "gzip"
+    //    就保守地 `return null`,**永不重压** —— 实测代价:线上 dsh web 的 `/plugins/??`
+    //    聚合包本来 gzip 后 5.12MB,被原样发出 13.39MB(2.6×),免费档 1Mbps 下从 40 秒变成 100+ 秒。
+    //    传空之后语义才是自洽的:"我手上这份 buf 是未编码的明文,可以压"。
+    contentEncoding: "",
     acceptEncoding: headerValue(reqHeaders, "accept-encoding"),
     status: res.status,
     method
@@ -693,12 +851,22 @@ export async function handleHttpFrame(dchOrSend, frame) {
     }
   }
   try {
+    // SSE 必须流式转发(否则会挂满 120s 超时,见 doHttpStream 注释)。
+    // 客户端是 EventSource 时必带 Accept: text/event-stream,以此为准(不看路径白名单,免得漏)。
+    if (routerCaps.has("http-stream") && String(headerValue(headers, "accept") || "").includes("text/event-stream")) {
+      const s = await doHttpStream(send, id, method, path, headers);
+      console.log(`[bridge] ${method} ${path} → SSE ${s.status} (${Date.now() - t0}ms, ${s.chunks} 块 / ${(s.bytes / 1024).toFixed(1)}KB${s.aborted ? ", 手机已断开" : ""})`);
+      return;
+    }
     const reply = await doHttp(method, path, headers, body, !!isB64);
     reply.id = id;
     reply.type = "http";
     send(reply);
     console.log(`[bridge] ${method} ${path} → ${reply.status} (${Date.now() - t0}ms, ${(reply.body.length * 3 / 4 / 1024).toFixed(0)}KB)`);
   } catch (e) {
+    // 上游不可达是「端口可能变了」的最强信号（Desktop 换端口 / dsh web 重启到别的端口）：
+    // 触发一次带冷却的重新发现，后续请求自动跟上，不必重启 bridge。
+    void refreshUpstream("上游请求失败");
     console.log(`[bridge] ${method} ${path} 上游错误: ${e.message}`);
     send({ id, type: "http", status: 502, headers: { "content-type": "application/json" }, body: Buffer.from(JSON.stringify({ error: String(e.message || e) })).toString("base64"), bodyBase64: true });
   }
@@ -760,6 +928,7 @@ export async function handleLegacyFrame(dchOrSend, frame) {
     send({ id, status: reply.status, headers: reply.headers, body: text });
     console.log(`[bridge] legacy ${method} ${path} → ${reply.status} (${Date.now() - t0}ms)`);
   } catch (e) {
+    void refreshUpstream("上游请求失败(legacy)");
     console.log(`[bridge] legacy ${method} ${path} 上游错误: ${e.message}`);
     send({ id, status: 502, headers: {}, body: JSON.stringify({ error: String(e.message || e) }) });
   }
@@ -1157,6 +1326,9 @@ function connectTunnel(token) {
     try {
       receive(raw, (frame) => {
         if (frame?.type === "tunnel-register-ok") {
+          // 记下中继声明的追加帧能力(旧中继不带 caps → 空集合 → 退回整包缓冲,见 routerCaps 注释)
+          routerCaps.clear();
+          for (const c of Array.isArray(frame.caps) ? frame.caps : []) routerCaps.add(String(c));
           // 中继注册成功 = 手机端此刻真的能进这台电脑:面板据此把阶段推进到 online(已连接 ✅)
           persistBridgeState({ device_id: DEVICE_ID, tunnel_registered_at: Date.now(), phase: "online", last_error: null });
           console.log(`[bridge] ✅ router 注册成功: ${DEVICE_ID},等待手机访问 /remote/${DEVICE_ID}/`);
@@ -1172,6 +1344,7 @@ function connectTunnel(token) {
     } catch (e) { console.log(`[bridge] 隧道帧错误: ${e.message}`); }
   });
   ws.on("close", (code, reason) => {
+    routerCaps.clear(); // 换中继/断线:能力重新协商,期间一律退回保守行为
     clearInterval(heartbeat);
     console.log(`[bridge] 隧道断开(code=${code}${reason ? ", " + reason : ""})`);
     closeAllWsSessions();
@@ -1348,6 +1521,9 @@ function startWeChat() {
     const cfg = loadLocalConfig();
     wechatRuntime = createWeChatRuntime({
       relayDir,
+      // 上游地址在 runTunnel() 开头已完成动态发现（见 refreshUpstream），所以这里拿到的是真实端口。
+      // ⚠️ 这是**取值**而非引用：运行中若上游端口又变了（自愈重发现），微信通道要等 bridge 重启才跟上；
+      //    隧道转发那一侧不受影响（它每次都读最新的 UPSTREAM）。
       upstream: UPSTREAM,
       cookieOf: harnessCookieOf,
       secret: process.env.DSH_BRIDGE_SECRET || (typeof cfg.bridge_secret === "string" ? cfg.bridge_secret : ""),
@@ -1393,6 +1569,10 @@ function redactText(e) {
 }
 
 async function runTunnel() {
+  // 先动态确定上游再连隧道：上游端口不是 3080 时（DSH Desktop 默认 43120）这一步是关键 ——
+  // 否则 bridge 会连上中继、手机也能打开页面，但每个请求都打到一个没人听的端口。
+  await refreshUpstream("启动");
+  console.log(`[bridge] 上游地址已确定: ${UPSTREAM}`);
   const token = await resolveToken();
   if (!token) {
     console.error("[bridge] 隧道模式需要账号认证:请设 DSH_BRIDGE_TOKEN,或 DSH_BRIDGE_PHONE+DSH_BRIDGE_PASSWORD");

package/runtime/clients/dsh-remote/mobile-adapter.mjs

@@ -95,7 +95,34 @@ const RUNTIME_HOST_RE =
   /(data-sidebar-collapsed|data-details-collapsed|data-rightbar-collapsed|data-shell-overlay)|(pI_x6G_frame|hHd-Xa_root|hHd-Xa_toggle)/;
 
 const STYLE = `
-/* ===== dsh-remote mobile adapter (bridge 注入;仅 ≤820px 生效,桌面宽屏无任何规则) ===== */
+/* ===== 首屏加载提示（0.6.14）=====
+   为什么要有它：镜像页首屏要拉 dsh web 的全部客户端插件（实测 ~14 MB，一个不可拆分的
+   /plugins/?? 聚合请求），免费档限速下几十秒起步。此前页面上**只有官方那个转圈**，
+   用户无法区分"在加载"和"卡死了"，只能反复刷新 —— 反而更慢。
+   这里给一句人话提示 + 分阶段的补充说明，加载完成（或超时兜底）即自动移除。
+   ⚠️ 刻意**不**放进 @media (max-width:820px)：Windows/桌面浏览器打开镜像页同样要等。
+   ⚠️ pointer-events:none + 半透明：万一移除逻辑失效，也绝不挡住任何点击。 */
+.dsh-ma-boot {
+  position: fixed; inset: 0; z-index: 2147483000;
+  display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 14px;
+  background: color-mix(in srgb, var(--dsw-alias-bg-base, #0f1115) 88%, transparent);
+  backdrop-filter: blur(2px);
+  pointer-events: none;
+  font-family: inherit; text-align: center; padding: 24px;
+  transition: opacity .3s ease;
+}
+.dsh-ma-boot[data-fading="1"] { opacity: 0; }
+.dsh-ma-boot-spin {
+  width: 34px; height: 34px; border-radius: 50%;
+  border: 3px solid color-mix(in srgb, currentColor 22%, transparent);
+  border-top-color: currentColor;
+  animation: dsh-ma-boot-spin 1s linear infinite;
+}
+@keyframes dsh-ma-boot-spin { to { transform: rotate(360deg); } }
+.dsh-ma-boot-title { font-size: 15px; font-weight: 600; }
+.dsh-ma-boot-sub { font-size: 13px; line-height: 1.6; opacity: .75; max-width: 22em; }
+.dsh-ma-boot-elapsed { font-size: 12px; opacity: .55; font-variant-numeric: tabular-nums; }
+
 @media (max-width: 820px) {
   html, body { max-width: 100%; overflow-x: hidden; }
   html { -webkit-text-size-adjust: 100%; text-size-adjust: 100%; }
@@ -426,6 +453,89 @@ html[data-dsh-ma-merged-e2ee] #dsh-e2ee-badge { display: none !important; }
 const SCRIPT = `(() => {
   "use strict";
 
+  /* ===== 首屏加载提示（0.6.14）=====
+     用户反馈：「普通用户加载进入镜像页面时等待时间较长，目前等待过程中一直在转圈」
+     —— 官方那个转圈不告诉用户任何事。这里在**页面解析的第一时间**就挂上一条人话提示，
+     并在官方 UI 就绪（或兜底超时）后自动移除。
+
+     ⚠️ 必须放在所有主机判定（HOSTISH / NARROW）之前：首屏慢的正是这些判定等不到的时候。
+     ⚠️ 只做提示，不做任何拦截：pointer-events:none，也没有遮罩语义。 */
+  var maBootTip = null, maBootTimers = [], maBootStart = Date.now(), maBootElapsedTimer = 0, maBootWatchTimer = 0;
+  function maBootSet(cls, text) {
+    try { var n = maBootTip && maBootTip.querySelector(cls); if (n) n.textContent = text; } catch (e) { /* 忽略 */ }
+  }
+  function maBootShow() {
+    try {
+      if (maBootTip) return;
+      if (!document.body) return; // 解析太早（body 还没出来）→ 交给 DOMContentLoaded 再挂
+      maBootTip = document.createElement("div");
+      maBootTip.className = "dsh-ma-boot";
+      maBootTip.setAttribute("role", "status");
+      maBootTip.setAttribute("aria-live", "polite");
+      maBootTip.innerHTML =
+        '<div class="dsh-ma-boot-spin" aria-hidden="true"></div>' +
+        '<div class="dsh-ma-boot-title">正在加载远程桌面…</div>' +
+        '<div class="dsh-ma-boot-sub">首次打开需要下载较完整的前端资源，请稍候</div>' +
+        '<div class="dsh-ma-boot-elapsed">已等待 0 秒</div>';
+      document.body.appendChild(maBootTip);
+      // 秒表：让"到底等了多久"可见（用户据此判断是慢还是死了）
+      maBootElapsedTimer = setInterval(function () {
+        try {
+          var s = Math.floor((Date.now() - maBootStart) / 1000);
+          var n = maBootTip && maBootTip.querySelector(".dsh-ma-boot-elapsed");
+          if (n) n.textContent = "已等待 " + s + " 秒";
+        } catch (e) { /* 忽略 */ }
+      }, 1000);
+      maBootTimers.push(setTimeout(function () {
+        maBootSet(".dsh-ma-boot-sub", "网络较慢时可能需要一两分钟；加载完成后会自动进入，不用重复刷新");
+      }, 8000));
+      maBootTimers.push(setTimeout(function () {
+        maBootSet(".dsh-ma-boot-sub", "还在加载…如果长时间停在这里，可以下拉刷新重试（重复刷新不会更快）");
+      }, 30 * 1000));
+    } catch (e) { /* 提示失败绝不影响主功能 */ }
+  }
+  function maBootHide() {
+    try {
+      for (var i = 0; i < maBootTimers.length; i++) clearTimeout(maBootTimers[i]);
+      maBootTimers = [];
+      if (maBootElapsedTimer) { clearInterval(maBootElapsedTimer); maBootElapsedTimer = 0; }
+      if (maBootWatchTimer) { try { clearInterval(maBootWatchTimer); } catch (e) { /* 忽略 */ } maBootWatchTimer = 0; }
+      var tip = maBootTip;
+      maBootTip = null;
+      if (tip && tip.parentNode) {
+        try { tip.setAttribute("data-fading", "1"); } catch (e) { /* 忽略 */ }
+        setTimeout(function () { try { if (tip.parentNode) tip.parentNode.removeChild(tip); } catch (e) { /* 忽略 */ } }, 300);
+      }
+    } catch (e) { /* 忽略 */ }
+  }
+  /** 官方 UI 是否已经可用了（= 提示可以撤了）。 */
+  function maBootLooksReady() {
+    try {
+      // ① 适配层认出来的官方 frame（与下方 boot() 同一组选择器）
+      if (document.querySelector(".pI_x6G_frame, [data-sidebar-collapsed], [data-details-collapsed], [data-rightbar-collapsed]")) return true;
+      // ② 出现输入框/会话区也算"进来了"（官方改版首选信号失灵时的兜底）
+      return Boolean(document.querySelector('textarea, [contenteditable="true"], [role="textbox"]'));
+    } catch (e) { return false; }
+  }
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", maBootShow);
+  } else {
+    maBootShow();
+  }
+  // 轮询撤下：1s 一次，成本可忽略（只是两次 querySelector）；一旦撤下就自我停止。
+  // 上限与"4 分钟兜底"对齐，避免页面异常时留下常驻定时器。
+  maBootWatchTimer = setInterval(function () {
+    if (maBootLooksReady()) { maBootHide(); return; }
+    if (!maBootTip) { try { clearInterval(maBootWatchTimer); } catch (e) { /* 忽略 */ } maBootWatchTimer = 0; }
+  }, 1000);
+  maBootTimers.push(setTimeout(function () { maBootHide(); }, 240 * 1000));
+  // 页面卸载/进 bfcache 时收干净（测试与真机都靠这条不留悬挂定时器）
+  try {
+    var maBootBye = function () { maBootHide(); };
+    window.addEventListener("pagehide", maBootBye);
+    window.addEventListener("unload", maBootBye);
+  } catch (e) { /* 忽略 */ }
+
   /* —— 主机门解除(2026-09):镜像页(如 n.risegao.cn)经设备流认证回连同一台 127.0.0.1:3080,
      桥已把 Host 回环化并剥 Origin(不扩大信任面)。官方客户端以 transport.ownsHost 判定
      「自有主机」,非回环域名下不置 true 会把设置页置为 memory(不可用)镜像 →
@@ -1096,6 +1206,36 @@ const SCRIPT = `(() => {
       } catch (e8) { /* 引导条失败绝不能影响主功能 */ }
     };
 
+    /* 适配层自己创建的「抽屉入口」引用(汉堡按钮 / 遮罩),提到 boot() 外层保存。
+       为什么必须提到外层:官方 SPA 重渲染时会整片替换 body 子树,把这两个节点一起冲掉;
+       留住引用才能在下面的「存在性看门狗」里把**同一个节点**补回去(节点不变 → 挂在它上面的
+       click 处理、CSS 类、aria 属性全都原样保留,不会出现"补回来点不动"的假按钮)。 */
+    let maHamburger = null, maScrim = null;
+
+    /* 节点是否已经脱离文档。判不出来时一律当作"还在"—— 宁可不补,也绝不重复插入。 */
+    const maDetached = (el) => {
+      if (!el) return false;
+      try { if (typeof el.isConnected === "boolean") return !el.isConnected; } catch (eConn) { /* 继续退化 */ }
+      try {
+        const b = document.body;
+        if (b && typeof b.contains === "function") return !b.contains(el);
+      } catch (eHas) { /* 继续退化 */ }
+      return false;
+    };
+
+    /* —— 存在性看门狗:「建好了」不等于「一直都在」----------------------------------
+       done=true 只保证**曾经**建出来过。官方在路由/会话切换时会重建 DOM 子树,我们的汉堡按钮
+       与遮罩会跟着消失 —— 用户看到的就是"抽屉按钮用着用着又没了"。
+       这里按**引用**补回(不是重建),只在窄屏做(宽屏本来就不需要抽屉入口)。
+       幂等:节点还在文档里 → 什么都不做;boot 还没成功(引用为 null) → 同样什么都不做。 */
+    const ensureDrawerChrome = () => {
+      try {
+        if (!NARROW() || !document.body) return;
+        if (maDetached(maScrim)) document.body.appendChild(maScrim);
+        if (maDetached(maHamburger)) document.body.appendChild(maHamburger);
+      } catch (eChrome) { /* 补不回去也不能影响抽屉开合本身 */ }
+    };
+
     let done = false;
     const boot = () => {
       if (!HOSTISH()) return;
@@ -1228,6 +1368,7 @@ const SCRIPT = `(() => {
       const scrim = document.createElement("div");
       scrim.className = "dsh-ma-scrim";
       document.body.appendChild(scrim);
+      maScrim = scrim;                          // 供「存在性看门狗」在被官方冲掉后补回
       scrim.addEventListener("click", (e) => {
         e.stopPropagation();
         userWantsOpen = false;                    // 用户明确要关(遮罩的作用就是关抽屉)
@@ -1245,6 +1386,7 @@ const SCRIPT = `(() => {
       hamburger.setAttribute("aria-label", "打开菜单");
       hamburger.innerHTML = '<svg width="22" height="22" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round" aria-hidden="true"><path d="M4 6h16M4 12h16M4 18h10"/></svg>';
       document.body.appendChild(hamburger);
+      maHamburger = hamburger;                  // 供「存在性看门狗」在被官方冲掉后补回
       hamburger.addEventListener("click", (e) => {
         e.stopPropagation(); e.preventDefault();
         const nowOpen = document.documentElement.classList.contains("dsh-ma-sidebar-open");
@@ -1516,10 +1658,82 @@ const SCRIPT = `(() => {
     };
 
     if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", boot); else boot();
-    /* 官方模块系统异步挂载 UI,晚一点再补几次(幂等,done 守卫);同时等鲸鱼/设置弹层就位 */
-    [700, 1600, 3200, 7000, 12000].forEach((ms) =>
-      setTimeout(() => { try { boot(); whaleHookInit(); watchSettings(); } catch (e) { /* 幂等重试 */ } }, ms)
-    );
+
+    /* ================= 执行时机:无限期等待官方 DOM 就绪 =================
+       用户实测原话(2026-09-2x):「在网络比较慢的情况下,左边的抽屉按钮有时候出不来。
+                                   甭管网络有多慢,都要让那个抽屉能加载出来。」
+       ⚠️ 旧实现是**一组写死的固定重试**([700, 1600, 3200, 7000, 12000]ms),而汉堡按钮的创建
+          排在 boot() 里 "if (!frame) return;" 那一行之后 —— 官方 SPA bundle 有 13.4MB(实测未压缩),
+          免费档被中继限速到 128KB/s 时冷启动要 1-2 分钟,官方 frame 在 12 秒内根本没出现:
+          5 次重试全部在那一行返回 → done 永远为 false → 汉堡按钮**永远**不创建
+          → 用户看到"左边抽屉按钮出不来"。任何固定窗口都只是把这个阈值往后挪,治不了根。
+       现在改成「事件驱动 + 低频兜底」的**无限期**等待,只要抽屉入口还没建好就一直试:
+         · MutationObserver(document/subtree):官方 frame 一挂上就立刻跟上(网络快时零延迟);
+         · setInterval(1000ms):兜底 + 存在性看门狗 —— observer 不可用/被绕过时照样收敛,
+           也负责在 done 之后发现官方重渲染冲掉了我们的节点并补回。
+       两条路都只是"再调一次 pump()",pump 内部**全部幂等**(done / fabDone / whaleGuardsOn /
+       settingsWatchOn / drawerAutoCloseOn 等守卫都在),重复调用不会产生任何副作用,
+       也不改变"执行什么"——开合、遮罩不变量、sync()、isDrawer() 判定一行未动。 */
+    let maTorn = false, maInterval = 0, maObserver = null, maRafPending = false;
+    /* 廉价的"boot() 还有事可做吗"闸门(只读两个现成的布尔标志,不做任何 DOM 操作):
+         · fab 还没建出来(fabDone=false) → 要跑;
+         · 抽屉那段还没建好(done=false)且当前是窄屏 → 要跑(旋转/缩放回窄屏也能补建)。
+       两者都不成立 → boot() 里已无事可做,**绝不能**再跑:boot() 第一行 HOSTISH() 会把
+       documentElement.outerHTML 整个序列化一遍(最长 200KB),而官方流式输出时每帧都有 DOM
+       变更 —— 没有这道闸门就会变成每秒几十次全量序列化(旧实现只跑 5 次,不会有这个问题)。 */
+    const bootUseful = () => !fabDone || (!done && NARROW());
+    const pump = () => {
+      if (maTorn) return;
+      if (bootUseful()) { try { boot(); } catch (eBoot) { /* 幂等重试 */ } }
+      try { ensureDrawerChrome(); } catch (eChrome2) { /* 忽略 */ }
+      if (!whaleGuardsOn || !settingsWatchOn) {
+        try { whaleHookInit(); watchSettings(); } catch (eHook) { /* 两者内部都自带一次性守卫 */ }
+      }
+    };
+    /* 节流:一次 DOM 变更往往产生几十条记录,逐条 boot() 就是忙轮询。
+       统一合并成"本帧最多跑一次"(有 rAF 用 rAF,没有就退化成 0ms 宏任务) —— 天然去重。 */
+    const schedulePump = () => {
+      if (maTorn || maRafPending) return;
+      maRafPending = true;
+      const run = () => { maRafPending = false; pump(); };
+      try { if (typeof requestAnimationFrame === "function") { requestAnimationFrame(run); return; } } catch (eRaf) { /* 退化 */ }
+      setTimeout(run, 0);
+    };
+    /* 挂上"叫醒"的两条路。做成可重入(先清旧的再建新的),这样 bfcache 恢复后能重新武装。 */
+    const maArm = () => {
+      maTorn = false;
+      maRafPending = false;            // 冻结时若有一帧没跑到,不清掉就会永远挡住后续调度
+      try { if (maObserver) maObserver.disconnect(); } catch (eA1) { /* 忽略 */ }
+      maObserver = null;
+      try { if (maInterval) clearInterval(maInterval); } catch (eA2) { /* 忽略 */ }
+      maInterval = 0;
+      try {
+        if (typeof MutationObserver === "function" && document.documentElement) {
+          maObserver = new MutationObserver(schedulePump);
+          /* 只观察 childList+subtree:节点被官方换掉/新增才叫醒我们。
+             ⚠️ 刻意**不**观察 attributes —— 我们自己的 sync() 就会不停改 class,那会变成自激循环。 */
+          maObserver.observe(document.documentElement, { childList: true, subtree: true });
+        }
+      } catch (eObs) { maObserver = null; /* 退化:只靠下面的兜底表 */ }
+      try { maInterval = setInterval(pump, 1000); } catch (eInt) { maInterval = 0; }
+    };
+    maArm();
+    /* 清理:页面卸载时断开观察者与兜底表(bfcache/长驻页面都不留悬挂回调)。
+       pagehide 覆盖 bfcache 场景,unload 兜底更老的浏览器。 */
+    const maTeardown = () => {
+      maTorn = true;
+      try { if (maObserver) maObserver.disconnect(); } catch (eD1) { /* 忽略 */ }
+      maObserver = null;
+      try { if (maInterval) clearInterval(maInterval); } catch (eD2) { /* 忽略 */ }
+      maInterval = 0;
+    };
+    try { window.addEventListener("pagehide", maTeardown); } catch (ePh) { /* 忽略 */ }
+    try { window.addEventListener("unload", maTeardown); } catch (eUl) { /* 忽略 */ }
+    /* 手机上"切到别的 App 再切回来"走的常是 bfcache:pagehide(persisted=true) → pageshow(persisted=true)。
+       DOM 原样保留但计时器/观察者已断 —— 这里重新武装,否则回到页面后看门狗就永久失灵了。 */
+    try {
+      window.addEventListener("pageshow", (ev) => { try { if (ev && ev.persisted) maArm(); } catch (ePs) { /* 忽略 */ } });
+    } catch (ePs2) { /* 忽略 */ }
   } catch (e) { if (window.console) console.warn("[dsh-mobile-adapter]", e && e.message); }
 })();`;
 

package/runtime/clients/dsh-remote/upstream-discovery.mjs

@@ -0,0 +1,292 @@
+/**
+ * 上游（dsh web）地址发现 —— **单一实现**，watcher（dsh-setup.mjs）与 bridge（dsh-bridge.mjs）共用。
+ *
+ * ## 为什么需要它
+ *
+ * 桥接链路的两端（watcher 的存活探测、bridge 的转发目标）原本把上游写死
+ * `http://127.0.0.1:3080`（独立 `dsh web` 的默认端口）。但真实世界里端口是会变的：
+ *
+ *   · `dsh web --port 8090` / profile 里配了 port / `--port 0` 让系统分配空闲端口；
+ *   · **DSH Desktop**（Electron 壳 `dsh-plugin-desktop`）默认监听 **43120**，且被占用时按 +1 递增；
+ *   · `dsh web` 重启后端口可能不同。
+ *
+ * 2026-09-23 用户实测（DSH Desktop 2.0.4 + 插件 0.6.10）：上游在 43120，而 watcher 探 3080 →
+ * **永远探不到 → bridge 永远不被派生 → 面板永久停在「正在启动 Bridge…」**，设备从未登记。
+ * 这不是"某个用户环境特殊"，而是**所有改了端口的用户**都会踩的同一类问题，所以要有通用发现。
+ *
+ * ## 发现顺序（先便宜后昂贵，每一步都做**身份校验**）
+ *
+ *   1. `DSH_BRIDGE_UPSTREAM`（显式覆盖，部署/排障用）—— 唯一不做探测就采信的来源；
+ *   2. `<relayDir>/.dsh-upstream`（**插件半**在宿主进程里用 `ctx.webServer.port` 落盘，最权威）；
+ *   3. `DSH_WEB_URL` 的端口；
+ *   4. **实测端口**：本进程的祖先进程 / 本机 dsh 进程正在 LISTEN 的端口（lsof / netstat）；
+ *   5. 静态候选：3080 + DSH Desktop 的 43120 及其递增区间。
+ *
+ * ⚠️ 第 4、5 步必须**校验身份**：43120 之类的端口可能被别的本地程序占用，
+ *    把 bridge 接到一个陌生人身上既不可用、也可能泄露数据。判据见 `looksLikeDshWeb`。
+ *
+ * ⚠️ 探测全部**并行**且有总预算：本地端口连接被拒是瞬时的，只有"端口在听但不回包"才会等到超时，
+ *    串行探 12 个候选最坏要十几秒，会让 watcher 的轮询卡住。
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+/** 插件半落盘的上游地址文件名（与 packages/dsh-remote-web/lib/index.js 的常量同名同义）。 */
+export const UPSTREAM_FILE = ".dsh-upstream";
+/** 独立 `dsh web` 的默认端口（历史行为，最后的兜底）。 */
+export const FALLBACK_UPSTREAM = "http://127.0.0.1:3080";
+/** DSH Desktop（Electron 壳）的默认 Web 端口；被占用时它按 +1 递增，所以要扫一段区间。 */
+export const DESKTOP_DEFAULT_PORT = 43120;
+/** Desktop 端口区间扫多少个（43120..43120+11）。 */
+export const DESKTOP_PORT_SCAN = 12;
+/** 单个候选的探测超时（本地回环，超过它基本就是"在听但不回包"）。 */
+const PROBE_TIMEOUT_MS = 900;
+
+/** 规范化：去尾斜杠；非 http(s) 一律丢弃（返回空串）。 */
+export function normalizeUpstream(value) {
+  const raw = String(value ?? "").trim();
+  if (!raw) return "";
+  if (!/^https?:\/\/[^\s]+$/i.test(raw)) return "";
+  return raw.replace(/\/+$/, "");
+}
+
+/** 从字符串里取端口（拿不到返回 0）。 */
+function portOf(value) {
+  try {
+    const n = Number(new URL(String(value)).port);
+    return Number.isInteger(n) && n > 0 ? n : 0;
+  } catch {
+    return 0;
+  }
+}
+
+/** 1) 显式环境变量。 */
+export function upstreamFromEnv(env = process.env) {
+  return normalizeUpstream(env.DSH_BRIDGE_UPSTREAM);
+}
+
+/** 2) 插件半落盘的端口文件（插件不在场/首次安装时可能没有）。 */
+export function upstreamFromFile(relayDir) {
+  if (!relayDir) return "";
+  try {
+    return normalizeUpstream(fs.readFileSync(path.join(relayDir, UPSTREAM_FILE), "utf8"));
+  } catch {
+    return "";
+  }
+}
+
+/** 3) DSH_WEB_URL 的端口（bridge 的 loopback 围栏只认 127.0.0.1，这里也统一回环地址）。 */
+export function upstreamFromDshWebUrl(env = process.env) {
+  const raw = String(env.DSH_WEB_URL || "").trim();
+  if (!raw) return "";
+  const port = portOf(raw);
+  return port ? `http://127.0.0.1:${port}` : "";
+}
+
+/**
+ * 按优先级取出"提示地址"（不做任何网络探测）。
+ * @returns {{url: string, source: "env"|"file"|"dsh_web_url"|""}}
+ */
+export function resolveUpstreamHint({ relayDir = "", env = process.env } = {}) {
+  const explicit = upstreamFromEnv(env);
+  if (explicit) return { url: explicit, source: "env" };
+  const fromFile = upstreamFromFile(relayDir);
+  if (fromFile) return { url: fromFile, source: "file" };
+  const fromWebUrl = upstreamFromDshWebUrl(env);
+  if (fromWebUrl) return { url: fromWebUrl, source: "dsh_web_url" };
+  return { url: "", source: "" };
+}
+
+// ---------- 实测端口（best effort，任何失败都只是少一个候选，绝不影响主流程） ----------
+
+function tryExec(cmd, args, timeoutMs = 4000) {
+  try {
+    return String(execFileSync(cmd, args, { encoding: "utf8", timeout: timeoutMs, stdio: ["ignore", "pipe", "ignore"] }) || "");
+  } catch {
+    return "";
+  }
+}
+
+/** 某进程正在 LISTEN 的 TCP 端口。macOS/Linux 用 lsof，Windows 用 netstat -ano。 */
+export function listeningPortsOfPid(pid, platform = process.platform) {
+  const n = Number(pid);
+  if (!Number.isInteger(n) || n <= 0) return [];
+  const ports = new Set();
+  if (platform === "win32") {
+    for (const line of tryExec("netstat", ["-ano"], 6000).split(/\r?\n/)) {
+      if (!/LISTENING/i.test(line)) continue;
+      const cols = line.trim().split(/\s+/);
+      if (cols.length < 5) continue;
+      if (Number(cols[cols.length - 1]) !== n) continue;
+      const m = /:(\d+)$/.exec(cols[1] || "");
+      if (m) ports.add(Number(m[1]));
+    }
+    return [...ports];
+  }
+  const out = tryExec("lsof", ["-nP", "-a", "-p", String(n), "-iTCP", "-sTCP:LISTEN"], 5000);
+  for (const line of out.split("\n")) {
+    const m = /:(\d+)\s*\(LISTEN\)/.exec(line);
+    if (m) ports.add(Number(m[1]));
+  }
+  return [...ports];
+}
+
+/** 祖先进程 pid（最多 6 层）：被插件/宿主拉起的 watcher、bridge 走这条路能找到宿主。 */
+export function ancestorPids(startPid = process.pid, maxDepth = 6, platform = process.platform) {
+  if (platform === "win32") return []; // Windows 无 ps；靠 netstat+pgrep 不可行，交给端口文件与静态候选
+  const out = [];
+  let pid = Number(startPid);
+  for (let i = 0; i < maxDepth; i++) {
+    const txt = tryExec("ps", ["-o", "ppid=", "-p", String(pid)], 2000).trim();
+    const ppid = Number(txt);
+    if (!Number.isInteger(ppid) || ppid <= 1) break;
+    out.push(ppid);
+    pid = ppid;
+  }
+  return out;
+}
+
+/** 本机 dsh 相关进程（pgrep）—— Desktop 壳/独立 dsh web 都可能命中。 */
+export function dshProcessPids(platform = process.platform) {
+  if (platform === "win32") return [];
+  const out = tryExec("pgrep", ["-f", "dsh"], 4000);
+  return out
+    .split(/\s+/)
+    .map((s) => Number(s))
+    .filter((n) => Number.isInteger(n) && n > 1 && n !== process.pid);
+}
+
+/**
+ * 候选列表（已去重，按"可能性"排序），每项带**来源标注**（用于日志与测试断言）。
+ * 顺序 = 提示里的端口 → 显式额外端口 → DSH_WEB_URL 的端口 → 祖先/dsh 进程实测监听端口
+ *        → 3080 → Desktop 默认端口区间。
+ * @returns {Array<{port:number, source:string}>}
+ */
+export function candidatePorts({ relayDir = "", env = process.env, extraPorts = [], platform = process.platform } = {}) {
+  const out = [];
+  const seen = new Set();
+  const push = (p, source) => {
+    const n = Number(p);
+    if (!Number.isInteger(n) || n <= 0 || n >= 65536 || seen.has(n)) return;
+    seen.add(n);
+    out.push({ port: n, source });
+  };
+  const hint = resolveUpstreamHint({ relayDir, env });
+  push(portOf(hint.url), hint.source || "hint");
+  for (const p of extraPorts) push(p, "extra");
+  push(portOf(upstreamFromDshWebUrl(env)), "dsh_web_url");
+  const pids = [...new Set([process.pid, ...ancestorPids(process.pid, 6, platform), ...dshProcessPids(platform)])];
+  for (const pid of pids) for (const p of listeningPortsOfPid(pid, platform)) push(p, "process");
+  push(3080, "static");
+  for (let i = 0; i < DESKTOP_PORT_SCAN; i++) push(DESKTOP_DEFAULT_PORT + i, "static");
+  return out;
+}
+
+// ---------- 身份校验 ----------
+
+/**
+ * 这个地址**真的**是 dsh web 吗？
+ *
+ * 为什么必须有：候选探测会去敲 43120 这类可能被别的程序占用的端口。只看"端口有响应"就把
+ * bridge 接上去，用户会得到一个"能连上但不工作"的怪状态，而且等于把这台机器的流量交给陌生服务。
+ * 判据取 dsh web 自身的稳定特征（HTML/标题/鉴权文案），任一命中即通过。
+ */
+export const DSH_WEB_MARKERS = [
+  "__ModuleLoader__",
+  "dsh-client-modules",
+  "deepseek harness",
+  "dsh web authentication required",
+  "dsh-remote"
+];
+
+export function looksLikeDshWeb(status, text) {
+  const body = String(text || "").toLowerCase();
+  if (!body) return false;
+  if (status >= 500) return false;
+  return DSH_WEB_MARKERS.some((m) => body.includes(m));
+}
+
+/**
+ * 探测一个候选：GET `/`，带身份校验。
+ * @returns {Promise<boolean>}
+ */
+export async function probeDshWeb(url, { timeoutMs = PROBE_TIMEOUT_MS, fetchImpl } = {}) {
+  const target = normalizeUpstream(url);
+  if (!target) return false;
+  const doFetch = fetchImpl || globalThis.fetch;
+  if (typeof doFetch !== "function") return false;
+  try {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeoutMs);
+    let res;
+    try {
+      // redirect: manual —— 不跟随跳转（跳走的多半不是我们要的宿主）
+      res = await doFetch(`${target}/`, { signal: ac.signal, redirect: "manual" });
+    } finally {
+      clearTimeout(timer);
+    }
+    const status = Number(res && res.status) || 0;
+    if (status >= 500) return false;
+    // 只读前 8KB 足够命中特征；读流失败按"不是"处理（宁可少一个候选，不可误接）
+    let text = "";
+    try {
+      if (res.body && typeof res.body.getReader === "function") {
+        const reader = res.body.getReader();
+        const { value } = await reader.read();
+        text = value ? Buffer.from(value).toString("utf8") : "";
+        try { await reader.cancel(); } catch { /* ignore */ }
+      } else if (typeof res.text === "function") {
+        text = await res.text();
+      }
+    } catch { /* 读失败 → text 为空 → 判否 */ }
+    return looksLikeDshWeb(status, text.slice(0, 8192));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 发现上游地址（带身份校验）。
+ *
+ * @param {number[]} [extraPorts] 调用方已知的额外候选(排在静态候选之前;测试与特化部署用)。
+ * @returns {Promise<{url: string, source: string, probed: number[], rejected: string[]}>}
+ *          source: env | file | dsh_web_url | process | static | extra | fallback
+ */
+export async function discoverUpstream({
+  relayDir = "",
+  env = process.env,
+  timeoutMs = PROBE_TIMEOUT_MS,
+  fetchImpl,
+  platform = process.platform,
+  extraPorts = [],
+  log
+} = {}) {
+  const hint = resolveUpstreamHint({ relayDir, env });
+  // ① 显式环境变量:部署方说是什么就是什么(不探测,保持既有语义)
+  if (hint.source === "env") return { url: hint.url, source: "env", probed: [], rejected: [] };
+  // ② 提示地址先验证:文件/DSh_WEB_URL 都可能过期(宿主换端口/换了程序占用)
+  if (hint.url && (await probeDshWeb(hint.url, { timeoutMs, fetchImpl }))) {
+    return { url: hint.url, source: hint.source, probed: [portOf(hint.url)], rejected: [] };
+  }
+
+  // ③ 候选并行探测(本地端口,拒绝是瞬时的;并行是为了不让 watcher 卡住)
+  const hintPort = portOf(hint.url);
+  const entries = candidatePorts({ relayDir, env, platform, extraPorts }).filter((e) => e.port !== hintPort);
+  const results = await Promise.all(entries.map(async (e) => ({ ...e, ok: await probeDshWeb(`http://127.0.0.1:${e.port}`, { timeoutMs, fetchImpl }) })));
+  const hit = results.find((r) => r.ok);
+  if (hit) {
+    const url = `http://127.0.0.1:${hit.port}`;
+    if (typeof log === "function") log(`[upstream] 动态发现上游 ${url}（来源 ${hit.source}；提示 ${hint.url || "无"} 不可用）`);
+    return { url, source: hit.source, probed: entries.map((e) => e.port), rejected: hint.url ? [hint.url] : [] };
+  }
+
+  // ④ 都没找到:保持历史行为(3080),让上层按"上游没起来"正常重试
+  return {
+    url: hint.url || FALLBACK_UPSTREAM,
+    source: hint.url ? hint.source : "fallback",
+    probed: entries.map((e) => e.port),
+    rejected: hint.url ? [hint.url] : []
+  };
+}

package/runtime/dsh-setup.mjs

@@ -29,6 +29,7 @@ import path from "node:path";
 import { spawn, spawnSync, execSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { childStopped, stopChildGracefully } from "./clients/dsh-remote/src/lifecycle.mjs";
+import { discoverUpstream, resolveUpstreamHint, FALLBACK_UPSTREAM } from "./clients/dsh-remote/upstream-discovery.mjs";
 
 const THIS_DIR = path.dirname(fileURLToPath(import.meta.url)); // 本包目录（仓库或 node_modules）
 const IS_NPM_INSTALL = THIS_DIR.includes(`${path.sep}node_modules${path.sep}`);
@@ -779,14 +780,21 @@ function restartBridgeService() {
  * 【2026-09-23 用户实测事故】这里原本处处写死 `http://127.0.0.1:3080`：只要用户的 dsh web
  * 不在默认端口（`dsh web --port 8090`、profile 里配了 port、或 `--port 0` 让系统分配空闲端口），
  * watcher 的在线探测就**永远**失败 → bridge 永远不启动，而面板只会说「正在启动 Bridge…」。
- * 优先级：显式环境变量 > 插件半留下的端口文件 > DSH_WEB_URL > 默认 3080。
- * 为什么要有「端口文件」这一层：开机自启（登录任务 / launchd）拉起 watcher 时**没有**任何环境变量，
- * 只有插件半知道 dsh web 真实监听在哪个端口，所以它会把地址落盘（见插件 half 的 publishUpstream）。
+ * 优先级：显式环境变量 > **运行时动态发现** > 插件半留下的端口文件 > DSH_WEB_URL > 默认 3080。
+ *
+ * 为什么还要「动态发现」这一层（2026-09-23 第二起实测，DSH Desktop）：
+ *   DSH Desktop（Electron 壳 `dsh-plugin-desktop`）默认把 Web 服务放在 **43120**，被占用还会 +1；
+ *   而端口文件要等**插件半**加载后才有。于是「端口文件还没写」或「写的是上一轮的旧端口」时，
+ *   光靠文件仍会永久探错端口。发现逻辑（含 DSH 进程实际监听端口 + Desktop 端口区间 + 身份校验）
+ *   统一在 clients/dsh-remote/upstream-discovery.mjs，watcher 与 bridge 共用同一份实现。
  */
 const UPSTREAM_FILE = ".dsh-upstream";
+/** 运行时动态发现到的上游（优于可能过期的端口文件；进程内缓存）。 */
+let discoveredUpstream = "";
 function upstreamUrl() {
   const explicit = String(process.env.DSH_BRIDGE_UPSTREAM || "").trim();
   if (explicit) return explicit.replace(/\/+$/, "");
+  if (discoveredUpstream) return discoveredUpstream;
   try {
     const fromFile = String(fs.readFileSync(path.join(CONFIG_DIR, UPSTREAM_FILE), "utf8")).trim();
     if (/^https?:\/\/[^\s]+$/i.test(fromFile)) return fromFile.replace(/\/+$/, "");
@@ -798,28 +806,69 @@ function upstreamUrl() {
       if (u.port) return `http://127.0.0.1:${u.port}`; // bridge 的 loopback 围栏只认 127.0.0.1
     } catch { /* 非 URL：忽略 */ }
   }
-  return "http://127.0.0.1:3080";
+  return FALLBACK_UPSTREAM;
 }
 /** 上游端口（诊断/日志用；取不到就回退 3080）。 */
 function upstreamPort() {
   try { return Number(new URL(upstreamUrl()).port) || 3080; } catch { return 3080; }
 }
 
+/** 发现结果缓存与冷却：避免每轮轮询都去 lsof/pgrep + 逐个端口探测。 */
+let upstreamDiscoveryAt = 0;
+let upstreamDiscoveryInflight = null;
+const UPSTREAM_DISCOVERY_COOLDOWN_MS = 15_000;
+
 /**
- * dsh web 是否正在运行（默认 127.0.0.1:3080，端口以 upstreamUrl() 为准）。
- * bridge 本身依赖 dsh web 才工作：dsh web 没开时 bridge 起来也会立刻退出，
- * 所以「装完当下 bridge 没在跑」是**正常状态**，不能当失败吓用户（见 install 汇总）。
+ * 动态发现上游（带身份校验），成功后写入 `discoveredUpstream` 供全局复用。
+ * @param {boolean} force 忽略冷却（探测失败后的重试用）
  */
-async function isDshWebUp(timeoutMs = 1200) {
+async function refreshUpstreamDiscovery(force = false) {
+  if (upstreamDiscoveryInflight) return upstreamDiscoveryInflight;
+  const now = Date.now();
+  if (!force && now - upstreamDiscoveryAt < UPSTREAM_DISCOVERY_COOLDOWN_MS) return upstreamUrl();
+  upstreamDiscoveryAt = now;
+  upstreamDiscoveryInflight = (async () => {
+    try {
+      const found = await discoverUpstream({ relayDir: CONFIG_DIR, log: (m) => console.log(`[dsh-remote] ${m}`) });
+      // 「提示地址验证通过」与「候选命中」都值得记下来；fallback（什么都没找到）不污染现有判断
+      if (found.url && found.source !== "fallback") discoveredUpstream = found.url;
+      return upstreamUrl();
+    } catch {
+      return upstreamUrl();
+    } finally {
+      upstreamDiscoveryInflight = null;
+    }
+  })();
+  return upstreamDiscoveryInflight;
+}
+
+/** 上游是否**有响应**（判据刻意宽松：4xx/5xx 也算"端口在听"，那种情况问题在别处）。 */
+async function upstreamReachable(url = upstreamUrl(), timeoutMs = 1200) {
   try {
     const ac = new AbortController();
     const timer = setTimeout(() => ac.abort(), timeoutMs);
-    await fetch(upstreamUrl() + "/", { signal: ac.signal });
+    await fetch(url + "/", { signal: ac.signal });
     clearTimeout(timer);
     return true;
   } catch { return false; }
 }
 
+/**
+ * dsh web 是否正在运行（端口以 upstreamUrl() 为准，**绝不写死 3080**）。
+ * bridge 本身依赖 dsh web 才工作：dsh web 没开时 bridge 起来也会立刻退出，
+ * 所以「装完当下 bridge 没在跑」是**正常状态**，不能当失败吓用户（见 install 汇总）。
+ *
+ * 探测失败时会**主动做一次动态发现**再试一次 —— 这一条正是 DSH Desktop 场景的关键：
+ * 上游在 43120（Desktop 默认，占用还会 +1），而端口文件可能还没写或写着上一轮的旧端口。
+ */
+async function isDshWebUp(timeoutMs = 1200) {
+  if (await upstreamReachable(upstreamUrl(), timeoutMs)) return true;
+  const before = upstreamUrl();
+  const after = await refreshUpstreamDiscovery(true);
+  if (after === before) return false;
+  return upstreamReachable(after, timeoutMs);
+}
+
 /**
  * 解析 dsh web profile 目录（安装与插件管理共用同一口径）。
  */
@@ -1125,14 +1174,13 @@ async function runBridge() {
   /** 限流提示只打一次，避免刷屏。 */
   let warnedRateLimit = false;
 
-  // watcher：检测 dsh web 是否存活（端口以 upstreamUrl() 为准，绝不写死 3080），存活才启动 bridge
-  const checkUpstream = () => new Promise((resolve) => {
-    const t = setTimeout(() => resolve(false), 2000);
-    fetch(upstreamUrl() + "/")
-      .then(() => { clearTimeout(t); resolve(true); })
-      .catch(() => { clearTimeout(t); resolve(false); });
-  });
+  // watcher：检测 dsh web 是否存活（端口动态解析，绝不写死 3080），存活才启动 bridge。
+  // 走 isDshWebUp()：探测失败会自动做一次动态发现（DSH Desktop 的 43120 / 自定义端口都靠它）。
+  const checkUpstream = () => isDshWebUp(2000);
 
+  // 先做一次动态发现再打印/派生：否则日志会长期写着错误的端口（用户实测就卡在
+  // 「等待 dsh web（127.0.0.1:3080）启动...」而真实上游在 43120）。
+  await refreshUpstreamDiscovery(true);
   console.log(`[dsh-remote] 等待 dsh web（${upstreamUrl()}）启动...`);
   let bridgeProc = null;
   let starting = false;