@mrrisega/dsh-remote 0.6.12 → 0.6.14

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

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+/**
+ * 上游（dsh web）地址发现契约测试。
+ *
+ * 背景（两起真实事故，见 upstream-discovery.mjs 顶部注释）：
+ *   ① `dsh web --port 8090` / `--port 0`（系统分配端口）→ 写死 3080 的探测永远失败；
+ *   ② **DSH Desktop**（Electron 壳 `dsh-plugin-desktop`）默认 43120、占用则 +1，插件 0.6.10
+ *      实测「面板永久停在 starting、设备从未登记」——watcher 探 3080 探不到就永不派生 bridge。
+ *
+ * 这里守四件事：
+ *   ① 提示优先级（env > 端口文件 > DSH_WEB_URL）与规范化；
+ *   ② **身份校验**：候选端口可能被别的程序占用，绝不能把 bridge 接到陌生人身上；
+ *   ③ 提示不可用时会去探候选（含 Desktop 端口区间），并报出**准确的来源**；
+ *   ④ 什么都找不到时保持历史行为（回退 3080），不能变成"抛错/空地址"。
+ *
+ * 用法: node --test test/upstream-discovery.test.mjs
+ */
+import assert from "node:assert/strict";
+import http from "node:http";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import {
+  candidatePorts,
+  discoverUpstream,
+  listeningPortsOfPid,
+  looksLikeDshWeb,
+  normalizeUpstream,
+  probeDshWeb,
+  resolveUpstreamHint,
+  DESKTOP_DEFAULT_PORT,
+  FALLBACK_UPSTREAM,
+  UPSTREAM_FILE
+} from "../upstream-discovery.mjs";
+
+const DIR = mkdtempSync(path.join(os.tmpdir(), "dsh-upstream-"));
+process.on("exit", () => { try { rmSync(DIR, { recursive: true, force: true }); } catch { /* ignore */ } });
+
+/** 假的 dsh web：回一段带官方特征标记的 HTML（身份校验靠它）。 */
+const DSH_HTML = "<!doctype html><html><head><title>DeepSeek Harness</title></head><body><script>__ModuleLoader__</script></body></html>";
+/** 冒牌服务：端口在听，但不是 dsh web。 */
+const STRANGER = "hello, I am some other local server";
+
+async function listen(handler) {
+  const srv = http.createServer(handler);
+  await new Promise((r) => srv.listen(0, "127.0.0.1", r));
+  return { srv, port: srv.address().port, url: `http://127.0.0.1:${srv.address().port}` };
+}
+const close = (x) => new Promise((r) => x.srv.close(r));
+
+const writeHint = (url) => writeFileSync(path.join(DIR, UPSTREAM_FILE), url + "\n");
+/**
+ * 把 3080 封掉的 fetch 包装。
+ * 为什么需要:开发机上真实存在一个 dsh web 监听 3080,候选扫描会命中它 ——
+ * 那是**宿主**而不是测试夹具,断言就变成了"看运气"。封掉它,测试才只依赖自己起的假服务。
+ */
+const realFetch = globalThis.fetch;
+const blockedFetch = (input, init) => {
+  const url = String(typeof input === "string" ? input : (input && input.url) || "");
+  if (/:3080(\/|$)/.test(url)) return Promise.reject(new Error("blocked: host 3080"));
+  return realFetch(input, init);
+};
+
+
+test("规范化:去尾斜杠;非 http(s) / 空值一律丢弃", () => {
+  assert.equal(normalizeUpstream("http://127.0.0.1:43120/"), "http://127.0.0.1:43120");
+  assert.equal(normalizeUpstream("  http://127.0.0.1:3080  "), "http://127.0.0.1:3080");
+  assert.equal(normalizeUpstream("wss://n.risegao.cn:13443"), "");
+  assert.equal(normalizeUpstream(""), "");
+  assert.equal(normalizeUpstream(undefined), "");
+});
+
+test("提示优先级:env > 端口文件 > DSH_WEB_URL", () => {
+  writeHint("http://127.0.0.1:43120");
+  assert.deepEqual(
+    resolveUpstreamHint({ relayDir: DIR, env: { DSH_BRIDGE_UPSTREAM: "http://127.0.0.1:9001" } }),
+    { url: "http://127.0.0.1:9001", source: "env" }
+  );
+  assert.deepEqual(resolveUpstreamHint({ relayDir: DIR, env: {} }), { url: "http://127.0.0.1:43120", source: "file" });
+  // 文件坏掉 → 落到 DSH_WEB_URL
+  writeHint("not-a-url");
+  assert.deepEqual(
+    resolveUpstreamHint({ relayDir: DIR, env: { DSH_WEB_URL: "https://example.com:8090/?token=x" } }),
+    { url: "http://127.0.0.1:8090", source: "dsh_web_url" }
+  );
+  writeHint("http://127.0.0.1:43120");
+});
+
+test("身份校验:只认 dsh web 特征,拒绝陌生服务与空响应", () => {
+  assert.equal(looksLikeDshWeb(200, DSH_HTML), true);
+  assert.equal(looksLikeDshWeb(401, "dsh web authentication required; reopen the URL printed by dsh web."), true);
+  assert.equal(looksLikeDshWeb(200, STRANGER), false);
+  assert.equal(looksLikeDshWeb(200, ""), false);
+  assert.equal(looksLikeDshWeb(500, DSH_HTML), false, "5xx 不算");
+});
+
+test("行为:probeDshWeb 认得出真 dsh web,也拒绝陌生服务与死端口", async () => {
+  const dsh = await listen((_req, res) => { res.writeHead(200, { "content-type": "text/html" }); res.end(DSH_HTML); });
+  const stranger = await listen((_req, res) => { res.writeHead(200, { "content-type": "text/plain" }); res.end(STRANGER); });
+  try {
+    assert.equal(await probeDshWeb(dsh.url), true);
+    assert.equal(await probeDshWeb(stranger.url), false, "端口在听但不是 dsh web → 必须拒绝");
+    assert.equal(await probeDshWeb("http://127.0.0.1:1"), false, "死端口 → false");
+    assert.equal(await probeDshWeb("wss://x"), false, "非 http(s) → false");
+  } finally {
+    await close(dsh); await close(stranger);
+  }
+});
+
+test("★ DSH Desktop 场景:端口文件过期/缺失时,靠候选探测找到 43120 上的 dsh web", async () => {
+  // 模拟 Desktop：dsh web 在 43120，而端口文件写的是上一轮的旧端口（已无人监听）
+  const desktop = await listen((_req, res) => { res.writeHead(200, { "content-type": "text/html" }); res.end(DSH_HTML); });
+  // 探测真的走 43120 —— 测试里换成"把 Desktop 端口作为 extraPorts 注入"，避免占用真实端口
+  writeHint("http://127.0.0.1:1"); // 过期提示
+  try {
+    const found = await discoverUpstream({
+      relayDir: DIR,
+      env: {},
+      extraPorts: [desktop.port],
+      fetchImpl: blockedFetch,
+      platform: "win32" // 隔离宿主：不走 ps/pgrep/netstat，候选只来自提示/额外端口/静态表
+    });
+    assert.equal(found.url, desktop.url, "必须落到候选命中的那个 dsh web");
+    assert.equal(found.source, "extra");
+    assert.ok(found.rejected.includes("http://127.0.0.1:1"), "过期提示应被记入 rejected");
+  } finally {
+    await close(desktop);
+  }
+});
+
+test("★ 候选探测不做身份校验的话会接错人:陌生服务在候选端口上也必须被拒绝", async () => {
+  const stranger = await listen((_req, res) => { res.writeHead(200, { "content-type": "text/plain" }); res.end(STRANGER); });
+  writeHint("http://127.0.0.1:1");
+  try {
+    const found = await discoverUpstream({ relayDir: DIR, env: {}, extraPorts: [stranger.port], fetchImpl: blockedFetch, platform: "win32" });
+    assert.notEqual(found.url, stranger.url, "陌生服务绝不能成为上游");
+    assert.equal(found.url, "http://127.0.0.1:1", "找不到时回落到提示地址(让上层按'上游没起来'重试)");
+  } finally {
+    await close(stranger);
+  }
+});
+
+test("提示可用时不做候选扫描(省掉无谓探测)", async () => {
+  const dsh = await listen((_req, res) => { res.writeHead(200, { "content-type": "text/html" }); res.end(DSH_HTML); });
+  writeHint(dsh.url);
+  try {
+    const found = await discoverUpstream({ relayDir: DIR, env: {}, fetchImpl: blockedFetch, platform: "win32" });
+    assert.equal(found.url, dsh.url);
+    assert.equal(found.source, "file");
+    assert.deepEqual(found.probed, [dsh.port], "只探了提示本身");
+  } finally {
+    await close(dsh);
+  }
+});
+
+test("显式 DSH_BRIDGE_UPSTREAM 直接采信(探测都不做) —— 保持既有语义", async () => {
+  const found = await discoverUpstream({
+    relayDir: DIR,
+    env: { DSH_BRIDGE_UPSTREAM: "http://127.0.0.1:63999" },
+    platform: "win32",
+    fetchImpl: () => { throw new Error("不该发请求"); }
+  });
+  assert.equal(found.url, "http://127.0.0.1:63999");
+  assert.equal(found.source, "env");
+  assert.deepEqual(found.probed, []);
+});
+
+test("什么都找不到 → 回退历史默认 3080(不抛错、不放空)", async () => {
+  writeHint("not-a-url");
+  const found = await discoverUpstream({ relayDir: DIR, env: {}, fetchImpl: blockedFetch, platform: "win32", timeoutMs: 120 });
+  assert.equal(found.url, FALLBACK_UPSTREAM);
+  assert.equal(found.source, "fallback");
+});
+
+test("候选构成:含 3080 与 DSH Desktop 默认端口区间,且去重、带来源", () => {
+  writeHint("http://127.0.0.1:43120");
+  const list = candidatePorts({ relayDir: DIR, env: {}, platform: "win32" });
+  const ports = list.map((e) => e.port);
+  assert.ok(ports.includes(3080), "必须包含历史默认端口");
+  for (let i = 0; i < 12; i++) assert.ok(ports.includes(DESKTOP_DEFAULT_PORT + i), `必须覆盖 Desktop 端口区间 +${i}`);
+  assert.equal(new Set(ports).size, ports.length, "不得重复");
+  assert.equal(list.find((e) => e.port === 43120).source, "file", "首个候选应来自端口文件");
+});
+
+test("实测端口:能从本进程真实监听端口里读出来(macOS/Linux 用 lsof)", async (t) => {
+  if (process.platform === "win32") return t.skip("Windows 走 netstat，另有实现");
+  const srv = await listen((_req, res) => res.end("x"));
+  try {
+    const ports = listeningPortsOfPid(process.pid);
+    assert.ok(ports.includes(srv.port), `应包含 ${srv.port}，实际 ${JSON.stringify(ports)}`);
+  } finally {
+    await close(srv);
+  }
+});

package/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/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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrisega/dsh-remote",
-  "version": "0.6.12",
+  "version": "0.6.14",
   "description": "手机远程控制 DeepSeek Harness · Remote control DeepSeek Harness (dsh web) from any phone browser — 100% 全功能 App 级体验：发消息、看工具执行、审批权限、改设置、管凭据，含特权操作，免内网穿透。一条命令安装 npx @mrrisega/dsh-remote。Mobile remote control for DSH, self-host or SaaS, no server needed on LAN.",
   "keywords": [
     "deepseek-harness",
@@ -51,7 +51,7 @@
   },
   "scripts": {
     "test": "npm run test:router && npm run test:plugin && npm run test:bridge",
-    "test:router": "NODE_OPTIONS=\"--require $PWD/scripts/test-net-guard.cjs ${NODE_OPTIONS:-}\" node --test packages/relay-router/test/native-device-selection.test.mjs packages/relay-router/test/native-app-entry.test.mjs packages/relay-router/test/presence-report.test.mjs packages/relay-router/test/logger.test.mjs",
+    "test:router": "NODE_OPTIONS=\"--require $PWD/scripts/test-net-guard.cjs ${NODE_OPTIONS:-}\" node --test packages/relay-router/test/native-device-selection.test.mjs packages/relay-router/test/native-app-entry.test.mjs packages/relay-router/test/presence-report.test.mjs packages/relay-router/test/logger.test.mjs packages/relay-router/test/device-free-assets.test.mjs packages/relay-router/test/sse-streaming-contract.test.mjs",
     "_comment:test:plugin": "DSH_RELAY_BUNDLED_RUNTIME=/nonexistent = 强制走 npx 兜底分支（否则本机跑过 npm pack 后 packages/dsh-remote-web/runtime 存在，用例会改成走本地拷贝）。DSH_RELAY_SKIP_SERVICE=1 = 测试隔离：插件加载时不做真实系统操作（npx 补装 / launchctl / 重启 harness）；需要真实分支的用例自行 unset（见 account-switch / runtime-provision / harness-restart 用例注释）。DSH_RELAY_DEFAULT_API= 死端口：用例拆掉临时目录后，仍在飞的后台请求（装机上报重试等）会读到空配置并回落「默认云端地址」—— 指到本地死端口才不会打生产。",
     "test:plugin": "DSH_REMOTE_TELEMETRY=0 DSH_RELAY_SKIP_SERVICE=1 DSH_RELAY_DEFAULT_API=http://127.0.0.1:1 DSH_RELAY_BUNDLED_RUNTIME=/nonexistent-dsh-bundled NODE_OPTIONS=\"--require $PWD/scripts/test-net-guard.cjs ${NODE_OPTIONS:-}\" node --test --test-concurrency=1 packages/dsh-remote-web/test/*.test.mjs",
     "_comment:test:bridge": "⚠️ 必须 --test-concurrency=1（与 test:plugin 对齐）：tunnel-auth 有一条「bridge 5 秒内必须重连」的硬期限，并行跑时新增用例抢 CPU 会把它撞破 → 偶发假红（实测单独跑 2/2 通过、并发跑偶发 0/2）。假红比慢更贵。",