@wenbin_wb/dsh-bridge 2.10.7 → 2.10.9

package/lib/auth/manager.js

@@ -3,6 +3,9 @@
 
 import { randomBytes, pbkdf2 as pbkdf2Callback, timingSafeEqual } from 'node:crypto'
 import { promisify } from 'node:util'
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, dirname } from 'node:path'
 
 const pbkdf2Async = promisify(pbkdf2Callback)
 
@@ -18,6 +21,50 @@ const LEGACY_PBKDF2_ITERATIONS = 10000
 const PBKDF2_KEYLEN = 32
 const PBKDF2_PREFIX = 'pbkdf2-sha256$'
 
+// 登录 Session 持久化：宿主（dsh web 进程）重启后，已登录设备免重输访问密码。
+// 落盘文件与 config.json 同目录（~/.dsh/dsh-bridge/sessions.json，权限 600）；
+// sessionToken 与 secretToken 同级机密（48 位随机 hex），同目录存储不扩大暴露面。
+// 改密码 / 切模式 / 重新生成 token 时的 sessions.clear() 会同步清空文件（吊销语义保持）；
+// 文件缺失或损坏时安全降级为空 Map（等价于旧行为：重新登录一次）。
+// 路径可通过构造参数 sessionsFile 注入（测试传临时目录，避免读写真实环境）。
+const DEFAULT_SESSIONS_FILE = join(
+  process.env.DSH_HOME ?? join(homedir(), '.dsh'),
+  'dsh-bridge', 'sessions.json'
+)
+
+class PersistentSessionMap extends Map {
+  /** @param {string} file 会话落盘文件路径 */
+  constructor(file) {
+    super()
+    this._file = file
+  }
+  _flush() {
+    try {
+      mkdirSync(dirname(this._file), { recursive: true })
+      writeFileSync(this._file, JSON.stringify([...this.entries()]), { mode: 0o600 })
+    } catch { /* 落盘失败降级为纯内存语义，不阻断认证流程 */ }
+  }
+  static load(file) {
+    const m = new PersistentSessionMap(file)
+    try {
+      const arr = JSON.parse(readFileSync(file, 'utf8'))
+      if (Array.isArray(arr)) {
+        const now = Date.now()
+        for (const [k, v] of arr) {
+          // 只恢复结构合法且未过期的会话
+          if (typeof k === 'string' && v && Number.isFinite(v.expiresAt) && v.expiresAt > now) {
+            Map.prototype.set.call(m, k, { createdAt: Number(v.createdAt) || 0, expiresAt: Number(v.expiresAt) })
+          }
+        }
+      }
+    } catch { /* 文件缺失/损坏：降级为空 */ }
+    return m
+  }
+  set(k, v) { super.set(k, v); this._flush(); return this }
+  delete(k) { const r = super.delete(k); if (r) this._flush(); return r }
+  clear() { super.clear(); this._flush() }
+}
+
 export class AuthManager {
   /**
    * @param {object} opts
@@ -30,9 +77,10 @@ export class AuthManager {
    * @param {boolean} [opts.config.allowLoopback=true]
    * @param {boolean} [opts.config.adminProtection=true] 管理保护独立开关：关闭后管理操作免 adminToken
    * @param {(patch: object) => Promise<void>|void} [opts.onPersist]
+   * @param {string} [opts.sessionsFile] 登录会话持久化文件路径（默认 ~/.dsh/dsh-bridge/sessions.json；测试注入临时目录）
    * @param {object} [opts.logger]
    */
-  constructor({ config = {}, onPersist, logger = console } = {}) {
+  constructor({ config = {}, onPersist, sessionsFile, logger = console } = {}) {
     this.logger = logger
     this.onPersist = onPersist
 
@@ -51,8 +99,9 @@ export class AuthManager {
     // 内部隧道专用鉴权密钥（内存生成，用于辨别本地自建隧道转发流量与真实本机访问）
     this.internalTunnelSecret = randomBytes(24).toString('hex')
 
-    // Session 内存存储：sessionToken -> { createdAt, expiresAt }
-    this.sessions = new Map()
+    // Session 存储与重启恢复：sessionToken -> { createdAt, expiresAt }
+    // 持久化到 sessions.json（路径可经 sessionsFile 注入），宿主（dsh web）重启后已登录设备免重输访问密码
+    this.sessions = PersistentSessionMap.load(sessionsFile ?? DEFAULT_SESSIONS_FILE)
     // 管理员解锁 Session 内存存储：adminToken -> { createdAt, expiresAt }
     this.adminSessions = new Map()
     // 防暴力破解：ip -> { failedCount, lockUntil }
@@ -540,7 +589,8 @@ export class AuthManager {
 
   dispose() {
     clearInterval(this._cleanupTimer)
-    this.sessions.clear()
+    // 不清空 sessions：进程退出时内存随进程自然消失；
+    // 若此处 clear() 会把持久化文件一并清空，宿主重启后已登录设备仍会全部丢失
     this.rateLimits.clear()
   }
 }

package/lib/bridge-rpc-constants.js

@@ -16,6 +16,7 @@ export const BRIDGE_ENDPOINTS = {
   setLanIp: 'setLanIp',
   checkVersion: 'checkVersion',
   upgradePlugin: 'upgradePlugin',
+  upgradeDsh: 'upgradeDsh',
   restartDsh: 'restartDsh',
   exportBackup: 'exportBackup',
   importBackup: 'importBackup',

package/lib/bridge-rpc.js

@@ -3,6 +3,7 @@
 
 import QRCode from 'qrcode';
 import { BRIDGE_RPC_CHANNEL, BRIDGE_ENDPOINTS } from './bridge-rpc-constants.js';
+import { registerRpcChannel } from './connection-compat.js';
 import { RateLimiter } from './security/rate-limiter.js';
 
 export { BRIDGE_RPC_CHANNEL, BRIDGE_ENDPOINTS };
@@ -87,7 +88,10 @@ export function installBridgeRpc(ctx, { service, authManager, platformManager, l
     return () => {};
   }
 
-  return ctx.connection.rpc.handle(
+  // 经 connection-compat 注册：兼容 DSH ≥ 0.1.5-alpha.1 的 webServer 注入回归
+  // （上游 register() 里对 connection 自身 ctx 取 webServer 而未加 inject 作用域）
+  return registerRpcChannel(
+    ctx,
     BRIDGE_RPC_CHANNEL,
     async (endpoint, payload = {}, signal) => {
       if (signal?.aborted) return fail('cancelled', 'Request was cancelled');
@@ -289,6 +293,14 @@ export function installBridgeRpc(ctx, { service, authManager, platformManager, l
           return ok(result);
         }
 
+        if (endpoint === BRIDGE_ENDPOINTS.upgradeDsh) {
+          const adminErr = checkAdminAuth(authManager, payload, { requireConfigured: true });
+          if (adminErr) return adminErr;
+
+          const result = await service.upgradeDsh(payload);
+          return ok(result);
+        }
+
         if (endpoint === BRIDGE_ENDPOINTS.restartDsh) {
           const adminErr = checkAdminAuth(authManager, payload, { requireConfigured: true });
           if (adminErr) return adminErr;
@@ -478,7 +490,10 @@ export function installBridgeRpc(ctx, { service, authManager, platformManager, l
         return fail('bad-request', err.message);
       }
     },
-    { authority: 'loopback' }
+    // DSH 0.1.0/0.1.1 支持 authority 选项（仅回环可达）；0.1.2+ 忽略之，透传无副作用。
+    // 见 lib/connection-compat.js 的 registerRpcChannel 说明。
+    { authority: 'loopback' },
+    logger
   );
 }
 

package/lib/compat.js

@@ -1,129 +1,129 @@
-// 运行时兼容垫片（lib/compat.js）
-//
-// 背景：DSH 核心依赖链（@deepseek-ai/dsh-timeout ← dsh-llm）在每次 agent 请求上
-// 调用 AbortSignal.any([...])，该 API 仅存在于 Node 20.3+/22+。运行在低版本 Node
-// （如 Node 18）上时，通过桥接发送消息会直接抛
-//   "AbortSignal.any is not a function ... (internal)"
-// 本模块在缺失时安装规范兼容的垫片；环境本身支持时不做任何事（返回 false）。
-//
-// 浏览器侧（旧 Safari/WebView）由 lib/index.js 的 HTML_HEAD_INJECTIONS 注入同语义垫片。
-
-function abortWith(controller, reason) {
-  try {
-    controller.abort(reason)
-  } catch {
-    try { controller.abort() } catch { /* 不可中止的信号：忽略 */ }
-  }
-}
-
-/**
- * 在目标环境中安装 AbortSignal.any / AbortSignal.timeout 垫片（仅缺失时）。
- * @param {object} [target] 可注入的环境（默认 globalThis），便于测试
- * @returns {boolean} 是否实际安装了垫片
- */
-export function installAbortSignalCompat(target = globalThis) {
-  const Signal = target.AbortSignal
-  const Controller = target.AbortController
-  if (!Signal || !Controller) return false
-
-  let installed = false
-
-  // ---- AbortSignal.any ----
-  if (typeof Signal.any !== 'function') {
-    Signal.any = (signals) => {
-      const list = Array.from(signals ?? [])
-      const controller = new Controller()
-      // 规范语义：任一源信号已中止 → 立即以该原因中止
-      for (const s of list) {
-        if (s && s.aborted) {
-          abortWith(controller, s.reason)
-          return controller.signal
-        }
-      }
-      const onAbort = (eventOrSignal) => {
-        // 真实 EventTarget 的 abort 事件参数是 event（event.target = 信号），
-        // 部分非标准实现直接传信号本身——两者都兼容取 reason
-        const src = eventOrSignal && eventOrSignal.target ? eventOrSignal.target : eventOrSignal
-        cleanup()
-        abortWith(controller, src ? src.reason : undefined)
-      }
-      const cleanup = () => {
-        for (const s of list) {
-          try { s.removeEventListener('abort', onAbort) } catch { /* 非标准信号：忽略 */ }
-        }
-      }
-      for (const s of list) {
-        try { s.addEventListener('abort', onAbort, { once: true }) } catch { /* 非标准信号：忽略 */ }
-      }
-      return controller.signal
-    }
-    installed = true
-  }
-
-  // ---- AbortSignal.timeout（Node 17.3+ / 较新浏览器才有，顺手补齐）----
-  if (typeof Signal.timeout !== 'function') {
-    Signal.timeout = (delayMs) => {
-      const controller = new Controller()
-      const delay = Math.max(0, Number(delayMs) || 0)
-      const reason = typeof target.DOMException === 'function'
-        ? new target.DOMException('The operation timed out.', 'TimeoutError')
-        : new Error('The operation timed out.')
-      const timer = setTimeout(() => abortWith(controller, reason), delay)
-      // 规范语义：timeout 信号的超时定时器不阻止进程退出
-      if (typeof timer.unref === 'function') timer.unref()
-      return controller.signal
-    }
-    installed = true
-  }
-
-  return installed
-}
-
-/**
- * 浏览器侧垫片源码：由代理注入到 HTML <head>（在宿主所有脚本之前执行），
- * 为 iOS 16 / 旧 Safari / 旧 WebView（无 AbortSignal.any，Safari 17.4 才加入）
- * 上的 DSH 网页客户端补齐。多行可读源码，勿手工压缩成单行（配平易错）。
- */
-export const BROWSER_ABORT_SIGNAL_POLYFILL = `<script data-dsh-bridge-polyfill="2">
-!function () {
-  try {
-    var S = self.AbortSignal;
-    if (typeof S !== 'function') return;
-    if (typeof S.any !== 'function') {
-      S.any = function (signals) {
-        var list = Array.prototype.slice.call(signals || []);
-        var c = new self.AbortController();
-        var onAbort = function (ev) {
-          var src = ev && ev.target ? ev.target : ev;
-          cleanup();
-          try { c.abort(src ? src.reason : undefined); } catch (e) { c.abort(); }
-        };
-        var cleanup = function () {
-          for (var i = 0; i < list.length; i++) {
-            try { list[i].removeEventListener('abort', onAbort); } catch (e) {}
-          }
-        };
-        for (var i = 0; i < list.length; i++) {
-          if (list[i] && list[i].aborted) {
-            try { c.abort(list[i].reason); } catch (e) { c.abort(); }
-            return c.signal;
-          }
-        }
-        for (var i = 0; i < list.length; i++) {
-          try { list[i].addEventListener('abort', onAbort, { once: true }); } catch (e) {}
-        }
-        return c.signal;
-      };
-    }
-    if (typeof S.timeout !== 'function') {
-      S.timeout = function (ms) {
-        var c = new self.AbortController();
-        setTimeout(function () {
-          try { c.abort(new Error('The operation timed out.')); } catch (e) { c.abort(); }
-        }, Math.max(0, Number(ms) || 0));
-        return c.signal;
-      };
-    }
-  } catch (e) { /* 环境异常时不影响页面其余脚本 */ }
-}();
-</script>`
+// 运行时兼容垫片（lib/compat.js）
+//
+// 背景：DSH 核心依赖链（@deepseek-ai/dsh-timeout ← dsh-llm）在每次 agent 请求上
+// 调用 AbortSignal.any([...])，该 API 仅存在于 Node 20.3+/22+。运行在低版本 Node
+// （如 Node 18）上时，通过桥接发送消息会直接抛
+//   "AbortSignal.any is not a function ... (internal)"
+// 本模块在缺失时安装规范兼容的垫片；环境本身支持时不做任何事（返回 false）。
+//
+// 浏览器侧（旧 Safari/WebView）由 lib/index.js 的 HTML_HEAD_INJECTIONS 注入同语义垫片。
+
+function abortWith(controller, reason) {
+  try {
+    controller.abort(reason)
+  } catch {
+    try { controller.abort() } catch { /* 不可中止的信号：忽略 */ }
+  }
+}
+
+/**
+ * 在目标环境中安装 AbortSignal.any / AbortSignal.timeout 垫片（仅缺失时）。
+ * @param {object} [target] 可注入的环境（默认 globalThis），便于测试
+ * @returns {boolean} 是否实际安装了垫片
+ */
+export function installAbortSignalCompat(target = globalThis) {
+  const Signal = target.AbortSignal
+  const Controller = target.AbortController
+  if (!Signal || !Controller) return false
+
+  let installed = false
+
+  // ---- AbortSignal.any ----
+  if (typeof Signal.any !== 'function') {
+    Signal.any = (signals) => {
+      const list = Array.from(signals ?? [])
+      const controller = new Controller()
+      // 规范语义：任一源信号已中止 → 立即以该原因中止
+      for (const s of list) {
+        if (s && s.aborted) {
+          abortWith(controller, s.reason)
+          return controller.signal
+        }
+      }
+      const onAbort = (eventOrSignal) => {
+        // 真实 EventTarget 的 abort 事件参数是 event（event.target = 信号），
+        // 部分非标准实现直接传信号本身——两者都兼容取 reason
+        const src = eventOrSignal && eventOrSignal.target ? eventOrSignal.target : eventOrSignal
+        cleanup()
+        abortWith(controller, src ? src.reason : undefined)
+      }
+      const cleanup = () => {
+        for (const s of list) {
+          try { s.removeEventListener('abort', onAbort) } catch { /* 非标准信号：忽略 */ }
+        }
+      }
+      for (const s of list) {
+        try { s.addEventListener('abort', onAbort, { once: true }) } catch { /* 非标准信号：忽略 */ }
+      }
+      return controller.signal
+    }
+    installed = true
+  }
+
+  // ---- AbortSignal.timeout（Node 17.3+ / 较新浏览器才有，顺手补齐）----
+  if (typeof Signal.timeout !== 'function') {
+    Signal.timeout = (delayMs) => {
+      const controller = new Controller()
+      const delay = Math.max(0, Number(delayMs) || 0)
+      const reason = typeof target.DOMException === 'function'
+        ? new target.DOMException('The operation timed out.', 'TimeoutError')
+        : new Error('The operation timed out.')
+      const timer = setTimeout(() => abortWith(controller, reason), delay)
+      // 规范语义：timeout 信号的超时定时器不阻止进程退出
+      if (typeof timer.unref === 'function') timer.unref()
+      return controller.signal
+    }
+    installed = true
+  }
+
+  return installed
+}
+
+/**
+ * 浏览器侧垫片源码：由代理注入到 HTML <head>（在宿主所有脚本之前执行），
+ * 为 iOS 16 / 旧 Safari / 旧 WebView（无 AbortSignal.any，Safari 17.4 才加入）
+ * 上的 DSH 网页客户端补齐。多行可读源码，勿手工压缩成单行（配平易错）。
+ */
+export const BROWSER_ABORT_SIGNAL_POLYFILL = `<script data-dsh-bridge-polyfill="2">
+!function () {
+  try {
+    var S = self.AbortSignal;
+    if (typeof S !== 'function') return;
+    if (typeof S.any !== 'function') {
+      S.any = function (signals) {
+        var list = Array.prototype.slice.call(signals || []);
+        var c = new self.AbortController();
+        var onAbort = function (ev) {
+          var src = ev && ev.target ? ev.target : ev;
+          cleanup();
+          try { c.abort(src ? src.reason : undefined); } catch (e) { c.abort(); }
+        };
+        var cleanup = function () {
+          for (var i = 0; i < list.length; i++) {
+            try { list[i].removeEventListener('abort', onAbort); } catch (e) {}
+          }
+        };
+        for (var i = 0; i < list.length; i++) {
+          if (list[i] && list[i].aborted) {
+            try { c.abort(list[i].reason); } catch (e) { c.abort(); }
+            return c.signal;
+          }
+        }
+        for (var i = 0; i < list.length; i++) {
+          try { list[i].addEventListener('abort', onAbort, { once: true }); } catch (e) {}
+        }
+        return c.signal;
+      };
+    }
+    if (typeof S.timeout !== 'function') {
+      S.timeout = function (ms) {
+        var c = new self.AbortController();
+        setTimeout(function () {
+          try { c.abort(new Error('The operation timed out.')); } catch (e) { c.abort(); }
+        }, Math.max(0, Number(ms) || 0));
+        return c.signal;
+      };
+    }
+  } catch (e) { /* 环境异常时不影响页面其余脚本 */ }
+}();
+</script>`

package/lib/connection-compat.js

@@ -0,0 +1,115 @@
+// 运行时兼容垫片：DSH ≥ 0.1.5-alpha.1 的 connection RPC 通道注册回归
+// （lib/connection-compat.js）
+//
+// 背景（上游回归，非本插件声明问题）
+// ---------------------------------------------------------------
+// @deepseek-ai/dsh-client-connection 在 0.1.5-alpha.1 改了插件级服务声明：
+//     ≤ 0.1.3-alpha.2    const inject = ["webServer", "credentials"];
+//     ≥ 0.1.5-alpha.1    const inject = ["credentials"];      // webServer 改为可选
+// 同时把 /api 路由改用作用域注入 ctx.inject(["webServer"], (webCtx) => …)。
+// 但 HostConnectionService.register() 里那一句没有同步改（各版本行号均为 618）：
+//     return owner.effect(() => owner.webServer.register(route),
+//                         `client-connection: ${channel} rpc channel`);
+// 其中 owner === this.ctx，即 connection 插件自己的 ctx。该 ctx 的 fiber 不再把
+// webServer 记入 inject，于是 cordis 4 的服务守卫直接抛：
+//     cannot get property "webServer" without inject
+// 注册发生在插件树加载期，异常向上冒泡 → 整棵插件树加载失败，`dsh web` 起不来：
+//     Error: dsh: plugin tree failed to load: failed to apply loader entry
+//            dsh-bridge (@wenbin_wb/dsh-bridge): cannot get property "webServer" without inject
+//
+// 影响面：任何调用 ctx.connection.rpc.handle() 的插件都会踩中（dsh-bridge 只是第一个撞上的）。
+// 已逐一核对 npm 上的版本：0.1.5-alpha.1 / alpha.2 / rc.1 / rc.2 全部未修
+// （0.1.5-rc.2 为当前已发布的最新版），0.1.3-alpha.2 及更早正常。
+//
+// 本垫片的做法
+// ---------------------------------------------------------------
+// 不改上游代码、不猜内部私有方法，只走两个公开面：
+//   1. 正常路径：ctx.connection.rpc.handle(channel, handler)（公开 API，未来上游修好即恢复）；
+//   2. 兜底路径：仅当该调用抛出 "webServer … without inject" 时，在 root 的
+//      `internal/get` 瀑布事件上临时挂一个监听器 —— 先让默认解析跑，默认解析失败
+//      （抛出的正是同一个 error 对象）才补上本插件已通过 inject 拿到的 webServer 引用。
+//      webServer 是单例服务，语义等价；默认解析成功时零干预。
+// 监听器只在这一次同步注册调用期间存在，返回后立即摘除（cordis 的 effect 同步执行，
+// 注册完成后 owner.webServer 不再被访问），因此对宿主其余部分完全无副作用。
+//
+// 上游修好后本模块自动空转：首次调用不再抛错，兜底分支根本不会进入。
+
+const MISSING_INJECT = /without inject/;
+
+/**
+ * 判断错误是否为"跨服务取属性缺 inject 作用域"的守卫错误，且对象是 webServer。
+ * @param {unknown} err 捕获到的异常
+ * @returns {boolean} 是否命中该回归
+ */
+export function isMissingWebServerInjectError(err) {
+  if (!(err instanceof Error)) return false;
+  return MISSING_INJECT.test(err.message) && /webServer/.test(err.message);
+}
+
+/**
+ * 在 root 的 `internal/get` 瀑布事件上挂一个临时兜底：默认解析失败时提供 webServer。
+ *
+ * cordis 4 的 `ctx.events` 是所有子 ctx 共享的同一个实例，且 `internal/get` 派发时
+ * 不带 context 过滤条件（thisArg 为 null），因此在本插件 ctx 上注册的监听器同样会对
+ * connection 插件 ctx 的查找生效。监听器由 root fiber 持有，须手工摘除。
+ *
+ * @param {object} ctx 本插件的 ctx
+ * @returns {() => void} 摘除函数
+ */
+export function installWebServerResolutionFallback(ctx) {
+  const webServer = ctx?.webServer;
+  if (webServer === undefined) return () => {};
+
+  const listener = function (lookupCtx, prop, error, next) {
+    if (prop !== 'webServer') return next();
+    try {
+      return next();
+    } catch (err) {
+      // 默认解析抛的不是本次守卫错误 → 原样上抛，绝不掩盖真实故障
+      if (err !== error) throw err;
+    }
+    // 默认解析确认失败：补上本插件已 inject 的单例引用（语义等价）
+    return webServer;
+  };
+
+  const off = ctx.on?.('internal/get', listener, { global: true });
+  return typeof off === 'function' ? off : () => {};
+}
+
+/**
+ * 注册 connection RPC 通道，并兼容 DSH ≥ 0.1.5-alpha.1 的 webServer 注入回归。
+ *
+ * @param {object} ctx 本插件的 ctx（须已 inject `connection` 与 `webServer`）
+ * @param {string} channel RPC 通道名（如 `/dsh-bridge`）
+ * @param {Function} handler 通道处理器
+ * @param {object} [rpcOptions] 透传给 connection 的通道选项。
+ *        DSH 0.1.0/0.1.1 的 `rpc.handle(channel, handler, options)` 支持
+ *        `{ authority: 'loopback' }`（仅回环可达，非回环请求 403）；
+ *        0.1.2-rc.1 起该第三参数已被移除（更高版本忽略它，传入无副作用）。
+ *        本插件依赖它来做回环加固，因此必须原样透传、不得丢失。
+ * @param {{warn?: Function}} [logger] 可选日志器
+ * @returns {Function} 由 connection 服务返回的处置函数
+ */
+export function registerRpcChannel(ctx, channel, handler, rpcOptions, logger) {
+  try {
+    return ctx.connection.rpc.handle(channel, handler, rpcOptions);
+  } catch (err) {
+    if (!isMissingWebServerInjectError(err)) throw err;
+
+    // 上游回归：owner（connection 插件自己的 ctx）解析不到 webServer。
+    // 该调用在 owner.webServer 处、于 webServer.register() 之前就抛，未产生任何副作用，
+    // 因此可以安全地补上兜底后重试一次。
+    const dispose = installWebServerResolutionFallback(ctx);
+    try {
+      const registered = ctx.connection.rpc.handle(channel, handler, rpcOptions);
+      logger?.warn?.(
+        'dsh-bridge: 检测到宿主 DSH 的 connection RPC 注册回归（cannot get property "webServer" without inject，'
+        + '见 dsh-client-connection 的 register()）；已用 webServer 解析兜底完成通道注册。'
+        + '此为宿主侧问题（DSH 0.1.5-alpha.1 起），插件侧垫片会在上游修复后自动空转。'
+      );
+      return registered;
+    } finally {
+      dispose();
+    }
+  }
+}