@mrrisega/dsh-remote 0.6.12 → 0.6.14

package/packages/dsh-remote-web/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;

package/packages/dsh-remote-web/test/connect-stuck-visibility.test.mjs

@@ -370,8 +370,23 @@ test("运行时 dsh-setup.mjs：上游端口只有一处真相源，watcher/子
   const code = SETUP_SRC.split("\n").filter((l) => !/^\s*(\/\/|\*|\/\*)/.test(l)).join("\n");
   assert.ok(!/fetch\("http:\/\/127\.0\.0\.1:3080/.test(code), "探测不得写死 3080（dsh web 可能在别的端口）");
   assert.ok(!/findstr ":3080"|iTCP:3080/.test(code), "按端口找 dsh web 进程也不得写死 3080");
-  assert.ok(/fetch\(upstreamUrl\(\) \+ "\/"\)/.test(code), "watcher 的在线判据必须用 upstreamUrl()");
+  assert.ok(/async function upstreamReachable\(url = upstreamUrl\(\)/.test(code), "在线判据必须用解析出来的上游地址");
+  assert.ok(/await upstreamReachable\(upstreamUrl\(\)/.test(code), "isDshWebUp 必须基于 upstreamUrl() 探测");
   assert.ok(/DSH_BRIDGE_UPSTREAM: upstreamUrl\(\)/.test(code), "必须把上游显式透传给 bridge 子进程");
+  // ── 上游端口动态发现（2026-09-23 第二起实测：DSH Desktop 默认 43120，占用还会 +1）──
+  // 只靠"端口文件"不够：文件可能还没写、或写着上一轮的旧端口；那时必须自己去找。
+  assert.ok(
+    /from "\.\/clients\/dsh-remote\/upstream-discovery\.mjs"/.test(SETUP_SRC),
+    "必须复用共享的上游发现实现（watcher/bridge 同一份，避免两边漂移）"
+  );
+  assert.ok(
+    /const after = await refreshUpstreamDiscovery\(true\)/.test(code),
+    "探测失败必须主动做一次动态发现再试（否则端口一变就永远卡在 starting）"
+  );
+  assert.ok(
+    /await refreshUpstreamDiscovery\(true\);/.test(code),
+    "启动时先发现再打印：日志不得再谎称固定端口"
+  );
   // 半装运行时的根因之一：本安装器自己 import 的 src/lifecycle.mjs 必须在同步表里
   assert.ok(/"src\/lifecycle\.mjs"/.test(SETUP_SRC), "RUNTIME_CLIENT_FILES 必须包含 src/lifecycle.mjs（否则会漏同步出半装运行时）");
 });

package/packages/dsh-remote-web/test/picker-pin.test.mjs

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+/**
+ * 目录选择器固定为「浏览器内实现」的契约测试。
+ *
+ * 用户实测（Windows）：镜像页点「添加工作区」**没反应**；同功能在 Mac 上正常。
+ * 根因：官方 `directory-picker-auto` 只在**绑定非回环**时才改选 browse，否则 darwin/win32 一律挂
+ * **原生**选择器 —— 那个对话框弹在**电脑那台机器的屏幕上**，拿手机的人看不到；
+ * Windows 那条原生链路还要 koffi 原生模块 + worker 子进程（合成 Alt 抢前台），失败点更多。
+ * 远程控制不能把"手机能不能选工作区"押在宿主的绑定地址上，所以插件主动把它钉成 browse。
+ *
+ * 这里守的是三条护栏（顺序错一条就会把用户的选择器搞没）：
+ *   ① 已是 browse → 一根手指都不许动；
+ *   ② **先建 browse、后摘 auto**：browse 建不起来时必须原样保留原生；
+ *   ③ 全程不抛异常（插件绝不能把 dsh web 拖挂）。
+ *
+ * 用法: node --test test/picker-pin.test.mjs
+ */
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+import {
+  __pinBrowseDirectoryPicker,
+  __pickerPinState,
+  __PICKER_AUTO_ENTRY_ID,
+  __PICKER_BROWSE_PACKAGES
+} from "../lib/index.js";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const SRC = readFileSync(path.join(HERE, "..", "lib", "index.js"), "utf8");
+
+/** 假宿主：loader 记录 create/remove 的**调用顺序**，directoryPicker 报告当前 kind。 */
+function fakeCtx({ kind = "native", failCreateOn = null } = {}) {
+  const calls = [];
+  const store = { [__PICKER_AUTO_ENTRY_ID]: { id: __PICKER_AUTO_ENTRY_ID } };
+  const loader = {
+    store,
+    async create({ name }) {
+      calls.push(`create:${name}`);
+      if (failCreateOn && name === failCreateOn) throw new Error("browse 装不起来");
+      const id = `dyn-${calls.length}`;
+      store[id] = { id };
+      return id;
+    },
+    async remove(id) {
+      calls.push(`remove:${id}`);
+      delete store[id];
+    }
+  };
+  return {
+    ctx: {
+      get(name) {
+        if (name === "loader") return loader;
+        if (name === "directoryPicker") return { capability: () => ({ kind }) };
+        return null;
+      },
+      logger: { info() {}, warn() {} }
+    },
+    calls,
+    store
+  };
+}
+
+const withEnv = async (value, fn) => {
+  const prev = process.env.DSH_REMOTE_NATIVE_PICKER;
+  if (value === undefined) delete process.env.DSH_REMOTE_NATIVE_PICKER;
+  else process.env.DSH_REMOTE_NATIVE_PICKER = value;
+  try { return await fn(); } finally {
+    if (prev === undefined) delete process.env.DSH_REMOTE_NATIVE_PICKER;
+    else process.env.DSH_REMOTE_NATIVE_PICKER = prev;
+  }
+};
+
+test("★ 原生(native)→ 换成 browse：先建 browse 那一对,再摘 auto 条目", async () => {
+  const { ctx, calls, store } = fakeCtx({ kind: "native" });
+  const state = await withEnv(undefined, () => __pinBrowseDirectoryPicker(ctx, { attempts: 1, gapMs: 1 }));
+
+  assert.deepEqual(calls, [
+    `create:${__PICKER_BROWSE_PACKAGES[0]}`,
+    `create:${__PICKER_BROWSE_PACKAGES[1]}`,
+    `remove:${__PICKER_AUTO_ENTRY_ID}`
+  ], "顺序必须是「先建 browse、后摘 auto」——反过来一旦建失败,用户就没有选择器了");
+  assert.equal(store[__PICKER_AUTO_ENTRY_ID], undefined, "auto 条目应被摘除（它的析构会卸掉 native 那对）");
+  assert.equal(state.action, "pinned");
+  assert.equal(state.kind, "browse");
+  assert.match(state.detail, /远程/, "详情要写明为什么改（远程看不到原生对话框）");
+});
+
+test("已经是 browse → 完全不干预（自建部署 / 绑了 0.0.0.0 的场景）", async () => {
+  const { ctx, calls } = fakeCtx({ kind: "browse" });
+  const state = await withEnv(undefined, () => __pinBrowseDirectoryPicker(ctx, { attempts: 1, gapMs: 1 }));
+  assert.deepEqual(calls, [], "不得创建、也不得摘除任何条目");
+  assert.equal(state.action, "none");
+});
+
+test("★ browse 装不起来 → 原样保留原生(宁可原生可用,也不能让选择器消失)", async () => {
+  const { ctx, calls, store } = fakeCtx({ kind: "native", failCreateOn: __PICKER_BROWSE_PACKAGES[0] });
+  const state = await withEnv(undefined, () => __pinBrowseDirectoryPicker(ctx, { attempts: 1, gapMs: 1 }));
+  assert.ok(!calls.some((c) => c.startsWith(`remove:${__PICKER_AUTO_ENTRY_ID}`)), "摘 auto 必须发生在 browse 建成之后");
+  assert.ok(store[__PICKER_AUTO_ENTRY_ID], "auto 条目必须还在");
+  assert.equal(state.action, "kept_native");
+  assert.match(state.detail, /保留原生/);
+});
+
+test("第二个 browse 包失败 → 回滚已建的那个,并保留原生", async () => {
+  const { ctx, calls, store } = fakeCtx({ kind: "native", failCreateOn: __PICKER_BROWSE_PACKAGES[1] });
+  const state = await withEnv(undefined, () => __pinBrowseDirectoryPicker(ctx, { attempts: 1, gapMs: 1 }));
+  assert.equal(calls[0], `create:${__PICKER_BROWSE_PACKAGES[0]}`);
+  assert.equal(calls[1], `create:${__PICKER_BROWSE_PACKAGES[1]}`);
+  assert.ok(calls[2] && calls[2].startsWith("remove:"), "失败后必须回滚刚建的宿主");
+  assert.ok(store[__PICKER_AUTO_ENTRY_ID], "auto 条目必须还在");
+  assert.equal(state.action, "kept_native");
+});
+
+test("DSH_REMOTE_NATIVE_PICKER=1 → 整体退出，保留系统原生对话框", async () => {
+  const { ctx, calls } = fakeCtx({ kind: "native" });
+  const state = await withEnv("1", () => __pinBrowseDirectoryPicker(ctx, { attempts: 1, gapMs: 1 }));
+  assert.deepEqual(calls, []);
+  assert.equal(state.action, "skipped");
+  assert.match(state.detail, /DSH_REMOTE_NATIVE_PICKER/);
+});
+
+test("服务还没挂上(kind 未知)→ 不抛错、按 skipped 收尾", async () => {
+  const { ctx, calls } = fakeCtx({ kind: "" });
+  const state = await withEnv(undefined, () => __pinBrowseDirectoryPicker(ctx, { attempts: 1, gapMs: 1 }));
+  assert.deepEqual(calls, []);
+  assert.equal(state.action, "skipped");
+});
+
+test("没有 loader 服务 / ctx.get 抛错 → 静默跳过（绝不把宿主拖挂）", async () => {
+  const noLoader = { get: () => null, logger: { info() {}, warn() {} } };
+  const throwing = { get() { throw new Error("ctx destroyed"); }, logger: {} };
+  const a = await __pinBrowseDirectoryPicker(noLoader, { attempts: 1, gapMs: 1 });
+  const b = await __pinBrowseDirectoryPicker(throwing, { attempts: 1, gapMs: 1 });
+  assert.equal(a.action, "skipped");
+  assert.equal(b.action, "skipped");
+});
+
+test("诊断面板必须显示目录选择器状态(这类'按钮没反应'才能一眼定位)", () => {
+  assert.match(SRC, /`目录选择器: \$\{/, "诊断行缺失");
+  assert.match(SRC, /系统原生（远程时对话框弹在电脑那台机器上/, "原生时要给出可操作的解释");
+});
+
+test("接线:apply 里挂了选择器固定（eff/effect），并且是 fire-and-forget 不阻塞装载", () => {
+  assert.match(SRC, /ctx\.effect\(\(\) => \{[\s\S]{0,200}?pinBrowseDirectoryPicker\(ctx\)[\s\S]{0,120}?\}, "dsh-remote-web: pin browser directory picker"\);/);
+});

package/packages/dsh-remote-web/test/watcher-upstream-port.test.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+/**
+ * watcher 的上游端口发现回归 —— 复现 2026-09-23 两起真实事故的**用户可见形态**。
+ *
+ * 现场（用户报告，DSH Desktop 2.0.4 + 插件 0.6.10）：
+ *   ```
+ *   连接阶段: starting（正在启动 Bridge…）
+ *   bridge 进程: 未运行   中继注册: 未注册   自动重试: 已尝试 6 次
+ *   ```
+ *   面板永久停在 starting，设备从未登记。根因：**watcher 把上游写死 3080**，
+ *   而 DSH Desktop（Electron 壳 `dsh-plugin-desktop`）把 Web 服务放在 **43120**（占用则 +1）、
+ *   独立用户也可能 `dsh web --port 8090` / `--port 0`。探不到 → `checkUpstream()` 恒 false
+ *   → **bridge 永远不被派生**，而面板只会说「正在启动 Bridge…」。
+ *
+ * 本用例锁的是**决策点**（不是实现细节）：只要上游在**非默认端口**且应答像 dsh web，
+ * watcher 就必须走进「dsh web 在线，启动 bridge...」并带着**正确的**
+ * `DSH_BRIDGE_UPSTREAM` 去派生 bridge。
+ *
+ * 隔离手法与 runtime-provision / connect-loop 一致：临时 HOME + 假 launchctl/pgrep/ps/npx，
+ * 绝不用到本机真实服务；上游是**测试进程内**起的假 dsh web（真 dsh web 只在 3080，
+ * 那正是我们要避开的默认值）。
+ */
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const SETUP = path.join(HERE, "..", "..", "..", "dsh-setup.mjs");
+
+/** 假 dsh web 的应答：带官方特征（身份校验靠它），并记录被访问过。 */
+const DSH_HTML = "<!doctype html><html><head><title>DeepSeek Harness</title></head>"
+  + "<body><script>__ModuleLoader__</script></body></html>";
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** 起一个假的上游（= 非默认端口上的 dsh web）。 */
+async function startFakeDshWeb() {
+  const hits = [];
+  const srv = http.createServer((req, res) => {
+    hits.push(req.url);
+    res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+    res.end(DSH_HTML);
+  });
+  await new Promise((r) => srv.listen(0, "127.0.0.1", r));
+  return { srv, port: srv.address().port, hits, url: `http://127.0.0.1:${srv.address().port}` };
+}
+
+/** 临时 relayDir + 一份"已登录"的配置（指向本地死端口，绝不外联）。 */
+function makeEnv() {
+  const root = mkdtempSync(path.join(os.tmpdir(), "dsh-upstream-port-"));
+  const home = path.join(root, "home");
+  const relayDir = path.join(root, "relay");
+  const bin = path.join(root, "bin");
+  for (const d of [home, relayDir, bin]) mkdirSync(d, { recursive: true });
+
+  // 假命令：让 watcher/插件的系统操作全部落空，绝不碰本机真实服务
+  const stub = (name, body) => {
+    const p = path.join(bin, name);
+    writeFileSync(p, `#!/bin/sh\n${body}\n`);
+    chmodSync(p, 0o755);
+  };
+  stub("launchctl", 'case "$1" in list) exit 0 ;; print) echo "could not find service" >&2; exit 113 ;; esac\nexit 0');
+  stub("pgrep", "exit 1");
+  stub("ps", 'case "$*" in *ppid*) echo 1 ;; *lstart*) echo "Mon Jan  1 00:00:00 2026" ;; esac\nexit 0');
+  stub("npx", "exit 127");
+
+  writeFileSync(path.join(relayDir, ".dsh-config.json"), JSON.stringify({
+    phone: "13800000000",
+    password: "pw",
+    device_id: "dev-aaaaaaaaaaaa",
+    tunnel_url: "ws://127.0.0.1:1",
+    api_url: "http://127.0.0.1:1"
+  }, null, 2), { mode: 0o600 });
+
+  return { root, home, relayDir, bin };
+}
+
+/** 起 watcher，返回 {proc, out(), stop()}。 */
+function startWatcher(env, extraEnv = {}) {
+  let out = "";
+  const proc = spawn(process.execPath, [SETUP, "run"], {
+    cwd: env.root,
+    env: {
+      ...process.env,
+      HOME: env.home,
+      DSH_RELAY_DIR: env.relayDir,
+      DSH_BRIDGE_CONFIG: path.join(env.relayDir, ".dsh-config.json"),
+      PATH: `${env.bin}:${process.env.PATH}`,
+      DSH_REMOTE_TELEMETRY: "0",
+      ...extraEnv
+    },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  proc.stdout.on("data", (d) => { out += String(d); });
+  proc.stderr.on("data", (d) => { out += String(d); });
+  return {
+    proc,
+    out: () => out,
+    async stop() {
+      try { proc.kill("SIGKILL"); } catch { /* ignore */ }
+      await sleep(120);
+    }
+  };
+}
+
+const waitFor = async (fn, timeoutMs = 12_000) => {
+  const t0 = Date.now();
+  while (Date.now() - t0 < timeoutMs) {
+    if (fn()) return true;
+    await sleep(150);
+  }
+  return false;
+};
+
+test("★ 上游在非默认端口(DSH Desktop 场景):watcher 必须发现它并派生 bridge", async (t) => {
+  const env = makeEnv();
+  const upstream = await startFakeDshWeb();
+  let watcher = null;
+  try {
+    // 真实的 Desktop 情形：端口文件要么还没写、要么写着上一轮的旧端口
+    writeFileSync(path.join(env.relayDir, ".dsh-upstream"), "http://127.0.0.1:1\n", { mode: 0o600 });
+    // DSH_WEB_URL 是宿主真实端口的合法来源之一（Desktop 包就是用它把端口暴露给子进程的）
+    watcher = startWatcher(env, { DSH_WEB_URL: upstream.url });
+
+    const started = await waitFor(() => /dsh web 在线，启动 bridge/.test(watcher.out()));
+    assert.ok(
+      started,
+      `上游在 ${upstream.port}（非 3080）时 watcher 依然要启动 bridge。实际输出：\n${watcher.out().slice(0, 1200)}`
+    );
+    assert.ok(upstream.hits.length > 0, "watcher 必须真的探测了那个非默认端口");
+    assert.ok(
+      !/等待 dsh web（http:\/\/127\.0\.0\.1:3080）/.test(watcher.out()),
+      "日志不得再宣称自己在等 3080（用户实测就是被这句误导）"
+    );
+    // ★ 关键：派生出去的 bridge 必须拿到**被发现的那个端口**（否则它会自己去探 3080 并永久失败）
+    const gotBridgeUpstream = await waitFor(() => new RegExp(`上游地址已确定: http://127\\.0\\.0\\.1:${upstream.port}`).test(watcher.out()), 6000);
+    assert.ok(
+      gotBridgeUpstream,
+      `bridge 应被注入发现到的上游 ${upstream.url}。实际输出：\n${watcher.out().slice(0, 1200)}`
+    );
+  } finally {
+    if (watcher) await watcher.stop();
+    await new Promise((r) => upstream.srv.close(r));
+    rmSync(env.root, { recursive: true, force: true });
+  }
+});
+
+test("上游确实不在时:watcher 保持等待(不谎报在线,也不派生 bridge)", async (t) => {
+  const env = makeEnv();
+  // ⚠️ 必须用**显式** DSH_BRIDGE_UPSTREAM 钉死死端口：不加它时动态发现会去探 3080，
+  //    而开发机/CI 上真的可能有一个 dsh web 在 3080 —— 那样这条断言就变成看环境了。
+  //    显式值优先且不做探测（既有语义），于是"上游不可达"这件事在测试里是确定的。
+  let watcher = null;
+  try {
+    writeFileSync(path.join(env.relayDir, ".dsh-upstream"), "http://127.0.0.1:1\n", { mode: 0o600 });
+    watcher = startWatcher(env, { DSH_BRIDGE_UPSTREAM: "http://127.0.0.1:1" });
+    await sleep(3500);
+    const out = watcher.out();
+    assert.ok(!/dsh web 在线，启动 bridge/.test(out), `不得谎报在线：\n${out.slice(0, 600)}`);
+    assert.match(out, /等待 dsh web/, "应如实说明在等 dsh web");
+  } finally {
+    if (watcher) await watcher.stop();
+    rmSync(env.root, { recursive: true, force: true });
+  }
+});