dsh-mobile-plugin 0.1.74 → 0.1.75

package/README.md

@@ -60,7 +60,15 @@ cd <DSH_HOME>/profiles/<profile>
 pnpm add dsh-mobile-plugin@<版本>
 ```
 
-宿主会优先挂载 profile 中安装的插件；未安装时才使用源码树版本。设备凭据库随 npm 包一同提供，不需要单独安装。不要使用 `npm install --legacy-peer-deps`；仓库锁文件应使用 `pnpm install --frozen-lockfile`。
+宿主会优先挂载 profile 中安装的插件；未安装时才使用源码树版本。设备凭据库随 npm 包一同提供，不需要单独安装。仓库锁文件应使用 `pnpm install --frozen-lockfile`。
+
+> 不要使用 `npm install --legacy-peer-deps` 安装插件；正式安装请使用 DSH 插件市场。
+
+## 本机调试 OTA
+
+新版插件的管理面板提供「本机调试 OTA」卡片，可手动检查并安装中转发布的紧急完整包。入口仅限宿主本机访问，不会由手机或公网触发；安装后通过实现代切换生效，切换失败会恢复上一代。npm 仍是正式发布源；后续 npm 正式版本达到 OTA 版本时会接管该版本。首次发布带此功能的 npm 包需要重启一次 DSH，让稳定外壳加载 OTA 能力。
+
+发布 OTA 完整包时，在插件仓库根目录执行 `npm pack`，再按中转服务器的部署说明上传到 `dsh-hub.wnluo.com`。
 
 ## 开发
 

package/lib/index.js

@@ -15,16 +15,11 @@
  * 这一层同时是**故障边界**：代装载失败时外壳回滚到上一代并把错误暴露出去，而不是让整个
  * 插件从宿主里消失（那会让手机连不上，且日志里只剩一行 pending）。
  *
- * ## 更新从哪儿来（2026-10 改，2026-10-11 再分一刀）
+ * ## 更新来源
  *
- * **查与装都归实现自己**：查直接问 npm 注册表、装在 profile 里跑它自己的包管理器
- * （`lib/update-registry.cjs` / `lib/update-install.cjs`），市场不再是这条路上的任何一环。
- * 装完会把 `<profile>/node_modules/dsh-mobile-plugin` 指向一个新的 store 目录，外壳照着新
- * realpath 重新 import 一代即可，**不需要重启 DSH**。自动更新（默认关）按 `AUTO_INTERVAL_MS`
- * 轮询，见 `shell/updater.js`。
- *
- * 这里那个 `updateState` 对象记的是「最近一次查/装的结果」。名字里别再叫 market：里面那份
- * 市场信息（`marketResult`）只是外壳从市场那条老路继承下来的兜底，装的时候用不到它。
+ * 正式 npm 更新由 `shell/updater.js` 处理（自动安装默认关闭）；紧急完整包由
+ * `shell/device-ota.js` 经本机控制面激活，正式版成功接管前保留 OTA 回退包。
+ * `updateState` 记录 npm 查装结果；`marketResult` 是旧外壳保留的兜底状态。
  */
 
 import path from 'node:path'
@@ -32,6 +27,7 @@ import { fileURLToPath } from 'node:url'
 import { createRuntime } from './shell/runtime.js'
 import * as updater from './shell/updater.js'
 import { installedPackageDir, installedVersion, profileNodeModules } from './shell/manager.js'
+import { createDeviceOta } from './shell/device-ota.js'
 
 export const name = 'dsh-mobile-plugin'
 export const inject = ['webServer', 'sessions']
@@ -45,6 +41,7 @@ export const inject = ['webServer', 'sessions']
  */
 export function apply(ctx) {
   const runtime = createRuntime()
+  const deviceOta = createDeviceOta({ installed: installedVersion, runtime })
   // 跑着的外壳的指纹。它必须在**启动时**算：之后盘上那份可能已经被市场换掉了。
   const runningShellHash = updater.shellFingerprint(path.dirname(path.dirname(fileURLToPath(import.meta.url))))
   const updateState = {
@@ -70,6 +67,7 @@ export function apply(ctx) {
     if (updateState.checking) return updateState.result
     updateState.checking = true
     try {
+      await deviceOta.reconcileOfficial()
       updateState.result = await updater.checkUpdate(base())
       updateState.lastError = null
     } catch (error) {
@@ -153,6 +151,7 @@ export function apply(ctx) {
     check,
     apply: applyUpdate,
     reload: version => runtime.reload(version),
+    deviceOta,
     setAutoUpdate: enabled => {
       const value = updater.setAutoUpdate(enabled)
       log('info', 'dsh-mobile-plugin: 自动更新已%s', value ? '开启' : '关闭')
@@ -164,13 +163,14 @@ export function apply(ctx) {
     .start(ctx)
     .then(() => {
       log('info', 'dsh-mobile-plugin: 已装载 %s（来源 %s）', runtime.status().version, runtime.status().source)
-      // 自动更新：默认关。开了才轮询；每次都是「查一次 → 有新版就自己装 → 就地换代」。
+      // 每 10 分钟让已落盘的正式版接管 OTA；自动安装仍由开关控制。
       const timer = setInterval(() => {
-        if (!updater.autoUpdateEnabled()) return
-        applyUpdate().catch(error => {
-          updateState.lastError = String(error?.message || error)
-          log('warn', 'dsh-mobile-plugin: 自动更新失败：%s', updateState.lastError)
-        })
+        deviceOta.reconcileOfficial()
+          .then(() => updater.autoUpdateEnabled() ? applyUpdate() : null)
+          .catch(error => {
+            updateState.lastError = String(error?.message || error)
+            log('warn', 'dsh-mobile-plugin: 更新检查失败：%s', updateState.lastError)
+          })
       }, updater.AUTO_INTERVAL_MS)
       if (typeof timer.unref === 'function') timer.unref()
       ctx.effect(() => () => clearInterval(timer), 'dsh-mobile-plugin: auto update timer')

package/lib/mobile/archive-clean.js

@@ -12,14 +12,19 @@
 
 const { sendJson, readJsonBody } = require('../shared/http-util');
 const { withIdempotency, requestIdOf } = require('./idempotency.js');
-const { canonicalDeviceKey } = require('./session-cache.js');
+const {
+  canonicalDeviceKey,
+  rememberDeletedSessionIds,
+  pendingUnarchiveSessionIdsOf,
+  clearPendingUnarchiveSessionIds,
+} = require('./session-cache.js');
 const { invalidateSessionList } = require('./sessions.js');
 const { unwrap } = require('./envelope.js');
 const { deleteSessionData, forgetArchivedSessions } = require('../session-cleanup.cjs');
 
 /**
  * POST /api/mobile/v1/workspace/clear-archived（token）
- * body: { confirm: true } → { ok: true, deleted: N }。confirm 不为 true 一律 400。
+ * body: { confirm: true } → { ok: true, deleted: N, unarchiveFailedSessionIds }。confirm 不为 true 一律 400。
  */
 async function handleClearArchived(ctx, req, res) {
   const body = await readJsonBody(req, 64 * 1024);
@@ -46,12 +51,25 @@ async function handleClearArchived(ctx, req, res) {
     //
     // 擦集合是 best-effort：它失败**不**让整条清理报错（日志已经删成功，报错等于骗用户）。
     const removed = await deleteSessionData(selected);
-    await forgetArchivedSessions(ctx, removed, 'mobile');
+    rememberDeletedSessionIds(ctx, removed);
+    const pendingUnarchive = pendingUnarchiveSessionIdsOf(ctx);
+    const retryable = [...new Set(selected)].filter((id) => pendingUnarchive.has(id));
+    const failedToUnarchive = await forgetArchivedSessions(ctx, retryable, 'mobile');
+    const failed = new Set(failedToUnarchive);
+    clearPendingUnarchiveSessionIds(ctx, retryable.filter((id) => !failed.has(id)));
     // 删的是列表里可见的行：手机端正开着列表，不立刻失效最长 10 秒还能点到死行。
     invalidateSessionList(ctx);
-    // 只报**真删掉**的那些：没匹配到日志的 id 留着，否则集合里那一行会被清掉却没有任何东西消失。
-    const cleared = new Set(removed);
-    return { status: 200, body: { ok: true, deleted: removed.length, archivedSessionIds: archivedIds.filter((id) => !cleared.has(id)) } };
+    // 只从返回的归档集合中移除宿主确认已取消归档的 ID；失败项保留为重试候选。
+    const cleared = new Set(retryable.filter((id) => !failed.has(id)));
+    return {
+      status: 200,
+      body: {
+        ok: true,
+        deleted: removed.length,
+        archivedSessionIds: archivedIds.filter((id) => !cleared.has(id)),
+        unarchiveFailedSessionIds: failedToUnarchive,
+      },
+    };
   });
   sendJson(res, outcome.status, outcome.body);
 }

package/lib/mobile/deepseek-account.js

@@ -0,0 +1,125 @@
+'use strict';
+
+/** Read-only DeepSeek account projection for the mobile app. */
+
+const { sendJson } = require('../shared/http-util');
+const { unwrap } = require('./envelope.js');
+
+function readClientMetadata(req) {
+  let query;
+  try {
+    query = new URL(req.url, 'http://127.0.0.1').searchParams;
+  } catch {
+    return null;
+  }
+  const version = query.get('version');
+  const locale = query.get('locale');
+  const timezoneOffset = query.get('timezoneOffsetSeconds');
+  const timezoneOffsetSeconds = Number(timezoneOffset);
+  if (!version || !locale || timezoneOffset === null || !timezoneOffset.trim() || !Number.isInteger(timezoneOffsetSeconds)) return null;
+  return { version, locale, timezoneOffsetSeconds };
+}
+
+async function callAccount(ctx, method, payload = {}) {
+  try {
+    const call = ctx.apiProxy && ctx.apiProxy.account && ctx.apiProxy.account[method];
+    if (typeof call !== 'function') return { error: { code: 'host-unavailable' } };
+    return unwrap(await call({
+      rpcId: 'mobile',
+      method: `account.${method}`,
+      payload,
+    }));
+  } catch {
+    return { error: { code: 'host-unavailable' } };
+  }
+}
+
+function textOrNull(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function normalizeProfile(result) {
+  const profile = result && result.status === 'ready' ? result.value : null;
+  if (!profile || typeof profile !== 'object') return { status: 'failed' };
+  return {
+    status: 'ready',
+    name: textOrNull(profile.name),
+    contact: textOrNull(profile.contact),
+  };
+}
+
+function normalizeWallets(result) {
+  if (!result || result.status !== 'ready') return { status: 'failed' };
+  const walletsOf = (value) => Array.isArray(value)
+    ? value.filter((wallet) => wallet && (wallet.currency === 'CNY' || wallet.currency === 'USD') && typeof wallet.balance === 'string')
+      .map((wallet) => ({ currency: wallet.currency, balance: wallet.balance }))
+    : [];
+  return {
+    status: 'ready',
+    wallets: walletsOf(result.value),
+    bonusWallets: walletsOf(result.bonusWallets),
+  };
+}
+
+function safeLinks(state) {
+  const links = state && state.links;
+  return {
+    usageUrl: textOrNull(links && links.usageUrl),
+    topUpUrl: textOrNull(links && links.topUpUrl),
+  };
+}
+
+/** GET /api/mobile/v1/deepseek-account — safe account details only; never login state or credentials. */
+async function handleDeepSeekAccount(ctx, req, res) {
+  const client = readClientMetadata(req);
+  if (!client) {
+    return sendJson(res, 400, {
+      ok: false,
+      error: { code: 'bad-request', message: '需要 version、locale 和 timezoneOffsetSeconds' },
+    });
+  }
+
+  const stateResult = await callAccount(ctx, 'getState');
+  if (stateResult.error) {
+    return sendJson(res, 502, {
+      ok: false,
+      error: { code: stateResult.error.code || 'host-unavailable', message: '这台宿主暂时无法读取 DeepSeek 账号信息' },
+    });
+  }
+
+  const state = stateResult.value;
+  if (!state || (state.status !== 'signed-out' && state.status !== 'credential-stored')) {
+    return sendJson(res, 502, {
+      ok: false,
+      error: { code: 'host-response-invalid', message: '宿主返回的 DeepSeek 账号状态无效' },
+    });
+  }
+
+  const links = safeLinks(state);
+  if (state.status === 'signed-out') {
+    return sendJson(res, 200, {
+      ok: true,
+      status: 'signed-out',
+      profile: { status: 'unavailable' },
+      balance: { status: 'unavailable' },
+      links,
+    });
+  }
+
+  const [profileResult, balanceResult] = await Promise.all([
+    callAccount(ctx, 'getProfile', { client }),
+    callAccount(ctx, 'getBalance', { client }),
+  ]);
+  const profile = normalizeProfile(profileResult.value);
+  const balance = normalizeWallets(balanceResult.value);
+
+  return sendJson(res, 200, {
+    ok: true,
+    status: 'credential-stored',
+    profile: profileResult.error ? { status: 'failed' } : profile,
+    balance: balanceResult.error ? { status: 'failed' } : balance,
+    links,
+  });
+}
+
+module.exports = { handleDeepSeekAccount, readClientMetadata, normalizeProfile, normalizeWallets, safeLinks };

package/lib/mobile/host-bridge/endpoints.js

@@ -136,6 +136,11 @@ const ENDPOINTS = {
   'goals.complete': (ctx, payload, signal) => goalAction(ctx, 'complete', payload, signal),
   'goals.clear': (ctx, payload, signal) => goalAction(ctx, 'clear', payload, signal),
 
+  // account: mobile can inspect the stored DeepSeek account and its safe profile/balances only.
+  'account.getState': inv('account', 'getState', () => ({})),
+  'account.getProfile': inv('account', 'getProfile', (p) => ({ client: p.client })),
+  'account.getBalance': inv('account', 'getBalance', (p) => ({ client: p.client })),
+
   // settings / llm / credentials
   'settings.describe': inv('settings', 'describe', () => ({})),
   'settings.mutate': inv('settings', 'mutate', (p) => pick(p, ['ns', 'ops', 'expectedRevision'])),

package/lib/mobile/session-cache.js

@@ -21,6 +21,7 @@ const sessionModelsCache = new WeakMap();
 const MAX_SESSION_MODEL_CACHE_ENTRIES = 256;
 
 const sessionListResponseCache = new WeakMap();
+const deletedSessionState = new WeakMap();
 const mirrorHistoryCache = new WeakMap();
 // Cache only the derived last-message preview. The full history stays outside
 // the cache so repeated mobile list refreshes do not re-read/decompress logs.
@@ -81,6 +82,37 @@ function sessionListResponseState(ctx, deviceKey = 'legacy') {
   return state;
 }
 
+function sessionCleanupStateOf(ctx) {
+  let state = deletedSessionState.get(ctx);
+  if (!state) {
+    state = { deleted: new Set(), pendingUnarchive: new Set() };
+    deletedSessionState.set(ctx, state);
+  }
+  return state;
+}
+
+function rememberDeletedSessionIds(ctx, sessionIds) {
+  const state = sessionCleanupStateOf(ctx);
+  for (const sessionId of sessionIds) {
+    if (typeof sessionId !== 'string' || !sessionId) continue;
+    state.deleted.add(sessionId);
+    state.pendingUnarchive.add(sessionId);
+  }
+}
+
+function deletedSessionIdsOf(ctx) {
+  return sessionCleanupStateOf(ctx).deleted;
+}
+
+function pendingUnarchiveSessionIdsOf(ctx) {
+  return sessionCleanupStateOf(ctx).pendingUnarchive;
+}
+
+function clearPendingUnarchiveSessionIds(ctx, sessionIds) {
+  const pending = sessionCleanupStateOf(ctx).pendingUnarchive;
+  for (const sessionId of sessionIds) pending.delete(sessionId);
+}
+
 function sessionPreviewStateOf(ctx) {
   let state = sessionPreviewCache.get(ctx);
   if (!state) {
@@ -249,6 +281,10 @@ module.exports = {
   invalidateSessionModels,
   sessionListResponseState,
   invalidateSessionList,
+  rememberDeletedSessionIds,
+  deletedSessionIdsOf,
+  pendingUnarchiveSessionIdsOf,
+  clearPendingUnarchiveSessionIds,
   dropSessionListCache,
   sessionPreviewStateOf,
   sessionPreviewInFlightStateOf,

package/lib/mobile/sessions.js

@@ -10,7 +10,7 @@
  *
  *   envelope.js        信封拆解（unwrap / envelopeValue），唯一的实现
  *   rpc.js             对宿主 apiProxy 的窄接口封装（callSessions / callAgentPresets）
- *   session-cache.js   按 ctx 隔离的八张状态表，全部 WeakMap 集中在这里
+ *   session-cache.js   按 ctx 隔离的状态表，全部 WeakMap 集中在这里
  *   attachments.js     图片附件还原
  *   completion.js      完成提醒状态机
  *   session-models.js  模型目录与切模型
@@ -34,7 +34,7 @@ const { listTitle, deriveMessages, lastMessageOf, promptErrorObject, MODEL_UNAVA
 const { unwrap } = require('./envelope.js');
 const { callSessions } = require('./rpc.js');
 const {
-  canonicalDeviceKey, sessionListResponseState, invalidateSessionList,
+  canonicalDeviceKey, sessionListResponseState, invalidateSessionList, deletedSessionIdsOf,
   sessionPreviewStateOf, sessionPreviewInFlightStateOf, sessionPreviewClockOf,
   completionGenerationOf, bumpCompletionGeneration,
   completionStateOf, sessionModelsStateOf, invalidateSessionModels, sendIdempotencyStateOf,
@@ -223,12 +223,13 @@ async function buildSessionsResponse(ctx, deviceKey = 'legacy', generation = com
   }
   // 归档会话在这里剔除，与桌面端侧边栏行为一致：宿主 sessions.list 自己不过滤归档，
   // 「哪些会话已归档」只存在于 workspaceRegistry.archivedSessionIds（见 workspaceSessionFlags）。
+  // 清理时已删日志的 ID 也要压住：宿主 list 或 workspace.list 的短暂旧快照不能让它们复活。
   // archivedOnly（App 的「只看已归档」筛选视图）反过来只保留归档里的那些行：默认视图藏
   // 它们，筛选视图正是为了把它们找回来（查看 / 取消归档）。
+  const deleted = deletedSessionIdsOf(ctx);
   const { archived, pinned } = await workspaceSessionFlags(ctx);
-  const allSummaries = archivedOnly
-    ? summaries.filter(s => s && archived.has(s.sessionId))
-    : summaries.filter(s => s && !archived.has(s.sessionId));
+  const allSummaries = summaries.filter((item) => item && !deleted.has(item.sessionId)
+    && (archivedOnly === archived.has(item.sessionId)));
   // 状态跟踪覆盖完整列表，不能受预览补全上限影响。
   const completionStatesForContext = updateCompletionStates(ctx, allSummaries, deviceKey);
   // 列表完整返回：侧边栏分组依赖全部会话（工作区 sessionIds 排序 + 未分组兜底），