dsh-crossterm 0.9.3 → 0.9.4

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 0.9.4 — 2026-10-20
+
+自动重启组件 **0.3.28 → 0.3.29**（只动 `components/restart/**`；由该组件负责人 `a3e9f80e` 提交、主维护会话发版）。插件内其余五个组件不变。
+
+- **忙时判定补第三路信号**：`components/restart/core.js` 每 2 秒把所有 agent 的 `{sessionId,inTurn}` 写 `logs/busy-agents.json`；`scripts/busy-check.mjs` 新增 `heartbeatBusy()`（文件 8 秒内有效，`inTurn` 且不是自己即算忙），`othersBusy()` 合并「市场运行列表 + transcript 写入时间 + 回合心跳」三路，`sources` 记 `heartbeat:busy-agents` / `heartbeat:unavailable`。
+  - 背景：长工具调用期间 transcript 不写盘，市场 `runningAgents` 也会掉出列表 —— 旧的两路判据会把「真在跑」判成空闲，于是在别人干活时重启。
+- **守卫终检**：helper 的等待下限 3000 → **250 ms**；守卫通过后 400 ms 再探一次，有人开工就带剩余预算重新等（最多 3 次，日志 `idle guard recheck#N`）。
+- **倒计时与正计时对齐**：`scripts/countdown.html` 归零后先停在 `00:00` + 「倒计时结束，正在准备重启…」，只有 helper 的 ui-state 进 `killing`/`starting` 才切 `+mm:ss`。
+  - 背景：helper 起得晚时窗口已归零而 helper 还在等，被读成「没读完就变正计时」，实际 kill 还在 `scheduledAt` 之后 1~5 秒。
+
+> 本机是 `link:` 源码版：重启后 `ensureRestartRuntime()` 因版本变化（`.version` 0.9.3 → 0.9.4）把 8 个脚本整组重拷到 `<总线目录>\restart-module`。
+
 ## 0.9.3 — 2026-10-20
 
 修 0.9.2 的两处显示缺陷（代码逻辑没变，只动 `GET /crossterm/api/about` 与 ui 组件清单）：

package/README.md

@@ -23,7 +23,7 @@ A 终端看不到 B 终端里有哪个会话、在干什么，也没法把一条
 | ③ | 跨终端 | v0.9.2 | 同一台机器上的多个 DSH 终端/进程之间互发邮件与文件 | `term_whoami` `term_list` `term_send` `term_send_files` |
 | ④ | 跨设备 | v0.9.2 | 经云端中转站，在多台机器的 DSH 之间互发邮件与文件 | `term_cloud` |
 | ⑤ | 跨账号 | v0.9.2 | 预留位：后续用于跨账号互通，当前不挂工具 | — |
-| ⑥ | 自动重启 | v0.3.28 | 改完插件/配置后让 DSH 自己重启一次，并自动拉起离线会话（原 `dsh-restart` 插件，0.9.0 起并入） | `dsh_restart` |
+| ⑥ | 自动重启 | v0.3.29 | 改完插件/配置后让 DSH 自己重启一次，并自动拉起离线会话（原 `dsh-restart` 插件，0.9.0 起并入） | `dsh_restart` |
 
 > 入口行为什么必须用裸包名：浏览器 client 半端只对裸包名行生效（`dsh-client-modules` 的
 > `locatePkgJson()` 对子路径行返回 undefined），而插件页顶部标题与这一行共用同一份 `locale/zh.json` 的 meta，
@@ -31,20 +31,18 @@ A 终端看不到 B 终端里有哪个会话、在干什么，也没法把一条
 >
 > 组件版本号怎么升：**只在该组件自己的文件改动时升它**，跟着插件一起发版（例：只改自动重启 → `components/restart` 的 `0.3.28` → `0.3.29`，其余五个不动）。插件总版本仍按发版技能的三分位规则。
 
-**本版更新（0.9.3）**
+**本版更新（0.9.4）**
 
-- **组件表补全**：`GET /crossterm/api/about` 的 `components` 现在按插件页顺序给六个组件 —— 入口、跨会话、跨终端、跨设备、跨账号、自动重启，每个都带 `version`；卡片「包含的组件」不会再漏掉自动重启。
-- **入口组件的名字**：`components/ui/manifest.json` 的 `name` 从 `ui` 改成「跨端互通（入口）」，并补了简介。
-- **组件版本号各升各的**（新规矩第一次落地）：这次只改 ui 组件，所以只有它 0.9.2 → 0.9.3；其余五个仍是 0.9.2，自动重启仍是 0.3.28。
+- **只管本次变动**：插件总版本 0.9.3 → 0.9.4，组件里只有**自动重启 0.3.28 → 0.3.29**，其余五个（入口 0.9.3 / 跨会话 0.9.2 / 跨终端 0.9.2 / 跨设备 0.9.2 / 跨账号 0.9.2）不动。
+- **重启前先确认没人干活（第三路信号）**：插件每 2 秒把「哪些会话正在回合中」写进 `<总线目录>\restart-module\logs\busy-agents.json`，重启守卫读它 —— 长工具调用期间 transcript 不写盘、市场运行列表也会掉，过去靠这两路会误判空闲。
+- **守卫终检 + 倒计时对齐**：守卫放行后 400 ms 再确认一次；倒计时归零先停 `00:00`（「正在准备重启…」），等 helper 真开始杀进程才转正计时。
 
-**上一版（0.9.2）**
+**上一版（0.9.3）**
 
-- **组件分目录存放**：`components/<part>/` 各放各的 `manifest.json` 与代码，`parts/` 删除；原 `lib/restart/` 整体搬进 `components/restart/`。
-- **每个组件有独立版本号**：插件页与更新说明都显示「名称 vX.Y.Z」，方便看清这次改的是哪个组件、由谁维护。
-- **组件维护分出去**：`MAINTAINERS.md` 的 `modules` 段记录每个组件的负责人；自动重启 = `a3e9f80e`，其余由主维护会话 `b6aa099b` 负责。
-- 兼容：`cordis.patch.yml` 的 `name` 改为 `dsh-crossterm/components/<part>`，`exports` 同步；升级后重启 DSH 生效。
+- 组件表补全：`/crossterm/api/about` 的 `components` 现在六个组件都在（之前漏了自动重启），入口名从 `ui` 改成「跨端互通（入口）」。
+- 组件版本号各升各的第一次落地：那次只改 ui，所以只有它 0.9.2 → 0.9.3。
 
-**更早（0.9.0 / 0.8.14 / 0.8.13 / 0.8.12 / 0.8.11 / 0.8.10 / 0.8.9 / 0.8.8 / 0.8.7 / 0.8.6 / 0.8.5 / 0.8.0）**
+**更早（0.9.2 / 0.9.0 / 0.8.14 / 0.8.13 / 0.8.12 / 0.8.11 / 0.8.10 / 0.8.9 / 0.8.8 / 0.8.7 / 0.8.6 / 0.8.5 / 0.8.0）**
 
 - 0.9.0：自动重启并进来当第 6 个组件（`dsh_restart` + 8 个 helper 脚本），由原 `dsh-restart` 会话继续维护、不再单独发版。
 - 0.8.14：装完未重启时卡片显示「待重启」、更新按钮变灰「已装待重启」，`/check` 回 `needRestart=true`。

package/components/restart/core.js

@@ -465,6 +465,48 @@ function scheduleRevive(root) {
   mark(`revive: scheduled in ${REVIVE_DELAY_MS}ms`)
 }
 
+// ── 忙时心跳 ────────────────────────────────────────────────────────────────
+// 判定「谁还在回合里」最可靠的信号在宿主进程内：agent.session.events 的最后一条是
+// turn/start 还是 turn/end。市场 /dsh-market/status 的 runningAgents 在工具调用期间
+// 会掉出去（实测），transcript mtime 在长工具调用期间也不写盘 —— 两个都会误判空闲。
+// 所以插件每 2 秒把「所有 agent 的 id + 是否在回合中」写成 logs\busy-agents.json，
+// helper 侧的 busy-check.mjs 拿它当第三路信号。
+const BUSY_HEARTBEAT = path.join(LOG_DIR, 'busy-agents.json')
+
+function inTurn(agent) {
+  try {
+    const events = agent && agent.session && agent.session.events
+    if (!events || !events.length) return false
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+      const type = String((events[i] && events[i].type) || '')
+      if (type === 'turn/end') return false
+      if (type === 'turn/start') return true
+    }
+    return false
+  } catch { return false }
+}
+
+function writeBusyHeartbeat(ctx) {
+  try {
+    const seen = new Map()
+    const add = (agent) => {
+      const id = String((agent && agent.id) || '')
+      if (!id || seen.has(id)) return
+      seen.set(id, { sessionId: id, inTurn: inTurn(agent) })
+    }
+    try { for (const agent of ctx.agents.roots()) add(agent) } catch { /* ignore */ }
+    try {
+      for (const s of (ctx.sessions?.list?.() || [])) {
+        try { add(ctx.agents?.get?.(s.id)) } catch { /* ignore */ }
+      }
+    } catch { /* ignore */ }
+    fs.mkdirSync(LOG_DIR, { recursive: true })
+    fs.writeFileSync(BUSY_HEARTBEAT, JSON.stringify({ at: new Date().toISOString(), agents: [...seen.values()] }), 'utf8')
+  } catch (e) {
+    mark(`busy heartbeat failed: ${(e && e.message) || String(e)}`)
+  }
+}
+
 export default {
   name: 'crossterm-restart',
   apply(root) {
@@ -515,6 +557,13 @@ export default {
         return () => clearInterval(timer)
       }, 'dsh-restart: 会话工具补挂')
 
+      writeBusyHeartbeat(ctx)
+      ctx.effect(() => {
+        const timer = setInterval(() => writeBusyHeartbeat(ctx), 2000)
+        if (timer && typeof timer.unref === 'function') timer.unref()
+        return () => clearInterval(timer)
+      }, 'dsh-restart: 忙时心跳')
+
       ctx.on('agent/created', ({ agent }) => mount(agent))
       ctx.on('agent/disposed', ({ agent }) => { mounted.delete(agent) })
       mark('ready')

package/components/restart/manifest.json

@@ -1,5 +1,5 @@
 {
   "name": "自动重启",
   "description": "改完插件/配置后让 DSH 自己重启一次，并自动拉起离线会话（原 dsh-restart 插件，0.9.0 起并入）",
-  "version": "0.3.28"
+  "version": "0.3.29"
 }

package/components/restart/scripts/busy-check.mjs

@@ -9,10 +9,17 @@
 import http from 'node:http'
 import fs from 'node:fs'
 import path from 'node:path'
+import { fileURLToPath } from 'node:url'
 
 export const QUIET_MS = 3000
 export const DEFAULT_PORT = Number(process.env.DSH_RESTART_PORT || 19387)
 
+// 心跳文件：插件（宿主进程内）每 2 秒写一次「谁还在回合中」，比市场 runningAgents
+// （工具调用期间会掉出列表）和 transcript mtime（长工具调用期间不写盘）都准。
+const HERE = path.dirname(fileURLToPath(import.meta.url))
+const HEARTBEAT_FILE = process.env.DSH_BUSY_HEARTBEAT || path.join(HERE, 'logs', 'busy-agents.json')
+const HEARTBEAT_FRESH_MS = Number(process.env.DSH_BUSY_HEARTBEAT_MS || 8000)
+
 const norm = (id) => String(id ?? '').replace(/^session-/, '')
 
 function httpGetJson(port, pathName, timeoutMs) {
@@ -110,16 +117,47 @@ export async function othersBusy({ selfSessionId, port = DEFAULT_PORT, recentMs
   const recent = recentSessionWriter({ selfSessionId: self, recentMs, dshHome })
   if (recent) {
     sources.push(`transcript-mtime(${recentMs}ms)`)
-    if (!busy.some((b) => b.sessionId === recent.sessionId)) {
+    if (!busy.some((b) => norm(b.sessionId) === norm(recent.sessionId))) {
       busy.push({ sessionId: recent.sessionId, why: 'transcript-write' })
     }
   } else {
     sources.push('transcript-mtime:quiet')
   }
 
+  const hb = heartbeatBusy({ selfSessionId: self })
+  if (hb.stale) {
+    sources.push('heartbeat:unavailable')
+  } else {
+    sources.push('heartbeat:busy-agents')
+    for (const item of hb.busy) {
+      if (!busy.some((b) => norm(b.sessionId) === norm(item.sessionId))) busy.push(item)
+    }
+  }
+
   return { busy, sources, checkedAt: new Date().toISOString() }
 }
 
+/** 读插件写的 busy-agents.json：文件够新才采信，其中 inTurn 的会话都算忙。 */
+export function heartbeatBusy({ selfSessionId, heartbeatFile = HEARTBEAT_FILE, freshMs = HEARTBEAT_FRESH_MS } = {}) {
+  try {
+    const stat = fs.statSync(heartbeatFile)
+    if (Date.now() - stat.mtimeMs > freshMs) return { stale: true, busy: [] }
+    const raw = fs.readFileSync(heartbeatFile, 'utf8').replace(/^\uFEFF/, '')
+    const data = JSON.parse(raw)
+    const agents = Array.isArray(data && data.agents) ? data.agents : []
+    const self = norm(selfSessionId)
+    const busy = []
+    for (const agent of agents) {
+      const id = String((agent && agent.sessionId) || '')
+      if (!id || norm(id) === self) continue
+      if (agent && agent.inTurn === true) busy.push({ sessionId: id, why: 'agent-in-turn' })
+    }
+    return { stale: false, busy }
+  } catch {
+    return { stale: true, busy: [] }
+  }
+}
+
 /**
  * 等到「连续 quietMs 内没有其他会话活动」。
  * maxWaitMs=0 表示只探一次（用于排程时的快速拒绝）。

package/components/restart/scripts/countdown.html

@@ -381,23 +381,34 @@ function fitWindow() {
     }
     if (!spawned) { el("clock").textContent = "00:00"; el("fill").style.width = "0%"; zeroAt = Date.now(); spawnHelper(); }
 
-    // 归零后正计时：数字显示已经等了多久，进度条位置换成“加载中”的转圈
+    // 归零后先停在 00:00 等 helper 真动手（守卫可能还在等空闲），
+    // 只有 helper 进入 killing/starting 才切正计时 + 转圈，避免“倒计时没读完就开始 +”。
+    var u = readJson(UI);
+    var phase = u && u.phase ? String(u.phase) : "";
+    var killing = phase === "killing" || phase === "starting";
     if (zeroAt && !done) {
-      el("clock").textContent = "+" + mmss((Date.now() - zeroAt) / 1000);
-      if (el("fill").style.display !== "none") {
-        el("fill").style.display = "none";
-        var bar = el("bar");
-        if (bar) bar.className = "bar off";
-        var sp = el("spin");
-        if (sp) sp.className = "spin on";
-        dbg("spinner on");
+      if (killing) {
+        el("clock").textContent = "+" + mmss((Date.now() - zeroAt) / 1000);
+        if (el("fill").style.display !== "none") {
+          el("fill").style.display = "none";
+          var bar = el("bar");
+          if (bar) bar.className = "bar off";
+          var sp = el("spin");
+          if (sp) sp.className = "spin on";
+          dbg("spinner on");
+        }
+      } else {
+        el("clock").textContent = "00:00";
+        if (el("fill").style.display !== "none") {
+          el("fill").style.width = "0%";
+        }
       }
     }
 
-    var u = readJson(UI);
-    if (u && u.phase === "killing") el("hint").textContent = "正在结束 DSH 进程…";
-    else if (u && u.phase === "starting") el("hint").textContent = "正在启动 DSH…";
-    else if (u && u.phase === "waiting") el("hint").textContent = "等待其他会话空闲后重启…";
+    if (phase === "killing") el("hint").textContent = "正在结束 DSH 进程…";
+    else if (phase === "starting") el("hint").textContent = "正在启动 DSH…";
+    else if (phase === "waiting") el("hint").textContent = "等待其他会话空闲后重启…";
+    else if (zeroAt && !killing) el("hint").textContent = "倒计时结束，正在准备重启…";
 
     var r = readJson(RES);
     var when = r ? Date.parse(r.finishedAt || r.at || "") : NaN;

package/components/restart/scripts/dsh-restart-helper.mjs

@@ -157,7 +157,9 @@ async function main() {
   log(`pre-kill port ${PORT}: ${(await portOpen()) ? 'open' : 'closed'}`);
 
   let waitMs = targetMs - Date.now();
-  if (waitMs < 3000) waitMs = 3000;
+  // 不再强加 3 秒下限：以前 helper 起得比窗口晚时会被推到 scheduledAt 之后，
+  // 窗口那边倒计时已经归零、这边还没动手，于是“没读完就变正计时”。现在只留 250ms 防呆。
+  if (waitMs < 250) waitMs = 250;
   log(`waiting ${waitMs}ms before kill`);
   ui('waiting', `还剩 ${Math.round(waitMs / 1000)} 秒`);
   // 等待期间每 500ms 复查请求是否被 cancel / 被新排程替换：撤销了就立刻作废，绝不杀进程。
@@ -199,13 +201,38 @@ async function main() {
     const quietWaitSec = Math.max(0, Number(req.quietWaitSec ?? 180));
     const selfSessionId = req.selfSessionId || req.sessionId || '';
     log(`idle guard: self=${selfSessionId || '(unknown)'} quietWait=${quietWaitSec}s`);
-    const quiet = await waitQuiet({
+    const guardStart = Date.now();
+    const guardDeadline = guardStart + quietWaitSec * 1000;
+    let quiet = await waitQuiet({
       selfSessionId,
       maxWaitMs: quietWaitSec * 1000,
       onPoll: ({ elapsedMs, busy }) => {
         if (busy.length > 0) log(`idle guard waiting ${Math.round(elapsedMs / 1000)}s: busy=${JSON.stringify(busy)}`);
       },
     });
+    // 终检：静默窗刚满足时，可能有会话正好在这几秒里开了新回合。
+    // 连续两次「立刻探测」都空闲才真放行；中间有人开工就重新进等待（共用同一预算）。
+    if (quiet.ok) {
+      for (let attempt = 1; attempt <= 3; attempt += 1) {
+        await sleep(400);
+        const probe = await waitQuiet({ selfSessionId, maxWaitMs: 0 });
+        if (!probe.ok) {
+          log(`idle guard recheck#${attempt}: 有人在这几秒里开工 -> 重新等待：${JSON.stringify(probe.busy)}`);
+          const remaining = Math.max(0, guardDeadline - Date.now());
+          quiet = await waitQuiet({
+            selfSessionId,
+            maxWaitMs: remaining,
+            onPoll: ({ elapsedMs, busy }) => {
+              if (busy.length > 0) log(`idle guard re-wait ${Math.round(elapsedMs / 1000)}s: busy=${JSON.stringify(busy)}`);
+            },
+          });
+          if (!quiet.ok) break;
+        } else {
+          log(`idle guard recheck#${attempt}: still quiet`);
+          break;
+        }
+      }
+    }
     log(`idle guard result: ${JSON.stringify(quiet)}`);
     if (!quiet.ok) {
       const result = { ok: false, dryRun: false, reason: 'others-busy', busy: quiet.busy, waitedMs: quiet.waitedMs, at: new Date().toISOString(), logFile };

package/lib/bus.js

@@ -23,7 +23,7 @@ import path from 'node:path'
 import crypto from 'node:crypto'
 import { rotateIfNeeded } from './logs.js'
 
-export const VERSION = '0.9.3'
+export const VERSION = '0.9.4'
 
 /** DSH 的家目录：与宿主其它状态（sessions / profiles）同一个根，多终端天然共享 */
 export function dshHome() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-crossterm",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "description": "跨端互通：同一 DSH 账号下的会话、终端、设备之间互通 —— 特征码链、内联邮件、云端中转站与自动备份",
   "type": "module",
   "main": "./lib/index.js",