lark-relay 0.4.5 → 0.4.7

package/lib/dispatch.js

@@ -1,276 +0,0 @@
-'use strict'
-
-// dispatch:常驻循环 = take + 唤起 claude。无人在场也跑。
-// **内部就是调 take** —— 保证两场景不实现分叉(旧架构三份 wrapper 各自演化出
-// 253 行就是分叉的教训)。
-const fs = require('fs')
-const path = require('path')
-const { execFileSync } = require('child_process')
-const { loadTask, listTasks, lrRoot } = require('./tasks')
-const { takeBatch } = require('./take')
-const { groupByChatThread, renderText } = require('./render')
-const { acquireBlocking } = require('./lock')
-const { paths, ensureDir } = require('./paths')
-const store = require('./store')
-const claude = require('./claude')
-const { sendCard } = require('./card')
-const { CotSession } = require('./cot')
-const { reply } = require('./reply')
-
-function cmdList() {
-  const tasks = listTasks()
-  if (!tasks.length) {
-    process.stdout.write(
-      `没有 dispatch 任务。LR_ROOT=${lrRoot()}\n` +
-        `建任务:在 $LR_ROOT/<任务名>/dispatch.yaml 写配置(模板见 lark-relay dispatch --help)\n`,
-    )
-    return 0
-  }
-  const rows = [['任务', 'app', '群数', '单元', '上次派活']]
-  for (const t of tasks) {
-    const unit = `lark-relay-dispatch@${t.name}.service`
-    let state = 'inactive'
-    try {
-      state = execFileSync('systemctl', ['is-active', unit], { encoding: 'utf8' }).trim()
-    } catch (err) {
-      state = (err.stdout || '').trim() || 'inactive'
-    }
-    let last = '—'
-    for (const chat of t.config.chats || []) {
-      try {
-        const st = fs.statSync(paths.ledgerFile(t.name, chat))
-        const m = Math.round((Date.now() - st.mtimeMs) / 60000)
-        last = m < 60 ? `${m}m ago` : `${Math.round(m / 60)}h ago`
-      } catch {}
-    }
-    rows.push([
-      t.name,
-      String(t.config.app || '?'),
-      String((t.config.chats || []).length),
-      state,
-      last,
-    ])
-    if (t.errs.length) rows.push([`  ⚠ ${t.errs.join('; ')}`, '', '', '', ''])
-  }
-  const wid = [0, 1, 2, 3, 4].map((i) => Math.max(...rows.map((r) => (r[i] || '').length)))
-  for (const r of rows) {
-    process.stdout.write(r.map((c, i) => String(c || '').padEnd(wid[i] + 2)).join('').trimEnd() + '\n')
-  }
-  return 0
-}
-
-// ledger:dispatch 每轮追加一条,四个字段。session 会因空闲滚动/过期丢上下文,
-// 结论不能丢,供跨会话回溯。
-function ledgerAppend(task, chatId, epoch, trigger, result) {
-  try {
-    ensureDir(paths.ledger)
-    const line = JSON.stringify({
-      ts: new Date().toISOString(),
-      epoch: Number(epoch) || 0,
-      trigger: String(trigger).slice(0, 500),
-      result: String(result).slice(0, 4000),
-    })
-    fs.appendFileSync(paths.ledgerFile(task, chatId), `${line}\n`)
-  } catch {}
-}
-
-// 处理一个 (chat_id, thread_id) 组:派一轮活
-async function handleGroup(t, group, opts = {}) {
-  const { name: task, taskDir, insPath, dirs, mode } = t
-  const cfg = t.config
-  const profile = cfg.app
-  const chatId = group.chatId
-  const threadId = group.threadId
-  const events = group.events
-
-  const cwd = dirs[0] || taskDir
-  const addDirs = dirs.slice(1)
-  const batch = renderText(events)
-  const lastMsg = events[events.length - 1]?.message_id || '-'
-
-  // 每(任务,群)一把锁串行:并发会写坏 append-only ledger、错算 epoch,
-  // 且同群两轮 claude 会互相打断。粒度是群而非话题 —— session 与 epoch 状态按群竞争。
-  const lock = await acquireBlocking(`dispatch-${task}__${chatId}`, 1800_000)
-  if (!lock.ok) {
-    process.stderr.write(`dispatch: ${task}/${chatId} 获取锁超时,跳过本批\n`)
-    return 0
-  }
-
-  try {
-    // session 派生:work 模式按 thread_id 隔离(话题即边界,不滚动,epoch 恒 0);
-    // chat 模式按 (群, epoch),空闲超 idle_gap 就开新世代
-    let uuid
-    let epoch = 0
-    if (mode.thread && threadId) {
-      uuid = claude.deriveUuid(task, `${chatId}|thread:${threadId}`)
-    } else {
-      epoch = claude.sessionEpoch(paths.root, task, chatId, Number(cfg.idle_gap) || 86400)
-      uuid = claude.deriveUuid(task, `${chatId}|${epoch}`)
-    }
-
-    // 过程展示:work 模式挂 COT 消息。建不起来就静默降级(结论照发)
-    let cot = null
-    if (mode.cot) {
-      cot = new CotSession({ profile, chatId, lastMsg, replyInThread: mode.thread })
-      try {
-        if (!(await cot.create())) throw new Error('建 COT 消息失败')
-      } catch (err) {
-        process.stderr.write(`cot: ${err.message},本轮无过程展示\n`)
-        cot = null
-      }
-    }
-
-    const res = await claude.runClaude({
-      cwd,
-      prompt: claude.PROMPTS[mode.prompt](batch),
-      uuid,
-      instructions: insPath,
-      addDirs,
-      allowedTools: cfg.allowed || 'Read Edit Write Bash',
-      model: cfg.model,
-      timeoutSec: Number(cfg.timeout) || 1800,
-      stream: !!cot,
-      onEvent: cot
-        ? (kind, text) => {
-            if (kind === 'say') cot.onSay(text)
-            else if (kind === 'tool') cot.onTool(text)
-            else if (kind === 'final') cot.onFinal()
-          }
-        : null,
-    })
-
-    // 兜底文案分两套:要发回群的(deliver != none)面向群里的人写,
-    // agent 模式的 final 只进台账,不该出现「稍后重试或换个说法」这种对人说的话
-    let final = (res.final || '').trim()
-    if (!final) {
-      const errTail = String(res.err).replace(/\n/g, ' ').slice(-300)
-      if (mode.deliver === 'none') {
-        final = res.rc === 0 ? '(本轮无自述)' : `(异常 rc=${res.rc}) ${errTail}`
-      } else {
-        final =
-          res.rc === 0
-            ? '(完成,但没拿到最终结论)'
-            : `⚠️ 处理超时或异常(rc=${res.rc})。稍后重试或换个说法。\n\n错误:${errTail}`
-      }
-    }
-
-    // 收尾必须包 try/catch:handleGroup 外层只有 try/finally(无 catch),
-    // 收尾一抛就会跳过下面的结论投递 + ledgerAppend,而 take 游标已推
-    // → 结论既不进群也不进台账,这批消息永不重来
-    if (cot) {
-      try {
-        await cot.finalize({ rc: res.rc, error: res.err })
-        await cot.stop()
-      } catch (err) {
-        process.stderr.write(`cot: 收尾异常(不影响结论)→ ${err.stack || err}\n`)
-      }
-    }
-
-    // 结论投递:card = 卡片(markdown 渲染、不受 3500 字符分片限制),失败降级纯文本;
-    // text = 纯文本;none = **引擎不发**,agent 模式下模型已自己发过了,
-    // final 只是它的一句自述(进台账供回溯)
-    if (mode.deliver !== 'none') {
-      const sent = mode.deliver === 'card'
-        ? await sendCard(final, { profile, chatId, replyTo: lastMsg, inThread: mode.thread })
-        : false
-      if (!sent) await reply(profile, chatId, lastMsg, final, { inThread: mode.thread })
-    }
-
-    ledgerAppend(task, chatId, epoch, batch, final)
-    process.stderr.write(
-      `dispatch: ${task}/${chatId}${threadId ? `/${threadId}` : ''} 完成 rc=${res.rc} ` +
-        `${events.length} 条 → ${final.length} 字符\n`,
-    )
-    return res.rc === 0 ? 0 : 1
-  } finally {
-    lock.release()
-  }
-}
-
-async function run(task, opts = {}) {
-  const t = loadTask(task)
-  if (!t) {
-    process.stderr.write(
-      `找不到任务 ${task}:${path.join(lrRoot(), task, 'dispatch.yaml')} 不存在\n` +
-        `LR_ROOT=${lrRoot()};看现有任务:lark-relay dispatch --list\n`,
-    )
-    return 2
-  }
-  if (t.errs.length) {
-    process.stderr.write(`任务 ${task} 配置有问题:\n  ${t.errs.join('\n  ')}\n`)
-    return 2
-  }
-
-  const cfg = t.config
-  const chats = cfg.chats || []
-  // work=话题内一问一答要跟手 → 1s;chat=群里多行需求 → 15s 让人打完
-  const debounceMs = (Number(cfg.debounce) || t.mode.debounce) * 1000
-
-  process.stderr.write(
-    `dispatch ${task}: app=${cfg.app} ${chats.length} 群 mode=${t.modeName} ` +
-      `model=${cfg.model || '(默认路由)'} 防抖 ${debounceMs / 1000}s\n`,
-  )
-
-  const consumer = `dispatch-${task}`
-  if (store.readCursor(consumer, cfg.app) === null) store.seedCursorNow(consumer, cfg.app)
-
-  const ac = new AbortController()
-  let stopping = false
-  const onSig = () => {
-    stopping = true
-    ac.abort()
-  }
-  process.on('SIGTERM', onSig)
-  process.on('SIGINT', onSig)
-
-  for (;;) {
-    let res
-    try {
-      res = await takeBatch({
-        app: cfg.app,
-        chats,
-        name: consumer,
-        filter: cfg.filter,
-        debounceMs,
-        maxWaitMs: 75_000,
-        timeoutMs: opts.once ? 300_000 : 12 * 3600 * 1000,
-        signal: ac.signal,
-      })
-    } catch (err) {
-      // 取批阶段的异常绝不能让进程退出:Restart=on-failure 会变成每 5s 崩一次,
-      // 而卡住的那条消息永远在队首 → 任务彻底停摆且看不出原因
-      process.stderr.write(`dispatch: ${task} 取批失败,15s 后重试 → ${err.stack || err}\n`)
-      if (opts.once) return 1
-      await new Promise((r) => setTimeout(r, 15_000))
-      continue
-    }
-
-    if (res.events.length) {
-      // 一个防抖窗口会吐同群多话题的消息,只按 chat_id 分组会**串话题**
-      const groups = groupByChatThread(res.events)
-      for (let i = 0; i < groups.length; i++) {
-        // 收到停止信号后不再开新一轮 claude:单元 TimeoutStopSec=30,
-        // 而一轮最长 1800s → 会被 SIGKILL,卡片停在占位符、结论不回群。
-        // 游标此时也没推(take 的 abort 分支只在有批次时推),故剩余组下次重新取到
-        if (stopping) {
-          process.stderr.write(
-            `dispatch: ${task} 正在停止,剩余 ${groups.length - i} 组留到下次\n`,
-          )
-          break
-        }
-        try {
-          await handleGroup(t, groups[i])
-        } catch (err) {
-          process.stderr.write(`dispatch: ${task} 处理组失败 ${err.stack || err}\n`)
-        }
-      }
-    } else if (opts.once) {
-      process.stderr.write(`dispatch: 没等到消息(${res.reason})\n`)
-      return res.reason === 'timeout' ? 4 : 0 // 与 take 对齐:4 = 等超时,0 = 正常
-    }
-
-    if (opts.once || stopping) return 0
-  }
-}
-
-module.exports = { run, cmdList, handleGroup }

package/lib/reply.js

@@ -1,69 +0,0 @@
-'use strict'
-
-// 回群:超长按**字符**分片。飞书单条 text 有长度上限,超长会整条发送失败
-// (用户收不到任何东西),故必须分片而非截断。
-const larkcli = require('./larkcli')
-const { errText, tail } = larkcli
-
-const CHUNK = Number(process.env.LR_REPLY_CHUNK || 3500)
-
-// 首片 reply、其余直发;每片尾标 (i/n)。任一片失败只置 rc,循环继续发完剩余片。
-async function reply(profile, chatId, msgId, text, opts = {}) {
-  if (!text) return true
-  // 按码点数,不按字节 —— C locale 下按字节会切坏中文
-  const chars = [...String(text)]
-  if (chars.length <= CHUNK) {
-    return await replyOne(profile, chatId, msgId, text, opts.inThread)
-  }
-  const n = Math.ceil(chars.length / CHUNK)
-  process.stderr.write(`lr: 回复超长(${chars.length} 字符)→ 分 ${n} 片发送 chat=${chatId}\n`)
-  let ok = true
-  for (let i = 0; i < n; i++) {
-    const part = `${chars.slice(i * CHUNK, (i + 1) * CHUNK).join('')}\n(${i + 1}/${n})`
-    // 话题由首条锚定即可,续片不带 reply-in-thread
-    const r =
-      i === 0
-        ? await replyOne(profile, chatId, msgId, part, opts.inThread)
-        : await replyOne(profile, chatId, '-', part, false)
-    if (!r) ok = false
-  }
-  return ok
-}
-
-async function replyOne(profile, chatId, msgId, text, inThread) {
-  const hasParent = msgId && msgId !== '-'
-  if (hasParent) {
-    try {
-      const data = { msg_type: 'text', content: JSON.stringify({ text }) }
-      if (inThread) data.reply_in_thread = true
-      const { stdout } = await larkcli.run([
-        '--profile', profile, 'api', 'POST',
-        `/open-apis/im/v1/messages/${msgId}/reply`,
-        '--as', 'bot', '--data', JSON.stringify(data),
-      ])
-      if (/"ok":\s*true/.test(stdout)) return true
-      process.stderr.write(`lr: reply 未 ok chat=${chatId} msg=${msgId} → ${tail(stdout)}\n`)
-    } catch (err) {
-      // 原消息过期/权限不足 → 自动退回直发群
-      process.stderr.write(`lr: reply 失败 chat=${chatId} msg=${msgId} → ${tail(errText(err))}\n`)
-    }
-  }
-  try {
-    const { stdout } = await larkcli.run([
-      '--profile', profile, 'im', '+messages-send',
-      '--params', JSON.stringify({ receive_id_type: 'chat_id' }),
-      '--data', JSON.stringify({
-        receive_id: chatId, msg_type: 'text', content: JSON.stringify({ text }),
-      }),
-      '--as', 'bot',
-    ])
-    if (/"ok":\s*true/.test(stdout)) return true
-    process.stderr.write(`lr: 发群未 ok chat=${chatId} → ${tail(stdout)}\n`)
-    return false
-  } catch (err) {
-    process.stderr.write(`lr: 发群失败 chat=${chatId} → ${tail(errText(err))}\n`)
-    return false
-  }
-}
-
-module.exports = { reply, CHUNK }

package/lib/tasks.js

@@ -1,181 +0,0 @@
-'use strict'
-
-// dispatch 任务发现:扫 $LR_ROOT/*/dispatch.yaml —— 有文件即是任务,无需注册表。
-// LR_ROOT 是唯一的目录绑定,在 systemd 单元里指定,与代码位置无关。
-const fs = require('fs')
-const path = require('path')
-
-function lrRoot() {
-  return process.env.LR_ROOT || process.cwd()
-}
-
-// 极小 YAML 子集解析器:dispatch.yaml 只需要标量、行内数组 [a, b]、块数组 - a。
-// 不引 js-yaml —— 包保持零依赖,而配置面就这 8 个键。
-function parseYaml(text) {
-  const out = {}
-  const lines = text.split('\n')
-  let curKey = null // 正在收集块数组的键
-  for (let raw of lines) {
-    const line = stripComment(raw)
-    if (!line.trim()) continue
-
-    const blockItem = line.match(/^\s*-\s*(.*)$/)
-    if (blockItem && curKey) {
-      out[curKey].push(scalar(blockItem[1]))
-      continue
-    }
-
-    const kv = line.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/)
-    if (!kv) continue
-    const key = kv[1]
-    const val = kv[2].trim()
-    if (val === '') {
-      // 下面跟块数组
-      out[key] = []
-      curKey = key
-      continue
-    }
-    curKey = null
-    if (val.startsWith('[')) {
-      out[key] = parseInline(val)
-    } else {
-      out[key] = scalar(val)
-    }
-  }
-  return out
-}
-
-// 注释剥离要避开引号内的 # (filter 表达式里常有 open_id,不含 # 但别赌)
-function stripComment(line) {
-  let inS = false
-  let inD = false
-  for (let i = 0; i < line.length; i++) {
-    const c = line[i]
-    if (c === "'" && !inD) inS = !inS
-    else if (c === '"' && !inS) inD = !inD
-    else if (c === '#' && !inS && !inD) {
-      // 只有 # 前是行首或空白才算注释
-      if (i === 0 || /\s/.test(line[i - 1])) return line.slice(0, i)
-    }
-  }
-  return line
-}
-
-function parseInline(val) {
-  const inner = val.replace(/^\[/, '').replace(/\]\s*$/, '')
-  if (!inner.trim()) return []
-  return splitTop(inner).map(scalar)
-}
-
-// 按顶层逗号切,尊重引号
-function splitTop(s) {
-  const out = []
-  let cur = ''
-  let inS = false
-  let inD = false
-  for (const c of s) {
-    if (c === "'" && !inD) {
-      inS = !inS
-      cur += c
-    } else if (c === '"' && !inS) {
-      inD = !inD
-      cur += c
-    } else if (c === ',' && !inS && !inD) {
-      out.push(cur)
-      cur = ''
-    } else cur += c
-  }
-  if (cur.trim()) out.push(cur)
-  return out
-}
-
-function scalar(s) {
-  let v = s.trim()
-  if (
-    (v.startsWith("'") && v.endsWith("'") && v.length >= 2) ||
-    (v.startsWith('"') && v.endsWith('"') && v.length >= 2)
-  ) {
-    return v.slice(1, -1)
-  }
-  if (v === 'true') return true
-  if (v === 'false') return false
-  if (v === 'null' || v === '~') return null
-  if (/^-?\d+$/.test(v)) return Number(v)
-  return v
-}
-
-const REQUIRED = ['app', 'chats', 'dirs', 'instructions']
-
-// 三个场景,不是几个正交开关的组合 —— 一个 mode 键定死全部行为。
-// deliver 决定「结论由谁发」:card/text = 引擎发,none = 模型自己发。
-const MODES = {
-  // 日常闲聊:群里直接对话,不开话题
-  chat: { thread: false, cot: false, deliver: 'text', prompt: 'task', debounce: 15 },
-  // 处理工作:话题内一问一答,过程挂 COT,结论发卡片
-  work: { thread: true, cot: true, deliver: 'card', prompt: 'task', debounce: 1 },
-  // 模型自己当运营者:引擎只拉起它 + 传消息 + 记台账,**不发任何消息**。
-  // 发不发、回哪条、用谁的身份、文字还是表情,全由模型按 instructions 决定
-  // (它有 Bash + lark-cli)。多数轮的正解是沉默 —— 引擎不该逼它每轮都说话
-  agent: { thread: false, cot: false, deliver: 'none', prompt: 'agent', debounce: 15 },
-}
-
-function validate(name, cfg, taskDir) {
-  const errs = []
-  for (const k of REQUIRED) {
-    if (cfg[k] === undefined || cfg[k] === null || cfg[k] === '') errs.push(`缺 ${k}`)
-  }
-  if (cfg.chats && !Array.isArray(cfg.chats)) errs.push('chats 必须是数组')
-  if (cfg.dirs && !Array.isArray(cfg.dirs)) errs.push('dirs 必须是数组')
-  for (const c of cfg.chats || []) {
-    if (typeof c !== 'string' || !c.startsWith('oc_')) errs.push(`chats 项不是 oc_ 开头:${c}`)
-  }
-  const modeName = cfg.mode || 'work'
-  if (!MODES[modeName]) errs.push(`mode 只能 ${Object.keys(MODES).join('|')},给的是 ${modeName}`)
-  const mode = MODES[modeName] || MODES.work
-
-  // instructions 相对任务目录解析 —— 执行偏好是资产,必须留仓库
-  let insPath = null
-  if (cfg.instructions) {
-    insPath = path.resolve(taskDir, cfg.instructions)
-    if (!fs.existsSync(insPath)) errs.push(`instructions 文件不存在:${insPath}`)
-  }
-  const dirs = (cfg.dirs || []).map((d) => path.resolve(taskDir, d))
-  for (const d of dirs) {
-    if (!fs.existsSync(d)) errs.push(`dirs 目录不存在:${d}`)
-  }
-  return { errs, insPath, dirs, modeName, mode }
-}
-
-function loadTask(name, root = lrRoot()) {
-  const taskDir = path.join(root, name)
-  const file = path.join(taskDir, 'dispatch.yaml')
-  let text
-  try {
-    text = fs.readFileSync(file, 'utf8')
-  } catch {
-    return null
-  }
-  const cfg = parseYaml(text)
-  const v = validate(name, cfg, taskDir)
-  return { name, taskDir, file, config: cfg, ...v }
-}
-
-function listTasks(root = lrRoot()) {
-  let names
-  try {
-    names = fs.readdirSync(root, { withFileTypes: true })
-      .filter((d) => d.isDirectory() && !d.name.startsWith('.'))
-      .map((d) => d.name)
-      .sort()
-  } catch {
-    return []
-  }
-  const out = []
-  for (const name of names) {
-    const t = loadTask(name, root)
-    if (t) out.push(t)
-  }
-  return out
-}
-
-module.exports = { lrRoot, parseYaml, loadTask, listTasks, validate }