lark-relay 0.6.0 → 0.6.2

package/lib/collect.js

@@ -1,42 +1,25 @@
 'use strict'
 
-// collect:底座。全部 profile 各起一个 consume -> 读 stdout NDJSON -> 原子落盘。
-// 零参数、零配置 —— app 列表实时读 `lark-cli profile list`。
-//
-// 必须独立常驻:lark 事件是流式的,进程不在的时刻消息永久丢失
-// (实测:消息发出 8s 后才起 consumer,收到 0 条)。
-//
-// 踩坑史见 docs/lessons.md
+// 启动时读取 profile,每 app 一个 consumer,消息原子落盘
 const readline = require('readline')
 const larkcli = require('./larkcli')
 const store = require('./store')
 const { paths, ensureDir, dayKey } = require('./paths')
 const { acquireExclusive } = require('./lock')
-const { init: logInit, logLine } = require('./log')
+const { logLine } = require('./log')
 
-const EVENT_KEY = process.env.LARK_RELAY_EVENT_KEY || 'im.message.receive_v1'
+const EVENT_KEY = 'im.message.receive_v1'
 const GC_INTERVAL_MS = 3600_000
 
-// 游标空闲多久算遗弃。默认 2 天:take 是实时场景的取用口,
-// 空闲一两天以上再重挂,下次消费一定从新的开始
-const CURSOR_TTL_DAYS = (() => {
-  const d = Number(process.env.LARK_RELAY_CURSOR_TTL_DAYS)
-  return Number.isFinite(d) && d > 0 ? d : 2
-})()
-
 class AppCollector {
-  constructor(app, opts) {
+  constructor(app) {
     this.app = app
-    this.opts = opts
     this.seq = 0
-    this.received = 0
     this.child = null
     this.stopped = false
     this.backoffMs = 1000
-    this.restarts = 0
     this.healthyTimer = null
-    // 落盘侧去重:同一条消息在盘上只出现一次,消费侧因此完全不必去重。
-    // 种子从当天已落盘的事件读回 —— 重启后 bus 重投时它是**新文件**,游标拦不住
+    // 启动时从当天落盘事件恢复去重集合
     this.day = dayKey()
     this.seen = store.seedIds(app, this.day)
   }
@@ -48,13 +31,10 @@ class AppCollector {
       this.day = today
       this.seen = new Set()
     }
-    const id = obj && (obj.message_id || obj.id)
-    if (id) {
-      if (this.seen.has(id)) return false
-      this.seen.add(id)
-    }
+    const id = obj?.message_id
+    if (id && this.seen.has(id)) return false
     store.writeEvent(this.app, obj, this.seq++)
-    this.received++
+    if (id) this.seen.add(id)
     return true
   }
 
@@ -63,8 +43,7 @@ class AppCollector {
     const child = larkcli.spawnConsume(this.app, EVENT_KEY, ['--as', 'bot', '--timeout', '0'])
     this.child = child
 
-    // stdin 必须是保持打开的管道:unbounded consume 把 EOF 当退出信号,
-    // 给 /dev/null 会疯狂重启 -- 见 docs/lessons.md#stdin-eof
+    // unbounded consume 把 stdin EOF 当退出信号,保持管道打开
     if (child.stdin) child.stdin.on('error', () => {})
 
     const rl = readline.createInterface({ input: child.stdout, crlfDelay: Infinity })
@@ -85,29 +64,25 @@ class AppCollector {
       }
     })
 
-    // 退避重置的判据是「活够久」而非「收到消息」-- 后者会让安静的 app
-    // 一路顶到 60s 上限再也不降。见 docs/lessons.md
+    // 安静的连接也应重置退避
     this.healthyTimer = setTimeout(() => {
       this.backoffMs = 1000
     }, 30_000)
 
-    // 不加 --quiet:它会隐藏事件丢失。必须走 readline 按行读,不能裸接 'data'
-    // (归属错乱/记录被切/中文截断三个 bug)-- 见 docs/lessons.md
+    // readline 保留跨 chunk 的行和 UTF-8 字符
     const erl = readline.createInterface({ input: child.stderr, crlfDelay: Infinity })
     erl.on('line', (line) => {
       const text = line.trimEnd()
       if (text) logLine(`[${this.app}] ${text}`)
     })
 
-    // spawn 失败只发 error+close,**没有 exit** -- 重启逻辑必须挂 close,
-    // 否则该 app 永久停摆而主进程看着还 active。见 docs/lessons.md
+    // spawn 失败也发 close,重启逻辑统一挂在这里
     let restarted = false
     const scheduleRestart = (why) => {
       if (restarted || this.stopped) return
       restarted = true
       clearTimeout(this.healthyTimer)
       this.child = null
-      this.restarts++
       logLine(
         `[${this.app}] consume 退出(${why}),${Math.round(this.backoffMs / 1000)}s 后重启 ` +
           `—— 这段时间该 app 的消息会永久丢失`,
@@ -138,20 +113,13 @@ class AppCollector {
 async function runCollect(opts) {
   ensureDir(paths.store)
   ensureDir(paths.cursors)
-  // 最早做 —— 启动横幅、profile 报错都该带时间戳
-  logInit()
 
-  // 互斥:一个 collect 就够。同一 app 服务端只放行一个 event bus,第二个起来会
-  // 互相挤掉并退避互抢,实测约 5 分钟才稳定 -- 那 5 分钟的消息永久丢失。
-  // 锁按 LARK_RELAY_HOME 隔离,不是全机唯一。见 docs/lessons.md#事件总线单实例
+  // 同一 app 的事件总线只允许一个实例;本地锁按 LARK_RELAY_HOME 隔离
   const lock = acquireExclusive('collect')
   if (!lock.ok) {
     logLine(
       `error: 已有一个 lark-relay-collect 在跑(pid ${lock.holder}),本进程退出。\n` +
-        `同一 app 服务端只放行一个 event bus —— 两个 collect 会互相挤掉并退避重连,\n` +
-        `实测约 5 分钟才稳定,那段时间的消息永久丢失。\n` +
-        `确认是谁在跑:  launchctl print system/com.adaex.lark-relay-collect\n` +
-        `要接管请先停掉它:sudo launchctl bootout system/com.adaex.lark-relay-collect`,
+        `检查持锁进程或 lark-relay status,接管前先停止现有采集`,
     )
     return 1
   }
@@ -161,8 +129,6 @@ async function runCollect(opts) {
   try {
     profiles = await larkcli.listProfiles()
   } catch (err) {
-    // 不抛给 bin 的顶层 catch —— 那行是所有命令共用的裸 stderr,
-    // 会让「collect 崩了」这条最关键的记录反而没有时间戳
     logLine(
       `error: 读不到 lark-cli profile 列表:${(err.message || '').split('\n')[0]}\n` +
         `collect 依赖 lark-cli 提供认证与事件总线。检查:\n` +
@@ -203,12 +169,10 @@ async function runCollect(opts) {
       `  event_key=${EVENT_KEY} store 保留 ${opts.retain}天`,
   )
 
-  const collectors = chosen.map((p) => new AppCollector(p.name, opts))
+  const collectors = chosen.map((p) => new AppCollector(p.name))
   for (const c of collectors) c.start()
 
-  // gc 在本进程内每小时自查:回收逻辑就是「删超期的东西」,
-  // 另起 gc 命令 + timer 是为几行逻辑加两个部署件。
-  // store 按天删目录,cursors 按空闲时长删 —— 同构,故同处一地
+  // 只回收超期事件,保留消费者的断点
   const runGc = () => {
     try {
       const s = store.gcStore(opts.retain)
@@ -216,16 +180,6 @@ async function runCollect(opts) {
     } catch (err) {
       logLine(`gc: store 回收失败 ${err.message}`)
     }
-    try {
-      // 游标按空闲时长自动回收 —— 引擎自己过期,不需要人判断。
-      // 判据错过两次,见 docs/lessons.md#游标判据
-      const c = store.gcCursors(CURSOR_TTL_DAYS)
-      if (c.length) {
-        logLine(`gc: 回收游标 ${c.length} 个(空闲超 ${CURSOR_TTL_DAYS} 天):${c.join(' ')}`)
-      }
-    } catch (err) {
-      logLine(`gc: 游标回收失败 ${err.message}`)
-    }
   }
   const gcTimer = setInterval(runGc, GC_INTERVAL_MS)
   // 启动时先跑一次,别等一小时

package/lib/filter.js

@@ -1,42 +1,41 @@
 'use strict'
 
-// 业务过滤只准进 --filter。硬约束:曾有 6 个逐业务加出来的过滤参数,这条线会一直长。
-// 收敛成 --chats(配置)+ --filter(逻辑)两项,中心不随业务生长。
-const { execFileSync, spawnSync } = require('child_process')
+// 业务逻辑统一由 jq 表达式提供
+const { execFileSync } = require('child_process')
 
 const JQ = process.env.LARK_RELAY_JQ || 'jq'
 
-let jqChecked = false
-function ensureJq() {
-  if (jqChecked) return
-  const r = spawnSync(JQ, ['--version'], { encoding: 'utf8' })
-  if (r.error || r.status !== 0) {
-    const e = new Error(
-      `--filter 需要 jq,但没找到可执行的 \`${JQ}\`。\n` +
-        `装一个(apt install jq / brew install jq),或去掉 --filter。`,
-    )
-    e.userFacing = true
-    throw e
+function validateFilter(expr) {
+  if (!expr) return
+  try {
+    // 空输入只编译,表达式与实际过滤一致,不执行虚构事件
+    execFileSync(JQ, ['-c', `[${expr}] | any`], {
+      input: '', encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+    })
+  } catch (err) {
+    const reason = (err.stderr || err.message).trim().split('\n')[0]
+    throw Object.assign(new Error(`--filter 无法编译,请检查 jq 和表达式:${reason}`), {
+      userFacing: true,
+      exitCode: 2,
+    })
   }
-  jqChecked = true
 }
 
 // 一批只 spawn 一次 jq:把事件按 NDJSON 喂进去,表达式逐行求值成 true/false,
 // 按行号对回原事件。比每条 spawn 一次快两个数量级。
 function applyFilter(events, expr) {
   if (!expr || events.length === 0) return events
-  ensureJq()
   const input = events.map((e) => JSON.stringify(e)).join('\n')
   let out
   try {
     out = execFileSync(JQ, ['-c', `[${expr}] | any`], {
       input,
       encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
       maxBuffer: 64 * 1024 * 1024,
     })
   } catch (err) {
-    // 保守放行 + warn,**绝不抛** -- 抛出去会让消费者崩溃循环、任务彻底停摆。
-    // 见 docs/lessons.md#filter
+    // 数据导致的求值错误保守放行,避免同一条消息卡住消费
     process.stderr.write(
       `warn: --filter 求值失败,本批不过滤(${events.length} 条放行)。表达式:${expr}\n` +
         `      ${(err.stderr || err.message || '').trim().split('\n')[0]}\n` +
@@ -56,4 +55,4 @@ function applyFilter(events, expr) {
   return events.filter((_, i) => verdicts[i] === 'true')
 }
 
-module.exports = { applyFilter }
+module.exports = { validateFilter, applyFilter }

package/lib/help.js

@@ -1,100 +1,69 @@
 'use strict'
 
-// 帮助文本是 AI 的主入口 -- 实际行为是「先空参数跑一下看看」,
-// 故 take 空参输出必须是完整的照做指导,而非报错。
-// 所有提示按「AI 读到后下一步该做什么」来写:给完整命令、给退出码语义、给判据。
-//
-// 说理、部署教程、踩坑史都不在这里 -- 它们在 README.md 与 docs/lessons.md。
-// 帮助只回答「现在该敲什么」。
-//
-// ⚠️ 公网包:示例只用占位符(oc_xxx/<app>/ou_xxx),绝不含真实 chat_id/open_id/profile 名。
-
-function takeHelp(apps) {
-  const appLine = apps && apps.length ? apps.join(' ') : '(跑 `lark-cli profile list` 看)'
-  return `需要 --app 和 --chats。监听要求 bot 已在群内。
-
-一、查群 ID(用户身份;bot 搜不到自己没加入的群)
+const TAKE_HELP = `需要 --app 和 --chats,监听要求 bot 已在群内
+
+1. 查群 ID(用户身份)
   lark-cli --profile <app> im +chat-search --as user --query "<群名>"
-  -> 取 oc_ 开头的 chat_id;多个匹配时向用户确认是哪个
+  -> 取 oc_ 开头的 chat_id,多个匹配时确认目标群
 
-二、验 bot 在群(用户身份;bot 不在群时用 bot 身份查不到,不能作判据)
+2. 验 bot 在群(用户身份)
   lark-cli --profile <app> im chat.members bots --as user --params '{"chat_id":"oc_xxx"}'
-  -> bots[] 含本 app 才算在群
-  -> 不在群:请用户拉 bot 进群(对群可见动作,先征得同意)
+  -> bots[] 应含本 app,不在群则先安排入群
 
-三、监听(Claude Code 用 run_in_background 起,有消息会自动通知你)
+3. 取一批
   lark-relay take --app <app> --chats oc_xxx --render text
-
-  起来后 stderr 先打一行「监听中 ...」-- 没这行就是没起来,看 stderr 报错。
-  阻塞等消息,有一批就吐到 stdout 并退出(默认防抖 5s、最长等 12h)。
-  处理完再起一个,如此循环。
-
-可用 app:${appLine}
+  -> stderr 出现「监听中」表示参数校验完成并进入等待
+  -> 有一批输出到 stdout 后退出,处理完再次运行
 
 参数
-  --app <name>      必填,= lark-cli profile 名
-  --chats <ids>     必填,oc_ 开头;逗号分隔多个;或 @文件(首列 chat_id)
-  --name <n>        游标身份,省略时按 app+chats 自动派生
+  --app <name>      必填,lark-cli profile 名(用 lark-cli profile list 查询)
+  --chats <ids>     必填,逗号分隔的 chat_id,或 @文件(首列 chat_id)
+  --name <n>        消费断点身份,默认按 app+chats 派生;并行消费使用不同身份
   --filter <jq>     业务过滤,如 '.sender_id != "ou_xxx"'
-  --debounce N      防抖秒数(默认 5;聊天场景建议 15)
-  --max-wait N      从第一条起最多攒多久就吐(默认 25 秒)
-  --timeout N       没消息时最多阻塞多久,到点空手退出码 4(默认 12 小时)
-  --render text     按群分组紧凑文本(默认 NDJSON)
-  --since now|all   起始位置(默认 now,不重放历史)
-
-退出码
-  0  吐了一批(stdout);空参求教也是 0
-  2  参数错 -- stderr 有短错误和正确写法,照着重跑
-  3  游标身份被另一个 take 占用 -- 换 --name
-  4  超时没消息 -- 正常,再起一个继续
-
-最佳实践
-  · 一直等不到消息 -> 九成是 bot 不在群,回第二步验(最常见故障)
-  · 多个消费者盯同一 app 用不同 --name,游标互不干扰
-  · 不盯了直接走开 -- 空闲超 2 天的游标由 collect 自动回收`
-}
-
-const COLLECT_HELP = `把全部 lark-cli profile 的事件收下来,原子落盘。零参数、零配置。
-
-  lark-relay-collect            # 前台跑(调试)
-  常驻:macOS launchd,部署见 README
+  --debounce N      新消息静默多久后吐批,默认 5 秒
+  --max-wait N      从第一条起最多攒多久,默认 25 秒
+  --timeout N       本次取用最多阻塞多久,默认 43200 秒(12 小时)
+  --render <mode>   text 或 ndjson,默认 ndjson
+  --since <mode>    首次取用的起点:now 或 all,默认 now;已有断点始终续接
+  -h, --help       用法
 
-app 列表实时读 \`lark-cli profile list\`,新增 profile 自动纳入,无需改配置。
-每 app 一个子进程;某个挂了单独重启,不影响其他。
-未授权或授权过期的 profile 自动跳过并 warn(永久失败,重试是死循环)。
+断点持续保留,不随空闲时间过期;store 只保留采集端设定天数的消息
+使用新的 --name 可从新的起点消费
 
-⚠️ **一个 collect 就够,第二个会拒绝启动并报出持有者 pid**。
-不是洁癖:同一 app 服务端只放行一个 event bus,两个 collect 会互相挤掉并按
-1s->2s->...->60s 退避重连,实测约 5 分钟才稳定 -- 那段时间的消息永久丢失。
-所以上面那条「前台跑(调试)」在常驻服务已在跑时会直接退出,不会抢它。
+退出码:0=有一批/帮助/信号退出,2=参数错,3=身份被占用,4=超时无消息`
 
-为什么必须常驻:lark 事件是流式的,进程不在的时刻消息永久丢失(实测:消息发出
-8s 后才起 consumer,收到 0 条)。
+const COLLECT_HELP = `lark-relay-collect -- 常驻收集 im.message.receive_v1 消息并原子落盘
 
-装完先 \`lark-relay status\` 确认 -- collect 行应为 running;不在跑看日志:
-  tail -f ~/.lark-relay/logs/collect.err.log
-  (launchd 把 stderr 直写该文件,不进统一日志,log show 查不到)
+  lark-relay-collect
+  lark-relay status
 
-落盘:~/.lark-relay/store/<app>/<YYYY-MM-DD>/<纳秒>_<pid>_<seq>.json
-同一 message_id 只落一次。回收在本进程内每小时自查(启动时先跑一次):
-store 删超过 --retain 天的日期目录,游标删空闲超 TTL 的。
+启动时读取 lark-cli profile list,每个可用 profile 启动一个 consumer
+新增 profile 或重新授权后需重启采集
+每 app 独立退避重连,断线期间的消息无法回放
+同一 app 只允许一个事件总线实例,接管前先停止现有采集
 
 参数
-  --exclude <apps>  排除指定 profile(逗号分隔)
-  --retain N        store 保留天数(默认 3)
+  --exclude <apps>  排除指定 profile,逗号分隔
+  --retain N        事件保留的整数天数,默认 3;每小时回收,启动时也执行
+  -h, --help       用法
+  -v, --version    版本
 
-环境变量
-  LARK_RELAY_CURSOR_TTL_DAYS  游标空闲多久算遗弃(默认 2)`
+macOS 常驻部署
+  使用 LaunchDaemon + UserName,开机启动且不依赖 GUI 登录
+  ProgramArguments 写绝对路径,显式设置 HOME/PATH/UTF-8 locale
+  KeepAlive 使用 SuccessfulExit=false,日志路径的父目录须已存在
+  sudo launchctl bootstrap system /Library/LaunchDaemons/<label>.plist
+  修改 plist 后需 bootout + bootstrap,代码升级后用 kickstart -k
 
-const STATUS_HELP = `一眼看清全局:谁在跑、各 app 收了多少、游标在哪。
+落盘:~/.lark-relay/store/<app>/<YYYY-MM-DD>/<stamp>_<pid>_<seq>.json
+日志写 stderr,每行带时间戳;launchd 部署应配置 StandardErrorPath`
 
-  lark-relay status              # 概览
-  lark-relay status --json       # 机器可读
+const STATUS_HELP = `lark-relay status -- 采集状态、事件数量和消费断点
 
-消费者:● 有 take 持锁在跑 / ○ 空闲 Nh(重挂 take 接着盯)
+  lark-relay status
+  lark-relay status --json
 
-排障入口:「○ 空闲」而你以为它在盯 -> 它的 take 没起来或早退了。
-collect 行不是 running -> tail -f ~/.lark-relay/logs/collect.err.log
-(launchd 不进统一日志),collect 停摆的每一秒都在丢消息。`
+消费者以持锁进程是否存活区分在跑/未运行,未运行的断点仍保留
+collect running 只表示主进程在跑,各 app 的连接状态需查看采集日志`
 
-module.exports = { takeHelp, COLLECT_HELP, STATUS_HELP }
+module.exports = { TAKE_HELP, COLLECT_HELP, STATUS_HELP }

package/lib/larkcli.js

@@ -23,15 +23,7 @@ function run(args, opts = {}) {
   })
 }
 
-// profile list 默认输出 JSON,无需 --json。
-// 两类不可用,都要跳过,否则 consume 一直失败重试(死循环):
-// - tokenStatus 为 expired:授权过期,永久失败直到用户重新 login
-// - 没有 user 字段:该 profile 从未 auth 过(实测未登录的 profile 只有
-//   name/appId/brand/active 四个字段,无 user 也无 tokenStatus)
-//
-// 注:2026-09-06 删掉了 stripToJson / errText / tail 三个导出 —— 零调用方
-// (含测试)。stripToJson 还带着 6 行「只适用于对象响应」的警告,
-// 等于为没人调用的函数维护陷阱说明。要用再从 git 历史取
+// profile list 输出 JSON;授权过期或缺少 user 的 profile 不参与采集
 async function listProfiles() {
   const { stdout } = await run(['profile', 'list'])
   const arr = JSON.parse(stdout)
@@ -41,21 +33,13 @@ async function listProfiles() {
     else if (!p.user) reason = 'not-authed'
     return {
       name: p.name,
-      appId: p.appId,
-      tokenStatus: p.tokenStatus || 'unknown',
       usable: reason === null,
       reason,
     }
   })
 }
 
-// 事件流:NDJSON 到 stdout。我们自己接 stdout 后原子落盘,
-// 不用 --output-dir —— 它非原子写(先 0 字节再填充),是 partial write 的根因。
-//
-// ⚠️ stdin 必须是**保持打开的管道**:unbounded consume 把 stdin EOF 当退出信号
-// (帮助文本原话:"Bounded runs ignore stdin EOF" —— 反过来 unbounded 不忽略)。
-// 给 'ignore' 会拿到 /dev/null,立刻读到 EOF 就退出 → 变成疯狂重启循环(实测)。
-// 旧架构 bash 侧用 `< <(tail -f /dev/null)` 解决同一问题;Node 里开管道且永不写即可。
+// 保持 stdin 管道打开,stdout NDJSON 由 collect 原子写入
 function spawnConsume(profile, eventKey, extraArgs = []) {
   const args = ['--profile', profile, 'event', 'consume', eventKey, ...extraArgs]
   return spawn(CLI, args, { stdio: ['pipe', 'pipe', 'pipe'] })

package/lib/lock.js

@@ -1,13 +1,7 @@
 'use strict'
 
-// 消费者锁(非阻塞):同一 --name 不该有两个 take 在跑,抢不到直接退出并说清楚。
-// 否则两个进程互相推游标,批次会被撕成两半。collect 也用它保证全局单实例。
-//
-// 原语:`mkdir` 非 recursive —— 目标已存在就 EEXIST,这就是原子的 test-and-set。
-// 建目录与写 pid 之间有个微秒级窗口(目录在但 pid 还没写),此时**保守拒绝**,
-// 不夺锁 —— 恢复动作只是「再跑一次」,而夺错锁会造成双实例。
-// 曾用 staging+rename+steal 的 5 次重试循环应对 12 进程并发,那个并发度不存在,
-// 见 docs/lessons.md#锁
+// 非阻塞目录锁:collect 单实例,同一消费身份只能有一个 take
+// mkdir 与写 pid 之间的空目录保守拒绝,避免抢走正在初始化的锁
 const fs = require('fs')
 const path = require('path')
 const { paths, ensureDir } = require('./paths')
@@ -29,13 +23,9 @@ function acquireExclusive(key) {
 
     const holder = readPid(pidFile)
     if (holder === process.pid) return mkHandle(dir, pidFile, me) // 自己已持有,复用
-    if (holder === null && attempt === 0) {
-      // 要么是上面那个微秒级窗口,要么是持有者被 SIGKILL 后留下的空壳。
-      // 等一拍再读一次:还是空就当陈旧锁清掉
-      try {
-        fs.rmSync(dir, { recursive: true, force: true })
-      } catch {}
-      continue
+    if (holder === null) {
+      // 无法区分初始化中的锁与崩溃留下的空壳,需确认持有者后处理
+      return { ok: false, file: dir, holder: null }
     }
     if (holder && alive(holder)) return { ok: false, file: dir, holder }
     // 持有者已死:清掉重试一次

package/lib/log.js

@@ -1,38 +1,13 @@
 'use strict'
 
-// 常驻日志:给每行加 ISO 时间戳。**只给 collect 这类常驻服务用**,
-// CLI 的用户可见输出(take 的 NDJSON、status --json)绝不能过这里 —— 会破坏解析契约。
-//
-// 为什么要时间戳:launchd 只把 stderr 直写文件,没有 journald 那种免费的时间戳。
-// 而本项目的核心排查问题恰是「**什么时候**断线、断了多久、那个窗口丢了几条」。
-//
-// 不做轮转:实测 6 天 172KB(约 10MB/年),而轮转要自己 open 一份 fd、
-// 做 dev/ino 校验、管 KEEP 代数 —— 为一年后的事写 140 行。嫌大就
-// `> ~/.lark-relay/logs/collect.err.log`(launchd 持有 fd,truncate 即可,别 rm)
-let active = false
-
-// ⚠️ 必须按 \n 逐行加前缀,不能只在整块前面拼一个:
-// 调用方存在单次输出多行的情况(启动横幅 3 行、子进程转发的多行诊断),
-// 只给首行加前缀会让后续行无法归属到时间点
+// 仅用于采集日志,逐行加时间戳;CLI 数据输出直接写 stdout
 function logLine(text) {
   const s = String(text)
   const body = s.endsWith('\n') ? s.slice(0, -1) : s
-  if (!active) return void process.stderr.write(`${body}\n`)
   const ts = new Date().toISOString()
   let out = ''
   for (const line of body.split('\n')) out += `${ts} ${line}\n`
   process.stderr.write(out)
 }
 
-// 常驻入口调一次
-function init() {
-  active = true
-  return active
-}
-
-// 测试用:重置模块态
-function _reset() {
-  active = false
-}
-
-module.exports = { init, logLine, _reset }
+module.exports = { logLine }

package/lib/render.js

@@ -1,7 +1,5 @@
 'use strict'
 
-// 渲染字段取并集(sender/mentions/reply_to/root_id/thread_id 全渲染),多几个不碍事
-
 function fmtTime(ts) {
   const ms = Number(ts)
   if (!Number.isFinite(ms) || ms <= 0) return '?'
@@ -38,9 +36,7 @@ function renderNdjson(events) {
   return events.map((e) => JSON.stringify(e)).join('\n')
 }
 
-// 按群分组的紧凑文本。分组必须按 (chat_id, thread_id) 双维度,只按 chat_id 会串话题。
-// 复合 key 的分隔符是 **NUL**,且必须写成 `\x00` 转义(裸字节会让 git 判成 binary,
-// 那次改动就没法 review)。见 docs/lessons.md#渲染分组
+// 群与话题共同确定分组,使用转义 NUL 分隔
 function renderText(events) {
   const groups = new Map()
   for (const e of events) {
@@ -56,11 +52,11 @@ function renderText(events) {
     head += `  (${list.length} 条)`
     out.push(head)
     for (const e of list) {
-      const line = [`[${fmtTime(e.create_time || e.timestamp)}]`, senderLabel(e)]
+      const line = [`[${fmtTime(e.create_time)}]`, senderLabel(e)]
       if (e.message_type && e.message_type !== 'text') line.push(`<${e.message_type}>`)
       out.push(`${line.join(' ')}: ${bodyOf(e)}`)
       const meta = []
-      meta.push(`message_id=${e.message_id || e.id || '?'}`)
+      meta.push(`message_id=${e.message_id || '?'}`)
       meta.push(`sender_id=${e.sender_id || '?'}`)
       // sender_type 是业务判据(如「自家 bot 的消息跳过」),必须渲染出来
       meta.push(`sender_type=${e.sender_type || '?'}`)
@@ -68,7 +64,7 @@ function renderText(events) {
       if (mentions.length) {
         meta.push(`mentions=${mentions.map((m) => `${m.name || '?'}(${m.id || '?'})`).join(',')}`)
       }
-      if (e.parent_id) meta.push(`reply_to=${e.parent_id}`)
+      if (e.reply_to) meta.push(`reply_to=${e.reply_to}`)
       if (e.root_id) meta.push(`root_id=${e.root_id}`)
       if (e.thread_id) meta.push(`thread_id=${e.thread_id}`)
       out.push(`    ${meta.join(' ')}`)

package/lib/status.js

@@ -18,15 +18,6 @@ function ago(ms) {
   return `${Math.round(s / 86400)}d ago`
 }
 
-// 空闲时长。向下取整:它是 gc 判据,宁可少报不可多报
-function idleTxt(ms) {
-  if (!Number.isFinite(ms)) return '未知'
-  const m = Math.floor(ms / 60000)
-  if (m < 60) return `${m}m`
-  const h = Math.floor(m / 60)
-  return h < 48 ? `${h}h` : `${Math.floor(h / 24)}d`
-}
-
 const COLLECT_LABEL = process.env.LR_COLLECT_LABEL || 'com.adaex.lark-relay-collect'
 
 function serviceState() {
@@ -36,8 +27,7 @@ function serviceState() {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],
     })
-    // 取值到行尾再 trim,不能用 (\S+):launchd 输出 `state = not running`,
-    // (\S+) 只吃到 "not" —— 而那正是最要命的状态(见 docs/lessons.md#launchd-state)
+    // state 可以是多词值,如 not running
     const state = (out.match(/^\s*state\s*=\s*(.+)$/m) || [])[1]
     const pid = Number((out.match(/^\s*pid\s*=\s*(\d+)/m) || [])[1]) || null
     const s = (state || '').trim()
@@ -55,7 +45,6 @@ function listCursors() {
   } catch {
     return []
   }
-  const now = Date.now()
   const out = []
   for (const name of names.sort()) {
     const dir = path.join(paths.cursors, name)
@@ -71,14 +60,7 @@ function listCursors() {
       if (app.startsWith('.') || app.endsWith('.tmp')) continue
       const cursor = store.readCursor(name, app)
       if (!cursor) continue
-      const mtime = store.cursorMtime(name, app)
-      out.push({
-        name,
-        app,
-        cursor,
-        pid,
-        idleMs: mtime === null ? Infinity : Math.max(0, now - mtime),
-      })
+      out.push({ name, app, cursor, pid })
     }
   }
   return out
@@ -107,7 +89,7 @@ async function buildStatus() {
     return {
       app,
       today: store.countToday(app),
-      latestMs: Number(ev?.timestamp || ev?.create_time) || null,
+      latestMs: Number(ev?.timestamp) || null,
       consumers: byApp.get(app) || [],
     }
   })
@@ -163,12 +145,14 @@ function formatStatus(s) {
     // 消费者各占一行:「谁在跑」是排障第一问,挤在一行里 ●/○ 会被淹掉
     out.push(`${w(r.app, 8)}${w(r.today, 10)}${w(ago(r.latestMs), 13)}`.trimEnd())
     for (const c of r.consumers) {
-      const note = c.pid ? `在跑 (pid ${c.pid})` : `空闲 ${idleTxt(c.idleMs)}(重挂 take 接着盯)`
+      const note = c.pid ? `在跑 (pid ${c.pid})` : '未运行 (断点保留)'
       out.push(`  ${w(c.name, 24)}${c.pid ? '●' : '○'} ${note}`)
     }
   }
   out.push('')
-  out.push(`游标 ${s.cursorsDir}(空闲超 2 天自动回收;等不及就 rm -rf 它)`)
+  out.push(
+    `游标 ${s.cursorsDir}(保留断点,下次继续取用)`,
+  )
 
   return out.join('\n')
 }