dsh-crossterm 0.3.37 → 0.3.39

package/README.md

@@ -244,6 +244,48 @@ dsh plugin --profile desktop remove dsh-crossterm
 
 > 插件、npm 包、B 机安装包**都不携带任何凭证**；换机器要各自配自己的。
 
+### 看有哪些机器连着（0.3.38）
+
+插件页卡片展开后有「云端设备」一行，也可以直接 `GET /crossterm/api/devices`：
+
+- 数据来自云端总线的 `presence/*.json`（每台机器 10 秒一次心跳），字段含名字、nodeId、版本、平台、会话数、入链；
+- 最后心跳 3 分钟内的算「在线」，其余显示「N 分钟前」；
+- 本机永远在列表里（标「（本机）」），取自本地 presence，不依赖云端往返；
+- 没配云盘的机器只显示「未连接云盘」，不会假装有别的设备。
+
+> 0.3.38 之前这里常常显示「云端还没有其他设备」：云端 `presence/` 里堆了 220 多个 `.tmp`
+> 残骸，而百度网盘列目录一页只给 200 条 —— 真实 json 被挤到了第二页。现在列目录会翻页，
+> 云端也不再上传 `.tmp`。
+
+### 云端目录：账号 / 设备 / 共享（0.3.39）
+
+打开云同步后，插件会在云盘的大文件夹（默认 `dsh`）下按账号和设备建目录，不用手动摆：
+
+```
+dsh/
+  <账号>/                       ← _account.json：ownerDevice（第一个进云的设备 = 管理员）
+    <设备>/                     ← _device.json：role（admin/member）、lastSeen、版本
+      sessions/<会话>/            part-0001.bin… full-<时间>.bin  + _session.json（水位标注）
+      attachments/<sha256>        附件按内容寻址，天生去重
+    shared/                    ← 云端设备共享文件夹：跨设备的信息、文件、邮件都走这里
+      <设备>/
+        inbox/                 收件箱（别的设备投给你的信）
+        done/                  收完归档
+        files/<mailId>/        附件
+```
+
+- **账号**：默认取云盘账号名；想改名在 `config.json` 写 `cloudAccount`，或设环境变量 `DSH_ACCOUNT`。
+- **角色**：账号下第一个进云的设备自动是 `admin`（看 `_account.json.ownerDevice`），之后的是 `member`。
+- **收信（云端中转站）**：每 20 秒查一次自己的 `inbox/`，取信 → 存本机
+  `<总线目录>/cloud/relay/incoming/` → 按**收件人会话名**投递 → 归档到 `done/` 再从收件箱删。
+- **会话备份**：每 5 分钟一轮，按字节增量（**不解压** transcript）：首次整份 `full-*.bin`，
+  之后只传新增那段 `part-NNNN.bin`；`_session.json` 里的 `bytes` 就是「备份到哪了」的标注，
+  下次从标注往后继续。附件单轮 20 个、会话单轮 20 个，余量下一轮接着传。
+- 卡片三行：**云端账号**（角色 + 设备号）、**云端中转站**（已收 / 失败 / 间隔）、
+  **会话备份**（会话数 · 体积 · 上次时间）；按钮 **收信**、**备份会话** 可手动催一轮。
+- 命令行等价物：`term_cloud action="home"`（看状态）、`action="layout"`（重建目录）、
+  `action="relay"`（收一轮）、`action="backup"`（备份一轮）。
+
 ### 手动 / 自动注入开关（三层）
 
 | 层 | 开关 | 粒度 |

package/client/client.js

@@ -131,11 +131,51 @@ window.__ModuleLoader__.load({
 			);
 		}
 
+		function agoText(ts) {
+			if (!ts) return "未知";
+			const mins = Math.round((Date.now() - ts) / 60000);
+			if (mins <= 0) return "刚刚";
+			if (mins < 60) return mins + " 分钟前";
+			const hours = Math.round(mins / 60);
+			if (hours < 24) return hours + " 小时前";
+			return Math.round(hours / 24) + " 天前";
+		}
+
+		function devicesText(status, devices) {
+			if (!(status && status.cloud && status.cloud.configured)) return "未连接云盘";
+			if (!devices || devices.loading) return "读取中…";
+			if (!devices.ok) return devices.message || "读取失败";
+			const list = devices.devices || [];
+			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 : "");
+				})
+				.join("；");
+		}
+
+		function sizeText(bytes) {
+			const n = Number(bytes || 0);
+			if (n < 1024) return n + " B";
+			if (n < 1024 * 1024) return (n / 1024).toFixed(1) + " KB";
+			if (n < 1024 * 1024 * 1024) return (n / 1024 / 1024).toFixed(1) + " MB";
+			return (n / 1024 / 1024 / 1024).toFixed(2) + " GB";
+		}
+
+		function backupText(backup) {
+			if (!backup || !backup.files) return "还没有备份（会在开云同步后自动开始）";
+			const when = backup.lastAt ? agoText(backup.lastAt) : "未知";
+			return `${backup.files} 个会话 · ${sizeText(backup.bytes)} · 上次 ${when}`;
+		}
+
 		function Card() {
 			const [open, setOpen] = React.useState(false);
 			const [status, setStatus] = React.useState(null);
 			const [busy, setBusy] = React.useState("");
 			const [msg, setMsg] = React.useState("");
+			const [devices, setDevices] = React.useState(null);
 
 			const load = React.useCallback(() => {
 				call("/crossterm/api/status")
@@ -150,6 +190,21 @@ window.__ModuleLoader__.load({
 				load();
 			}, [load]);
 
+			const loadDevices = React.useCallback(async () => {
+				setDevices({ loading: true, devices: [] });
+				try {
+					const data = await call("/crossterm/api/devices");
+					setDevices({ loading: false, ...(data || {}) });
+				} catch (error) {
+					setDevices({ loading: false, ok: false, devices: [], message: String((error && error.message) || error) });
+				}
+			}, []);
+
+			// 展开时自动读一次云端设备（收起不读，避免每次进页面都等网盘）
+			React.useEffect(() => {
+				if (open && !devices) void loadDevices();
+			}, [open, devices, loadDevices]);
+
 			const onCheck = async () => {
 				setBusy("check");
 				setMsg("正在检查更新…");
@@ -229,9 +284,48 @@ window.__ModuleLoader__.load({
 				}
 			};
 
+			const onRelayCloud = async () => {
+				setBusy("relay");
+				setMsg("正在检查云端收件箱…");
+				try {
+					const data = await call("/crossterm/api/home?action=relay");
+					const relay = (data && data.relay) || {};
+					setMsg(
+						data && data.ok
+							? `收信完成：拉到 ${relay.fetched || 0} 封，投递 ${relay.delivered || 0} 封${relay.failed ? "，失败 " + relay.failed : ""}`
+							: "收信失败：" + ((data && (data.message || relay.error)) || "未知错误"),
+					);
+					if (data && data.home && status) setStatus({ ...status, home: data.home });
+				} catch (error) {
+					setMsg("收信失败：" + String((error && error.message) || error));
+				} finally {
+					setBusy("");
+				}
+			};
+
+			const onBackupNow = async () => {
+				setBusy("backup");
+				setMsg("正在备份会话…");
+				try {
+					const data = await call("/crossterm/api/backup", "POST");
+					const b = (data && data.backup) || {};
+					setMsg(
+						data && data.ok
+							? `备份完成：会话 ${(b.sessions && b.sessions.uploaded) || 0} 个，附件 ${(b.attachments && b.attachments.uploaded) || 0} 个（${Math.round((b.ms || 0) / 1000)} 秒）`
+							: "备份失败：" + ((data && data.message) || "未知错误"),
+					);
+					if (data && data.home && status) setStatus({ ...status, home: data.home });
+				} catch (error) {
+					setMsg("备份失败：" + String((error && error.message) || error));
+				} finally {
+					setBusy("");
+				}
+			};
+
 			const version = status ? "v" + status.version : "";
 			const mode = status && status.install ? status.install.mode : "";
 			const cloud = (status && status.cloud) || {};
+			const home = (status && status.home) || null;
 			const subtitle = status
 				? `${status.node || "本机"} · ${status.chains && status.chains.length ? status.chains.join(" / ") : "未入链"}`
 				: "加载中…";
@@ -265,6 +359,12 @@ window.__ModuleLoader__.load({
 							label: "当前终端",
 							value: status ? `${status.node}（${status.nodeId}）· ${status.hostname}` : "",
 						}),
+						h(
+							"div",
+							{ style: S.grid },
+							h("div", { style: S.key }, "云端设备"),
+							h("div", { style: S.val }, devicesText(status, devices)),
+						),
 						h(
 							"div",
 							{ style: S.grid },
@@ -313,11 +413,29 @@ window.__ModuleLoader__.load({
 									: null,
 							),
 						),
+						home && home.layout
+							? h(FriendlyRow, {
+								label: "云端账号",
+								value: `${home.layout.account}（${home.layout.role === "admin" ? "管理员" : "成员"}）· 设备 ${home.layout.deviceId}`,
+							})
+							: null,
+						home && home.relay
+							? h(FriendlyRow, {
+								label: "云端中转站",
+								value: `已收 ${home.relay.processed || 0} 封，失败 ${home.relay.failed || 0} 封 · 每 ${Math.round((home.relay.intervalMs || 0) / 1000)} 秒查一次`,
+							})
+							: null,
+						home && home.backup
+							? h(FriendlyRow, { label: "会话备份", value: backupText(home.backup) })
+							: null,
 						h(
 							"div",
 							{ style: S.actions },
 							h("button", { style: S.btn, onClick: onCheck, disabled: busy !== "" }, busy === "check" ? "检查中…" : "检查更新"),
 							h("button", { style: S.btnPrimary, onClick: onUpdate, disabled: busy !== "" }, busy === "update" ? "更新中…" : "更新"),
+							h("button", { style: S.btn, onClick: () => void loadDevices(), disabled: Boolean(devices && devices.loading) }, devices && devices.loading ? "读取中…" : "刷新设备"),
+							h("button", { style: S.btn, onClick: onRelayCloud, disabled: busy !== "" }, busy === "relay" ? "收信中…" : "收信"),
+							h("button", { style: S.btn, onClick: onBackupNow, disabled: busy !== "" }, busy === "backup" ? "备份中…" : "备份会话"),
 						),
 						msg ? h("div", { style: S.msg }, msg) : null,
 					),

package/lib/bus.js

@@ -22,7 +22,7 @@ import os from 'node:os'
 import path from 'node:path'
 import crypto from 'node:crypto'
 
-export const VERSION = '0.3.37'
+export const VERSION = '0.3.39'
 
 /** DSH 的家目录：与宿主其它状态（sessions / profiles）同一个根，多终端天然共享 */
 export function dshHome() {
@@ -63,6 +63,14 @@ const DEFAULTS = {
   cloudEnabled: false,
   cloudRoot: '/dsh云盘/crossterm/bus',
   cloudIntervalMs: 4000,
+  // 云端目录（0.3.39 起）：<cloudHome>/<账号>/<设备>/ + <账号>/shared/<设备>/inbox
+  cloudHome: 'dsh',
+  cloudAccount: '',
+  relayIntervalMs: 20000,
+  backupIntervalMs: 300000,
+  backupSessionsPerRun: 20,
+  backupAttachmentsPerRun: 20,
+  attachmentBackupEnabled: true,
   baiduAppFile: '',
   baiduAuthFile: '',
   cloudStateFile: '',
@@ -203,8 +211,9 @@ export function formatBytes(n) {
 export async function writeJsonAtomic(file, value) {
   await fsp.mkdir(path.dirname(file), { recursive: true })
   const tmp = `${file}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`
-  await fsp.writeFile(tmp, JSON.stringify(value, null, 2), 'utf8')
-  await fsp.rename(tmp, file)
+  const data = JSON.stringify(value, null, 2)
+  await fsp.writeFile(tmp, data, 'utf8')
+  await renameWithRetry(tmp, file, data)
 }
 
 /** 原子写文本：同上，用于邮件正文 */
@@ -212,7 +221,53 @@ export async function writeFileAtomic(file, text) {
   await fsp.mkdir(path.dirname(file), { recursive: true })
   const tmp = `${file}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`
   await fsp.writeFile(tmp, text, 'utf8')
-  await fsp.rename(tmp, file)
+  await renameWithRetry(tmp, file, text)
+}
+
+// Windows 上目标文件被别的进程（读方、杀毒、同步盘）短暂占用时 rename 会 EPERM/EBUSY，
+// 以前就这么把 .tmp 漏在原地：presence/ 攒了两百多个。这里重试几次，最后退化成直接覆盖，
+// 无论成败都把 tmp 删掉，绝不留垃圾。
+async function renameWithRetry(tmp, file, data) {
+  for (let attempt = 0; attempt < 5; attempt++) {
+    try {
+      await fsp.rename(tmp, file)
+      return
+    } catch (error) {
+      const code = error && error.code
+      if (!['EPERM', 'EBUSY', 'EACCES', 'ENOENT'].includes(code)) throw error
+      await new Promise((resolve) => setTimeout(resolve, 15 * (attempt + 1)))
+    }
+  }
+  await fsp.writeFile(file, data, 'utf8')
+  await fsp.rm(tmp, { force: true }).catch(() => {})
+}
+
+/** 清掉总线目录里超过 maxAgeMs 的 .tmp 残骸（原子写的漏网之鱼） */
+export async function sweepTmp(root, maxAgeMs = 10 * 60 * 1000, dirs = ['presence', 'chains', 'links', 'inbox', 'mail']) {
+  const now = Date.now()
+  let removed = 0
+  for (const dir of dirs) {
+    const abs = path.join(root, dir)
+    let entries
+    try {
+      entries = await fsp.readdir(abs, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith('.tmp')) continue
+      const target = path.join(abs, entry.name)
+      try {
+        const st = await fsp.stat(target)
+        if (now - st.mtimeMs < maxAgeMs) continue
+        await fsp.rm(target, { force: true })
+        removed += 1
+      } catch {
+        /* ignore */
+      }
+    }
+  }
+  return removed
 }
 
 export async function readJson(file) {
@@ -300,8 +355,14 @@ export class Bus {
     const file = this.mailFile(msg.id)
     fs.mkdirSync(path.dirname(file), { recursive: true })
     const tmp = `${file}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`
-    fs.writeFileSync(tmp, `${head.join('\n')}\n${body}\n`, 'utf8')
-    fs.renameSync(tmp, file)
+    const text = `${head.join('\n')}\n${body}\n`
+    fs.writeFileSync(tmp, text, 'utf8')
+    try {
+      fs.renameSync(tmp, file)
+    } catch {
+      fs.writeFileSync(file, text, 'utf8')
+      try { fs.rmSync(tmp, { force: true }) } catch { /* ignore */ }
+    }
     return file
   }
 

package/lib/cloud/devices.js

@@ -0,0 +1,95 @@
+import fsp from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+
+const ONLINE_MS = 3 * 60 * 1000
+
+function trimRoot(root) {
+  return String(root || '').replace(/\/+$/, '')
+}
+
+function summarize(data, now) {
+  const updatedAt = Number(data.updatedAt) || 0
+  return {
+    nodeId: String(data.nodeId || ''),
+    name: String(data.name || data.hostname || data.nodeId || ''),
+    hostname: String(data.hostname || ''),
+    version: String(data.version || ''),
+    platform: String(data.platform || ''),
+    pid: Number(data.pid) || 0,
+    sessions: Array.isArray(data.sessions) ? data.sessions.length : 0,
+    chains: Array.isArray(data.chains)
+      ? [...new Set(data.chains.map((c) => (typeof c === 'string' ? c : c && c.code)).filter(Boolean))]
+      : [],
+    updatedAt,
+    lastSeen: updatedAt ? new Date(updatedAt).toISOString() : '',
+    online: updatedAt > 0 && now - updatedAt < ONLINE_MS,
+  }
+}
+
+/**
+ * 云端设备列表：读 <cloudRoot>/presence/*.json（翻页列目录，跳过 .tmp 残骸），
+ * 逐个下载解析出 nodeId/名字/版本/最后心跳。
+ * 注意 cfg.cloudRoot 本身就是总线根（形如 /dsh云盘/crossterm/bus），不再拼一层 bus。
+ */
+export async function listCloudDevices(pan, cloudRoot, opts = {}) {
+  const now = opts.now || Date.now()
+  const root = trimRoot(cloudRoot)
+  const dir = `${root}/presence`
+  const result = { ok: false, dir, devices: [], files: 0, tmpFiles: 0, error: '' }
+  if (!root) {
+    result.error = '还没配置云盘'
+    return result
+  }
+  let listing
+  try {
+    listing = await pan.lsAll(dir)
+  } catch (error) {
+    result.error = String((error && error.message) || error)
+    return result
+  }
+  if (!listing || listing.errno !== 0) {
+    // 4 = 目录不存在（还没同步过）
+    result.ok = true
+    result.error = listing && listing.errno === -9 ? '云端目录不存在' : ''
+    return result
+  }
+  const entries = listing.list || []
+  const jsonFiles = entries.filter((f) => f.isdir === 0 && f.server_filename.endsWith('.json'))
+  result.files = jsonFiles.length
+  result.tmpFiles = entries.filter((f) => f.isdir === 0 && f.server_filename.endsWith('.tmp')).length
+
+  const tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'ct-devices-'))
+  try {
+    const byId = new Map()
+    for (const entry of jsonFiles) {
+      const name = entry.server_filename
+      const nodeId = name.slice(0, -'.json'.length)
+      const local = path.join(tmpDir, name)
+      try {
+        await pan.get(`${dir}/${name}`, local)
+        const data = JSON.parse(await fsp.readFile(local, 'utf8'))
+        if (!data || !data.nodeId) continue
+        byId.set(data.nodeId, summarize(data, now))
+      } catch {
+        /* 单个坏文件不影响整体 */
+      }
+      if (byId.size >= 50) break
+    }
+    result.devices = [...byId.values()].sort((a, b) => b.updatedAt - a.updatedAt)
+    result.ok = true
+    return result
+  } finally {
+    await fsp.rm(tmpDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+/** 本地自己的 presence（不依赖云端，用来兜底显示"我"） */
+export async function localDevice(presenceDir, nodeId, now = Date.now()) {
+  try {
+    const raw = await fsp.readFile(path.join(presenceDir, `${nodeId}.json`), 'utf8')
+    return summarize(JSON.parse(raw), now)
+  } catch {
+    return undefined
+  }
+}

package/lib/cloud/home.js

@@ -0,0 +1,152 @@
+// 云端目录编排（0.3.39）：把「账号/设备/共享收件箱 + 中转站 + 会话备份」串起来
+//   start() 后按两个定时器跑：relayIntervalMs 收信投递、backupIntervalMs 会话增量备份
+import fs from 'node:fs'
+import path from 'node:path'
+import { ensureLayout, readLayoutCache, DEFAULT_HOME } from './layout.js'
+import { createRelay } from './relay.js'
+import { backupSessions, backupAttachments, backupSummary } from './session-backup.js'
+
+/**
+ * @param {object} opts
+ * @param {object} opts.cfg 插件配置（readConfig 结果）
+ * @param {object} opts.device { nodeId, name, version, platform, sessions }
+ * @param {object} opts.pan 云盘客户端
+ * @param {string} opts.busDir 总线根（<DSH_HOME>/crossterm）
+ * @param {Function} opts.deliver async ({ to, envelope, files }) => { ok, sessionId, reason }
+ * @param {Function} [opts.names] 返回 { <会话短号>: { name } }，给 _session.json 补显示名
+ * @param {Function} [opts.log]
+ */
+export function createCloudHome({ cfg, device, pan, busDir, deliver, names, log = () => {} }) {
+  const home = path.dirname(busDir)
+  const root = path.join(busDir, 'cloud')
+  fs.mkdirSync(root, { recursive: true })
+  const cacheFile = path.join(root, 'layout.json')
+  const relayDir = path.join(root, 'relay')
+  const relayState = path.join(relayDir, 'state.json')
+  const backupState = path.join(root, 'backup-state.json')
+  const sessionsRoot = path.join(home, 'sessions')
+  const attachmentsRoot = path.join(home, 'attachments', 'v1', 'objects')
+
+  let timers = []
+  let started = false
+  let layoutBusy = null
+  let backupBusy = null
+  let relayTimer = 0
+  let backupTimer = 0
+
+  const relay = createRelay({
+    pan,
+    getLayout: () => getLayout(false),
+    localDir: relayDir,
+    stateFile: relayState,
+    deliver,
+    log: (line) => log('relay: ' + line),
+  })
+
+  async function getLayout(force = false) {
+    if (!force && layoutBusy) return layoutBusy
+    layoutBusy = (async () => {
+      try {
+        const info = await ensureLayout({
+          pan,
+          cfg,
+          device,
+          cacheFile,
+          force,
+          log: (line) => log('layout: ' + line),
+        })
+        return info
+      } catch (e) {
+        const msg = (e && e.message) || String(e)
+        log(`建云端目录失败：${msg}`)
+        const cached = readLayoutCache(cacheFile)
+        if (cached) return { ...cached, cached: true, error: msg }
+        return { error: msg }
+      } finally {
+        layoutBusy = null
+      }
+    })()
+    return layoutBusy
+  }
+
+  async function backupNow() {
+    if (backupBusy) return backupBusy
+    backupBusy = (async () => {
+      const layout = await getLayout(false)
+      if (!layout || !layout.paths) return { ok: false, error: layout?.error || '云端目录还没准备好' }
+      const namesMap = typeof names === 'function' ? names() || {} : {}
+      const sessionNames = {}
+      for (const [short, rec] of Object.entries(namesMap)) sessionNames[short] = { name: rec?.name || '', cwd: rec?.cwd || '' }
+      const started = Date.now()
+      const sessions = await backupSessions({
+        pan,
+        layout,
+        sessionsRoot,
+        tmpDir: path.join(root, 'tmp'),
+        stateFile: backupState,
+        log: (line) => log('backup: ' + line),
+        maxSessions: Number(cfg.backupSessionsPerRun || 20),
+        names: sessionNames,
+      })
+      let attachments = { ok: true, uploaded: 0, skipped: 0, pending: 0 }
+      if (cfg.attachmentBackupEnabled !== false) {
+        attachments = await backupAttachments({
+          pan,
+          layout,
+          objectsRoot: attachmentsRoot,
+          stateFile: backupState,
+          log: (line) => log('backup: ' + line),
+          maxFiles: Number(cfg.backupAttachmentsPerRun || 20),
+        })
+      }
+      const out = { ok: sessions.ok && attachments.ok, ms: Date.now() - started, sessions, attachments, summary: backupSummary(backupState) }
+      log(`会话备份：上传 ${sessions.uploaded} 个会话 / ${attachments.uploaded} 个附件（失败 ${sessions.error || attachments.error || '无'}）`)
+      return out
+    })()
+    try { return await backupBusy } finally { backupBusy = null }
+  }
+
+  async function relayNow() {
+    return relay.poll()
+  }
+
+  async function send(opts) {
+    return relay.sendEnvelope(opts)
+  }
+
+  function status() {
+    const layout = readLayoutCache(cacheFile)
+    return {
+      home: `${cfg.cloudHome || DEFAULT_HOME}`,
+      layout: layout
+        ? { account: layout.account, role: layout.role, deviceId: layout.deviceId, paths: layout.paths, ensuredAt: layout.ensuredAt }
+        : null,
+      relay: { ...relay.stats(), intervalMs: relayTimer },
+      backup: { ...backupSummary(backupState), intervalMs: backupTimer },
+      roots: { sessions: sessionsRoot, attachments: attachmentsRoot },
+    }
+  }
+
+  function start() {
+    if (started) return
+    started = true
+    relayTimer = Number(cfg.relayIntervalMs || 20000)
+    backupTimer = Number(cfg.backupIntervalMs || 300000)
+    void getLayout(false).catch(() => {})
+    timers.push(setInterval(() => { void relayNow().catch(() => {}) }, relayTimer))
+    timers.push(setInterval(() => { void backupNow().catch(() => {}) }, backupTimer))
+    for (const t of timers) if (t && typeof t.unref === 'function') t.unref()
+    // 启动 8 秒后先跑一轮收信、30 秒后跑第一轮备份（别和宿主启动抢资源）
+    setTimeout(() => { void relayNow().catch(() => {}) }, 8000)
+    setTimeout(() => { void backupNow().catch(() => {}) }, 30000)
+    log(`云端目录就绪：relay ${relayTimer}ms / backup ${backupTimer}ms（根 ${cfg.cloudHome || DEFAULT_HOME}）`)
+  }
+
+  function stop() {
+    started = false
+    for (const t of timers) clearInterval(t)
+    timers = []
+  }
+
+  return { start, stop, status, getLayout, backupNow, relayNow, send, cacheFile, relayDir }
+}