dsh-mobile-plugin 0.5.23 → 0.5.26

package/lib/mobile/phone/routes.js

@@ -20,6 +20,9 @@
 
 const { sendJson, readJsonBody } = require('../../shared/http-util');
 const binding = require('./binding.js');
+const pacing = require('./pacing.js');
+const routeHint = require('./route-hint.js');
+const knowledge = require('../phone-knowledge.js');
 
 /** 设备标题：机型优先，没有机型才用 deviceId 的短尾巴。与凭据面板同一口径。 */
 function deviceLabel(row) {
@@ -60,6 +63,9 @@ function listDevices(deps) {
       osVersion: row.osVersion || '',
       appVersion: row.appVersion || '',
       online: Boolean(live),
+      // 能力清单只对「此刻连着」的那台有意义：设置页据此说「这台手机支持什么」。
+      // 没连上时报空表，界面那边按「还没连上」处理，不拿上一次的旧清单冒充。
+      capabilities: live && Array.isArray(live.capabilities) ? live.capabilities : [],
       lastSeenAt: row.lastSeenAt || 0,
     });
     if (live) online.delete(row.deviceId);
@@ -74,6 +80,7 @@ function listDevices(deps) {
       osVersion: device.osVersion || '',
       appVersion: device.appVersion || '',
       online: true,
+      capabilities: Array.isArray(link.capabilities) ? link.capabilities : [],
       lastSeenAt: Date.now(),
     });
   }
@@ -105,6 +112,12 @@ async function handlePhoneStatus(deps, _ctx, req, res) {
       lastSender: binding.lastSenderOf(sessionId) || '',
     };
   }
+  // 顶层再带一份「这台手机能做什么」：设置页问的是「我现在操作的是哪台、它能做什么」，
+  // 那条会话绑了就看绑的那台，没绑就看唯第一台在线的。都没有就是空表。
+  const focus = (payload.binding && payload.binding.deviceId)
+    ? devices.find((row) => row.deviceId === payload.binding.deviceId)
+    : devices.find((row) => row.online);
+  payload.capabilities = focus && Array.isArray(focus.capabilities) ? focus.capabilities : [];
   sendJson(res, 200, payload);
 }
 
@@ -141,6 +154,71 @@ async function handlePhoneUnbind(deps, _ctx, req, res) {
   sendJson(res, 200, { ok: true, clearedSession: false, clearedBindings: cleared, disconnected: targets, localReset: 'requested' });
 }
 
+/**
+ * GET /phone/knowledge?package=… —— 知识库里有哪些 App、有哪些网站，各自包名 / 域名，以及按就
+ * 包名查询时的命中情况。
+ *
+ * 只读：把 `knowledge/apps/*.md` 与 `knowledge/sites/*.md` 的目录清单摊平给设置页看，不碰手机、
+ * 不发任何动作。`package` 是可选的前台包名；给了就标出哪一条 App 命中（`hit`），并回填 `matched`。
+ */
+async function handlePhoneKnowledge(deps, _ctx, req, res) {
+  const url = new URL(req.url || '/', 'http://x');
+  const pkg = (url.searchParams.get('package') || '').trim();
+  const matched = pkg ? knowledge.matchApp(pkg) : null;
+  const apps = knowledge.listApps().map((app) => ({
+    name: app.name,
+    display: app.display,
+    packages: app.packages,
+    aliases: app.aliases,
+    open: app.open,
+    hit: Boolean(matched && matched.name === app.name),
+  }));
+  const sites = knowledge.listSites().map((site) => ({
+    name: site.name,
+    display: site.display,
+    description: site.description,
+    sites: site.sites,
+    aliases: site.aliases,
+  }));
+  sendJson(res, 200, { ok: true, apps, sites, matched: matched ? matched.name : '' });
+}
+
+/**
+ * GET /phone/routes?package=… —— 某个 App 以前成功过的路线（最多 5 条，只给步骤摘要）。
+ *
+ * 只读：从成功路线账本里读回，不碰手机、不发任何动作。**这些只是参考，不会自动执行** ——
+ * 模型看过之后仍要按当前屏重新判断。
+ */
+async function handlePhoneRoutes(_deps, _ctx, req, res) {
+  const url = new URL(req.url || '/', 'http://x');
+  const pkg = (url.searchParams.get('package') || '').trim();
+  const routes = pkg ? routeHint.hintFor(pkg) : [];
+  sendJson(res, 200, { ok: true, packageName: pkg, count: routes.length, routes });
+}
+
+/**
+ * GET / POST /phone/pacing —— 读或改「操作节奏」那一档。
+ *
+ * 和上面几条一样只碰设置，不往手机上发动作：节奏改了下一轮动作才生效，正在跑的那一批
+ * 不跟着变（动作中途改停留会让边界很奇怪，重开一轮才干净）。
+ */
+async function handlePhonePacing(_deps, _ctx, req, res) {
+  if (req.method === 'GET' || !req.method) {
+    const mode = pacing.get();
+    return sendJson(res, 200, { ok: true, mode, pace: pacing.paceFor(mode) });
+  }
+  const body = await readJsonBody(req);
+  const wanted = body && typeof body.mode === 'string' ? body.mode.trim().toLowerCase() : '';
+  if (!wanted) return sendJson(res, 400, { ok: false, error: 'missing-mode' });
+  try {
+    const mode = pacing.set(wanted);
+    sendJson(res, 200, { ok: true, mode, pace: pacing.paceFor(mode) });
+  } catch {
+    // 不认识的档名：如实回 400 并把可选值带上，别让设置页自己维护一份枚举。
+    sendJson(res, 400, { ok: false, error: 'unknown-mode', modes: pacing.MODES });
+  }
+}
+
 /**
  * 造出路由表要的那组 handler。
  *
@@ -154,6 +232,9 @@ function createPhoneRoutes(deps) {
     status: (ctx, req, res) => handlePhoneStatus(deps, ctx, req, res),
     devices: (ctx, req, res) => handlePhoneDevices(deps, ctx, req, res),
     unbind: (ctx, req, res) => handlePhoneUnbind(deps, ctx, req, res),
+    knowledge: (ctx, req, res) => handlePhoneKnowledge(deps, ctx, req, res),
+    routes: (ctx, req, res) => handlePhoneRoutes(deps, ctx, req, res),
+    pacing: (ctx, req, res) => handlePhonePacing(deps, ctx, req, res),
   };
 }
 
@@ -162,6 +243,9 @@ module.exports = {
   handlePhoneStatus,
   handlePhoneDevices,
   handlePhoneUnbind,
+  handlePhoneKnowledge,
+  handlePhoneRoutes,
+  handlePhonePacing,
   listDevices,
   describeDevice,
   deviceLabel,

package/lib/mobile/phone/service.js

@@ -22,7 +22,7 @@
  *   - `{t:'event', kind:'needs-human'|'progress', sessionId, …}` —— 暂只记账，不转发
  *
  * 宿主 → 手机：
- *   - `{t:'op', id, sessionId, action, args}`
+ *   - `{t:'op', id, sessionId, action, args, timeout}` —— timeout 是这一发自适应算出的预算(ms)
  *   - `{t:'cancel', id}`
  *
  * 动作名是封闭的一小张表（见 `ACTIONS`）；手机端认不出的动作回 `unsupported`，宿主不会因为
@@ -40,8 +40,13 @@ const { WebSocketServer } = require('ws');
 
 /** 一条帧的上限：截图是 base64 塞在 JSON 里的，留足余量；更大的东西手机不会发。 */
 const MAX_PAYLOAD = 12 * 1024 * 1024;
-/** 心跳：手机每 20 秒至少要有一次 ping/pong 往返，否则按掉线处理（等它自己重连）。 */
+/** 心跳间隔：每 20 秒发一次 ping。 */
 const HEARTBEAT_MS = 20_000;
+/**
+ * 连续丢这么多次心跳（约 60 秒）才按掉线处理，对齐手机端 60s 看门狗。
+ * 弱网下偶发一两次丢 pong 不算掉线，免得来回假掉线、把在途 op 全抹成 offline。
+ */
+const MAX_MISSED_HEARTBEATS = 3;
 /** 单次 op 的默认预算；每个动作另有自己的一档（见 ACTIONS）。 */
 const DEFAULT_OP_TIMEOUT_MS = 30_000;
 
@@ -64,8 +69,24 @@ const ACTIONS = new Map([
   ['app.list', 20_000],
   ['wait', 30_000],
   ['task.release', 20_000],
+  // `batch` 是多个动作打包：这里的数字只是它作为「一个动作」登记进表时的占位 seed，
+  // 真实预算由 budgetForBatch 按步数与等待上限单独算（见下），不走单动作那套。
+  ['batch', 120_000],
+  ['screen.wait', 30_000],
+  ['gesture', 20_000],
+  ['app.link', 20_000],
 ]);
 
+/**
+ * 帧压缩的测量开关，默认关。
+ *
+ * 宿主端 deflate 是「CPU 换带宽」：手机常在弱网，压缩看着划算，但每一帧都要在宿主上现算，
+ * 低端机与高频小帧下 CPU 代价明显，而这条通道的大头（截图 base64）早就一帧一封。到底值不值
+ * 要真机量过 p50/p99 延迟与宿主的占用才能定，所以默认维持原样关闭，只留一个环境变量把压缩
+ * 打开来测量，不擅自改线上默认。
+ */
+const COMPRESS_FRAMES = process.env.DSH_MOBILE_PHONE_COMPRESS === '1';
+
 function text(value) {
   return typeof value === 'string' ? value.trim() : '';
 }
@@ -85,16 +106,95 @@ function createPhoneService({ authorized, onLog } = {}) {
   let closed = false;
   let seq = 0;
 
+  /** 耗时 EWMA 的平滑系数：动作耗时用 0.3，心跳 RTT 用 0.2。 */
+  const EWMA_ALPHA = 0.3;
+  const RTT_ALPHA = 0.2;
+
+  function ewma(prev, sample, alpha) {
+    if (!prev || !(prev.n > 0) || !Number.isFinite(prev.value)) return { value: sample, n: 1 };
+    return { value: prev.value * (1 - alpha) + sample * alpha, n: prev.n + 1 };
+  }
+
+  /** 成功回包按「发送 → 收到」耗时更新 perAction 与全体两类统计。 */
+  function recordLatency(link, action, sample) {
+    if (!Number.isFinite(sample) || sample < 0) return;
+    const lat = link.latency;
+    lat.perAction.set(action, ewma(lat.perAction.get(action), sample, EWMA_ALPHA));
+    lat.all = ewma(lat.all, sample, EWMA_ALPHA);
+  }
+
+  /**
+   * 某动作这一发该给多少预算：估时 est 取自本动作（样本够）或全体，套 est*2.5 + rtt*2 + 1500，
+   * 冷启动抬到 seed*1.5 兜底，最后夹进 [max(2500, seed/2), min(120000, max(seed*8, floor))]。
+   * `ACTIONS` 里的数字只是这个 seed，不再直接当预算。
+   */
+  function budgetFor(link, action, args) {
+    if (action === 'batch') return budgetForBatch(link, args);
+    const seed = ACTIONS.get(action) || DEFAULT_OP_TIMEOUT_MS;
+    const lat = link.latency;
+    const pa = lat.perAction.get(action);
+    let est = seed;
+    if (pa && pa.n >= 2) est = pa.value;
+    else if (lat.all && lat.all.n >= 2) est = lat.all.value;
+    const rtt = lat.rtt > 0 ? lat.rtt : 0;
+    let budget = est * 2.5 + rtt * 2 + 1500;
+    const cold = Date.now() - link.connectedAt < 20_000 || !lat.all || lat.all.n < 1;
+    if (cold) budget = Math.max(budget, seed * 1.5);
+    const floor = Math.max(2500, seed * 0.5);
+    const ceil = Math.min(120_000, Math.max(seed * 8, floor));
+    return Math.round(Math.min(Math.max(budget, floor), ceil));
+  }
+
+  /**
+   * `batch` 的预算要按整批放，不能沿用单动作的估法 —— 一批十几步，每步都可能带一段等待，
+   * 单步预算乘一乘就把手机端「整批共用宿主下发 timeout」的约定撑破了。
+   *
+   * 累加三样：每步各自的估时（有实测 EWMA 就用实测，没有就用该动作的 seed），每步 `until`
+   * 声明的等待上限（与手机侧同口径：默认 8000、封顶 20000），以及每步一次往返的网络余量。
+   * 结果夹在 [5s, 180s]：低于 5s 连正常几步都装不下；高于 180s 基本是手机卡死，再等没意义。
+   */
+  function budgetForBatch(link, args) {
+    const steps = args && Array.isArray(args.steps) ? args.steps : [];
+    const lat = link.latency;
+    const rtt = lat.rtt > 0 ? lat.rtt : 0;
+    let total = 0;
+    for (const step of steps) {
+      const action = text(step && step.action);
+      const seed = ACTIONS.get(action) || DEFAULT_OP_TIMEOUT_MS;
+      const pa = lat.perAction.get(action);
+      let est = seed;
+      if (pa && pa.n >= 2) est = pa.value;
+      else if (lat.all && lat.all.n >= 2) est = lat.all.value;
+      total += est;
+      const until = step && step.until;
+      if (until && typeof until === 'object') {
+        const t = Number(until.timeoutMs);
+        total += Number.isFinite(t) && t > 0 ? Math.min(t, 20_000) : 8_000;
+      }
+    }
+    total += rtt * 2 * steps.length;
+    return Math.round(Math.min(Math.max(total, 5_000), 180_000));
+  }
+
   const log = (message) => { try { onLog?.(message); } catch { /* 日志失败不影响搬运 */ } };
 
-  const wss = new WebSocketServer({ noServer: true, perMessageDeflate: false, maxPayload: MAX_PAYLOAD });
+  const wss = new WebSocketServer({
+    noServer: true,
+    perMessageDeflate: COMPRESS_FRAMES ? { threshold: 1024 } : false,
+    maxPayload: MAX_PAYLOAD,
+  });
 
   function nextId() {
     seq += 1;
     return `p${seq}`;
   }
 
-  /** 关掉一条连接并结算它的在途 op。 */
+  /**
+   * 关掉一条连接并结算它的在途 op。
+   *
+   * 这里不区分动作：`batch` 和单步一样挂在 `link.pending` 上，走到一半断线就连同它的结果一起
+   * 以 offline 结算，手机侧那套「整批共用宿主 timeout」不需要宿主特殊对待。
+   */
   function drop(deviceId, reason) {
     const link = devices.get(deviceId);
     if (!link) return;
@@ -108,6 +208,7 @@ function createPhoneService({ authorized, onLog } = {}) {
       });
     }
     link.pending.clear();
+    try { clearInterval(link.heartbeat); } catch { /* 已经清过了 */ }
     try { link.socket.close(); } catch { /* 已经断了 */ }
   }
 
@@ -122,6 +223,8 @@ function createPhoneService({ authorized, onLog } = {}) {
       capabilities: hello && Array.isArray(hello.capabilities) ? hello.capabilities.filter((c) => typeof c === 'string') : [],
       connectedAt: Date.now(),
       alive: true,
+      missed: 0,
+      latency: { perAction: new Map(), all: null, rtt: 0 },
       pending: new Map(),
     };
     devices.set(deviceId, link);
@@ -137,6 +240,12 @@ function createPhoneService({ authorized, onLog } = {}) {
       if (!frame || typeof frame !== 'object') return;
       if (frame.t === 'pong') {
         link.alive = true;
+        if (Number.isFinite(link.pingAt) && link.pingAt > 0) {
+          const sample = Date.now() - link.pingAt;
+          const prev = link.latency.rtt;
+          link.latency.rtt = prev > 0 ? prev * (1 - RTT_ALPHA) + sample * RTT_ALPHA : sample;
+          link.pingAt = 0;
+        }
         return;
       }
       if (frame.t === 'hello') {
@@ -151,8 +260,12 @@ function createPhoneService({ authorized, onLog } = {}) {
         const pending = link.pending.get(text(frame.id));
         if (!pending) return;
         link.pending.delete(text(frame.id));
-        if (frame.ok) pending.settleOk(frame.data === undefined ? null : frame.data);
-        else {
+        if (frame.ok) {
+          if (pending.action && Number.isFinite(pending.sentAt)) {
+            recordLatency(link, pending.action, Date.now() - pending.sentAt);
+          }
+          pending.settleOk(frame.data === undefined ? null : frame.data);
+        } else {
           const error = frame.error && typeof frame.error === 'object' ? frame.error : {};
           pending.settleErr({
             code: text(error.code) || 'failed',
@@ -179,12 +292,19 @@ function createPhoneService({ authorized, onLog } = {}) {
     link.heartbeat = setInterval(() => {
       if (!statusOf(socket)) return;
       if (!link.alive) {
-        log(`phone ${deviceId}: 心跳丢了，按断线处理`);
-        drop(deviceId, 'offline');
-        return;
+        link.missed += 1;
+        if (link.missed >= MAX_MISSED_HEARTBEATS) {
+          log(`phone ${deviceId}: 连续 ${link.missed} 次心跳没回应，按断线处理`);
+          drop(deviceId, 'offline');
+          return;
+        }
+        log(`phone ${deviceId}: 心跳丢了（${link.missed}/${MAX_MISSED_HEARTBEATS}），再等等`);
+      } else {
+        link.missed = 0;
       }
       link.alive = false;
-      try { socket.send(JSON.stringify({ t: 'ping', at: Date.now() })); } catch { /* 下面 close 会来 */ }
+      link.pingAt = Date.now();
+      try { socket.send(JSON.stringify({ t: 'ping', at: link.pingAt })); } catch { /* 下面 close 会来 */ }
     }, HEARTBEAT_MS);
     link.heartbeat.unref?.();
 
@@ -210,7 +330,7 @@ function createPhoneService({ authorized, onLog } = {}) {
     if (!ACTIONS.has(action)) return Promise.reject({ code: 'unknown-action', message: `不支持的动作 ${action}` });
 
     const opId = nextId();
-    const budget = Number.isFinite(timeoutMs) ? timeoutMs : (ACTIONS.get(action) || DEFAULT_OP_TIMEOUT_MS);
+    const budget = Number.isFinite(timeoutMs) ? timeoutMs : budgetFor(link, action, args);
     return new Promise((resolve, reject) => {
       let settled = false;
       const settle = (fn, value) => {
@@ -222,9 +342,13 @@ function createPhoneService({ authorized, onLog } = {}) {
         fn(value);
       };
       const pending = {
+        action,
+        sentAt: Date.now(),
         settleOk: (data) => settle(resolve, { ok: true, data }),
         settleErr: (error) => settle(reject, error),
       };
+      // 超时 / 取消都发同一条 `cancel` 帧 —— 帧里只带 id，手机侧自己按 id 找那条 op，
+      // 所以正在跑的 `batch` 也能被这一步撤销，不需要另加批专用的停止帧。
       const timer = setTimeout(() => {
         settle(reject, { code: 'timeout', message: '迟迟没有回应这一步' });
         try { link.socket.send(JSON.stringify({ t: 'cancel', id: opId })); } catch { /* 已断 */ }
@@ -240,7 +364,7 @@ function createPhoneService({ authorized, onLog } = {}) {
       }
       link.pending.set(opId, pending);
       try {
-        link.socket.send(JSON.stringify({ t: 'op', id: opId, sessionId: text(sessionId), action, args: args || {} }));
+        link.socket.send(JSON.stringify({ t: 'op', id: opId, sessionId: text(sessionId), action, args: args || {}, timeout: budget }));
       } catch {
         settle(reject, { code: 'offline', message: '发不出去，那台手机断开了' });
       }
@@ -253,6 +377,20 @@ function createPhoneService({ authorized, onLog } = {}) {
     return Boolean(link && statusOf(link.socket));
   }
 
+  /**
+   * 这台手机报没报某项能力（工具层据此决定某个参数是否生效）。
+   *
+   * 手机在 hello / attached 帧里上行 `capabilities`，没连上或没报过就一律当作不支持 ——
+   * 「没听说」和「不支持」在这里是同一件事，宁可让工具层多说一句「需要升级手机上的 App」，
+   * 也不要凭空假定它能做。
+   */
+  function hasCapability(deviceId, capName) {
+    const link = devices.get(text(deviceId));
+    if (!link || !statusOf(link.socket)) return false;
+    const name = text(capName);
+    return name !== '' && Array.isArray(link.capabilities) && link.capabilities.includes(name);
+  }
+
   /** 一台手机的连接信息（给 App 的状态页用）。 */
   function statusOfDevice(deviceId) {
     const link = devices.get(text(deviceId));
@@ -302,7 +440,19 @@ function createPhoneService({ authorized, onLog } = {}) {
     wss.close?.();
   }
 
-  return { handleUpgrade, call, isOnline, statusOfDevice, kick, close, ACTIONS, devices };
+  return {
+    handleUpgrade,
+    call,
+    isOnline,
+    statusOfDevice,
+    hasCapability,
+    kick,
+    close,
+    ACTIONS,
+    devices,
+    // 测量开关的当前取值，供自检 / 日志读出（真实压缩在 wss 构造时就定了）。
+    compressionEnabled: COMPRESS_FRAMES,
+  };
 }
 
 function refuse(socket, status, reason, bodyText) {