dsh-mobile-plugin 0.5.3 → 0.5.4

package/lib/host-guard.cjs

@@ -9,15 +9,17 @@
  * 1. 游离的 Promise 拒绝——Node 15+ 默认 throw 并杀进程，插件里大量 fire-and-forget；
  * 2. 第三方回调（事件流、WS、timer）里抛错，没有 try 包着就是 uncaughtException。
  *
- * 策略：全部记入内存账本并保持存活；只有 uncaughtException 计入熔断，且必须落在时间窗
- * 内连发到 `fatalCount` 才主动退出，交给 `Restart=on-failure` 拉起。`createGuard()` 是
- * 纯状态机，`installProcessGuard()` 才是进程接线，拆分是为了能被守卫测试覆盖。
+ * 策略：全部记入内存账本并保持存活，**不主动退出进程**。这个进程里跑的不止我们：无头宿主
+ * 把整份 profile 的插件都装在同一个 process 上，别人的崩溃循环也走同一条 `uncaughtException`。
+ * 在这里 exit 就等于「别人的插件崩五次，我们把用户的 DSH 关掉」，而桌面端根本没有守护来拉起。
+ * 所以只记账、只报警，生死交给部署方（systemd 的 Restart、宿主的 installFailLoud 只管装载期）。
+ *
+ * `createGuard()` 是纯状态机，`installProcessGuard()` 才是进程接线，拆分是为了能被守卫测试覆盖。
  */
 
 const FATAL_FAULT_COUNT = 5;
 const CONSECUTIVE_FAULT_WINDOW_MS = 60 * 1000;
 const FAULT_LEDGER_LIMIT = 50;
-const FATAL_EXIT_CODE = 1;
 
 /** 把任意 throw 出来的值压成一行可读文本。 */
 function describeError(err) {
@@ -38,7 +40,6 @@ function describeError(err) {
  * @param {number}   [options.ledgerLimit]    账本上限，缺省 50
  * @param {() => number} [options.now]        注入时钟，便于测试
  * @param {(line: string) => void} [options.log] 注入日志，便于测试
- * @param {(code: number) => void} [options.exit] 注入退出，便于测试
  * @returns {{handleUncaughtException: Function, handleUnhandledRejection: Function,
  *            recordFault: Function, faults: Function, stats: Function, clear: Function,
  *            isFatal: Function}}
@@ -48,7 +49,6 @@ function createGuard(options = {}) {
   const windowMs = options.windowMs ?? CONSECUTIVE_FAULT_WINDOW_MS;
   const ledgerLimit = options.ledgerLimit ?? FAULT_LEDGER_LIMIT;
   const now = options.now ?? (() => Date.now());
-  const exit = options.exit ?? ((code) => process.exit(code));
   const log = options.log ?? ((line) => { process.stderr.write(`${line}\n`); });
 
   /** @type {{at: number, kind: string, message: string, fatal: boolean}[]} */
@@ -65,8 +65,8 @@ function createGuard(options = {}) {
 
   return {
     /**
-     * `process.on('uncaughtException')` 的处理函数。
-     * 记一笔，计入连续计数，够数才退出。
+     * `process.on('uncaughtException')` 的处理函数。只记一笔并计入连续计数：够数**不退出**，
+     * 只把这条故障在账本里标成 fatal，让 `/api/relay/status` 的自检能说出「这台在崩溃循环」。
      */
     handleUncaughtException(err) {
       const at = now();
@@ -77,16 +77,15 @@ function createGuard(options = {}) {
       const fatal = consecutive >= fatalCount;
       if (fatal) fatalEver = true;
       record('uncaughtException', describeError(err), fatal);
-      log(`[dsh-mobile-plugin] 未捕获异常（连续 ${consecutive}/${fatalCount}${fatal ? '，判定崩溃循环，将退出' : ''}）: ${describeError(err)}`);
-      if (fatal) exit(FATAL_EXIT_CODE);
+      log(`[dsh-mobile-plugin] 未捕获异常（连续 ${consecutive}/${fatalCount}${fatal ? '，判定崩溃循环；不退出进程，请查宿主日志' : ''}）: ${describeError(err)}`);
       return fatal;
     },
 
     /**
      * `process.on('unhandledRejection')` 的处理函数。
      *
-     * 刻意**不计入熔断**：游离 reject 在长驻服务里非常常见（一次后台推送失败就
-     * 一个），把它们累加成退出条件会制造新的崩溃源。挂上处理器本身就已经把
+     * 刻意**不计入连续计数**：游离 reject 在长驻服务里非常常见（一次后台推送失败就
+     * 一个），把它们算进崩溃循环的判据会制造新的误报。挂上处理器本身就已经把
      * Node 的默认「throw 并杀进程」改成了「记录并继续」。
      */
     handleUnhandledRejection(reason) {
@@ -196,5 +195,4 @@ module.exports = {
   FATAL_FAULT_COUNT,
   CONSECUTIVE_FAULT_WINDOW_MS,
   FAULT_LEDGER_LIMIT,
-  FATAL_EXIT_CODE,
 };

package/lib/impl.js

@@ -51,37 +51,27 @@ const { activeGuard } = require('./host-guard.cjs')
 // 有一个落盘处：客户端半边（lib/client.js）上报 → 这里 → 移动端读取。
 
 export const name = 'dsh-mobile-plugin'
-// The mobile API runs headless inside the Cordis Host. `webServer` and
-// `sessions` are the services it needs to serve /api/mobile/v1.
+// 0.2.0 移除了 `settings.register(namespace, schema, { base, applies })` 那套 API，所以不再
+// 注入 `settings`：配置改由插件自己的 relay.json 存储负责（见下面 createConfigStore）。
+// 0.2.0 里也没有 `apiProxy` 这个服务，宿主 RPC 全走 `typertGateway`；`ctx.apiProxy` 的
+// 旧形状由 apply 在本 fiber 上 provide 的兼容桥兜住（fiber.store 里就有，get trap 第一站
+// 就命中）。漏了这条分支，读 `ctx.apiProxy` 会抛 "without inject"，服务器宿主上 mirror
+// 推送曾整条挂掉。
 //
-// 0.2.0 移除了 `settings.register(namespace, schema, { base, applies })` 这套 API
-// （`@deepseek-ai/dsh-settings` 现在只导出 SettingsForms / redactSecrets /
-// SettingsConflictError），所以这里不再注入 `settings`，配置改由插件自己的
-// relay.json 存储负责 —— 见下面 createConfigStore。
+// 只有 `webServer` 是硬依赖：没有它这个插件一行路由都注册不上，等不到就是真的没得做。
 //
-// 0.2.0 里也没有 `apiProxy` 这个服务（整个 asar 零命中）：宿主 RPC 全部走
-// `ctx.get('typertGateway')` 的 `invoke({ namespace, method, args })`，见
-// mobile/plugins.js、mobile/references.js 里同款封装。留着 apiProxy 只会让插件永远
-// pending —— 服务不存在时 loader 不会激活这一行，于是路由、sidecar、中转全都不出现，
-// 而日志只有一行 "pending (waiting for service: apiProxy)"。
+// 其余服务**一律不写进 inject**，改成用到时 `ctx.get`。cordis 的 inject 是「缺一个就整行
+// pending」：`typertGateway` 由后装载的另一行提供、`sessions` 来自别的 bundle，任何一个被
+// 别人关掉 / 换掉 / 延迟，注进去的代价都是路由、sidecar、配对、二维码**一起不出现**，日志
+// 里只剩一行 pending —— 手机上表现为「装了插件但完全连不上」。
 //
-// 所以 `apiProxy` 是**按运行时二选一**的：
-//   旧运行时（自带 @deepseek-ai/dsh-host-apiproxy）→ 注入它，读宿主那份真服务；
-//   0.2.0                                        → 不注入，改由 apply 在本 fiber 上
-//                                                  provide 兼容桥（fiber.store 里
-//                                                  有，get trap 第一站就命中）。
-// 漏了这两个分支里的任何一个，读 `ctx.apiProxy` 都会抛
-// `cannot get property "apiProxy" without inject`：服务器宿主上 mirror 推送曾整条挂掉。
+// 取不到时如实降级：宿主 RPC 那条回 `host-unavailable`（见 host-bridge/transport.js 的
+// gatewayOf，它每次调用都现取），路由、局域网直连、控制面、镜像照常工作。实时流那条在
+// 网关永远不出现时保持空闲 + 心跳（`host-stream-unavailable`），下一次重连就会接上。
 //
-// `typertGateway` 必须出现在 inject 里（0.2.0 那一支）：宿主 RPC 全部经它派发，
-// 而它是**后于本插件**装载的服务。只 `ctx.get('typertGateway')` 而不注入，取到的是
-// 装载那一刻的空值，于是每一条事件流都抛「当前宿主版本没有提供该能力」——服务器宿主
-// 上实时推送整条挂掉，而收发消息、会话列表这些走普通请求的功能一切正常，看着像只有
-// 「刷新不实时」的小毛病。注入之后 cordis 会等服务就绪再激活本插件。
-// 旧运行时那一支不加：那版没有这个服务，注入只会让这一行永远 pending。
-export const inject = runtimeProvidesApiProxy()
-  ? ['webServer', 'apiProxy', 'sessions']
-  : ['webServer', 'sessions', 'typertGateway']
+// 旧运行时那一支多一个 `apiProxy`：宿主自己提供它（`@deepseek-ai/dsh-host-apiproxy` 装上
+// 了，就一定会被提供），读 `ctx.apiProxy` 必须有 inject，否则 get trap 直接抛。
+export const inject = runtimeProvidesApiProxy() ? ['webServer', 'apiProxy'] : ['webServer']
 
 export const REMOTE_CONTROL_SETTINGS_NAMESPACE = 'mobile-remote-control'
 export const RemoteControlSettingsSchema = z.object({
@@ -258,7 +248,27 @@ function apply(ctx) {
   // 这两条二选一，判据同源：0.1.x 宿主自带真 apiProxy（审批帧与回答都还走得通），
   // 0.2.x 才需要兼容桥，也才需要审批桥（见 mobile/approvals.js 的文件头）。
   const hasHostApiProxy = runtimeProvidesApiProxy()
-  if (!hasHostApiProxy) ctx.reflect.provide('apiProxy', createApiProxy(ctx))
+  /** 装配层自己的告警出口：拿不到 logger 也照样往下走，不打日志不是失败。 */
+  const warn = (message, ...rest) => {
+    try { ctx.logger?.warn?.(`${name}: ${message}`, ...rest) } catch { /* 日志本身不许反噬装配 */ }
+  }
+  /**
+   * 每一块装配各自兜住：一块挂不上只留一行日志，剩下的照常启动。
+   *
+   * 代价说清楚：别人撞了同一个路由、先占了一个服务名，缺的必须是**那一块**，不能是整张
+   * 移动 API —— 装配层里一个没兜住的 throw 会让 fiber 回滚，已经注册好的路由一起消失。
+   */
+  const mount = (label, fn) => {
+    try { return fn() } catch (error) {
+      warn(`${label} 没有挂上：%s`, error?.message || error)
+      return undefined
+    }
+  }
+  if (!hasHostApiProxy) {
+    // `apiProxy` 是公共名字：另一个兼容旧 API 的插件也可能 provide 它。撞上时用对方那份
+    // （同形状、同语义），不跟它抢 —— 抢的结果是我们自己整块装配失败，手机那边全断。
+    mount('apiProxy 兼容桥', () => ctx.reflect.provide('apiProxy', createApiProxy(ctx)))
+  }
 
   const state = core.loadState()
   // 0.2.0 之前是 `ctx.settings.register(REMOTE_CONTROL_SETTINGS_NAMESPACE,
@@ -329,11 +339,11 @@ function apply(ctx) {
   // 隧道刚连上时补推一次全量：未连通期间每轮推送都被 worker 以 503 拒绝。
   sidecarLifecycle.onTunnelUp(() => { void mirror.pushMirror(); })
 
-  ctx.effect(() => sidecarLifecycle.start(), `${name}: facade sidecar`)
-  ctx.effect(() => mirror.start(), `${name}: mobile mirror sync`)
+  mount('sidecar', () => ctx.effect(() => sidecarLifecycle.start(), `${name}: facade sidecar`))
+  mount('镜像推送', () => ctx.effect(() => mirror.start(), `${name}: mobile mirror sync`))
 
-  if (!hasHostApiProxy) ctx.effect(() => installApprovalBridge(ctx), `${name}: host approval bridge`)
-  if (!hasHostApiProxy) ctx.effect(() => installQuestionBridge(ctx), `${name}: host question bridge`)
+  if (!hasHostApiProxy) mount('审批桥', () => ctx.effect(() => installApprovalBridge(ctx), `${name}: host approval bridge`))
+  if (!hasHostApiProxy) mount('提问桥', () => ctx.effect(() => installQuestionBridge(ctx), `${name}: host question bridge`))
   ctx.effect(() => {
     // Profiles without the optional tools injection still support core remote control.
     try { installSessionCleanup(ctx) } catch (error) {
@@ -348,7 +358,7 @@ function apply(ctx) {
     }
     return undefined
   }, `${name}: extension tool`)
-  ctx.effect(() => statsScheduler.start(ctx), `${name}: stats collect`)
+  mount('统计采集', () => ctx.effect(() => statsScheduler.start(ctx), `${name}: stats collect`))
 
   const status = createStatusView({
     state,
@@ -365,11 +375,24 @@ function apply(ctx) {
   function applyServices() {
     void syncSidecar().catch(() => undefined)
   }
+  /**
+   * 一条路由挂不上只丢这一条。
+   *
+   * `webServer.register` 对重复地址是抛错（另一个插件用了同一个路径、上一代没卸干净都在
+   * 这一类），而这个调用本来就在 effect 里 —— 让它抛出去会把整个 fiber 带走，连已经挂上
+   * 的几百条一起消失。所以这里逐条兜住，日志里留下路径，别让手机端拿到一片 404。
+   */
+  const mountRoute = (route, upgrade) => mount(`路由 ${route.path}`, () => ctx.effect(() => {
+    try { return upgrade ? ctx.webServer.registerUpgrade(route) : ctx.webServer.register(route) } catch (error) {
+      warn('路由 %s 没挂上：%s', route.path, error?.message || error)
+      return () => {}
+    }
+  }, `${name}: ${route.path}`))
   function registerRoute(route) {
-    ctx.effect(() => ctx.webServer.register(route), `${name}: ${route.path}`)
+    mountRoute(route)
   }
 
-  registerControlPlaneRoutes({
+  mount('控制面路由', () => registerControlPlaneRoutes({
     registerRoute,
     // 更新的机制住在外壳（`lib/index.js`）里，代这边只把它开成本机接口。取不到就如实报
     // 不可用（`lib/impl.js` 被单独挂载时就是这样）。
@@ -408,7 +431,7 @@ function apply(ctx) {
     // 吊销时收掉这台设备已经开着的流（§3.3）：token 换了只保证「下一次请求」被拒，
     // 一条已经开着的 SSE 不会自己停，被踢的手机还能继续收消息直到它自己重连。
     dropDeviceStreams: (deviceId) => streamRegistry.drop(deviceId),
-  })
+  }))
 
 
   /**
@@ -452,13 +475,11 @@ function apply(ctx) {
 
   // 移动端路由表在 lib/routes/mobile-api.js：那里是一张可以对着 App 侧 apiPaths.ts
   // 核对的「路径 → handler」表，不用在 1000 行装配代码里翻。
-  registerMobileRoutes({
+  mount('移动端路由', () => registerMobileRoutes({
     registerRoute,
     // 预览是 WebSocket 升级路由，走的是 webServer 的另一套名字空间；与 registerRoute
     // 一样必须包在 ctx.effect 里，否则插件重载时重复注册会直接抛错。
-    registerUpgradeRoute: (route) => {
-      ctx.effect(() => ctx.webServer.registerUpgrade(route), `${name}: ${route.path}`)
-    },
+    registerUpgradeRoute: (route) => mountRoute(route, true),
     preview,
     guarded,
     state,
@@ -495,8 +516,8 @@ function apply(ctx) {
       credentials,
       activeGuard,
     },
-  })
-  ctx.effect(() => {
+  }))
+  mount('服务同步', () => ctx.effect(() => {
     const stopWatching = settings.watch(next => {
       Object.assign(state, next)
       core.saveState(state)
@@ -509,7 +530,7 @@ function apply(ctx) {
       // 那个 effect 独占。两个 effect 都停一次会让 worker 在 dispose 期间收到
       // 两次 stop，第二次撞上已关闭的进程句柄并抛出未捕获异常。
     }
-  }, `${name}: services`)
+  }, `${name}: services`))
 }
 
 export { apply }

package/lib/index.js

@@ -31,14 +31,14 @@ import { createDeviceOta } from './shell/device-ota.js'
 import { installHostHalf } from './shell/half-route.js'
 
 export const name = 'dsh-mobile-plugin'
-export const inject = ['webServer', 'sessions']
+// 外壳同样只等 `webServer`：它不读 `sessions`，多注一个只是多一种「整行 pending」的理由。
+export const inject = ['webServer']
 
 /**
  * 装载当前代，并把「查 / 装 / 换代码」这套动作暴露成服务。
  *
- * 对照 `lib/impl.js` 的 `apply`：那边签名也是 `(ctx)`，只是它注册的是真正的移动 API；
- * 这里注册的是「装载它」。两者的 effect 各自归属自己那层 fiber —— 外壳被卸载时，代的
- * fiber 作为它的子节点一起被 dispose，代里那些 `ctx.effect` 的清理动作照常执行。
+ * 对照 `lib/impl.js` 的 `apply`：那边注册真正的移动 API，这里注册「装载它」。两份 effect
+ * 各自归属自己那层 fiber —— 外壳被卸载时，代的 fiber 作为子节点一起 dispose。
  */
 export function apply(ctx) {
   const runtime = createRuntime()
@@ -97,32 +97,31 @@ export function apply(ctx) {
    * 就重试」都在 `updater.performUpdate` 里 —— 入口只留装载逻辑，行数钉着。
    */
   async function applyUpdate({ force = false, auto = false } = {}) {
-    return updater.performUpdate({
-      runtime, base, hostService, updateState, force, auto, log,
-      beforeInstall: snapshotRunning,
-    })
+    return updater.performUpdate({ runtime, base, hostService, updateState, force, auto, log, beforeInstall: snapshotRunning })
   }
 
-  // 换代前要知道有没有请求在飞（见 runtime.drain）。宿主 webServer 没有中间件机制，所以
-  // 这里包一层 register，把每条路由的 handler 变成「进 +1 / 出 -1」。包的时机在任何一代
-  // 装载之前，且 `wrapHandler` 遇到不认识的形状会原样放行。
+  // 换代前要知道有没有请求在飞（见 runtime.drain）。webServer 没有中间件机制，所以包一层
+  // register 把每条 handler 变成「进 +1 / 出 -1」（`wrapHandler` 认不出的形状原样放行）。
+  //
+  // 这层包装必须**可叠加**：别人后来也包一层时闭包着我们的包装，撤销时无条件还原会把
+  // 别人的那层一起摘掉。所以只在「现在挂的就是我们这层」时才还原。
   ctx.effect(() => {
     const server = ctx.webServer
-    const original = server?.register
-    if (typeof original !== 'function') return () => {}
-    server.register = function register(route) {
-      return original.call(this, runtime.wrapHandler(route))
+    const outer = server?.register
+    if (typeof outer !== 'function') return () => {}
+    const wrapper = function register(route) {
+      return outer.call(this, runtime.wrapHandler(route))
     }
+    server.register = wrapper
     return () => {
-      server.register = original
+      if (server.register === wrapper) server.register = outer
       return runtime.detach()
     }
   }, 'dsh-mobile-plugin: generation runtime')
 
   const installedShellHash = () => updater.shellFingerprint(installedPackageDir())
-
-  // 宿主半边的自检口（实现在 `shell/half-route.js`）：实现装载失败时整张控制面路由
-  // 都不在，只有外壳还活着 —— 那是「它为什么没起来」唯一说得通的落点。
+  // 宿主半边的自检口（`shell/half-route.js`）：实现装载失败时整张控制面路由都不在，只有
+  // 外壳还活着 —— 那是「它为什么没起来」唯一说得通的落点。
   ctx.effect(() => installHostHalf(ctx, runtime, { installedVersion, installedShellHash, runningShellHash }), 'dsh-mobile-plugin: host half self check')
 
   ctx.reflect.provide('dshMobilePluginRuntime', {
@@ -163,9 +162,8 @@ export function apply(ctx) {
     .start(ctx, { log })
     .then(() => {
       log('info', 'dsh-mobile-plugin: 已装载 %s（来源 %s）', runtime.status().version, runtime.status().source)
-      // 每 2 分钟让已落盘的正式版接管 OTA，并补上「盘上比运行中新」的那一次换代；
-      // 自动安装仍由开关控制，开着就**不等正在跑的对话**（`auto` 那一档，见 update-install）。
-      // 补换代不受开关管：它不下载任何东西，只是让已经在盘上的代码生效。
+      // 每 2 分钟让已落盘的正式版接管 OTA，并补上「盘上比运行中新」的那次换代（补换代不
+      // 受开关管：它不下载任何东西）；自动安装由开关控制，开着就不等正在跑的对话。
       const timer = setInterval(() => {
         deviceOta.reconcileOfficial()
           .then(() => updater.reconcileInstalledGeneration({ runtime, log }))
@@ -179,6 +177,7 @@ export function apply(ctx) {
       ctx.effect(() => () => clearInterval(timer), 'dsh-mobile-plugin: auto update timer')
       // 启动后延后一次：别和绑端口、连隧道抢带宽。
       if (updater.autoUpdateEnabled()) {
+
         const kick = setTimeout(() => {
           applyUpdate({ auto: true }).catch(error => {
             updateState.lastError = String(error?.message || error)

package/lib/shell/runtime.js

@@ -45,9 +45,10 @@ const START_RETRY_MS = Number(process.env.DSH_MOBILE_START_RETRY_MS) > 0
  * 代没有声明 `inject` 时的兜底（只有测试里的假代会走这里）。
  *
  * 真实实现 `lib/impl.js` 一定声明 inject，而且是按运行时二选一的，所以这里**不能**
- * 拿它去覆盖代自己的声明 —— 那会把旧运行时要用的 `apiProxy` 抹掉。
+ * 拿它去覆盖代自己的声明 —— 那会把旧运行时要用的 `apiProxy` 抹掉。兜底值同样只留
+ * `webServer`：多一个服务就多一种「整行 pending」的理由。
  */
-const DEFAULT_INJECT = ['webServer', 'sessions']
+const DEFAULT_INJECT = ['webServer']
 
 const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
 

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "Mobile API (/api/mobile/v1) and relay client for the DSH mobile app — desktop profile build (dsh 0.2.x, peers resolved by the host)",
   "license": "MIT",
   "icon": "./icon.png",
   "engines": {
-    "dsh": ">=0.2.0 <0.3.0"
+    "dsh": ">=0.2.0"
   },
   "type": "module",
   "main": "lib/index.js",