dsh-mobile-plugin 0.5.0 → 0.5.3

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/agent-presets.js

@@ -4,7 +4,8 @@
  * 移动端「Agent 预设管理」API：把桌面端设置页的预设管理分区补齐到手机上。
  *
  * 手机端只保留管理分区（app 的 PresetManager）：桌面那边设置里的一行与新建会话芯片已下线，
- * 手机一律吃宿主默认档。三条路由都只转发宿主的 agentPreset 域：read / copy / remove。
+ * 手机一律吃宿主默认档。四条路由：read / copy / remove 转发宿主的 agentPreset 域；default
+ * 写宿主 settings 里存「默认档」的那一格（见 handleAgentPresetDefault）。
  *
  * 语义按宿主原文透传：copy 是整份复制，标识符成为目录名且事后无法更改；remove 只对 user
  * 预设有效（随附预设回 agent-preset-read-only）。宿主的失败对象是 code + details，按 code
@@ -143,10 +144,73 @@ async function handleAgentPresetRemove(ctx, req, res) {
   sendJson(res, 200, { ok: true, agentPreset: id.value });
 }
 
+/** 宿主 settings 里存「默认预设」的那一格：桌面端「设为默认」写的就是它。 */
+const PRESET_SETTINGS_NS = 'agent-preset-registry';
+const PRESET_DEFAULT_FIELD = 'selectedDefault';
+
+/**
+ * POST /api/mobile/v1/agent-presets/default（token）{ agentPreset } → { ok, agentPreset }
+ *
+ * 「哪一档是新会话的默认档」不是预设自己的属性：宿主注册表从 settings 的
+ * `agent-preset-registry.selectedDefault` 读（没写过就退回部署时那个 default），桌面端那颗
+ * 「设为默认」写的就是这一格。手机此前没有这个入口，新会话只能吃部署时那一档。
+ *
+ * 先按名单确认这一档真在，再写：写一个不存在的 id 不会报错，但之后每次新建会话都会被宿主
+ * 拒（agent-preset-not-found），那时用户已经不知道是自己哪一步弄坏的。
+ */
+async function handleAgentPresetDefault(ctx, req, res) {
+  const body = await readJsonBody(req, PRESET_MAX_BODY);
+  const id = normalizeId(body && body.agentPreset);
+  if (!id.value) return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: id.problem } });
+
+  const listed = unwrap(await callAgentPresets(ctx, 'list', {}));
+  if (listed.error) return sendJson(res, statusOf(listed.error.code), { ok: false, error: failure(listed.error) });
+  const rows = listed.value && Array.isArray(listed.value.presets) ? listed.value.presets : [];
+  const row = rows.find((item) => item && item.id === id.value);
+  if (!row) {
+    return sendJson(res, 404, {
+      ok: false,
+      error: {
+        code: 'agent-preset-not-found',
+        message: presetMessage('agent-preset-not-found'),
+        details: { agentPreset: id.value, available: rows.map((item) => item && item.id).filter(Boolean) },
+      },
+    });
+  }
+  // 已经是默认档就不再写：settings.mutate 一次就推进一次 revision，白写等于让别处正在
+  // 改设置的人撞上冲突。
+  if (row.isDefault === true) return sendJson(res, 200, { ok: true, agentPreset: id.value });
+
+  const settings = ctx.apiProxy && ctx.apiProxy.settings;
+  if (!settings || typeof settings.mutate !== 'function') {
+    return sendJson(res, 400, {
+      ok: false,
+      error: { code: 'unsupported', message: '这台宿主没有设置写入接口，改不了默认预设' },
+    });
+  }
+  const { error } = unwrap(await settings.mutate({
+    rpcId: 'mobile',
+    method: 'settings.mutate',
+    payload: { ns: PRESET_SETTINGS_NS, ops: [{ op: 'set', path: [PRESET_DEFAULT_FIELD], value: id.value }] },
+  }));
+  if (error) {
+    const hostMessage = error && typeof error.message === 'string' ? error.message : '';
+    return sendJson(res, 400, {
+      ok: false,
+      error: {
+        code: error && typeof error.code === 'string' && error.code ? error.code : 'internal',
+        message: hostMessage ? `默认预设没写进去：${hostMessage}` : '默认预设没写进去',
+      },
+    });
+  }
+  sendJson(res, 200, { ok: true, agentPreset: id.value });
+}
+
 module.exports = {
   handleAgentPresetRead,
   handleAgentPresetCopy,
   handleAgentPresetRemove,
+  handleAgentPresetDefault,
   // 下面这些是给守卫测试直接驱动的纯函数（与 references.js 同做法）
   normalizeId,
   normalizeName,
@@ -159,4 +223,6 @@ module.exports = {
   PRESET_ID_MAX_CHARS,
   PRESET_NAME_MAX_CHARS,
   PRESET_BODY_MAX_CHARS,
+  PRESET_SETTINGS_NS,
+  PRESET_DEFAULT_FIELD,
 };

package/lib/mobile/debug-trace.js

@@ -0,0 +1,180 @@
+'use strict';
+
+/**
+ * 手机端调试轨迹的落盘口（`POST /api/mobile/v1/debug/trace`）。
+ *
+ * 为什么要有它：滑动手感出问题时，现场在手机上（偏移轨迹、每一行的实际高度、图片什么时候
+ * 才到），而能看这些东西的人在这台电脑上。让人把几万行日志抄进聊天不现实，所以 App 边录边把
+ * 一行行 JSONL 打到这里，插件落进 `<DSH_HOME>/mobile-debug/<capture>.jsonl`，维护者在这台
+ * 电脑上直接读文件。
+ *
+ * 三条边界，别放宽：
+ *  - **不是任意文件写入**：文件名只由 `capture` 生成，且只认 `[A-Za-z0-9._-]`。构造一个别的
+ *    capture 只会在这一个目录里多一份空文件，碰不到用户的任何东西；
+ *  - **只追加**：一次请求往 `<capture>.jsonl` 末尾续一段，从不覆盖、从不删别的文件；
+ *  - **封顶**：一份轨迹 8MB 之后停写（回 `capped: true`，App 收到就停手），目录里最多留 10 份，
+ *    第 11 份进来时删掉最旧那份。录音不会把盘写满。
+ *
+ * 与 `session/file`、`session/attachment` 那些读口方向相反：这条只写、写的位置固定，回给手机
+ * 的只有文件名与字节数，不回路径。
+ */
+
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+
+const { dshHome } = require('../shared/paths');
+const { sendJson, readJsonBody } = require('../shared/http-util');
+
+/** 一份轨迹的字节上限。真到这一步说明录得太久，该停了。 */
+const MAX_CAPTURE_BYTES = 8 * 1024 * 1024;
+/** 目录里最多留几份（按 mtime，新的来、旧的走）。 */
+const MAX_CAPTURES = 10;
+/** 一次请求最多带多少行；App 那边按 40KB 切批，正常远小于这个数。 */
+const MAX_LINES_PER_BATCH = 4000;
+/** 一次请求最多多少字节（`readJsonBody` 本身还有 344KB 的封顶，这里再收一道）。 */
+const MAX_BATCH_BYTES = 512 * 1024;
+/** 轨迹名（也就是文件名）：只认这几类字符，别的一律 400。 */
+const CAPTURE_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
+
+/** 轨迹目录。按调用时解析，测试可注入 `DSH_HOME`。 */
+function traceDir() {
+  return path.join(dshHome(), 'mobile-debug');
+}
+
+/** 某一份轨迹的落盘路径（`capture` 已经过白名单校验）。 */
+function capturePath(capture) {
+  return path.join(traceDir(), `${capture}.jsonl`);
+}
+
+/**
+ * 目录里留最近 `MAX_CAPTURES` 份。
+ *
+ * 按 mtime 而不是文件名：轨迹名由 App 带时间戳生成，但同一秒的两份、或者用户手改过的名字都
+ * 不该让清理算错。读不动 stat 的（正在被删）直接跳过，清理失败不该让这次上传失败。
+ */
+async function pruneCaptures() {
+  let names;
+  try {
+    names = await fsp.readdir(traceDir());
+  } catch {
+    return;
+  }
+  const files = [];
+  for (const name of names) {
+    if (!name.endsWith('.jsonl')) continue;
+    const full = path.join(traceDir(), name);
+    try {
+      const info = await fsp.stat(full);
+      if (info.isFile()) files.push({ name, full, mtime: info.mtimeMs });
+    } catch { /* 刚被删掉 / 读不动：跳过 */ }
+  }
+  if (files.length <= MAX_CAPTURES) return;
+  files.sort((a, b) => a.mtime - b.mtime);
+  for (const file of files.slice(0, files.length - MAX_CAPTURES)) {
+    try {
+      await fsp.unlink(file.full);
+    } catch { /* 删不掉就留着，下次再说 */ }
+  }
+}
+
+/**
+ * 续写一段轨迹。
+ *
+ * `lines` 是已经序列化好的 JSON 行（App 侧拼的），这里只做「拼成一段文本 + 追加」。一行都
+ * 不合法的批次按空处理：回 ok、写 0 字节，别让手机那头因为一次形状不对就整段录不上。
+ */
+async function handleDebugTrace(_ctx, req, res) {
+  const body = await readJsonBody(req);
+  const capture = body && typeof body.capture === 'string' ? body.capture : '';
+  if (!CAPTURE_RE.test(capture)) {
+    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 { capture }，且只认字母数字与 ._-' } });
+  }
+  const raw = body && Array.isArray(body.lines) ? body.lines : null;
+  if (!raw) {
+    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 { lines: string[] }' } });
+  }
+  if (raw.length > MAX_LINES_PER_BATCH) {
+    return sendJson(res, 413, { ok: false, error: { code: 'too-many-lines', message: `一次最多 ${MAX_LINES_PER_BATCH} 行` } });
+  }
+  const lines = raw.filter((line) => typeof line === 'string' && line.length > 0);
+  if (lines.length === 0) {
+    return sendJson(res, 200, { ok: true, file: `${capture}.jsonl`, bytes: 0, lines: 0, capped: false });
+  }
+  const text = `${lines.join('\n')}\n`;
+  const bytes = Buffer.byteLength(text, 'utf8');
+  if (bytes > MAX_BATCH_BYTES) {
+    return sendJson(res, 413, { ok: false, error: { code: 'too-large', message: `一次最多 ${MAX_BATCH_BYTES} 字节` } });
+  }
+
+  const file = capturePath(capture);
+  try {
+    await fsp.mkdir(traceDir(), { recursive: true });
+  } catch (error) {
+    return sendJson(res, 500, { ok: false, error: { code: 'io', message: `建目录失败：${error && error.message ? error.message : ''}` } });
+  }
+
+  let existing = 0;
+  let created = false;
+  try {
+    existing = (await fsp.stat(file)).size;
+  } catch {
+    created = true;
+  }
+
+  if (existing >= MAX_CAPTURE_BYTES) {
+    // 已经写满：回 capped 让 App 停手。文件留着，人要看的正是前面那一段。
+    return sendJson(res, 200, { ok: true, file: `${capture}.jsonl`, bytes: existing, lines: 0, capped: true });
+  }
+  // 快写满时**按整行留**：切在字节中间会让最后一行变成半截 JSON，读的人只会看到一行坏数据。
+  const room = MAX_CAPTURE_BYTES - existing;
+  let payload = text;
+  if (bytes > room) {
+    const kept = [];
+    let used = 0;
+    for (const line of lines) {
+      const size = Buffer.byteLength(line, 'utf8') + 1;
+      if (used + size > room) break;
+      kept.push(line);
+      used += size;
+    }
+    payload = kept.length > 0 ? `${kept.join('\n')}\n` : '';
+  }
+  try {
+    await fsp.appendFile(file, payload);
+  } catch (error) {
+    return sendJson(res, 500, { ok: false, error: { code: 'io', message: `写盘失败：${error && error.message ? error.message : ''}` } });
+  }
+  // 清理放在写完之后：这一份刚建出来的文件按 mtime 是最新的，留下来的正是它。
+  if (created) await pruneCaptures();
+  let total = existing;
+  try {
+    total = (await fsp.stat(file)).size;
+  } catch { /* 写成功但 stat 失败：回一个估计值，不影响 App */ }
+  sendJson(res, 200, {
+    ok: true,
+    file: `${capture}.jsonl`,
+    bytes: total,
+    lines: payload === text ? lines.length : (payload ? payload.split('\n').length - 1 : 0),
+    // 「这一段被切了」或「已经顶到上限」都算满：App 收到就停手，别继续往一条死路上发。
+    capped: payload !== text || total >= MAX_CAPTURE_BYTES,
+  });
+}
+
+/** 同步读一份轨迹（维护者在电脑上直接看文件；这里只给测试与将来的面板用）。 */
+function readCapture(capture) {
+  if (!CAPTURE_RE.test(capture)) return null;
+  try {
+    return fs.readFileSync(capturePath(capture), 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  handleDebugTrace,
+  readCapture,
+  traceDir,
+  MAX_CAPTURE_BYTES,
+  MAX_CAPTURES,
+};

package/lib/mobile/deepseek-account.js

@@ -45,6 +45,9 @@ function normalizeProfile(result) {
     status: 'ready',
     name: textOrNull(profile.name),
     contact: textOrNull(profile.contact),
+    // 头像是资料的一部分（和名字、联系方式同级），手机拿去当 <Image> 的 uri 用；
+    // 账号 ID、token、attempt 仍然不出这一层。
+    avatarUrl: textOrNull(profile.avatarUrl),
   };
 }
 

package/lib/mobile/entry-window.js

@@ -15,9 +15,14 @@
  * 2000 不是随手取的上限：本机 1420 个真实回合量下来，最长一轮 576 条消息、超过 500 的
  * 有 3 个、超过 200 的有 18 个。它只是**上界**，宿主在跨过 `minTurns` 且遇到 turn/start
  * 时就会停，所以正常情况下读的仍是那几十条；只有碰上超长回合才会真往上读到 2000。
+ *
+ * `minTurns` 取 1，**不是 6**：进对话要的是「尾部这一屏」，不是「六轮上下文」。
+ * 取 6 的时候，一轮 40 步的会话会把窗口撑到一百多条，手机侧要铺十几屏才追得到底 ——
+ * 用户看到的是「进来之后内容一路往下滑」。窗口大小是这条链的总闸：窗口小，
+ * 「一屏就是终态」才成立；更早的内容由「加载更早」按需补。
  */
 const ENTRY_THIN_MAX_MESSAGES = 2000;
-const ENTRY_THIN_MIN_TURNS = 6;
+const ENTRY_THIN_MIN_TURNS = 1;
 
 /** 把入口窗口的取数参数写进宿主请求体（就地修改并返回，调用方只关心副作用）。 */
 function entryWindowPayload(payload, limit) {