@wenbin_wb/dsh-bridge 2.11.3 → 2.12.1

package/lib/bridge-rpc.js

@@ -16,7 +16,10 @@ function ok(value) {
 
 function fail(code, message, details = {}) {
   const allowedCodes = new Set([
-    'bad-request', 'cancelled', 'internal', 'settings-rejected', 'command-error'
+    'bad-request', 'cancelled', 'internal', 'settings-rejected', 'command-error',
+    // 'busy'：重启等操作因「有任务在跑」被拦下，需与普通 bad-request 区分，
+    // 面板据此弹二次确认（而不是报错）。
+    'busy'
   ]);
   const safeCode = allowedCodes.has(code) ? code : 'bad-request';
   return {
@@ -82,12 +85,18 @@ function checkAdminAuth(authManager, payload, { requireConfigured = false } = {}
   return fail('bad-request', '操作已被拦截：需要管理员权限，请先在控制台输入管理密码解锁');
 }
 
-export function installBridgeRpc(ctx, { service, authManager, platformManager, logger, saveCustomTunnelConfig, exportBackup, importBackup }) {
+export function installBridgeRpc(ctx, { service, authManager, platformManager, logger, saveCustomTunnelConfig, exportBackup, importBackup, runtime }) {
   if (!ctx?.connection?.rpc?.handle) {
     logger.warn('dsh-bridge: Connection RPC unavailable — UI will not work');
     return () => {};
   }
 
+  // 运行中任务探测所需的引用（由 apply 注入）。缺失时探测退化为「无任务」，不阻断重启。
+  if (runtime) {
+    service.runtimeCtx = runtime.ctx ?? null;
+    service.platformManager = runtime.platformManager ?? null;
+  }
+
   // 经 connection-compat 注册：兼容 DSH ≥ 0.1.5-alpha.1 的 webServer 注入回归
   // （上游 register() 里对 connection 自身 ctx 取 webServer 而未加 inject 作用域）
   return registerRpcChannel(
@@ -152,6 +161,12 @@ export function installBridgeRpc(ctx, { service, authManager, platformManager, l
           return ok(authManager.getStatus({ masked: false }));
         }
 
+        if (endpoint === BRIDGE_ENDPOINTS.dismissFirstRunGuide) {
+          // 无管理权限要求：这是纯本地提示状态，不涉及安全配置变更。
+          // 与 authUpdateConfig 中「切换 enabled 不需管理权限」同理，避免提示无法关闭。
+          return ok(await service.dismissFirstRunGuide());
+        }
+
         if (endpoint === BRIDGE_ENDPOINTS.authRegenerateToken) {
           if (!authManager) return fail('bad-request', 'AuthManager 未初始化');
           const adminErr = checkAdminAuth(authManager, payload);
@@ -305,6 +320,22 @@ export function installBridgeRpc(ctx, { service, authManager, platformManager, l
           const adminErr = checkAdminAuth(authManager, payload, { requireConfigured: true });
           if (adminErr) return adminErr;
 
+          // 打断保护：有任务在跑且调用方未显式确认时，**不重启**，改为把现场回给面板，
+          // 由面板弹二次确认。已确认（payload.confirm === true）则照常重启。
+          // 探测本身失败会降级为「无任务」，绝不会把重启锁死。
+          if (payload?.confirm !== true) {
+            let work;
+            try {
+              work = service.getActiveWork?.() ?? { total: 0, sessions: [], subagentSessions: [], pendingApprovals: [] };
+            } catch (err) {
+              logger?.debug?.('dsh-bridge: 重启前探测任务失败（按无任务处理）：%s', err?.message ?? err);
+              work = { total: 0, sessions: [], subagentSessions: [], pendingApprovals: [] };
+            }
+            if (work.total > 0) {
+              return fail('busy', '当前有任务正在运行，重启会打断它们', { activeWork: work });
+            }
+          }
+
           const result = await service.restartDsh();
           return ok(result);
         }

package/lib/index.js

@@ -11,13 +11,14 @@ import { networkInterfaces, homedir, totalmem, freemem, cpus, loadavg, platform,
 import { join, dirname, basename, resolve, normalize } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { readFileSync, appendFileSync, existsSync, realpathSync, mkdirSync } from 'node:fs';
-import { readFile, writeFile, mkdir, unlink, readdir, stat, access } from 'node:fs/promises';
+import { readFile, writeFile, mkdir, unlink, readdir, stat, access, chmod } from 'node:fs/promises';
 import { spawn } from 'node:child_process';
 import QRCode from 'qrcode';
 import { installBridgeRpc } from './bridge-rpc.js';
 import { CustomTunnelClient } from './tunnel-client.mjs';
 import { CloudflaredManager, CLOUDFLARED_LOG_NAME } from './cloudflared-manager.mjs';
 import { PlatformManager } from './platform/manager.js';
+import { describeOpenTurn } from './platform/conversation-bridge.js';
 import { applyRestoredPlatformConfig, RESTORED_STRING_FIELDS, PLATFORM_TIMING_FIELDS } from './platform/config-restore.js';
 import { WechatService } from './wechat/index.js';
 import { QqService } from './qq/index.js';
@@ -316,6 +317,49 @@ export function detectSupervisor({ env = process.env, cgroup = '' } = {}) {
   return { kind: 'self', reason: '未检出托管器（无 DSH_DAEMON/PM2_HOME，也不在 systemd 单元内）' };
 }
 
+/**
+ * 判断当前宿主是否跑在 DSH 桌面版（Electron）内（纯函数，便于单测）。
+ *
+ * 背景：桌面端宿主是 Electron 以 RunAsNode 模式拉起的同一套 @deepseek-ai/dsh，
+ * 进程生死由 Electron 壳经 IPC 管理（shutdown/quit-inspection），没有 systemd、
+ * DSH_DAEMON/PM2 这类托管器。插件若按 Web/CLI 版的假设自行重启/升级宿主，
+ * 会拉起脱离壳管理的孤儿进程（抢占 19387 端口、触发壳的恢复对话框）或把包
+ * 装进错误的 profile（桌面端 profile 名为 `desktop`，不是 `web`）。
+ *
+ * 判据（按可靠性排序，任一命中即判为桌面端）：
+ *   1. `process.versions.electron` 存在 —— Electron（含 RunAsNode 模式）的官方
+ *      行为保证该字段存在，跨平台最可靠；
+ *   2. 主模块路径含 `desktop-host` —— 桌面宿主入口固定为 desktop-host 包。
+ *
+ * fail-open：判不准时一律按 Web/CLI 版走，绝不能把正常用户的重启/升级拦掉。
+ *
+ * @param {object} [opts]
+ * @param {object} [opts.versions] process.versions（默认 process.versions）
+ * @param {string} [opts.argv1] process.argv[1]（默认 process.argv[1]）
+ * @returns {boolean}
+ */
+export function isDesktopHost({ versions = process.versions, argv1 = process.argv[1] } = {}) {
+  try {
+    if (versions && typeof versions.electron === 'string' && versions.electron.length > 0) return true;
+  } catch { /* 忽略，继续下一个判据 */ }
+  try {
+    // 必须按路径分段匹配（前后是分隔符或串 ends）：避免用户目录名恰好包含
+    // desktop-host 子串（如本仓库的 test/desktop-host-compat.test.mjs）时误判。
+    // 生产路径形如 .../dsh-desktop-host/lib/index.js。
+    if (typeof argv1 === 'string' && /(?:^|[/\\])(?:dsh-)?desktop-host(?:[/\\]|$)/i.test(argv1)) return true;
+  } catch { /* 忽略，fail-open */ }
+  return false;
+}
+
+/**
+ * 当前宿主加载的 profile 名（纯函数，便于单测）。
+ * 桌面端为 `desktop`，其余（Web/CLI）为 `web`。供 `dsh plugin --profile <name> add`
+ * 类命令使用，避免把包装进宿主不加载的 profile。
+ */
+export function currentProfileName(opts = {}) {
+  return isDesktopHost(opts) ? 'desktop' : 'web';
+}
+
 class ProxyServer {
   constructor({ localPort, targetPort, authManager, logger, allowedOrigins }) {
     this.localPort = localPort;
@@ -571,6 +615,27 @@ class ProxyServer {
         return;
       }
 
+      // 纵深防御：浏览器发起的升级请求若带 Origin 且不在已知面板来源内，拒绝握手，
+      // 防止恶意页面借用户浏览器已有的 Cookie 建立 WebSocket（CSWSH）。
+      // 认证已在上方完成，此处只做额外收紧，不构成绕过认证的路径。
+      // 关键兼容性约束：Origin 缺失一律放行——非浏览器客户端（IM 机器人、
+      // ws 库、命令行工具、隧道转发）通常不发 Origin，若按缺失拒绝会直接
+      // 打断现有用户的机器人通道。
+      const origin = req.headers?.origin;
+      if (origin) {
+        let allowed;
+        try {
+          allowed = this.allowedOrigins?.() ?? [];
+        } catch { allowed = []; }
+        if (!allowed.includes(origin)) {
+          // 直接内联 origin，避免依赖 logger 的 printf 插值（该 logger 在部分调用形态下不做替换）
+          this.logger?.warn?.(`dsh-bridge: 拒绝来源不明的 WebSocket 升级请求 (Origin=${origin})`);
+          socket.write('HTTP/1.1 403 Forbidden\r\nContent-Type: text/plain\r\n\r\nForbidden\r\n');
+          socket.destroy();
+          return;
+        }
+      }
+
       const headers = loopbackHeaders(req.headers, this.targetPort);
       const proxyReq = httpRequest({
         host: '127.0.0.1', port: this.targetPort, method: req.method, path: req.url, headers, agent: false,
@@ -666,9 +731,19 @@ class BridgeService {
     this.onPersist = onPersist ?? null;
     this.logger = logger;
 
+    // 运行中任务探测所需的运行时引用（由 apply 在构造后注入）：
+    //   ctx.sessions —— 枚举 live 会话及其事件流，判断是否有 turn 在跑
+    //   platformManager —— 遍历各 IM 平台 bridge，取其 pending 审批
+    // 二者缺失时探测退化为「未检测到任务」，重启照常执行（不得因探测失败而阻断重启）。
+    this.runtimeCtx = null;
+    this.platformManager = null;
+
     this.qrCache = new QrCache();
     this.proxy = null;
 
+    // 首次启用引导：是否仍需要向用户展示「开门禁」提示（由 apply 的启动链按保守判据置位）
+    this.firstRunGuidePending = false;
+
     this.customTunnel = null;
     this.customTunnelState = { phase: 'idle', detail: '' };
 
@@ -742,8 +817,17 @@ class BridgeService {
     return this._dshVersion;
   }
 
-  async setLanIp({ ip } = {}) {
-    const trimmed = ip ? String(ip).trim() : null;
+  /**
+   * 标记「首次启用引导」已展示/已确认，持久化后不再打扰用户。
+   * 与访问认证状态解耦：即便用户仍未开启门禁，确认过后也不再重复弹窗。
+   */
+  async dismissFirstRunGuide() {
+    this.firstRunGuidePending = false;
+    await this.onPersist?.({ wizard: { guideShown: true } });
+    return { ok: true };
+  }
+
+  async setLanIp({ ip } = {}) {    const trimmed = ip ? String(ip).trim() : null;
     this.selectedLanIp = trimmed || null;
     await this.onPersist?.({ lan: { selectedIp: this.selectedLanIp } });
     this.logger?.info('局域网选定 IP 更新为: %s', this.selectedLanIp || '自动推荐');
@@ -767,8 +851,17 @@ class BridgeService {
           `http://127.0.0.1:${this.dshPort}`, `http://localhost:${this.dshPort}`,
         ];
         try {
-          for (const iface of listAllLanIPv4()) origins.push(`http://${iface.address}:${this.proxyPort}`);
-          if (this.selectedLanIp) origins.push(`http://${this.selectedLanIp}:${this.proxyPort}`);
+          // LAN 面板与回环同理需要同时覆盖 3082（代理）与 dshPort（DSH 原生端口直连）：
+          // 浏览器从 LAN IP 直连原生端口时 Origin 是 http://<lanIp>:<dshPort>，
+          // 只配 proxyPort 会导致页面能打开但 WebSocket 升级被拒（实时通道静默失效）。
+          for (const iface of listAllLanIPv4()) {
+            origins.push(`http://${iface.address}:${this.proxyPort}`);
+            origins.push(`http://${iface.address}:${this.dshPort}`);
+          }
+          if (this.selectedLanIp) {
+            origins.push(`http://${this.selectedLanIp}:${this.proxyPort}`);
+            origins.push(`http://${this.selectedLanIp}:${this.dshPort}`);
+          }
           if (this.cloudflared?.url) origins.push(new URL(this.cloudflared.url).origin);
           if (this.customTunnel?.publicUrl) origins.push(new URL(this.customTunnel.publicUrl).origin);
           if (this.externalTunnelConfig?.url) origins.push(new URL(this.externalTunnelConfig.url).origin);
@@ -818,6 +911,13 @@ class BridgeService {
 
       auth: this.authManager?.getStatus({ masked: !adminAuthValid }) ?? { enabled: false },
 
+      // 首次启用引导：为 true 时面板应提示用户开启访问门禁（默认 0.0.0.0 且认证默认关闭）
+      firstRunGuide: {
+        pending: Boolean(this.firstRunGuidePending),
+        // 当前是否处于「监听 0.0.0.0 但认证未开启」的开箱敞开状态
+        exposedWithoutAuth: this.authManager?.enabled !== true,
+      },
+
       proxy: {
         running: !!this.proxy,
         port: this.proxyPort,
@@ -1113,16 +1213,24 @@ class BridgeService {
       try {
         dshRealPath = realpathSync(dshBin) || dshBin;
       } catch { /* 保留原始路径继续判断 */ }
-      // 2. 当前 node 对应的全局 node_modules 根
+      // npm root -g 返回的是 prefix 下的 node_modules（如 /prefix/lib/node_modules），
+      // 不能直接 dirname 后再作为 --prefix，否则会变成 /prefix/lib，实际安装到
+      // /prefix/lib/lib/node_modules，dsh 命令仍会加载旧的 /prefix/lib/node_modules。
+      // npm prefix -g 才是可传给 --prefix 的真实全局安装前缀。
+      const globalPrefix = await runCmd('npm', ['prefix', '-g']);
       const globalNodeModules = await runCmd('npm', ['root', '-g']);
-      const rootGlobal = globalNodeModules ? dirname(globalNodeModules) : dirname(nodeDir);
+      const rootGlobal = globalPrefix || (globalNodeModules ? dirname(dirname(globalNodeModules)) : dirname(nodeDir));
       const marker = join('node_modules', '@deepseek-ai', 'dsh');
       if (dshRealPath.includes(marker) && (dshRealPath.startsWith(rootGlobal) || dshRealPath.includes('node-v') && dshRealPath.includes('lib'))) {
         return { upgradable: true, rootGlobal, dshRealPath };
       }
       return {
         upgradable: false,
-        reason: 'dsh 非标准 npm 全局安装（Electron/打包/源码/pnpm 等），无法自动升级；请按官方渠道手动更新',
+        // 桌面端 dsh 装在 App 包内：走桌面应用内更新，不要用 npm 动它。
+        // 桌面检测是 fail-open 的，判不准时仍是这条通用文案，不影响 Web/CLI 用户。
+        reason: isDesktopHost()
+          ? '桌面版 DSH 由应用内更新统一管理（一键升级仅支持 npm 全局安装的 CLI 版）；请用桌面应用菜单的"检查更新"升级，勿用 npm 改动应用包内文件'
+          : 'dsh 非标准 npm 全局安装（Electron/打包/源码/pnpm 等），无法自动升级；请按官方渠道手动更新',
       };
     } catch {
       return { upgradable: false, reason: '探测 dsh 安装形态失败，请按官方渠道手动更新' };
@@ -1183,7 +1291,9 @@ class BridgeService {
   }
 
   // 一键直接升级插件（执行 dsh / npx / npm 自动升级，使用安全的参数数组彻底杜绝 shell 注入）
-  async upgradePlugin({ version } = {}) {
+  // opts.profile 供测试注入；默认按当前宿主推导（桌面端为 `desktop`，其余为 `web`），
+  // 绝不能写死 --profile web——桌面端会把包装进宿主不加载的 profile，造成"显示成功实际没升"。
+  async upgradePlugin({ version, spawnImpl = spawn, profile } = {}) {
     const targetVersion = version ? String(version).trim() : 'latest';
     // 严格 SemVer 白名单正则校验
     if (!/^(latest|\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?)$/.test(targetVersion)) {
@@ -1222,9 +1332,15 @@ class BridgeService {
     const siblingNpm = join(nodeDir, isWin ? 'npm.cmd' : 'npm');
     const siblingNpx = join(nodeDir, isWin ? 'npx.cmd' : 'npx');
 
+    // 目标 profile：显式传入优先，否则按宿主形态推导（桌面端 `desktop`，其余 `web`）。
+    // 桌面端 profile 名固定，见官方 desktop-host（runProfile profile: 'desktop'）。
+    // 安全：payload 里的 profile 不可信，白名单只认 desktop/web，其余一律按推导值处理，
+    // 避免未校验字符串进入 shell:true 的 spawn 参数（参数拼接有注入风险）。
+    const targetProfile = (profile === 'desktop' || profile === 'web') ? profile : currentProfileName();
+
     const tasks = [
-      { cmd: 'dsh', args: ['plugin', '--profile', 'web', 'add', pkgSpec] },
-      { cmd: existsSync(siblingNpx) ? siblingNpx : 'npx', args: ['--yes', '@deepseek-ai/dsh', 'plugin', '--profile', 'web', 'add', pkgSpec] },
+      { cmd: 'dsh', args: ['plugin', '--profile', targetProfile, 'add', pkgSpec] },
+      { cmd: existsSync(siblingNpx) ? siblingNpx : 'npx', args: ['--yes', '@deepseek-ai/dsh', 'plugin', '--profile', targetProfile, 'add', pkgSpec] },
       { cmd: existsSync(siblingNpm) ? siblingNpm : 'npm', args: ['install', pkgSpec] },
     ];
 
@@ -1235,7 +1351,7 @@ class BridgeService {
         const res = await new Promise((resolve, reject) => {
           let cp;
           try {
-            cp = spawn(task.cmd, task.args, {
+            cp = spawnImpl(task.cmd, task.args, {
               windowsHide: true,
               shell: true,
               env: augmentedEnv,
@@ -1272,7 +1388,8 @@ class BridgeService {
 
   // 一键升级 DSH 宿主 CLI（npm 全局包 @deepseek-ai/dsh）。
   // 升级的是"与当前 node 配对"的全局 prefix（dsh 命令所在目录），完成后需重启 DSH 生效。
-  async upgradeDsh({ version } = {}) {
+  // opts.spawnImpl 供测试注入，生产环境用 node:child_process 的 spawn。
+  async upgradeDsh({ version, spawnImpl = spawn } = {}) {
     const targetVersion = version ? String(version).trim() : 'latest';
     // 严格 SemVer 白名单校验（dsh 用 rc 版本号，如 0.1.2-rc.1）
     if (!/^(latest|\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?)$/.test(targetVersion)) {
@@ -1331,7 +1448,7 @@ class BridgeService {
         const res = await new Promise((resolve, reject) => {
           let cp;
           try {
-            cp = spawn(task.cmd, task.args, {
+            cp = spawnImpl(task.cmd, task.args, {
               windowsHide: true,
               shell: true,
               env: augmentedEnv,
@@ -1352,6 +1469,27 @@ class BridgeService {
         });
         const output = (res.stdout || res.stderr || '升级成功').trim().slice(-500);
         this.logger?.info('dsh-bridge: DSH 升级命令成功: %s %s', task.cmd, task.args.join(' '));
+        
+        // 升级成功后清理版本缓存，让 getDshVersion/checkVersion 下次重新探测
+        this._dshVersion = null;
+        this._dshVersionLoaded = false;
+        this._versionCheckCache = null;
+        
+        // 核验实际 dsh 版本：npm 命令成功不等于正在使用的 dsh 已经变新。
+        // 如果探测到的版本号仍然是旧版（或探测失败），则安装可能装到了错误位置。
+        const actualVersion = await this.getDshVersion();
+        if (actualVersion && targetVersion !== 'latest') {
+          // 用户指定了具体版本号（如 0.2.0-rc.2）：安装后 dsh --version 必须精确匹配
+          if (actualVersion !== targetVersion) {
+            return {
+              ok: false,
+              error: `npm 安装成功但 dsh 命令实际版本仍为 ${actualVersion}（预期 ${targetVersion}）。可能安装到了错误位置，请手动执行 \`npm install -g @deepseek-ai/dsh@${targetVersion}\` 并重启 DSH。`,
+              version: targetVersion,
+              installedButNotActive: true,
+            };
+          }
+        }
+        
         return { ok: true, command: `${task.cmd} ${task.args.join(' ')}`, output, version: targetVersion };
       } catch (err) {
         lastError = err;
@@ -1368,6 +1506,65 @@ class BridgeService {
   //   - 默认 KillMode=control-group，主进程退出时 systemd 会把 cgroup 里刚派生的子进程一起杀掉。
   //   结果就是"点了重启，dsh 再也没起来"，而且没有任何日志（旧实现 stdio: 'ignore'）。
   // 因此这里先识别托管方式：
+  // 探测「重启会打断哪些正在跑的任务」。
+  //
+  // 判据（均为可从宿主运行时直接读到的信号，不依赖任何新增宿主 API）：
+  //   1. 主会话进行中的 turn：事件流里存在未配对的 turn/start（无对应 turn/end）。
+  //      这是 Web/IM 两端「正在思考/工具调用中」的同一依据
+  //      （见 lib/platform/conversation-bridge.js 的 digestLine）。
+  //   2. 子代理/agent 会话：会话 header.origin === 'subagent'，同样按未闭合 turn 判断在跑。
+  //      嵌套委托最容易被遗忘，重启损失也最大。
+  //   3. 待审批请求：各 IM 平台 bridge 的 pending（用户尚未在机器人里点「同意/拒绝」）。
+  //      宿主 ctx.approval 只提供 request()，无查询 API，故以插件自身登记的 pending 为准。
+  //
+  // 任何一步探测失败都必须降级为「该项无任务」并继续，绝不因此阻断重启：
+  // 重启是救急能力，不能被探测逻辑锁死。
+  getActiveWork() {
+    const work = { sessions: [], subagentSessions: [], pendingApprovals: [], total: 0 };
+
+    // 1 + 2：遍历 live 会话，按未闭合 turn 判断是否在跑
+    try {
+      const list = this.runtimeCtx?.sessions?.list?.() ?? [];
+      for (const s of list) {
+        if (!s || !s.id) continue;
+        const isSubagent = s.origin === 'subagent' || s.header?.origin === 'subagent';
+        const turn = describeOpenTurn(s.events);
+        if (!turn) continue;
+        const entry = {
+          id: s.id,
+          title: s.title || (s.header?.cwd ? basename(s.header.cwd) : '') || '未命名会话',
+          turn: turn.turn,
+          tools: turn.tools,
+          lastTool: turn.lastTool,
+        };
+        if (isSubagent) work.subagentSessions.push(entry);
+        else work.sessions.push(entry);
+      }
+    } catch (err) {
+      this.logger?.debug?.('dsh-bridge: 探测进行中会话失败（视为无任务）：%s', err?.message ?? err);
+    }
+
+    // 3：各 IM 平台的待审批请求
+    try {
+      for (const platform of this.platformManager?.list?.() ?? []) {
+        const pending = platform?.bridge?.pending;
+        if (!pending || typeof pending.forEach !== 'function') continue;
+        pending.forEach((entry, number) => {
+          work.pendingApprovals.push({
+            platform: platform?.id ?? 'unknown',
+            number,
+            summary: entry?.summary || entry?.title || entry?.tool || '待审批请求',
+          });
+        });
+      }
+    } catch (err) {
+      this.logger?.debug?.('dsh-bridge: 探测待审批请求失败（视为无））：%s', err?.message ?? err);
+    }
+
+    work.total = work.sessions.length + work.subagentSessions.length + work.pendingApprovals.length;
+    return work;
+  }
+
   //   - systemd（从 /proc/self/cgroup 取单元名）→ 交给 `systemctl [--user] restart --no-block <unit>`，
   //     由 systemd 负责 stop+start，新进程仍在正确的 cgroup 里；
   //   - DSH_DAEMON / PM2 → 直接退出，交给守护进程拉起；
@@ -1375,6 +1572,17 @@ class BridgeService {
   //     并把全过程写入 ~/.dsh/dsh-bridge/restart.log（失败不再无声）。
   // opts 仅供单测注入（spawnImpl / readCgroup / env / scheduleExit）。
   async restartDsh(opts = {}) {
+    // 桌面端拦截（P0）：桌面宿主由 Electron 壳经 IPC 管理生死，插件绝不能自行
+    // 派生 helper 重拉进程——那会产生壳外孤儿（抢占 19387 端口、触发壳的恢复
+    // 对话框）。直接拒绝，并指引用户走应用菜单重启。
+    // isDesktopHost 是 fail-open 的：判不准时按 Web/CLI 版走，不拦正常用户。
+    if (isDesktopHost({ versions: opts.processVersions, argv1: opts.argv1 })) {
+      return {
+        ok: false,
+        error: '当前运行在 DSH 桌面版内，宿主由应用统一管理，插件不能自行重启。请用桌面应用菜单的重启/退出重进（有关闭确认保护正在跑的任务），不要用面板重启。',
+        desktopManaged: true,
+      };
+    }
     const env = opts.env ?? process.env;
     const spawnImpl = opts.spawnImpl ?? spawn;
     const readCgroup = opts.readCgroup
@@ -1962,9 +2170,42 @@ function apply(ctx, config = {}) {
     }
   }
 
+  // config.json 含平台 Token / 隧道凭据 / 访问密码哈希，属同机敏感文件：
+  // 落盘固定 0600，与 sessions.json（lib/auth/manager.js）保持一致。
+  const CONFIG_FILE_MODE = 0o600;
+
   async function writeConfig(data) {
     await mkdir(join(dshHome, 'dsh-bridge'), { recursive: true });
-    await writeFile(configFile, JSON.stringify(data, null, 2), 'utf8');
+    // mode 仅对新建文件生效；已存在的旧文件（历史版本落在 0644）由
+    // ensureConfigFileMode 在启动时收敛，两者配合覆盖新建与存量两种情形。
+    await writeFile(configFile, JSON.stringify(data, null, 2), { encoding: 'utf8', mode: CONFIG_FILE_MODE });
+  }
+
+  // 存量收敛：writeFile 的 mode 不会修改已存在文件的权限位，历史版本已把
+  // config.json 写成 0644（同机其他用户可读）。此处幂等收紧到 0600。
+  // 失败仅告警、不阻断启动（Windows 等平台 chmod 语义不同，且权限收紧
+  // 不应成为插件不可用的原因）。
+  async function ensureConfigFileMode() {
+    try {
+      await access(configFile);
+    } catch (err) {
+      // 仅「文件不存在」属预期（尚未写入，写入时会带上正确 mode）。
+      // 其余错误（EACCES/EIO 等）意味着我们无法确认权限状态，必须出声，
+      // 否则旧版遗留的宽松权限会被静默放过。
+      if (err?.code !== 'ENOENT') {
+        logger.warn('dsh-bridge: 无法检查 config.json 权限状态，跳过收紧：%s', err?.message ?? err);
+      }
+      return;
+    }
+    try {
+      const current = await stat(configFile);
+      const tightened = current.mode & 0o777;
+      if (tightened === CONFIG_FILE_MODE) return;
+      await chmod(configFile, CONFIG_FILE_MODE);
+      logger.info('dsh-bridge: 已将 config.json 权限从 %s 收敛为 0600', tightened.toString(8).padStart(4, '0'));
+    } catch (err) {
+      logger.warn('dsh-bridge: 收紧 config.json 权限失败（不影响运行）：%s', err?.message ?? err);
+    }
   }
 
   // 整对象写入（同样入队，避免与进行中的事务交错）
@@ -2022,7 +2263,7 @@ function apply(ctx, config = {}) {
   }
 
   // 启动时读取已保存的 auth 配置并执行保命标记检查
-  checkEmergencyReset().then(() => loadConfig()).then((stored) => {
+  checkEmergencyReset().then(() => ensureConfigFileMode()).then(() => loadConfig()).then((stored) => {
     if (stored?.auth) {
       if (stored.auth.enabled != null) authManager.enabled = Boolean(stored.auth.enabled);
       if (stored.auth.mode) authManager.mode = stored.auth.mode;
@@ -2053,6 +2294,10 @@ function apply(ctx, config = {}) {
 
   // 启动时读取已保存的局域网网卡配置与公网隧道配置并按需自动拉起
   loadConfig().then(async (stored) => {
+    // 首次启用引导判据（保守）：仅当「访问认证未开启」且「从未展示过引导」时才提示。
+    // 已开启认证的用户、以及已经看过引导的用户一律不再打扰。
+    // 目的：默认监听 0.0.0.0 且认证默认关闭时，让新用户在开箱状态被明确提醒去开门禁。
+    service.firstRunGuidePending = authManager.enabled !== true && stored?.wizard?.guideShown !== true;
     if (stored?.externalTunnel) {
       service.externalTunnelConfig = stored.externalTunnel;
     }
@@ -2201,6 +2446,8 @@ function apply(ctx, config = {}) {
     telegram,
     platformManager,
     logger,
+    // 运行中任务探测所需的引用：探测失败一律降级为「无任务」，不阻断重启
+    runtime: { ctx, platformManager },
     saveCustomTunnelConfig: async (serverUrl, accessToken, sseStreaming) => {
       const stored = await updateConfig((current) => {
         const prev = service.customTunnelConfig ?? {};

package/lib/platform/conversation-bridge.js

@@ -33,13 +33,30 @@ export { textOfAssistantMessage } from './message-split.js'
 
 
 function digestLine(session) {
+  const open = describeOpenTurn(session?.events)
+  if (!open) return null
+  const steps = open.tools > 0 ? `${open.tools} 次工具调用` : '思考中'
+  const last = open.lastTool ? ` | 最近: ${open.lastTool}` : ''
+  return `[处理中] 第 ${open.turn} 轮 | ${steps}${last}`
+}
+
+/**
+ * 判断会话是否有**未闭合**的 turn（即正在跑任务），返回结构化描述或 null。
+ * 依据：事件流里最后一次 turn/start 之后没有配对的 turn/end。
+ * 这是 Web/IM「正在思考 / 工具调用中」的同一判据；消息摘要与重启前探测共用它，
+ * 避免两处各写一套导致结论不一致。
+ *
+ * @param {Array} events 会话事件流（session.events）
+ * @returns {{turn:number, tools:number, lastTool:(string|undefined)}|null}
+ */
+export function describeOpenTurn(events) {
   let turn = 0
   let tools = 0
   let lastTool = undefined
   let inTurn = false
-  for (const event of session.events ?? []) {
+  for (const event of events ?? []) {
     if (event.type === 'turn/start') {
-      turn = event.data.turn
+      turn = event.data?.turn ?? 0
       inTurn = true
       tools = 0
       lastTool = undefined
@@ -47,13 +64,11 @@ function digestLine(session) {
       inTurn = false
     } else if (event.type === 'tool/call' && inTurn) {
       tools += 1
-      lastTool = event.data.name
+      lastTool = event.data?.name
     }
   }
   if (!inTurn || turn === 0) return null
-  const steps = tools > 0 ? `${tools} 次工具调用` : '思考中'
-  const last = lastTool ? ` | 最近: ${lastTool}` : ''
-  return `[处理中] 第 ${turn} 轮 | ${steps}${last}`
+  return { turn, tools, lastTool }
 }
 
 function summarizeError(error) {

package/lib/platform/dsh-storage.js

@@ -50,19 +50,73 @@ function peekCtxProperty(ctx, key) {
   try { return ctx[key] } catch { return undefined }
 }
 
-/** 读取 DSH 官方持久化会话缓存元数据（标题、是否空白、创建时间等） */
+// 读取单个 per-record 投影缓存文件，返回其 record（消费方期望的形状）。
+// 文件形状：{ version, record: { identity, rows } }
+function readProjRecordFile(file) {
+  try {
+    const data = JSON.parse(readFileSync(file, 'utf8'))
+    const record = data?.record
+    if (record && typeof record === 'object') return record
+  } catch { /* 损坏/半写文件：视为无缓存（宿主自身也把该格式视为可丢弃的派生数据） */ }
+  return undefined
+}
+
+/**
+ * 读取 DSH 官方持久化会话缓存元数据（标题、是否空白、创建时间等）。
+ *
+ * DSH 0.1.7 起 `session_projcache` 领域改为 **per-record 布局**：
+ *   `<DSH_HOME>/storages/session_projcache/sessions/<sessionId>.json`（每条会话一个文件，
+ *   顶层 `{ version, record: { identity, rows } }`）。
+ * 0.1.6 及更早则是单文件 `<DSH_HOME>/storages/session_projcache.json`
+ * （`{ tables: { sessions: { <id>: { identity, rows } } } }`）。
+ * 见 @deepseek-ai/dsh-session-projection-cache 的 projectionCacheDomainSpec
+ * （`layout: 'per-record'`）。
+ *
+ * 两种布局都必须支持：只读旧路径会让升级到 0.1.7 的用户标题全部退化为「新会话」，
+ * 只读新路径则会让未升级用户回归。故此处返回一个**按 id 惰性读取**的代理对象：
+ *   - 消费方（session-catalog）只按 sessionId 取值，从不遍历 keys，
+ *     因此无需为一次 /sessions 同步读取数百个文件（本机实测 470 个）；
+ *   - 形状与旧布局一致（直接给出 `{ identity, rows }`），消费方无需感知差异。
+ */
 export function getSessionProjCache(ctx) {
   const injected = peekCtxProperty(ctx, 'sessionProjCache')
   if (injected) return injected
-  try {
-    const home = process.env.DSH_HOME || join(homedir(), '.dsh')
-    const cacheFile = join(home, 'storages', 'session_projcache.json')
-    if (existsSync(cacheFile)) {
-      const data = JSON.parse(readFileSync(cacheFile, 'utf8'))
-      return data?.tables?.sessions || {}
-    }
-  } catch { /* ignore */ }
-  return {}
+
+  const home = process.env.DSH_HOME || join(homedir(), '.dsh')
+  const legacyFile = join(home, 'storages', 'session_projcache.json')
+  const recordDir = join(home, 'storages', 'session_projcache', 'sessions')
+
+  // 旧布局（0.1.6-）：整份读入，形状已与消费方一致
+  const legacy = (() => {
+    try {
+      if (!existsSync(legacyFile)) return null
+      const data = JSON.parse(readFileSync(legacyFile, 'utf8'))
+      const sessions = data?.tables?.sessions
+      return sessions && typeof sessions === 'object' ? sessions : null
+    } catch { return null }
+  })()
+
+  // 新布局（0.1.7+）：按 id 惰性读单文件；legacy 命中时优先用 legacy
+  const cache = new Map()
+  return new Proxy(legacy ?? {}, {
+    get(target, prop) {
+      if (typeof prop !== 'string') return Reflect.get(target, prop)
+      if (Object.prototype.hasOwnProperty.call(target, prop)) return target[prop]
+      if (cache.has(prop)) return cache.get(prop)
+      let record
+      try {
+        const file = join(recordDir, `${prop}.json`)
+        if (existsSync(file)) record = readProjRecordFile(file)
+      } catch { /* 读取失败视为无缓存 */ }
+      cache.set(prop, record)
+      return record
+    },
+    has(target, prop) {
+      if (typeof prop === 'string' && Object.prototype.hasOwnProperty.call(target, prop)) return true
+      if (typeof prop !== 'string') return Reflect.has(target, prop)
+      try { return existsSync(join(recordDir, `${prop}.json`)) } catch { return false }
+    },
+  })
 }
 
 /** 读取 DSH 官方注册的工作区列表及各自绑定的 sessionIds 列表 */