dsh-crossterm 0.8.4 → 0.8.6

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # dsh-crossterm 变更记录
 
+## 0.8.6 — 2026-10-19
+
+### 云端设备列表：只列别人，带权限和状态
+
+- **不显示本机**：`/crossterm/api/devices` 与卡片「云端设备」行都过滤掉本机 ——
+  本机已经在「当前终端」一栏，列在设备里等于把自己当远端。
+- **每台标角色**：`annotateDevices(list, { selfId, ownerDevice })`（`lib/web.js` 导出，纯函数可测）；
+  角色取云端 `_account.json` 的 `ownerDevice`：是它 → **管理员**，其余 → **成员**。
+- **离线时间口径修正**：以前只读 `updatedAt`，新布局心跳写的是 `at`，离线设备全显示「未知」；
+  现在按 `updatedAt → at → lastSeen` 依次取，显示「x 分钟前」。
+- **`term_list` 云端行带角色**：`lib/cloud/match.js` 的 `deviceRow()` 增 `role`；
+  `Term.cloudDevices()` 过滤本机，跨设备匹配更干净。
+- 探针 `probe-devices-086.mjs` **11 PASS**（排除本机、剔除无 nodeId、管理员/成员、字段保留、
+  at 三种来源、已有 role 不覆盖、空列表）。
+- **要不要跟着动手：不用**（纯展示改动，装上即可）。
+
+## 0.8.5 — 2026-10-19
+
+### 负责人留痕 + 运行日志可查（日志轮转）
+
+- **负责人写清楚**：新增 `MAINTAINERS.md` —— 任期表（起止时间精确到分钟）、换人时怎么改、
+  机器可读注释（`<!-- maintainers {...} -->`）。当前负责人 `session-b6aa099b…`（TS-01），
+  助手 `session-ccf34a5a…`（同端多会话2），上一任 `session-6ef6da30…`（2026-10-18 01:09 因会话故障交卸）。
+- **换人及时更正**：插件启动时对比 `MAINTAINERS.md` 里的当前负责人，一变就往
+  `<busDir>\logs\ownership.log` 追加一行（`logs/ownership-seen.json` 记住已记录的人，不重复写）；
+  `GET /crossterm/api/logs` 一并返回最近 10 条负责人变更，卡片刻「维护者」一栏。
+- **日志不再无限涨**：`<busDir>\logs\<nodeId>.jsonl` 超过 `logMaxBytes`（默认 5 MB）就压成
+  `logs/archive/<nodeId>-<时间戳>.jsonl.gz`，只留最近 `logKeep` 份（默认 20）；写日志时每 200 行检查一次。
+- **方便调阅**：新增 `GET /crossterm/api/logs?lines=120`（要接口令牌），返回当前文件、大小、归档清单、
+  最近 N 行（当前不够时自动接上一个归档的尾巴）；卡片底部新增「运行日志」按钮，点开即看。
+- 探针 `probe-logs-maintainers.mjs` **22 PASS**（轮转/清空/归档/清单/行数上限/keep、负责人解析、
+  首次记录、重复不记、about 带 maintainers）。
+- **要不要跟着动手：不用**（装上即可；想让日志更早归档可改 `config.json` 的 `logMaxBytes`）。
+
 ## 0.8.4 — 2026-10-19
 
 ### 修备份统计口径：卡片上「已归档 0/24 · 活跃中 38/10」

package/MAINTAINERS.md

@@ -0,0 +1,73 @@
+# 维护者：这个插件由谁在改
+
+插件目录 `F:\dsh\001X\dsh-crossterm`（npm 包 `dsh-crossterm`）只有「当前负责人」能直接改代码，
+其他会话只读（助手会话按主负责人的派活改 `lib/*.js`）。换人时要**及时**更正这里
+（发现换人就当天改，别拖到下次发版），并留下可核对的时间，事后能查清「哪一版是谁做的」。
+
+<!-- maintainers
+{
+  "current": {
+    "session": "session-b6aa099b-cfa6-42b7-961c-10f720236219",
+    "short": "b6aa099b",
+    "name": "互通插件主维护",
+    "role": "负责人",
+    "terminal": "TS-01",
+    "nodeId": "ts-01-a52535",
+    "since": "2026-10-18T00:59:27+08:00",
+    "basis": "用户交接：原负责人会话故障，指定本会话接手"
+  },
+  "assistant": {
+    "session": "session-ccf34a5a-ad6d-4423-9fa8-fd6ffc44052b",
+    "short": "ccf34a5a",
+    "name": "同端多会话2",
+    "role": "助手",
+    "terminal": "TS-01",
+    "nodeId": "ts-01-a52535",
+    "since": "2026-10-18T00:00:00+08:00",
+    "scope": "按负责人派活改 lib/*.js；不得改版本号、总线状态、重启、C 盘写入、AGENTS.md"
+  },
+  "previous": [
+    {
+      "session": "session-6ef6da30-a7f1-4a4e-...",
+      "short": "6ef6da30",
+      "name": "互通插件主维护（初版）",
+      "role": "负责人",
+      "terminal": "TS-01",
+      "nodeId": "ts-01-a52535",
+      "from": "2026-10-17T20:30:15+08:00",
+      "to": "2026-10-18T01:09:28+08:00",
+      "reason": "会话故障（投递不消费，转录停在 5.2 MB），用户改派"
+    }
+  ]
+}
+-->
+
+## 任期表
+
+| 起（本地时间） | 止（本地时间） | 会话 | 终端 / nodeId | 角色 | 交接依据 |
+| --- | --- | --- | --- | --- | --- |
+| 2026-10-17 20:30 | 2026-10-18 01:09 | `session-6ef6da30…`（初版负责人） | TS-01 / `ts-01-a52535` | 负责人 | 会话故障，转录停止增长、投递不消费；用户改派 |
+| 2026-10-18 00:59 | 至今 | `session-b6aa099b…`（互通插件主维护） | TS-01 / `ts-01-a52535` | 负责人 | 用户首条指令：「你现在是互通插件的新负责人」 |
+| 2026-10-17 21:44 | 至今（按派活） | `session-ccf34a5a…`（同端多会话2） | TS-01 / `ts-01-a52535` | 助手 | 用户：「指定同端多会话2为你的助手，部分修改可让他进行」 |
+
+时间口径：接手取该会话转录 `session.v4.jsonl.zstd` 的**创建时间**，交卸取其**最后写入时间**（本机 `C:\Users\Administrator\.dsh\sessions\--F-dsh-001X--\<会话>\`）。
+
+## 换人时怎么做（缺一步都算没交接）
+
+1. **改这张表**：给旧负责人补「止」时间，给新负责人补「起」时间（精确到分钟），写清交接依据（用户原话或故障证据）。
+2. **改上面的 JSON 注释**：`current` 换成新负责人，旧的推进 `previous[]`；助手变动同步 `assistant`。卡片与 `GET /crossterm/api/about` 的「维护者」一栏读的就是这段。
+3. **记一条日志**：往总线日志目录追加 `logs/ownership.log`，一行一个 JSON（见下）。
+4. **CHANGELOG 提一句**：当版写「负责人变更：… → …（时间，依据）」。
+5. **通知相关会话**：在链上用 `term_send` / `term_broadcast` 说明移交，并提醒对方不要再按旧负责人办事。
+
+`logs/ownership.log` 每行一条，格式：
+
+```json
+{"at":"2026-10-18T00:59:27+08:00","from":"6ef6da30","to":"b6aa099b","role":"负责人","basis":"用户交接：原负责人会话故障"}
+```
+
+## 规则（与 AGENTS.md §7 一致）
+
+- 只有当前负责人能改 `F:\dsh\001X\dsh-crossterm\`；其他会话可以测、可以报 bug、不能改。
+- 助手只能按负责人的派活改，且不得动版本号、总线状态文件、重启、C 盘写入、`AGENTS.md`。
+- 换人不是「口头说说」：没更新本文件、没写 `logs/ownership.log`，就还是旧负责人在负责。

package/README.md

@@ -28,19 +28,30 @@ A 终端看不到 B 终端里有哪个会话、在干什么，也没法把一条
 > `locatePkgJson()` 对子路径行返回 undefined），而插件页顶部标题与这一行共用同一份 `locale/zh.json` 的 meta，
 > 所以它单独做总开关，标题带「（总开关）」；卡片头用 `shortTitle` 显示短名「跨端互通」。
 
-**本版更新（0.8.4）**
+**本版更新（0.8.6）**
 
-- **修上一版的一个统计口径**：0.8.3 卡片一度显示 `已归档 0/24 · 活跃中 38/10`（历史备份记录里没有归档标记，
-  被当成没备过、还算进了活跃）。现在按「状态里有字节」算已备，显示恢复成 `已归档 24/24 · 活跃中 10/10`。
-- 备份行为本身没变：归档会话仍然只传一次，活跃会话仍按水位增量。
+- **云端设备只列「别人」**：卡片里那行不再显示本机（自己已经在「当前终端」一栏），
+  只列同一账号下的其他设备，避免把「本机」也当远端看。
+- **每台带权限和状态**：逐台显示 `名称 · 管理员/成员 · 在线/离线（x 分钟前）· v版本号`。
+  管理员就是云端 `_account.json` 里 `ownerDevice` 那台；其余都是成员。
+- **离线时间不再显示「未知」**：以前只认 `updatedAt`，新布局心跳写的是 `at`，
+  于是离线设备一律「未知」；现在按 `updatedAt → at → lastSeen` 依次取，显示「x 分钟前」。
+- **`term_list` 的云端行也带角色**：agent 侧看到的云端设备行同样标管理员/成员。
+- 纯展示改动，装上即可，无需改动配置。
 
-**上一版（0.8.3）**
+**上一版（0.8.5）**
 
-- **已归档会话不再反复备份**：备份前先读 DSH 的归档清单（`storages/workspace.json`），
-  归档会话第一次传完就标记，之后每轮直接跳过（本机 24 个已归档、9 个活跃中）。
-- **卡片细分**：「会话备份」行改成 `已归档 24/24 · 活跃中 9/9 · 43.1 MB · 上次 …`，
-  一眼看出哪类备份完了。
-- **活跃会话照旧增量**：从 `_session.json` 的水位往后传，不会重传整份。
+
+
+- **负责人写清楚、换人及时更正**：新增 `MAINTAINERS.md`（任期表 + 换人步骤 + 机器可读注释）。
+  当前负责人 `session-b6aa099b…`（TS-01），助手 `session-ccf34a5a…`（同端多会话2），
+  上一任是 `session-6ef6da30…`（2026-10-18 01:09 因会话故障交卸）。
+  负责人一变，插件启动时自动往 `<busDir>\logs\ownership.log` 记一行。
+- **运行日志存档、可轮转**：`logs\<nodeId>.jsonl` 超过 5 MB 自动压成
+  `logs\archive\<nodeId>-<时间戳>.jsonl.gz`，只留最近 20 份；不再担心日志把盘写满。
+- **方便调阅**：卡片底部新增「运行日志」按钮（看最近 120 行，当前文件不够时接上前一个归档）；
+  接口是 `GET /crossterm/api/logs?lines=120`（需接口令牌），同时返回归档清单与最近 10 条负责人变更。
+- 卡片新增「维护者」一栏，直接显示当前负责人（含上一任与交卸时间）。
 
 **上一版（0.8.2）**
 
@@ -492,8 +503,26 @@ dsh/
 - 收到消息后**会作为用户消息进入会话**，agent 会据此行动——所以总线目录只应放在你信任的位置；
   共享盘方式下，谁能写这个目录，谁就能往你的会话里塞话。
 - 文件落地目录可被 agent 读写，`inboxDir` 建议指向专门目录而非系统目录。
-- **谁能改这个插件**：主维护会话 = 桌面端那条长会话（`session-6ef6da30-…`）。其他会话（QQ 会话、别的终端/窗口）
-  默认只读，可协助测试与报 bug；**要改代码必须经用户明确点名允许**（见工作区 `AGENTS.md` 第 7 条）。
+- **谁能改这个插件**：看仓库根目录的 [`MAINTAINERS.md`](./MAINTAINERS.md)。当前负责人是
+  `session-b6aa099b…`（TS-01 / `ts-01-a52535`，自 2026-10-18 00:59），助手是 `session-ccf34a5a…`
+  （同端多会话2，只能按负责人派活改 `lib/*.js`）。其他会话（QQ 会话、别的终端/窗口）默认只读，
+  可协助测试与报 bug；**要改代码必须经用户明确点名允许**（见工作区 `AGENTS.md` 第 7 条）。
+
+### 八.1 负责人怎么交接、日志在哪
+
+- **换人**：改 `MAINTAINERS.md` 的任期表（起止时间精确到分钟），同步改文件顶部那段
+  `<!-- maintainers {...} -->` 注释（卡片与 `/crossterm/api/about` 的「维护者」读的就是它），
+  再在当版 `CHANGELOG.md` 写一句「负责人变更：… → …」。插件下次启动会把变更追加到
+  `<busDir>\logs\ownership.log`，两次启动之间不会重复写。
+- **时间口径**：接手取会话转录 `session.v4.jsonl.zstd` 的创建时间，交卸取它的最后写入时间
+  （本机在 `C:\Users\<你>\.dsh\sessions\--F-dsh-001X--\<会话>\`）。
+- **运行日志**：`<busDir>\logs\<nodeId>.jsonl`，一行一个 JSON（`{at, line}`）。
+  超过 `logMaxBytes`（默认 5 MB）自动压成 `logs\archive\<nodeId>-<时间戳>.jsonl.gz`，
+  只留最近 `logKeep` 份（默认 20）。
+- **怎么调阅**：卡片底部「运行日志」按钮看最近 120 行；或
+  `curl -H "x-crossterm-token: <令牌>" "http://127.0.0.1:19387/crossterm/api/logs?lines=200"`
+  （令牌先 `GET /crossterm/api/token` 取）；也可以直接读
+  `logs\ownership.log`（负责人变更）和 `logs\update.log`（更新过程）。
 
 ## 九、开发自测
 

package/client/client.js

@@ -175,13 +175,15 @@ window.__ModuleLoader__.load({
 			if (!(status && status.cloud && status.cloud.configured)) return "未连接云盘";
 			if (!devices || devices.loading) return "读取中…";
 			if (!devices.ok) return devices.message || "读取失败";
-			const list = devices.devices || [];
+			const list = (devices.devices || []).filter((d) => d && (!devices.me || d.nodeId !== devices.me));
 			if (!list.length) return "云端还没有其他设备";
 			return list
 				.map((d) => {
-					const label = (d.name || d.nodeId || "未知设备") + (d.nodeId === devices.me ? "（本机）" : "");
-					const state = d.online ? "在线" : agoText(d.updatedAt);
-					return label + " · " + state + (d.version ? " · v" + d.version : "");
+					const label = d.name || d.nodeId || "未知设备";
+					const role = d.role || "成员";
+					const at = d.updatedAt || d.at || (d.lastSeen ? Date.parse(d.lastSeen) : 0);
+					const state = d.online ? "在线" : agoText(at);
+					return label + " · " + role + " · " + state + (d.version ? " · v" + d.version : "");
 				})
 				.join("；");
 		}
@@ -194,6 +196,32 @@ window.__ModuleLoader__.load({
 			return (n / 1024 / 1024 / 1024).toFixed(2) + " GB";
 		}
 
+		function maintainersText(about) {
+			const m = about && about.maintainers;
+			const cur = m && m.current;
+			if (!cur) return "";
+			const since = String(cur.since || "").slice(0, 10);
+			const bits = [];
+			bits.push(`${cur.name || cur.short || "负责人"}（${cur.short || ""}）`);
+			if (since) bits.push(`自 ${since}`);
+			if (cur.terminal) bits.push(cur.terminal);
+			const prev = m && m.previous;
+			const head = bits.join(" · ");
+			return prev ? `${head}（上一任：${prev.short || prev.name || "—"}，止 ${String(prev.to || "").slice(0, 10)}）` : head;
+		}
+
+		function runLogText(log) {
+			if (!log || !log.lines) return "";
+			return log.lines
+				.map((row) => {
+					const at = String(row.at || "");
+					const stamp = at ? at.slice(11, 19) : "--:--:--";
+					return `${stamp}  ${row.line || ""}`;
+				})
+				.join("\n");
+		}
+
+
 		function backupText(backup) {
 			if (!backup || !backup.files) return "还没有备份（会在开云同步后自动开始）";
 			const when = backup.lastAt ? agoText(backup.lastAt) : "未知";
@@ -212,6 +240,8 @@ window.__ModuleLoader__.load({
 			const [devices, setDevices] = React.useState(null);
 			const [about, setAbout] = React.useState(null);
 			const [showLog, setShowLog] = React.useState(false);
+			const [runLog, setRunLog] = React.useState(null);
+			const [showRunLog, setShowRunLog] = React.useState(false);
 
 			const load = React.useCallback(() => {
 				call("/crossterm/api/status")
@@ -251,6 +281,25 @@ window.__ModuleLoader__.load({
 					.catch(() => {});
 			}, [open, about]);
 
+			// 运行日志（0.8.5）：点开才读，读最近 120 行，含上一个归档的尾巴
+			const onRunLog = async () => {
+				if (showRunLog) {
+					setShowRunLog(false);
+					return;
+				}
+				setBusy("logs");
+				try {
+					const data = await call("/crossterm/api/logs?lines=120");
+					setRunLog(data);
+					setShowRunLog(Boolean(data && data.ok));
+					if (!data || !data.ok) setMsg("日志读取失败：" + ((data && data.message) || "未知错误"));
+				} catch (error) {
+					setMsg("日志读取失败：" + String((error && error.message) || error));
+				} finally {
+					setBusy("");
+				}
+			};
+
 			const onCheck = async () => {
 				setBusy("check");
 				setMsg("正在检查更新…");
@@ -433,6 +482,12 @@ window.__ModuleLoader__.load({
 							label: "当前终端",
 							value: status ? `${status.node}（${status.nodeId}）· ${status.hostname}` : "",
 						}),
+						about && about.maintainers
+							? h(FriendlyRow, {
+								label: "维护者",
+								value: maintainersText(about),
+							})
+							: null,
 						h(
 							"div",
 							{ style: S.grid },
@@ -516,12 +571,33 @@ window.__ModuleLoader__.load({
 							? h(
 								"div",
 								{ style: { display: "flex", flexDirection: "column", gap: 8 } },
-								h("div", null, h(
-									"button",
-									{ style: S.btn, onClick: () => setShowLog((v) => !v) },
-									showLog ? "收起更新日志" : "更新日志",
-								)),
+								h(
+									"div",
+									{ style: { display: "flex", gap: 8, flexWrap: "wrap" } },
+									h(
+										"button",
+										{ style: S.btn, onClick: () => setShowLog((v) => !v) },
+										showLog ? "收起更新日志" : "更新日志",
+									),
+									h(
+										"button",
+										{ style: S.btn, onClick: () => void onRunLog(), disabled: busy !== "" },
+										busy === "logs" ? "读取中…" : showRunLog ? "收起运行日志" : "运行日志",
+									),
+								),
 								showLog ? h("div", { style: S.log }, about.changelog) : null,
+								showRunLog && runLog
+									? h(
+										"div",
+										null,
+										h(
+											"div",
+											{ style: { fontSize: 11, opacity: 0.7, marginBottom: 4 } },
+											`${runLog.file || "日志"} · 当前 ${sizeText(runLog.bytes)} · 归档 ${(runLog.archives || []).length} 份${runLog.fromArchive ? ` · 含归档 ${runLog.fromArchive}` : ""}`,
+										),
+										h("div", { style: S.log }, runLogText(runLog) || "（暂无日志）"),
+									)
+									: null,
 							)
 							: null,
 					),

package/lib/bus.js

@@ -21,8 +21,9 @@ import fsp from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
 import crypto from 'node:crypto'
+import { rotateIfNeeded } from './logs.js'
 
-export const VERSION = '0.8.4'
+export const VERSION = '0.8.6'
 
 /** DSH 的家目录：与宿主其它状态（sessions / profiles）同一个根，多终端天然共享 */
 export function dshHome() {
@@ -72,6 +73,9 @@ const DEFAULTS = {
   relayIntervalMs: 20000,
   backupIntervalMs: 300000,
   presenceIntervalMs: 60000,
+  // 运行日志（logs/<nodeId>.jsonl）：超过 logMaxBytes 就压成 archive/*.jsonl.gz，只留最近 logKeep 份
+  logMaxBytes: 5 * 1024 * 1024,
+  logKeep: 20,
   backupSessionsPerRun: 20,
   backupAttachmentsPerRun: 20,
   attachmentBackupEnabled: true,
@@ -680,6 +684,17 @@ export class Bus {
         `${JSON.stringify({ at: new Date().toISOString(), line: String(line) })}\n`,
         'utf8',
       )
+      // 每写若干行看一次大小，超上限压成 archive/<node>-<时间>.jsonl.gz，只留最近若干份
+      this._logWrites = (this._logWrites || 0) + 1
+      if (this._logWrites % 200 === 1) {
+        const cfg = this.cfg || {}
+        await rotateIfNeeded({
+          dir: this.logsDir,
+          nodeId,
+          maxBytes: cfg.logMaxBytes,
+          keep: cfg.logKeep,
+        })
+      }
     } catch {
       /* 日志失败不影响主流程 */
     }

package/lib/cloud/match.js

@@ -34,6 +34,7 @@ export function deviceRow(d) {
     hostname: d.hostname || '',
     workspace: '',
     pid: d.pid,
+    role: d.role || '',
     ageMs: Number(d.at) ? Math.max(0, Date.now() - Number(d.at)) : 0,
     online: d.online !== false,
     sessions: [],

package/lib/index.js

@@ -29,6 +29,7 @@ import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import crypto from 'node:crypto'
+import { fileURLToPath } from 'node:url'
 import { defineTool } from '@deepseek-ai/dsh-tools'
 import {
   Bus, VERSION, formatBytes, makeUniqueCode, normalizeCode, readConfig, readJson, slugify, stamp, writeConfig,
@@ -40,8 +41,10 @@ import { createCloudHome } from './cloud/home.js'
 import { runSetup } from './cloud/setup.js'
 import { deviceRow, matchDevice } from './cloud/match.js'
 import { registerWeb } from './web.js'
+import { recordOwnership } from './logs.js'
 
 const PLUGIN = 'dsh-crossterm'
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
 
 function textRender(fn) {
   return (_args, value) => [{ type: 'text', text: fn(value) }]
@@ -345,12 +348,13 @@ class CrossTerm {
 
   // ── 云端设备（跨设备投递，0.7.3 起）─────────────────────────────────
 
-  /** 云端设备列表：没连云端、没布局、或还读不到时统一回空数组 */
+  /** 云端设备列表：没连云端、没布局、或还读不到时统一回空数组（0.8.6 起不含本机） */
   async cloudDevices() {
     if (!this.home) return []
     try {
       const r = await this.home.devices()
-      return r && r.ok && Array.isArray(r.devices) ? r.devices : []
+      const list = r && r.ok && Array.isArray(r.devices) ? r.devices : []
+      return list.filter((d) => d && d.nodeId && d.nodeId !== this.nodeId)
     } catch (e) {
       this.warn(`cloudDevices: ${(e && e.message) || String(e)}`)
       return []
@@ -1396,6 +1400,8 @@ class CrossTerm {
     if (this.started) return
     this.started = true
     await this.bus.ensure()
+    // 负责人变更留痕：MAINTAINERS.md 里的当前负责人一变，就往 logs/ownership.log 记一行
+    await recordOwnership({ dir: this.bus.logsDir, root: ROOT }).catch(() => {})
     await this.loadLinks()
     await this.note(`links loaded: ${this.links.size} 条`)
     await this.loadNames()

package/lib/logs.js

@@ -0,0 +1,192 @@
+import fs from 'node:fs'
+import fsp from 'node:fs/promises'
+import path from 'node:path'
+import zlib from 'node:zlib'
+
+/**
+ * 运行日志的落盘与轮转。
+ *
+ * 位置：`<busDir>\logs\<nodeId>.jsonl`（一行一个 JSON，{at, line}）
+ * 归档：`<busDir>\logs\archive\<nodeId>-<时间戳>.jsonl.gz`，只留最近 keep 份
+ * 目的：长期跑下来日志不会无限涨，出问题时又能翻到上一轮、上上一轮的记录。
+ */
+
+export const DEFAULT_MAX_BYTES = 5 * 1024 * 1024
+export const DEFAULT_KEEP = 20
+
+export function logFile(dir, nodeId) {
+  return path.join(dir, `${nodeId}.jsonl`)
+}
+
+export function archiveDir(dir) {
+  return path.join(dir, 'archive')
+}
+
+async function pruneArchives(dir, keep) {
+  const removed = []
+  try {
+    const names = (await fsp.readdir(archiveDir(dir))).filter((n) => n.endsWith('.jsonl.gz')).sort()
+    const over = names.length - Math.max(1, Number(keep) || DEFAULT_KEEP)
+    for (let i = 0; i < over; i += 1) {
+      const name = names[i]
+      await fsp.rm(path.join(archiveDir(dir), name), { force: true })
+      removed.push(name)
+    }
+  } catch {
+    /* 归档目录不存在或读失败：不算错 */
+  }
+  return removed
+}
+
+/**
+ * 超过上限就把当前日志压成归档并清空。
+ * @returns {Promise<null|{name:string,bytes:number,gz:number,removed:string[]}>}
+ */
+export async function rotateIfNeeded({ dir, nodeId, maxBytes = DEFAULT_MAX_BYTES, keep = DEFAULT_KEEP } = {}) {
+  if (!dir || !nodeId) return null
+  const file = logFile(dir, nodeId)
+  let st
+  try {
+    st = await fsp.stat(file)
+  } catch {
+    return null
+  }
+  if (st.size < (Number(maxBytes) || DEFAULT_MAX_BYTES)) return null
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-')
+  const name = `${nodeId}-${stamp}.jsonl.gz`
+  const body = await fsp.readFile(file)
+  const gz = zlib.gzipSync(body)
+  await fsp.mkdir(archiveDir(dir), { recursive: true })
+  await fsp.writeFile(path.join(archiveDir(dir), name), gz)
+  // 清空而不是删除：保留 inode/权限，别的进程正在写也不会断
+  await fsp.writeFile(file, '', 'utf8')
+  const removed = await pruneArchives(dir, keep)
+  return { name, bytes: st.size, gz: gz.length, removed }
+}
+
+/** 从 MAINTAINERS.md 的机器可读注释里取负责人（当前 / 上一任 / 助手） */
+export function readMaintainersDoc(root) {
+  try {
+    const text = fs.readFileSync(path.join(root, 'MAINTAINERS.md'), 'utf8')
+    const m = text.match(/<!--\s*maintainers\s*([\s\S]*?)-->/)
+    if (!m) return null
+    const doc = JSON.parse(m[1])
+    const list = Array.isArray(doc.previous) ? doc.previous : []
+    return {
+      current: doc.current || null,
+      previous: list.length ? list[list.length - 1] : null,
+      assistant: doc.assistant || null,
+    }
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 负责人变了就在 `logs/ownership.log` 追加一行（一行一个 JSON），
+ * 并在 `logs/ownership-seen.json` 记住已记录的那一位，避免每次启动重复写。
+ */
+export async function recordOwnership({ dir, root } = {}) {
+  if (!dir || !root) return null
+  const doc = readMaintainersDoc(root)
+  const cur = doc && doc.current
+  if (!cur || !cur.short) return null
+  const seenFile = path.join(dir, 'ownership-seen.json')
+  let seen = null
+  try {
+    seen = JSON.parse(await fsp.readFile(seenFile, 'utf8'))
+  } catch {
+    seen = null
+  }
+  if (seen && seen.current === cur.short && seen.session === cur.session) return null
+  const line = {
+    at: new Date().toISOString(),
+    role: cur.role || '负责人',
+    to: cur.short,
+    session: cur.session || '',
+    terminal: cur.terminal || '',
+    nodeId: cur.nodeId || '',
+    since: cur.since || '',
+    basis: cur.basis || '',
+    previous: doc.previous ? { short: doc.previous.short || '', to: doc.previous.to || '' } : null,
+  }
+  await fsp.mkdir(dir, { recursive: true })
+  await fsp.appendFile(path.join(dir, 'ownership.log'), `${JSON.stringify(line)}\n`, 'utf8')
+  await fsp.writeFile(seenFile, JSON.stringify({ current: cur.short, session: cur.session || '', at: line.at }), 'utf8')
+  return line
+}
+
+/** 读负责人变更记录（最近 limit 条，新的在前） */
+export async function listOwnership({ dir, limit = 20 } = {}) {
+  const out = []
+  if (!dir) return out
+  try {
+    const text = await fsp.readFile(path.join(dir, 'ownership.log'), 'utf8')
+    for (const raw of text.split('\n').filter(Boolean)) {
+      try {
+        out.push(JSON.parse(raw))
+      } catch {
+        /* 坏行跳过 */
+      }
+    }
+  } catch {
+    return out
+  }
+  return out.slice(-Math.max(1, Number(limit) || 20)).reverse()
+}
+
+export async function listLogs({ dir, nodeId } = {}) {
+  const out = { file: '', bytes: 0, archives: [] }
+  if (!dir || !nodeId) return out
+  out.file = logFile(dir, nodeId)
+  try {
+    const st = await fsp.stat(out.file)
+    out.bytes = st.size
+    out.at = st.mtime.toISOString()
+  } catch {
+    out.bytes = 0
+  }
+  try {
+    const names = (await fsp.readdir(archiveDir(dir))).filter((n) => n.endsWith('.jsonl.gz')).sort().reverse()
+    for (const name of names) {
+      const full = path.join(archiveDir(dir), name)
+      const st = await fsp.stat(full).catch(() => null)
+      out.archives.push({ name, bytes: st ? st.size : 0, at: st ? st.mtime.toISOString() : '' })
+    }
+  } catch {
+    /* 没归档 */
+  }
+  return out
+}
+
+/** 读最近 lines 行（当前文件；不够时可带上前一个归档的尾巴） */
+export async function tailLogs({ dir, nodeId, lines = 100, withArchive = false } = {}) {
+  const want = Math.max(1, Math.min(2000, Number(lines) || 100))
+  const out = { file: '', lines: [], truncated: false, fromArchive: '' }
+  if (!dir || !nodeId) return out
+  out.file = logFile(dir, nodeId)
+  let text = ''
+  try {
+    text = await fsp.readFile(out.file, 'utf8')
+  } catch {
+    text = ''
+  }
+  let rows = text.split('\n').filter(Boolean)
+  out.truncated = rows.length > want
+  if (rows.length < want && withArchive) {
+    try {
+      const names = (await fsp.readdir(archiveDir(dir))).filter((n) => n.endsWith('.jsonl.gz')).sort()
+      const last = names[names.length - 1]
+      if (last) {
+        const gz = await fsp.readFile(path.join(archiveDir(dir), last))
+        const prev = zlib.gunzipSync(gz).toString('utf8').split('\n').filter(Boolean)
+        out.fromArchive = last
+        rows = prev.slice(-(want - rows.length)).concat(rows)
+      }
+    } catch {
+      /* 归档读不到就只给当前的 */
+    }
+  }
+  out.lines = rows.slice(-want)
+  return out
+}

package/lib/web.js

@@ -8,9 +8,10 @@ import { fileURLToPath } from 'node:url'
 import { spawn } from 'node:child_process'
 import { VERSION, readConfig, writeConfig } from './bus.js'
 import { createPan } from './cloud/pan.js'
-import { listCloudDevices, localDevice } from './cloud/devices.js'
+import { listCloudDevices } from './cloud/devices.js'
 import { listPresences } from './cloud/presence.js'
 import { runSetup } from './cloud/setup.js'
+import { listLogs, tailLogs, readMaintainersDoc, listOwnership } from './logs.js'
 
 const PKG = 'dsh-crossterm'
 const NPM_REGISTRIES = ['https://registry.npmmirror.com', 'https://registry.npmjs.org']
@@ -157,6 +158,22 @@ function cloudProvider(cfg) {
   return { id: 'none', name: '未连接', configured: false }
 }
 
+/**
+ * 云端设备列表的展示口径（0.8.6 起）：
+ * - 不显示本机（自己已经在「当前终端」那一行）；
+ * - 每台标上账号里的角色：`_account.json` 的 `ownerDevice` 是管理员，其余是成员；
+ * - 保底字段：`role` / `online` / `at`（离线时卡片用它算「x 分钟前」）。
+ */
+export function annotateDevices(list, { selfId = '', ownerDevice = '' } = {}) {
+  return (Array.isArray(list) ? list : [])
+    .filter((d) => d && d.nodeId && d.nodeId !== selfId)
+    .map((d) => ({
+      ...d,
+      role: d.role || (d.nodeId === ownerDevice ? '管理员' : '成员'),
+      at: Number(d.at || 0) || (d.lastSeen ? Date.parse(d.lastSeen) || 0 : 0) || (d.updatedAt ? Number(d.updatedAt) || 0 : 0),
+    }))
+}
+
 /** 语义化版本比较：只比 主.次.补（忽略预发布尾巴），a>b 返回正数 */
 function compareVersion(a, b) {
   const num = (v) => String(v || '').split('-')[0].split('.').map((x) => parseInt(x, 10) || 0)
@@ -466,6 +483,11 @@ function readChangelog(maxSections = 3, maxChars = 6000) {
   }
 }
 
+/** 从 MAINTAINERS.md 的机器可读注释里取当前/上一任负责人 */
+function readMaintainers() {
+  return readMaintainersDoc(ROOT)
+}
+
 function aboutOf() {
   if (aboutCache && aboutCache.version === VERSION) return aboutCache
   let meta = {}
@@ -492,6 +514,7 @@ function aboutOf() {
     shortTitle: meta.shortTitle || meta.title || PKG,
     description: meta.description || '',
     components,
+    maintainers: readMaintainers(),
     changelog: readChangelog(),
   }
   return aboutCache
@@ -544,6 +567,45 @@ export function registerWeb(ctx, term, log) {
             },
           }),
         )
+        disposers.push(
+          webCtx.webServer.register({
+            kind: 'exact',
+            path: '/crossterm/api/logs',
+            handler: async (req, res) => {
+              if (!checkHttp(req, res, term.cfg)) return
+              try {
+                const cfg = term.cfg || {}
+                const dir = path.join(cfg.busDir || path.join(os.homedir(), '.dsh', 'crossterm'), 'logs')
+                const nodeId = String(term.nodeId || 'node')
+                const url = new URL(String(req.url || '/'), 'http://127.0.0.1')
+                const lines = Number(url.searchParams.get('lines') || 120)
+                const info = await listLogs({ dir, nodeId })
+                const tail = await tailLogs({ dir, nodeId, lines, withArchive: true })
+                const ownership = await listOwnership({ dir, limit: 10 })
+                json(res, 200, {
+                  ok: true,
+                  nodeId,
+                  file: tail.file,
+                  bytes: info.bytes,
+                  archives: info.archives.slice(0, 10),
+                  truncated: tail.truncated,
+                  fromArchive: tail.fromArchive,
+                  ownership,
+                  lines: tail.lines.map((raw) => {
+                    try {
+                      const row = JSON.parse(raw)
+                      return { at: row.at || '', line: String(row.line || '') }
+                    } catch {
+                      return { at: '', line: String(raw) }
+                    }
+                  }),
+                })
+              } catch (error) {
+                json(res, 200, { ok: false, message: String((error && error.message) || error) })
+              }
+            },
+          }),
+        )
         disposers.push(
           webCtx.webServer.register({
             kind: 'exact',
@@ -577,12 +639,16 @@ export function registerWeb(ctx, term, log) {
                 const byId = new Map()
                 for (const d of result.devices || []) byId.set(d.nodeId, d)
                 for (const d of fresh.devices || []) byId.set(d.nodeId, { ...byId.get(d.nodeId), ...d, source: 'layout' })
-                result.devices = [...byId.values()].sort((a, b) => Number(b.lastSeen ? Date.parse(b.lastSeen) : b.at || 0) - Number(a.lastSeen ? Date.parse(a.lastSeen) : a.at || 0))
+                // 0.8.6：列表里不显示本机，只给「其他设备」；每台标上账号里的角色（管理员 = _account.json 的 ownerDevice）
+                const ownerDevice = (layout && layout.accountInfo && layout.accountInfo.ownerDevice) || (layout && layout.deviceId) || ''
+                const selfId = info.nodeId || ''
+                result.devices = annotateDevices([...byId.values()], { selfId, ownerDevice }).sort(
+                  (a, b) => Number(b.lastSeen ? Date.parse(b.lastSeen) : b.at || 0) - Number(a.lastSeen ? Date.parse(a.lastSeen) : a.at || 0),
+                )
                 delete result.tmpFiles
                 result.files = (result.files || 0) + (fresh.files || 0)
-                const me = await localDevice(path.join(cfg.busDir || '', 'presence'), info.nodeId || '')
-                if (me && !result.devices.some((d) => d.nodeId === me.nodeId)) result.devices.unshift(me)
-                json(res, 200, { ...result, configured: true, me: info.nodeId || '' })
+                result.ownerDevice = ownerDevice
+                json(res, 200, { ...result, configured: true, me: selfId })
               } catch (error) {
                 json(res, 200, {
                   ok: false,
@@ -815,4 +881,4 @@ export function registerWeb(ctx, term, log) {
 }
 
 // 只给探针用：把内部小工具导出来，宿主运行时不依赖这些导出
-export { decodeOutput, runtimeTools, looksMissingCommand, updateErrorText, aboutOf }
+export { decodeOutput, runtimeTools, looksMissingCommand, updateErrorText, aboutOf, readMaintainers }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-crossterm",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "description": "跨端互通：同一 DSH 账号下的会话、终端、设备之间互通 —— 特征码链、内联邮件、云端中转站与自动备份",
   "type": "module",
   "main": "./lib/index.js",
@@ -26,7 +26,8 @@
     "parts",
     "cordis.patch.yml",
     "README.md",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    "MAINTAINERS.md"
   ],
   "license": "MIT",
   "author": "crossterm",