dsh-mobile-plugin 0.4.9 → 0.5.1

package/lib/client.js

@@ -224,6 +224,15 @@ window.__ModuleLoader__.load({
     /** 自检上报的出口与间隔：只为可观测性存在，不做任何状态变更。 */
     const CLIENT_HALF_ENDPOINT = '/api/relay/client-half';
     const CLIENT_HALF_REPORT_MS = 10000;
+    /**
+     * 宿主半边的自检口（由外壳注册，实现挂了它也还在）。
+     *
+     * 实现装载失败时整张 `/api/relay/*` 都 404，这一项只显示一句「插件宿主侧没有加载」，
+     * 真正的原因（等哪个服务超时、哪一代装不上）就没人看得见。这两条是那个原因唯一的出口；
+     * 第二条点一下就在原地重新装载一次，不必重启整个 DSH。
+     */
+    const HOST_HALF_ENDPOINT = '/api/relay/host-half';
+    const HOST_HALF_RELOAD_ENDPOINT = '/api/relay/host-half/reload';
 
     /**
      * 把 sessionStatus 的快照摊成 [id, status] 列表。
@@ -469,6 +478,10 @@ window.__ModuleLoader__.load({
         panelMissing: '宿主还没给出页面地址，稍后再打开这一页试试。',
         loadFailed: '读取宿主状态失败',
         loadMissing: '插件宿主侧没有加载：把 DSH 完整退出再打开一次；还不行就在插件市场重装一遍插件。',
+        hostHalfReason: '宿主侧报的原因：',
+        hostHalfRetrying: '它还在后台自己重试，过几分钟刷新这一页就能看到结果；也可以点下面的按钮立刻再试一次。',
+        hostHalfReload: '重新装载',
+        hostHalfReloadFailed: '重新装载没成：',
         webAccessOn: '公网网页管理已开放，到期时间',
         webAccessOff: '公网网页管理已关闭',
         webAccessOpen: '开放网页管理 2 小时',
@@ -487,6 +500,10 @@ window.__ModuleLoader__.load({
         panelMissing: 'The host has not reported a page address yet — reopen this item in a moment.',
         loadFailed: 'Failed to read host status',
         loadMissing: 'The plugin host half is not loaded: quit and reopen DSH; if that does not help, reinstall the plugin from the market.',
+        hostHalfReason: 'Reported by the host: ',
+        hostHalfRetrying: 'It is still retrying on its own in the background — reopen this item in a few minutes, or press the button below to retry right now.',
+        hostHalfReload: 'Reload now',
+        hostHalfReloadFailed: 'Reload failed: ',
         webAccessOn: 'Public web management is open until',
         webAccessOff: 'Public web management is closed',
         webAccessOpen: 'Open web management for 2 hours',
@@ -514,6 +531,10 @@ window.__ModuleLoader__.load({
       const [webAccessBusy, setWebAccessBusy] = useState(false);
       /** 最近一次失败的 HTTP 状态码（0 = 网络异常 / 还没失败过）。404 单独说。 */
       const [errorStatus, setErrorStatus] = useState(0);
+      /** 宿主半边自检的结果（外壳给的那份），404 时才有内容。 */
+      const [half, setHalf] = useState(null);
+      const [halfBusy, setHalfBusy] = useState(false);
+      const [halfError, setHalfError] = useState(null);
 
       useEffect(() => {
         let alive = true;
@@ -528,6 +549,8 @@ window.__ModuleLoader__.load({
             if (!alive) return;
             setError(null);
             setErrorStatus(0);
+            setHalf(null);
+            setHalfError(null);
             setPanelUrl(typeof next.panelUrl === 'string' ? next.panelUrl : '');
             setWebAccess(next.webAccess && typeof next.webAccess.enabled === 'boolean' ? next.webAccess : null);
             if (retryTimer !== null) {
@@ -549,6 +572,20 @@ window.__ModuleLoader__.load({
               clearTimer(refreshTimer);
               refreshTimer = null;
             }
+            // 404 = 实现那一半没装载。它为什么没装载，只有外壳答得出来（这两条路由挂在
+            // 外壳上，实现挂了它们还在）；老版本宿主没有这条口，问不到就当没有，别报错。
+            if (problem?.status === 404) {
+              try {
+                const picture = await call(HOST_HALF_ENDPOINT);
+                if (!alive) return;
+                setHalf(picture && typeof picture.half === 'object' ? picture.half : null);
+              } catch {
+                if (!alive) return;
+                setHalf(null);
+              }
+            } else {
+              setHalf(null);
+            }
             // 无权的远程设置页不轮询；宿主还没启动等临时故障每 3s 重试。
             if (problem?.status !== 403 && problem?.status !== 423 && retryTimer === null) {
               retryTimer = setInterval(() => {
@@ -580,6 +617,27 @@ window.__ModuleLoader__.load({
         }
       };
 
+      /**
+       * 让外壳当场把实现再装一次。
+       *
+       * 装载失败那阵子，这是唯一不必重启整个 DSH 的出路；成不成以宿主回来的那份自检为准，
+       * 失败原因原样贴出来（它往往就是「等哪个服务超时」，过一会儿自己就好了）。
+       */
+      const reloadHalf = async () => {
+        if (halfBusy) return;
+        setHalfBusy(true);
+        setHalfError(null);
+        try {
+          const next = await postJson(HOST_HALF_RELOAD_ENDPOINT, {});
+          if (next && typeof next.half === 'object') setHalf(next.half);
+          if (next && next.ok === false) setHalfError(errorText(next, 200));
+        } catch (problem) {
+          setHalfError(String((problem && problem.message) || problem));
+        } finally {
+          setHalfBusy(false);
+        }
+      };
+
       const url = typeof panelUrl === 'string' ? panelUrl : '';
       const webAccessEnabled = Boolean(webAccess && webAccess.enabled);
       const expiresAt = webAccess && Number.isFinite(webAccess.expiresAt)
@@ -588,11 +646,32 @@ window.__ModuleLoader__.load({
       let webAccessStatus = t('webAccessUnavailable');
       if (webAccess) webAccessStatus = webAccessEnabled ? `${t('webAccessOn')} ${expiresAt}` : t('webAccessOff');
 
+      const missing = errorStatus === 404;
+
       return h('div', { className: 'dshm_root' }, [
         h('h2', { className: 'dshm_heading' }, t('heading')),
         error
-          ? h('p', { className: 'dshm_error' }, errorStatus === 404 ? t('loadMissing') : `${t('loadFailed')}: ${error}`)
+          ? h('p', { className: 'dshm_error' }, missing ? t('loadMissing') : `${t('loadFailed')}: ${error}`)
+          : null,
+        // 404 时把宿主那半边自己的说法贴出来：重启 / 重装这两句提示在「装载超时」那种
+        // 现场是帮倒忙的，真正该做的是等它后台补齐、或者点一下重新装载。
+        missing && half && typeof half.lastError === 'string' && half.lastError
+          ? h('p', { className: 'dshm_note' }, `${t('hostHalfReason')}${half.lastError}`)
+          : null,
+        missing && half && half.retrying === true
+          ? h('p', { className: 'dshm_note' }, t('hostHalfRetrying'))
+          : null,
+        missing
+          ? h('div', { className: 'dshm_actions' }, [
+            h('button', {
+              type: 'button',
+              className: 'dshm_btn',
+              disabled: halfBusy,
+              onClick: reloadHalf,
+            }, t('hostHalfReload')),
+          ])
           : null,
+        halfError ? h('p', { className: 'dshm_error' }, `${t('hostHalfReloadFailed')}${halfError}`) : null,
 
         // 用 `<a target="_blank">` 而不是 iframe：DSH 桌面端会把这个链接交给系统浏览器
         // 打开（网页版有自己的地址与刷新节奏，嵌在设置弹窗里反而不好用）。

package/lib/index.js

@@ -28,6 +28,7 @@ import { createRuntime } from './shell/runtime.js'
 import * as updater from './shell/updater.js'
 import { installedPackageDir, installedVersion, profileNodeModules, snapshotRunningGeneration } from './shell/manager.js'
 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']
@@ -118,16 +119,21 @@ export function apply(ctx) {
     }
   }, 'dsh-mobile-plugin: generation runtime')
 
+  const installedShellHash = () => updater.shellFingerprint(installedPackageDir())
+
+  // 宿主半边的自检口（实现在 `shell/half-route.js`）：实现装载失败时整张控制面路由
+  // 都不在，只有外壳还活着 —— 那是「它为什么没起来」唯一说得通的落点。
+  ctx.effect(() => installHostHalf(ctx, runtime, { installedVersion, installedShellHash, runningShellHash }), 'dsh-mobile-plugin: host half self check')
+
   ctx.reflect.provide('dshMobilePluginRuntime', {
     status: () => ({
       ...runtime.status(),
       /** 盘上装着的版本（市场装完立刻变，和运行中的版本对照就能看出「要不要换」）。 */
       installedVersion: installedVersion(),
-      /** 盘上那份的外壳指纹与跑着的对不上 = 新版本连外壳一起改了，那部分要等下次启动才生效。 */
       runningShellHash,
-      installedShellHash: updater.shellFingerprint(installedPackageDir()),
+      installedShellHash: installedShellHash(),
       shellChanged: (() => {
-        const installed = updater.shellFingerprint(installedPackageDir())
+        const installed = installedShellHash()
         return installed !== null && runningShellHash !== null && installed !== runningShellHash
       })(),
       profileNodeModules: profileNodeModules(),

package/lib/mobile/history-derive.js

@@ -12,6 +12,11 @@
  */
 
 const { cutAssistantBlock, cutToolResultEvent, createToolNameIndex } = require('./wire-cut.js');
+const {
+  reasoningStepSummary,
+  toolStepSummary,
+  toolStepState,
+} = require('./step-index.js');
 
 /**
  * 从 session.list 摘要行取会话标题（与桌面端侧栏同源，不再从 history 窗口猜）：
@@ -117,7 +122,14 @@ function buildToolResultMap(events) {
       return '';
     }).filter(Boolean).join('');
     const images = toolResultImages(parts);
-    map.set(src.callId, { isError, code, ...(output ? { output } : {}), ...(images.length ? { images } : {}) });
+    // `seq` 只给「按需取详情」用：手机点开这一步时拿它去回拉那一小窗事件。
+    map.set(src.callId, {
+      isError,
+      code,
+      ...(Number.isSafeInteger(e.seq) ? { seq: e.seq } : {}),
+      ...(output ? { output } : {}),
+      ...(images.length ? { images } : {}),
+    });
   }
   return map;
 }
@@ -428,8 +440,59 @@ function deriveMessages(events) {
   // 命令行按 commandId 唯一：command/run 发出行，command/done 原地升级（保 run 的 name，位置随 done 事件 seq 归位）。
   const commandAt = new Map();
 
+  /**
+   * 每一轮的「过程清单」：一步一行摘要，正文仍然一个字节都不下发。
+   *
+   * 清单挂在**这一轮开头那条消息**上（App 的头条行就是它派生的），收口后点开清单再按
+   * `seq` / `resultSeq` 去 `/session/step` 取那一步的详情 —— 这就是「按需获取」的那一半。
+   * 只做摘要不做正文：一条推理正文平均几万字、一次 `write` 的参数就是整份文件，把它们
+   * 塞进消息响应里正是 2026-10-27 砍掉它的理由。
+   */
+  const stepsByTurn = new Map();
+  const openerByTurn = new Map();
+  let lastOpener = null;
+  const collectSteps = (content, e) => {
+    if (!Array.isArray(content)) return;
+    const turn = e.data && typeof e.data.turn === 'number' ? e.data.turn : undefined;
+    if (turn === undefined) return;
+    if (!openerByTurn.has(turn) && lastOpener) openerByTurn.set(turn, lastOpener);
+    const list = stepsByTurn.get(turn) || [];
+    content.forEach((raw, index) => {
+      if (!raw || typeof raw !== 'object') return;
+      if (raw.type === 'reasoning') {
+        const text = typeof raw.text === 'string' ? raw.text : '';
+        // 空推理块（只有零宽字符那种）不算一步：App 点开一条什么都没有的行没有意义。
+        if (text.trim() === '') return;
+        list.push({
+          kind: 'think',
+          ...(Number.isSafeInteger(e.seq) ? { seq: e.seq } : {}),
+          index,
+          summary: reasoningStepSummary(text),
+        });
+        return;
+      }
+      if (raw.type !== 'tool-call') return;
+      const callId = raw.id != null ? String(raw.id) : undefined;
+      const result = callId ? toolResults.get(callId) : undefined;
+      const rawArgs = typeof raw.arguments === 'string'
+        ? raw.arguments
+        : (raw.arguments != null ? JSON.stringify(raw.arguments) : '');
+      list.push({
+        kind: 'tool',
+        ...(callId ? { callId } : {}),
+        ...(typeof raw.name === 'string' && raw.name ? { name: raw.name } : {}),
+        summary: toolStepSummary(raw.name, rawArgs),
+        state: toolStepState(result),
+        ...(Number.isSafeInteger(e.seq) ? { seq: e.seq } : {}),
+        ...(result && Number.isSafeInteger(result.seq) ? { resultSeq: result.seq } : {}),
+      });
+    });
+    if (list.length > 0) stepsByTurn.set(turn, list);
+  };
+
   // 普通消息（user/assistant）沿用原折叠逻辑。
   const pushMessage = (msg, e) => {
+    collectSteps(msg.content, e);
     const parsed = parseBlocks(msg.content, toolResults);
     // 工具产出的图挂成这条消息的图片附件：App 把它画在气泡上方（缩略图 + 文件名，点开全屏），
     // 与用户自己发的图同一种形状。工具卡里不再重复画同一张图 —— 一张图两处画会把字节也翻倍。
@@ -501,6 +564,8 @@ function deriveMessages(events) {
       if (timing) item.timing = timing;
     }
     out.push(item);
+    // 这一轮的过程清单挂在**开启这一轮的那条消息**上：App 的头条行按它派生。
+    if (item.role === 'user') lastOpener = item;
   };
 
   // 放入一行 compaction：同一 compactionId 只保留一行，检查点行原地替换 start 行（最终按 seq 排序归位）。
@@ -747,6 +812,19 @@ function deriveMessages(events) {
     }
     // tool/result 等其余类型照旧忽略（工具结果在预扫描里配对回填；compaction 行由 start/end 发出）。
   }
+  // 过程清单按轮回填：`steps` 只带摘要与位置，正文要用户点开某一步时再去取。
+  if (stepsByTurn.size > 0) {
+    for (const [turn, steps] of stepsByTurn) {
+      const opener = openerByTurn.get(turn);
+      if (!opener || steps.length === 0) continue;
+      opener.turnProcess = {
+        ...(opener.turnProcess && typeof opener.turnProcess === 'object' ? opener.turnProcess : {}),
+        count: steps.length,
+        steps,
+        ...(Number.isSafeInteger(opener.seq) ? { startSeq: opener.seq } : {}),
+      };
+    }
+  }
   // 产出清单按轮回填：这一轮所有 write / edit 的并集，挂到这一轮每条 assistant 消息上。
   // 挂「整轮」而不是「从写那一刻起」，与桌面 `selectProducedFiles(owner)` 同口径；正文里
   // 提到这一轮写的文件就能解析成可点（App 侧按文件名或整条路径唯一命中才画，见
@@ -869,13 +947,19 @@ function thinEntryMessages(items, options = {}) {
       const endSeq = Number.isSafeInteger(last.seq) ? last.seq : opener.seq;
       const at = kept.indexOf(opener);
       if (at >= 0) {
+        // 清单（`steps`）随入口窗口一起下发：过程正文不在线上，这一行摘要就是用户
+        // 「值不值得点开」的全部依据，摘掉它这一轮就没法点开了。
+        const steps = opener.turnProcess && Array.isArray(opener.turnProcess.steps)
+          ? opener.turnProcess.steps
+          : null;
         kept[at] = {
           ...kept[at],
           turnProcess: {
             startSeq: opener.seq,
             endSeq,
-            count: processCount,
+            count: steps ? steps.length : processCount,
             ...(typeof last.time === 'number' ? { endTime: last.time } : {}),
+            ...(steps ? { steps } : {}),
           },
         };
       }

package/lib/mobile/host-settings.js

@@ -16,6 +16,9 @@ const { unwrap } = require('./sessions.js');
 
 const HOST_SETTINGS_MAX_NAMESPACES = 60; // 命名空间数量上限（避免异常宿主把响应撑爆）
 const HOST_SETTINGS_MAX_MODELS_PER_GROUP = 200; // 单个提供方下的模型条数上限
+const HOST_SETTINGS_MAX_FIELDS = 40;     // 单个命名空间透出的字段元数据条数上限
+const HOST_SETTINGS_MAX_CHOICES = 40;    // 单个字段的候选值上限
+const HOST_SETTINGS_MAX_EFFORTS = 8;     // 单个模型的推理强度档位上限
 const HOST_SETTINGS_VALUE_DEPTH = 4;     // 值递归深度上限
 const HOST_SETTINGS_VALUE_KEYS = 40;     // 每层键/元素数量上限
 const HOST_SETTINGS_VALUE_CHARS = 4000;  // 单个字符串长度上限
@@ -51,6 +54,21 @@ function boundValue(value, depth = 0) {
   return null;
 }
 
+/**
+ * 取出序列化 zod 树的根字段表。
+ *
+ * 宿主 `settings.describe` 里的 schema 是 schemastery 的 `{ uid, refs }` 形状：refs 以数字 id
+ * 存放每个节点，根节点的 `dict` 是「字段名 → 子节点 id」。凭据引用与字段控件都要先摸到这张表。
+ */
+function schemaDict(schema) {
+  const refs = schema && typeof schema === 'object' && !Array.isArray(schema) ? schema.refs : null;
+  if (!refs || typeof refs !== 'object' || Array.isArray(refs)) return null;
+  const root = refs[String(schema.uid)];
+  const dict = root && typeof root === 'object' ? root.dict : null;
+  if (!dict || typeof dict !== 'object' || Array.isArray(dict)) return null;
+  return { refs, dict };
+}
+
 /**
  * 从序列化的 zod 树里读出「这个命名空间的密钥写到哪个凭据引用上」。
  *
@@ -62,11 +80,9 @@ function boundValue(value, depth = 0) {
  * 没有密钥槽的设置项画密码框。
  */
 function credentialRefOf(schema, value) {
-  const refs = schema && typeof schema === 'object' && !Array.isArray(schema) ? schema.refs : null;
-  if (!refs || typeof refs !== 'object' || Array.isArray(refs)) return null;
-  const root = refs[String(schema.uid)];
-  const dict = root && typeof root === 'object' ? root.dict : null;
-  if (!dict || typeof dict !== 'object' || Array.isArray(dict)) return null;
+  const shape = schemaDict(schema);
+  if (!shape) return null;
+  const { refs, dict } = shape;
 
   let refField = '';
   let refDefault = '';
@@ -90,6 +106,65 @@ function credentialRefOf(schema, value) {
   return ref ? { ref, refField } : null;
 }
 
+/**
+ * 一个字段该画什么控件，按宿主 schema 的形状定。
+ *
+ * 手机端把设置项直接铺成卡片，靠这张表决定控件，不再一律给文本框：
+ * - `boolean` → 开关
+ * - `union` 且每一支都是常量（`z.union(['standard', 'compact'])`）→ 点选，候选就是那些常量
+ * - `number` → 数字输入（带宿主的 min / max / step）
+ * - `string` → 文本框
+ *
+ * 其它形状（嵌套对象 / 数组 / transform）不出现：那种字段在手机上本来就不给控件。只描述
+ * 根那一层的字段，不透整棵树——宿主 schema 里对手机没用的东西仍然留在插件这一侧。
+ */
+function describeField(node, refs) {
+  const meta = node && typeof node === 'object' && node.meta && typeof node.meta === 'object' ? node.meta : {};
+  let type = '';
+  const out = {};
+  if (node && node.type === 'boolean') type = 'boolean';
+  else if (node && node.type === 'string') type = 'string';
+  else if (node && node.type === 'number') {
+    type = 'number';
+    if (typeof meta.min === 'number' && Number.isFinite(meta.min)) out.min = meta.min;
+    if (typeof meta.max === 'number' && Number.isFinite(meta.max)) out.max = meta.max;
+    if (typeof meta.step === 'number' && Number.isFinite(meta.step)) out.step = meta.step;
+  } else if (node && node.type === 'const') {
+    type = 'enum';
+    out.options = [node.value];
+  } else if (node && node.type === 'union') {
+    // 只有「每一支都是常量」才算候选集合；带 transform / 对象的联合没法枚举。
+    const options = [];
+    const list = Array.isArray(node.list) ? node.list : [];
+    let allConst = list.length > 0;
+    for (const uid of list) {
+      const child = refs[String(uid)];
+      if (child && child.type === 'const') options.push(child.value);
+      else { allConst = false; break; }
+    }
+    if (!allConst) return null;
+    type = 'enum';
+    out.options = options.slice(0, HOST_SETTINGS_MAX_CHOICES);
+  } else return null;
+  if (type === 'enum' && (!Array.isArray(out.options) || out.options.length < 2)) return null;
+  if (meta.required === true) out.required = true;
+  out.type = type;
+  return out;
+}
+
+/** 一个命名空间里各字段的控件形状；推不出来（老宿主 / 畸形 schema）就是 null。 */
+function fieldsOf(schema) {
+  const shape = schemaDict(schema);
+  if (!shape) return null;
+  const fields = [];
+  for (const key of Object.keys(shape.dict).slice(0, HOST_SETTINGS_MAX_FIELDS)) {
+    const node = shape.refs[String(shape.dict[key])];
+    const field = describeField(node, shape.refs);
+    if (field) fields.push({ key, ...field });
+  }
+  return fields.length > 0 ? fields : null;
+}
+
 /**
  * 把 settings.describe 的一条命名空间视图压成手机需要的形状。
  *
@@ -124,6 +199,10 @@ function normalizeNamespace(item) {
   };
   if (item.base !== undefined) out.base = boundValue(item.base);
   if (item.user !== undefined) out.user = boundValue(item.user);
+  // 每个字段该画什么控件（开关 / 点选 / 数字 / 文本框）：只描述根这一层，宿主整棵 schema 的
+  // 其余部分仍然留在插件这一侧，不透给手机。推不出来就不给，App 回退成文本框。
+  const fields = fieldsOf(item.schema);
+  if (fields) out.fields = fields;
   // 只有「宿主确实报了密钥槽」且「schema 里能推导出凭据引用」时才给出引用名；
   // 两者缺一，App 就不该显示写密钥的入口。
   if (secrets.length > 0) {
@@ -181,6 +260,21 @@ async function handleLlmProviders(ctx, req, res) {
   sendJson(res, 200, { ok: true, providers });
 }
 
+/**
+ * 一个模型支持的推理强度档位。
+ *
+ * 宿主给的是一张「id → 显示名」的表（如 `{ low: 'low', high: 'high', max: 'max' }`），偶尔是
+ * 数组。手机只要档位 id：设置里写的是 id，显示名归 App 的字典。没有就返回空数组。
+ */
+function normalizeReasoningEfforts(value) {
+  const ids = Array.isArray(value)
+    ? value
+    : (value && typeof value === 'object' && !Array.isArray(value) ? Object.keys(value) : []);
+  return ids
+    .filter((id) => typeof id === 'string' && id !== '')
+    .slice(0, HOST_SETTINGS_MAX_EFFORTS);
+}
+
 /** 把 llm.models 的一组渠道压成手机选择器要的形状；没有模型的组丢掉。 */
 function normalizeModelGroup(group) {
   if (!group || typeof group !== 'object') return null;
@@ -193,7 +287,10 @@ function normalizeModelGroup(group) {
       const id = typeof item.id === 'string' ? item.id.trim() : '';
       if (!id) return null;
       const name = typeof item.name === 'string' && item.name.trim() ? item.name.trim() : id;
-      return { id, name };
+      // 推理强度档位给设置页里的「推理强度」用：那个字段在宿主 schema 里只是普通字符串，
+      // 唯一知道有哪些档位的地方就是模型目录这一份。
+      const reasoningEfforts = normalizeReasoningEfforts(item.reasoningEfforts);
+      return { id, name, ...(reasoningEfforts.length > 0 ? { reasoningEfforts } : {}) };
     })
     .filter(Boolean)
     .slice(0, HOST_SETTINGS_MAX_MODELS_PER_GROUP);