@feiyang666/dsh-mobile-remote 1.6.1 → 1.7.1-1

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # 更新日志 / Changelog
 
+## v1.7.1-1 (2026-08-29) — 预发布（beta，供前端测试）
+
+### 新增 / New
+- **外网访问面板显示数据通道状态**（`lib/index.js` + `lib/client.js`）：`/status` 新增 `external.ws` 字段（`available` = ws 依赖是否可用 / `connected` = WS 长连接是否建立 / `source` = 当前数据来源 `ws` | `http` | `none` / `lastPushAt` = 最后推送时刻），设置页「外网访问」卡片新增「数据通道」行徽标，让用户一眼看清当前是 **WS 实时推送**（绿色）、**HTTP 兜底（退让模式）**（未安装 ws 依赖）、**WS 已连接等待推送**、**WS 已断开 / 重连中**（含最后推送时间）中的哪一种。
+- **运行时长本地每秒刷新**（`lib/client.js`）：`runtimeInfo()` 增加采集时刻 `at`，前端新增 `LiveDuration` 组件——基于「采样秒数 + 采集时刻」在浏览器本地每秒累加，让「运行时长 / 开机时长 / 隧道已运行」等秒级数字每秒跳动（秒表效果），不再依赖 5s 的 `/status` 轮询刷新（此前数字每 5s 才跳一次且跳幅不连续）。
+
+### 变更 / Changed
+- 无 API 破坏；旧版 host / 新版 client 混用时，缺少 `at` / `ws` 字段会自动降级为原行为（数字按轮询刷新、不显示数据通道行）。
+
+## v1.7.0 (2026-08-28)
+
+### 新增 / New
+- **中转服务器 WS 状态推送客户端**（`lib/ws-client.js` + `lib/external.js`）：外网隧道开启后，插件端改为通过 **WebSocket 长连接**（`/api/tunnel/ws?bindCode=…`）接收中转服务器的隧道状态实时推送，**替代原来每 5s 的 HTTP 轮询** `/api/tunnel/stats`，中转服务器请求压力降为 0（服务器资源集中用于 frp 隧道中转）。
+  - 指数退避自动重连（2s → 4s → … → 60s 封顶），断线自动恢复；
+  - `ws` 依赖缺失（如离线安装未带依赖）时自动降级：WS 客户端 no-op，心跳与状态查询回退 HTTP 低频兜底，**功能不中断**；
+  - 停止外网 / 插件卸载时主动断开，不再自动重连。
+- **心跳优先经 WS 长连接发送**（`lib/external.js` `sendHeartbeat`）：WS 已连上时心跳直接经长连接送达（零 HTTP 请求），未连上才回退 HTTP `/api/tunnel/heartbeat`。
+- **状态查询 60s 节流缓存**（`lib/index.js` `queryServerStatus`）：即使移动端前端每 5s 轮询本机 `/status`，也不会高频打中转服务器；前端 `/status` 优先读 WS 推送缓存，仅在从未收到推送（ws 缺失 / WS 未建立）时才回退 HTTP 低频查询。
+
+### 变更 / Changed
+- 新增运行时依赖 `ws`（`^8.18.0`）；`npm run check` / `prepublishOnly` 增加 `lib/ws-client.js` 语法检查。
+
 ## v1.6.1 (2026-08-23)
 
 ### 修复 / Fixed

package/RELEASE_NOTES.md

@@ -1,4 +1,4 @@
-# dsh-mobile-remote v1.6.1
+# dsh-mobile-remote v1.7.0
 
 **DeepSeek Harness 移动端远程控制插件** —— 在 Web UI 设置页内置「远程控制」：连接二维码、一键开关、在线设备数，让手机通过局域网访问并操控电脑上的 DeepSeek Harness。移动端提供上传图片入口、底部抽屉式模型选择、发送状态提示等移动优先体验。
 
@@ -10,25 +10,23 @@ dsh plugin --profile web add @feiyang666/dsh-mobile-remote
 
 安装完成后**重启 dsh web 服务**，打开 `http://127.0.0.1:3080` → **设置 → 远程控制** 即可使用。
 
-## 本版更新（v1.6.1）
+## 本版更新（v1.7.0）
 
-### 🐛 用量插件等宽表在移动端被压成逐字竖排（可靠兜底）
+### 🆕 中转服务器 WS 状态推送（长连接替代轮询）
 
-`dsh-usage-plugin` 的「消耗表 / 消耗明细 / 每日统计」等 9–11 列宽表依赖其运行时注入的全局样式（`.dsh-usage-table{min-width:720px}` + ≤540px 折叠中间列）来避免列被压到极限宽度；若该样式因 CSP / 加载时序未生效，手机窄屏下每列会被压到约 1 字符宽、内容逐字竖排、无法阅读。
+外网隧道开启后，插件端改为通过 **WebSocket 长连接**（`/api/tunnel/ws?bindCode=…`）接收中转服务器的隧道状态实时推送，**替代原来每 5s 的 HTTP 轮询** `/api/tunnel/stats`，中转服务器请求压力降为 0（服务器资源集中用于 frp 隧道中转）。
 
-本插件（dsh-mobile-remote）的样式是**随 index.html 一起由服务端下发、必定生效**，故在 `<style id="dsh-mobile-remote-css">` 中新增兜底：
+- **指数退避自动重连**：断线后 2s → 4s → … → 60s 封顶自动恢复；
+- **心跳优先走 WS**：WS 已连上时心跳经长连接送达（零 HTTP 请求），未连上才回退 HTTP 兜底；
+- **状态查询 60s 节流**：即使移动端每 5s 轮询本机 `/status`，也不会高频打中转服务器；前端优先读 WS 推送缓存；
+- **ws 依赖缺失自动降级**：`ws` 未安装时 WS 客户端 no-op，心跳与状态查询回退 HTTP 低频兜底，**功能不中断**。
 
-- `html[data-dsh-mobile] .dsh-usage-table { min-width: 720px !important; }`，宽表强制保持 720px 宽；
-- ≤540px 时对带 `collapse-mobile` 的宽表隐藏第 4 列至倒数第 2 列，只保留前 3 个主标识列与最后合计列，关键数据一屏看全；
-- 价格表等窄表（无 `collapse-mobile`）不折叠，保留横向滚动。
+> ⚠️ 本版新增运行时依赖 `ws`（`^8.18.0`）。通过 `dsh plugin --profile web add` 安装会自动带上；若使用离线 tgz 手动安装，请确保 `ws` 已安装（缺失时插件自动降级，不会崩溃）。
 
-这样即使旧版用量插件未更新或其样式表注入失败，移动端宽表也始终可横向滑动阅读。
+## 历史更新（v1.6.x）
 
-## 历史更新（v1.6.0）
-
-### 🆕 SSE 实时推送端点
-
-新增 `GET /__dsh_remote/events` 事件流端点（受远程密码门禁保护），设备心跳上报 / 远程开关切换 / 外网隧道启动停止等状态变化时向订阅者推送 `data: {"type":"changed","at":<时间戳>}`。桌面端数据中心等客户端订阅该流即可**即时**感知远程设备与隧道状态变化，无需轮询。无订阅者时零开销，插件独立使用不受影响。
+- **v1.6.1**：用量插件等宽表移动端兜底（强制 720px + ≤540px 折叠中间列）
+- **v1.6.0**：新增 `GET /__dsh_remote/events` SSE 实时推送端点（设备心跳 / 远程开关 / 外网隧道状态变化即时推送）
 
 ## 已知事项
 

package/lib/client.js

@@ -225,6 +225,23 @@ window.__ModuleLoader__.load({
       return ss + ' 秒';
     }
 
+    // 实时时长组件：基于「一次采样的秒数 + 采集时刻」在浏览器本地每秒累加刷新，
+    // 让"运行时长 / 开机时长 / 隧道已运行"等秒级数字每秒跳动（秒表效果），
+    // 不再依赖 5s 的 /status HTTP 轮询（那会导致数字每 5s 才跳一次，且跳幅不连续）。
+    // 只要 host 在采集时带上 at 时间戳，两次 /status 之间也能精确走到下一秒。
+    function LiveDuration(props) {
+      var _n = useState(Date.now());
+      var now = _n[0];
+      var setNow = _n[1];
+      useEffect(function () {
+        var t = setInterval(function () { setNow(Date.now()); }, 1000);
+        return function () { clearInterval(t); };
+      }, []);
+      var at = props.at || now;
+      var sec = props.baseSec + Math.max(0, Math.floor((now - at) / 1000));
+      return fmtDuration(sec);
+    }
+
     function fmtBytes(b) {
       if (b === null || b === undefined) return '—';
       var n = Number(b);
@@ -405,6 +422,32 @@ window.__ModuleLoader__.load({
       // 后端探测到的错误（如鉴权失败 / token 不匹配），优先于请求时的临时错误
       var extErrText = extErr || (extError && status && status.external && status.external.error ? status.external.error : null);
 
+      // ---- WS 状态推送通道（host 连接中转服务器的数据通道）----
+      // 让用户明确看到当前外网状态数据是经 WS 长连接实时推送，还是退让为 HTTP 低频轮询。
+      var wsInfo = status && status.external && status.external.ws ? status.external.ws : null;
+      var wsBadge = null;
+      var wsHint = null;
+      if (extStarted && wsInfo) {
+        if (wsInfo.connected && wsInfo.source === 'ws') {
+          wsBadge = el('span', { style: Object.assign({}, st.badge, st.badgeOn) }, 'WS 实时推送');
+          wsHint = '隧道状态经 WebSocket 长连接实时更新（零 HTTP 轮询）';
+        } else if (wsInfo.available === false) {
+          // 退让版本：ws 依赖缺失（如离线安装），WS 客户端 no-op，走 HTTP 低频兜底
+          wsBadge = el('span', { style: Object.assign({}, st.badge, st.badgeBusy) }, 'HTTP 兜底（退让模式）');
+          wsHint = '未安装 ws 依赖，已自动退让为 HTTP 低频查询（60s 节流），功能不受影响';
+        } else if (wsInfo.connected) {
+          wsBadge = el('span', { style: Object.assign({}, st.badge, st.badgeBusy) }, 'WS 已连接，等待推送');
+          wsHint = 'WS 长连接已建立，收到首条推送后自动切换为实时模式';
+        } else if (wsInfo.source === 'ws') {
+          wsBadge = el('span', { style: Object.assign({}, st.badge, st.badgeBusy) }, 'WS 已断开');
+          wsHint = 'WS 长连接已断开，正在自动重连；当前显示最近一次推送的缓存数据' +
+            (wsInfo.lastPushAt ? '（最后推送 ' + fmtAgo(wsInfo.lastPushAt) + '）' : '');
+        } else {
+          wsBadge = el('span', { style: Object.assign({}, st.badge, st.badgeBusy) }, 'WS 未连接');
+          wsHint = 'WS 长连接尚未建立（连接中 / 自动重连），期间数据走 HTTP 兜底';
+        }
+      }
+
       function externalStart() {
         if (extBusy || extConnecting) return;
         if (!bindCode || !bindCode.trim()) {
@@ -730,8 +773,8 @@ window.__ModuleLoader__.load({
                 el('span', { style: Object.assign({}, st.badge, st.badgeOff) },
                   'PID ' + status.runtime.pid)),
               el('div', { style: { display: 'flex', flexDirection: 'column', gap: 4 } }, kvList([
-                ['运行时长', fmtDuration(status.runtime.uptime)],
-                ['开机时长', fmtDuration(status.runtime.sysUptime)],
+                ['运行时长', el(LiveDuration, { baseSec: status.runtime.uptime || 0, at: status.runtime.at })],
+                ['开机时长', el(LiveDuration, { baseSec: status.runtime.sysUptime || 0, at: status.runtime.at })],
                 ['Node.js', status.runtime.nodeVersion],
                 ['主机名', status.runtime.hostname],
                 ['系统', (status.runtime.platform || '—') + ' ' + (status.runtime.release || '') + ' (' + (status.runtime.arch || '—') + ')'],
@@ -857,8 +900,16 @@ window.__ModuleLoader__.load({
                   el('span', { style: st.meta },
                     'frpc 进程：' + (status.external.pid ? 'PID ' + status.external.pid : '—')),
                   status.external.startedAt
-                    ? el('span', { style: st.meta }, '已运行 ' + fmtDuration(Math.floor((Date.now() - status.external.startedAt) / 1000)))
+                    ? el('span', { style: st.meta }, '已运行 ',
+                        el(LiveDuration, { baseSec: 0, at: status.external.startedAt }))
                     : null),
+                wsBadge
+                  ? el('div', { style: st.row },
+                      el('span', { style: st.meta }, '数据通道'),
+                      el('div', { style: { display: 'flex', flexDirection: 'column', alignItems: 'flex-end', gap: 2 } },
+                        wsBadge,
+                        wsHint ? el('span', { style: st.hint }, wsHint) : null))
+                  : null,
                 el('div', { style: st.row },
                   el('span', { style: st.meta },
                     '绑定码：' + (status.external.bindCodeShort || '—')),

package/lib/external.js

@@ -6,7 +6,8 @@
 //   - 写 profile 的 connection trustedHosts，放行外网域名（通过 /api 信任围栏）
 //   - 心跳上报、状态查询、停止
 //
-// 零运行时依赖：仅 Node 内置模块。frpc 二进制由中转服务提供或用户本地放置。
+// 运行时依赖：Node 内置模块 + `ws`（WebSocket 长连接接收中转服务状态推送，
+// 替代高频轮询；ws 依赖缺失时自动回退 HTTP 低频查询）。frpc 二进制由中转服务提供或用户本地放置。
 //
 // 稳健性说明（针对"开启难/开了又关"问题）：
 //   - 强制给 frpc.toml 追加 loginFailExit=false：连不上 frps 时持续重试，
@@ -22,6 +23,7 @@ import {
   existsSync, readFileSync, writeFileSync, mkdirSync, openSync, closeSync, rmSync,
 } from 'node:fs'
 import { spawn } from 'node:child_process'
+import { createWsStatusClient } from './ws-client.js'
 
 /** 默认中转服务地址（自建 dsh-update-server，Nginx 反代 443→3200，对外无端口）。
  *  可用 DSH_REMOTE_SERVER 覆盖。 */
@@ -480,6 +482,19 @@ async function startExternalInner(state, body, patchFile, defaultLocalPort) {
       state.serverBase = base
       state.localPort = Number((body && body.localPort) || defaultLocalPort)
       savePersistedState(state)
+      // 建立 WS 长连接接收隧道状态推送（替代每 5s HTTP 轮询中转服务器）；
+      // ws 依赖缺失（离线安装）时 wsClient.connect() 自动 no-op，心跳走 HTTP 兜底
+      state.serverStatus = null
+      if (state.wsClient) {
+        try { state.wsClient.disconnect() } catch { /* ignore */ }
+      }
+      state.wsClient = createWsStatusClient({
+        serverBase: base,
+        bindCode: state.bindCode,
+        onStatus: (data) => { state.serverStatus = data },
+        logger: null,
+      })
+      state.wsClient.connect()
       // 隧道确认建立后启动持续心跳，让后端 last_seen 保持新鲜（管理端在线判定依赖它）
       startKeepAlive(state)
     }
@@ -568,6 +583,12 @@ async function startExternalInner(state, body, patchFile, defaultLocalPort) {
  */
 function stopExternal(state, opts = {}) {
   stopKeepAlive(state)
+  // 断开 WS 长连接（中转服务端据此判定离线）
+  if (state.wsClient) {
+    try { state.wsClient.disconnect() } catch { /* ignore */ }
+    state.wsClient = null
+  }
+  state.serverStatus = null
   // 停止前上报离线，让管理端/成员端立即反映（后端支持 status 字段才生效）
   if (!opts.keepState) {
     state.status = 'offline'
@@ -612,20 +633,23 @@ function frpcLogTail(bytes = 6000) {
 /** 持续心跳间隔（毫秒）：后端据此维持 last_seen，并做离线超时判定。 */
 const HEARTBEAT_INTERVAL = 60_000
 
-/** 上报一次在线/离线心跳（尽力而为，失败静默）。 */
+/** 上报一次在线/离线心跳（尽力而为，失败静默）。
+ *  优先经 WS 长连接发送（零 HTTP 请求）；WS 不可用/未连上时回退 HTTP。 */
 async function sendHeartbeat(state) {
   const base = state.serverBase || process.env.DSH_REMOTE_SERVER || DEFAULT_SERVER_BASE
   const bindCode = state.bindCode
   if (!bindCode) return
+  const status = state.status === 'online' ? 'online' : 'offline'
+  // WS 已连接 → 直接经长连接发送，减轻中转服务器 HTTP 压力
+  if (state.wsClient && state.wsClient.isOpen() && state.wsClient.sendHeartbeat(status)) {
+    return
+  }
+  // WS 不可用 / 未连上 → HTTP 心跳兜底（旧后端 / ws 依赖缺失场景）
   try {
     await fetch(`${base.replace(/\/$/, '')}/api/tunnel/heartbeat`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        bindCode,
-        // offline 表示隧道已停止，让管理端立即标记离线（后端支持时才生效）
-        status: state.status === 'online' ? 'online' : 'offline',
-      }),
+      body: JSON.stringify({ bindCode, status }),
     })
   } catch { /* ignore */ }
 }

package/lib/index.js

@@ -43,6 +43,7 @@ import {
   hasPassword, verifyPassword, setPassword,
   isEnabled, login, verifyToken, revokeToken, clearSessions,
 } from './password.js'
+import { wsAvailable } from './ws-client.js'
 
 /** 插件名（loader 诊断用）。 */
 export const name = 'dsh-mobile-remote'
@@ -214,11 +215,14 @@ function getLanInterfaces() {
 
 /** 当前进程运行时信息（诊断用，设置页展示）。 */
 function runtimeInfo() {
+  // 采集时刻：前端可据此在两次 /status 轮询之间本地累加，让"运行时长"每秒跳动。
+  const at = Date.now()
   const mem = process.memoryUsage()
   const cpu = cpus()
   const load = loadavg()
   const total = totalmem()
   return {
+    at,
     pid: process.pid,
     hostname: hostname(),
     platform: platform(),
@@ -602,11 +606,18 @@ self.addEventListener('fetch', function (event) {
 
 /**
  * 从中转服务器查询本成员隧道状态与统计；失败时返回 null（不影响整体 status）。
+ * 仅作 WS 推送不可用（ws 依赖缺失 / 旧后端）时的 HTTP 兜底。
  * 优先调用 /api/tunnel/stats（含 frps 实时流量/连接数等），接口不可用则回退到
- * /api/tunnel/status（旧版后端）。任一失败返回 null。
+ * /api/tunnel/status（旧版后端）。
+ * 注意：带 60s 节流缓存——即使前端每 5s 轮询本机 /status，也不会高频打中转服务器。
  */
+let serverStatusCache = { at: 0, value: null }
 async function queryServerStatus(base, bindCode) {
   if (!bindCode) return null
+  const now = Date.now()
+  if (serverStatusCache.value && now - serverStatusCache.at < 60000) {
+    return serverStatusCache.value
+  }
   const server = String(base || DEFAULT_SERVER_BASE).replace(/\/$/, '')
   const call = (path) => fetch(`${server}${path}`, {
     headers: { Accept: 'application/json' },
@@ -619,8 +630,9 @@ async function queryServerStatus(base, bindCode) {
   }).catch(() => null)
   const q = `?bindCode=${encodeURIComponent(bindCode)}`
   const stats = await call(`/api/tunnel/stats${q}`)
-  if (stats) return stats
-  return call(`/api/tunnel/status${q}`)
+  const data = stats || await call(`/api/tunnel/status${q}`)
+  serverStatusCache = { at: now, value: data }
+  return data
 }
 
 /** 当前 profile 的 cordis.patch.yml 绝对路径。 */
@@ -730,11 +742,21 @@ function handleStatus(ctx, devices, external, tracker, dshCache) {
       })
     }
     deviceList.sort((a, b) => b.lastSeen - a.lastSeen)
-    // 外网隧道在线时，向中转服务器查询成员真实状态（成员名 / frps 在线 / 最后心跳）
+    // 外网隧道在线时，优先读 WS 推送缓存（经长连接实时更新，零中转服务器请求）；
+    // 仅当从未收到推送（ws 依赖缺失 / WS 未建立）时才回退 HTTP 低频查询（60s 节流）。
     let server = null
+    let serverSource = 'none'
     if (extRunning && persisted) {
-      server = await queryServerStatus(persisted.serverBase || undefined, persisted.bindCode)
+      if (external.serverStatus) {
+        server = external.serverStatus
+        serverSource = 'ws'
+      } else {
+        server = await queryServerStatus(persisted.serverBase || undefined, persisted.bindCode)
+        serverSource = 'http'
+      }
     }
+    // WS 长连接是否已建立（供前端判断当前处于"实时推送"还是"退让/重连"）
+    const wsConnected = !!(external.wsClient && external.wsClient.isOpen())
     json(res, 200, {
       host: ctx.webServer.host,
       port: ctx.webServer.port,
@@ -776,6 +798,19 @@ function handleStatus(ctx, devices, external, tracker, dshCache) {
           : null,
         // 中转服务器返回的成员状态（外网在线时才有）
         server,
+        // WS 状态推送通道信息：让前端明确当前数据是 WS 实时推送还是 HTTP 兜底退让
+        ws: {
+          // ws 依赖是否可用（离线安装未带依赖时为 false，自动退让 HTTP）
+          available: wsAvailable(),
+          // WS 长连接是否已建立
+          connected: wsConnected,
+          // 当前 server 数据来源：'ws'（实时推送缓存）/ 'http'（兜底查询）/ 'none'
+          source: serverSource,
+          // 最近一次收到 WS 推送的时刻（未收到过为 null）
+          lastPushAt: external.serverStatus && external.serverStatus._at
+            ? external.serverStatus._at
+            : null,
+        },
       },
       // 远程访问密码门禁状态（供设置面板展示）
       auth: {

package/lib/ws-client.js

@@ -0,0 +1,152 @@
+// dsh-mobile-remote — 中转服务器 WS 状态推送客户端（host 侧）。
+//
+// 目标：用 WebSocket 长连接接收中转服务器的隧道状态推送，替代插件端
+// 每 5s 轮询 /api/tunnel/stats，把中转服务器的请求压力降为 0。
+//
+// 说明：
+//  - 本插件运行在 Electron 内置 Node（当前 20.x，无原生全局 WebSocket），
+//    因此需要 `ws` 第三方库。若依赖缺失（如离线 tgz 安装未装依赖），
+//    wsAvailable() 返回 false，调用方自动回退 HTTP 低频查询，功能不中断。
+//  - 连接管理：指数退避自动重连（2s→4s→…→60s）；心跳由 external.js 的
+//    keepAliveTimer 统一驱动（每 60s），WS 已连上时走 WS、否则走 HTTP。
+//  - 收到 tunnel:status 后更新本地缓存并回调 onStatus，前端 /status 直接读缓存。
+
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url)
+
+/** 尝试加载 ws 库（Node 20 无原生 WebSocket，需要它）。 */
+let WsCtor = null
+try {
+  WsCtor = require('ws')
+} catch {
+  WsCtor = null
+}
+
+/** 当前环境是否可用 WebSocket（ws 依赖是否加载成功）。 */
+export function wsAvailable() {
+  return !!WsCtor
+}
+
+/**
+ * 创建成员端 WS 状态推送客户端。
+ * @param {object} opts
+ * @param {string} opts.serverBase 中转服务基地址（https://… 或 http://…）
+ * @param {string} opts.bindCode    绑定码
+ * @param {(data: object) => void} [opts.onStatus] 收到 tunnel:status 时的回调
+ * @param {(msg: string, ...args: unknown[]) => void} [opts.logger] 日志（默认静默）
+ */
+export function createWsStatusClient({ serverBase, bindCode, onStatus, logger }) {
+  let ws = null
+  let manualClose = false
+  let retryTimer = null
+  let retryDelay = 2000
+  let lastStatus = null
+  const log = logger || (() => {})
+
+  function wsUrl() {
+    // http:// → ws://，https:// → wss://
+    const base = String(serverBase || '').replace(/^http/, 'ws').replace(/\/+$/, '')
+    return `${base}/api/tunnel/ws?bindCode=${encodeURIComponent(String(bindCode || ''))}`
+  }
+
+  function isOpen() {
+    return !!(ws && ws.readyState === ws.OPEN)
+  }
+
+  function scheduleReconnect() {
+    if (manualClose || retryTimer) return
+    retryTimer = setTimeout(() => {
+      retryTimer = null
+      connect()
+    }, retryDelay)
+    if (retryTimer.unref) retryTimer.unref()
+    retryDelay = Math.min(retryDelay * 2, 60000)
+  }
+
+  function connect() {
+    if (!WsCtor) return
+    if (manualClose) return
+    if (ws && (ws.readyState === ws.OPEN || ws.readyState === ws.CONNECTING)) return
+    let client
+    try {
+      client = new WsCtor(wsUrl())
+    } catch (e) {
+      log('[ws-client] 连接失败:', String((e && e.message) || e))
+      scheduleReconnect()
+      return
+    }
+    ws = client
+
+    client.on('open', () => {
+      retryDelay = 2000
+      log('[ws-client] 已连接（bindCode=****）')
+    })
+
+    client.on('message', (buf) => {
+      try {
+        const msg = JSON.parse(buf.toString())
+        if (msg && msg.type === 'tunnel:status' && msg.data) {
+          msg.data._at = Date.now() // 缓存新鲜度标记
+          lastStatus = msg.data
+          try { onStatus && onStatus(msg.data) } catch (e) { /* ignore */ }
+        }
+      } catch (e) { /* ignore */ }
+    })
+
+    client.on('close', (code, reason) => {
+      log('[ws-client] 连接关闭 code=' + code, String(reason || ''))
+      ws = null
+      if (!manualClose) scheduleReconnect()
+    })
+
+    client.on('error', (err) => {
+      log('[ws-client] 错误:', String((err && err.message) || err))
+      try { client.terminate() } catch (e) { /* ignore */ }
+    })
+  }
+
+  /** 主动断开（停止外网 / 插件卸载时调用），之后不再自动重连。 */
+  function disconnect() {
+    manualClose = true
+    if (retryTimer) { clearTimeout(retryTimer); retryTimer = null }
+    if (ws) {
+      try { ws.close() } catch (e) { /* ignore */ }
+      try { ws.terminate() } catch (e) { /* ignore */ }
+      ws = null
+    }
+  }
+
+  /** 重置并重连（绑定码 / 中转地址变化后使用）。 */
+  function reconnect() {
+    manualClose = false
+    if (retryTimer) { clearTimeout(retryTimer); retryTimer = null }
+    retryDelay = 2000
+    if (ws) {
+      try { ws.terminate() } catch (e) { /* ignore */ }
+      ws = null
+    }
+    connect()
+  }
+
+  /**
+   * 经 WS 发送心跳（成功返回 true；未连接返回 false，调用方回退 HTTP）。
+   * @param {'online'|'offline'} [status]
+   */
+  function sendHeartbeat(status) {
+    if (!isOpen()) return false
+    try {
+      ws.send(JSON.stringify({ type: 'heartbeat', status: status || 'online' }))
+      return true
+    } catch (e) {
+      return false
+    }
+  }
+
+  /** 最近一次收到的隧道状态（未收到过为 null）。 */
+  function getLastStatus() {
+    return lastStatus
+  }
+
+  return { connect, disconnect, reconnect, isOpen, sendHeartbeat, getLastStatus }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feiyang666/dsh-mobile-remote",
-  "version": "1.6.1",
+  "version": "1.7.1-1",
   "description": "DeepSeek Harness mobile remote-control plugin: LAN/external remote control (QR / on-off toggle / remote-access password gate), rich telemetry (expandable device details, system CPU/memory/load, DSH app state: version/sessions/workspaces/plugins/models), real external-tunnel status detection (frpc token / reconnect diagnostics), mobile-first UI polish (composer image upload entry via system picker, settings single-column layout) and faster remote loading.",
   "keywords": [
     "deepseek",
@@ -40,6 +40,9 @@
   "engines": {
     "node": ">=18"
   },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
@@ -62,8 +65,8 @@
   ],
   "scripts": {
     "pack:list": "npm pack --dry-run",
-    "check": "node --check lib/index.js && node --check lib/client.js && node --check lib/external.js && node --check lib/password.js && node --check lib/qrcode.js",
-    "prepublishOnly": "node --check lib/index.js && node --check lib/client.js && node --check lib/external.js && node --check lib/password.js && node --check lib/qrcode.js",
+    "check": "node --check lib/index.js && node --check lib/client.js && node --check lib/external.js && node --check lib/ws-client.js && node --check lib/password.js && node --check lib/qrcode.js",
+    "prepublishOnly": "node --check lib/index.js && node --check lib/client.js && node --check lib/external.js && node --check lib/ws-client.js && node --check lib/password.js && node --check lib/qrcode.js",
     "pack": "npm pack"
   },
   "peerDependencies": {