sintbot 1.0.16 → 1.3.0

package/src/cdp.js

@@ -1,254 +0,0 @@
-'use strict'
-// 常驻浏览器的 CDP 客户端(Chrome DevTools Protocol)—— 控制台「接管浏览器」页的底座。
-//
-// 为什么自己写而不用 chrome-devtools-mcp:MCP 是给 agent 用的工具面(元素 uid、快照),接管页要的是
-// **原始画面 + 原始输入** —— 截屏推流(Page.startScreencast)与按坐标的鼠标 / 键盘事件(Input.*),
-// 且要在 daemon 进程里长连接、按需 attach 到某个标签页。MCP 没有这两样,也不该有(它面向 agent)。
-//
-// 传输:HTTP 端点(/json、/json/new …)走 node:http;协议通道走 WebSocket(`ws` 包 —— 飞书 SDK 已带同一份,
-// 声明进依赖是为了不靠提升的巧合;Node 18/20 没有全局 WebSocket)。`WebSocketImpl` 可注入 ⇒ 单测用假的。
-//
-// ⚠ 只连 cfg.browser.cdpUrl(默认本机 9222)。9222 只绑 localhost,但本机任意进程都能经它操控已登录的浏览器
-//   (docs/BROWSER.md 安全口径)—— 这里不再加门,门在控制台那层(登录 / 一次性链接)。
-
-const http = require('node:http')
-
-const DEFAULT_CDP_URL = 'http://127.0.0.1:9222'
-
-// —— HTTP 端点 ——
-function httpJSON(url, { method = 'GET', timeoutMs = 3000 } = {}) {
-  return new Promise((resolve, reject) => {
-    const u = new URL(url)
-    const req = http.request({ host: u.hostname, port: u.port || 80, path: u.pathname + u.search, method, timeout: timeoutMs }, (res) => {
-      let b = ''
-      res.setEncoding('utf8')
-      res.on('data', (c) => { b += c })
-      res.on('end', () => {
-        if (res.statusCode >= 400) return reject(new Error(`浏览器端点 ${u.pathname} 返回 HTTP ${res.statusCode}`)) // 文案可能原样到接管页 / 群里,不带协议名
-        if (!b.trim()) return resolve(null)
-        try { resolve(JSON.parse(b)) } catch { resolve(b) } // /json/close 之类返回纯文本
-      })
-    })
-    req.on('timeout', () => req.destroy(new Error('浏览器端点超时')))
-    req.on('error', reject)
-    req.end()
-  })
-}
-
-// 浏览器还活着吗:/json/version(Browser 字段形如 "Chrome/152.0.7977.83")
-const versionInfo = (cdpUrl = DEFAULT_CDP_URL, opts = {}) => httpJSON(`${cdpUrl}/json/version`, opts)
-
-// 页面型 target 清单(过滤掉 chrome:// / devtools:// / 扩展页这类不是「网页」的东西)
-async function listTargets(cdpUrl = DEFAULT_CDP_URL) {
-  const all = (await httpJSON(`${cdpUrl}/json`)) || []
-  return all
-    .filter((t) => t && t.type === 'page' && /^(https?:|about:|file:)/.test(String(t.url || '')))
-    .map((t) => ({ id: t.id, title: t.title || '', url: t.url || '', wsUrl: t.webSocketDebuggerUrl || '' }))
-}
-
-const newTarget = (cdpUrl, url) => httpJSON(`${cdpUrl}/json/new?${encodeURIComponent(url || 'about:blank')}`, { method: 'PUT' })
-const activateTarget = (cdpUrl, id) => httpJSON(`${cdpUrl}/json/activate/${encodeURIComponent(id)}`)
-const closeTarget = (cdpUrl, id) => httpJSON(`${cdpUrl}/json/close/${encodeURIComponent(id)}`)
-
-// —— 协议会话 ——
-// 一个 target 一条 ws。call() 按 id 配对回包;on() 收事件(Page.screencastFrame 之类)。
-// 超时 / 断线时把所有挂着的 call 一起拒掉,调用方不会悬着。
-class CdpSession {
-  constructor(wsUrl, { WebSocketImpl = null, timeoutMs = 15000 } = {}) {
-    this.wsUrl = wsUrl
-    this.WebSocketImpl = WebSocketImpl || require('ws')
-    this.timeoutMs = timeoutMs
-    this.ws = null
-    this.connected = false
-    this._id = 0
-    this._pending = new Map() // id -> { resolve, reject, timer }
-    this._handlers = new Map() // method -> Set(fn)
-    this._onClose = new Set()
-  }
-
-  connect() {
-    return new Promise((resolve, reject) => {
-      const ws = new this.WebSocketImpl(this.wsUrl)
-      this.ws = ws
-      const fail = (e) => { if (!this.connected) reject(e instanceof Error ? e : new Error(String(e && e.message || e || '连不上浏览器'))) }
-      ws.on('open', () => { this.connected = true; resolve(this) })
-      ws.on('error', (e) => { fail(e); this._failAll(e) })
-      ws.on('close', () => { this.connected = false; this._failAll(new Error('浏览器连接已断开')); for (const fn of this._onClose) { try { fn() } catch {} } })
-      ws.on('message', (data) => this._onMessage(data))
-    })
-  }
-
-  _onMessage(data) {
-    let m
-    try { m = JSON.parse(typeof data === 'string' ? data : data.toString('utf8')) } catch { return }
-    if (m.id != null && this._pending.has(m.id)) {
-      const p = this._pending.get(m.id); this._pending.delete(m.id); clearTimeout(p.timer)
-      if (m.error) p.reject(new Error(`${p.method}: ${m.error.message || JSON.stringify(m.error)}`))
-      else p.resolve(m.result || {})
-      return
-    }
-    if (m.method) {
-      const hs = this._handlers.get(m.method)
-      if (hs) for (const fn of hs) { try { fn(m.params || {}) } catch (e) { /* 单个处理器出错不影响别的 */ } }
-    }
-  }
-
-  _failAll(e) {
-    for (const [, p] of this._pending) { clearTimeout(p.timer); p.reject(e) }
-    this._pending.clear()
-  }
-
-  call(method, params = {}) {
-    if (!this.connected || !this.ws) return Promise.reject(new Error('浏览器连接未就绪'))
-    const id = ++this._id
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => { if (this._pending.delete(id)) reject(new Error(`${method} 超时`)) }, this.timeoutMs)
-      this._pending.set(id, { resolve, reject, timer, method })
-      try { this.ws.send(JSON.stringify({ id, method, params })) } catch (e) { this._pending.delete(id); clearTimeout(timer); reject(e) }
-    })
-  }
-
-  on(method, fn) { if (!this._handlers.has(method)) this._handlers.set(method, new Set()); this._handlers.get(method).add(fn); return () => this.off(method, fn) }
-  off(method, fn) { const hs = this._handlers.get(method); if (hs) hs.delete(fn) }
-  onClose(fn) { this._onClose.add(fn); return () => this._onClose.delete(fn) }
-
-  close() { this.connected = false; try { this.ws && this.ws.close() } catch {} ; this._failAll(new Error('已关闭')) }
-}
-
-// —— 截屏推流 ——
-// 帧只在页面重绘时才来(静止页面零流量),所以开流后先补一张 captureScreenshot 当首帧,免得人盯着空白。
-// ack 放在 onFrame 之后:消费方(SSE 写入)慢了,浏览器就攒着不发下一帧 —— 天然背压,不用自己丢帧。
-// 默认值的来由(2026-09-10 真机实测,手机尺寸):640 宽 / 45 质量一帧约 12 KB;everyNthFrame=2 把不限速时的 ~28 fps 压到一半,
-// 再由「onFrame 完成后才 ack」的背压按链路自然降到几帧每秒 —— 画面够顺、公网隧道与手机流量都扛得住。
-async function startScreencast(session, { maxWidth = 640, maxHeight = 1280, quality = 45, everyNthFrame = 2 } = {}, onFrame) {
-  await session.call('Page.enable')
-  const off = session.on('Page.screencastFrame', async (p) => {
-    try { await onFrame({ data: p.data, meta: p.metadata || {}, sessionId: p.sessionId }) } catch {}
-    try { await session.call('Page.screencastFrameAck', { sessionId: p.sessionId }) } catch {}
-  })
-  await session.call('Page.startScreencast', { format: 'jpeg', quality, maxWidth, maxHeight, everyNthFrame })
-  try { await seedFrame(session, { maxWidth, maxHeight, quality }, onFrame) } catch { /* 首帧补不上就等真帧 */ }
-  return async () => { off(); try { await session.call('Page.stopScreencast') } catch {} }
-}
-
-// 补一张首帧(开流时、以及后来才加入同一路推流的订阅者)。
-// ⚠ 首帧必须与推流帧同尺寸:captureScreenshot 默认按视口原尺寸出图,而推流帧被 maxWidth/maxHeight 缩过 ——
-//   两者不一致时,接管页在第二帧到来那一刻画面会跳一下,手指正按着的位置就漂了(2026-09-10 真机:拖滑块位移 0)。
-//   先读视口尺寸,按同样的比例给截图加 clip.scale。
-async function seedFrame(session, { maxWidth = 640, maxHeight = 1280, quality = 45 } = {}, onFrame) {
-  const lm = await session.call('Page.getLayoutMetrics')
-  const vv = (lm && (lm.cssVisualViewport || lm.visualViewport)) || {}
-  const cw = vv.clientWidth || 0, ch = vv.clientHeight || 0
-  const scale = cw > 0 && ch > 0 ? Math.min(1, maxWidth / cw, maxHeight / ch) : 1
-  const params = { format: 'jpeg', quality }
-  if (cw > 0 && ch > 0) params.clip = { x: 0, y: 0, width: cw, height: ch, scale }
-  const shot = await session.call('Page.captureScreenshot', params)
-  await onFrame({ data: shot.data, meta: { deviceWidth: cw, deviceHeight: ch, seed: true }, sessionId: null })
-}
-
-// 给 CLI 用:截某个标签页一张缩略图(接管卡片上的「卡在哪个页面」)。连一次、截一张、关掉;失败抛错由调用方决定要不要图。
-async function captureTarget(cdpUrl, targetId, { maxWidth = 640, quality = 60, WebSocketImpl = null } = {}) {
-  const targets = await listTargets(cdpUrl)
-  const t = targets.find((x) => x.id === targetId)
-  if (!t) throw new Error('这个标签页已经不在了')
-  const session = new CdpSession(t.wsUrl, { WebSocketImpl })
-  await session.connect()
-  try {
-    let data = null
-    await seedFrame(session, { maxWidth, maxHeight: maxWidth * 2, quality }, (f) => { data = f.data })
-    return { data, title: t.title, url: t.url }
-  } finally { session.close() }
-}
-
-// —— 输入:接管页发来的事件 → CDP 调用(纯函数,可测)——
-// 坐标一律是页面 CSS 像素(接管页按帧的 deviceWidth/Height 换算好再发),这里只做校验与翻译。
-const KEYS = {
-  Enter: { key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13, text: '\r' },
-  Backspace: { key: 'Backspace', code: 'Backspace', windowsVirtualKeyCode: 8 },
-  Tab: { key: 'Tab', code: 'Tab', windowsVirtualKeyCode: 9 },
-  Escape: { key: 'Escape', code: 'Escape', windowsVirtualKeyCode: 27 },
-  Delete: { key: 'Delete', code: 'Delete', windowsVirtualKeyCode: 46 },
-  ArrowUp: { key: 'ArrowUp', code: 'ArrowUp', windowsVirtualKeyCode: 38 },
-  ArrowDown: { key: 'ArrowDown', code: 'ArrowDown', windowsVirtualKeyCode: 40 },
-  ArrowLeft: { key: 'ArrowLeft', code: 'ArrowLeft', windowsVirtualKeyCode: 37 },
-  ArrowRight: { key: 'ArrowRight', code: 'ArrowRight', windowsVirtualKeyCode: 39 },
-  Home: { key: 'Home', code: 'Home', windowsVirtualKeyCode: 36 },
-  End: { key: 'End', code: 'End', windowsVirtualKeyCode: 35 },
-  PageUp: { key: 'PageUp', code: 'PageUp', windowsVirtualKeyCode: 33 },
-  PageDown: { key: 'PageDown', code: 'PageDown', windowsVirtualKeyCode: 34 },
-}
-// 一次插入的文本上限:验证码 / 账号 / 一段地址都远小于此;更长的多半是误粘贴(整页文本),不该一股脑塞进输入框
-const MAX_TEXT = 4000
-const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? Math.round(v * 10) / 10 : null)
-
-// 非文本键必须带 windowsVirtualKeyCode:CDP 只凭 key/code 不会触发页面里按键盘码判断的逻辑(表单的 Enter 提交、退格删字)—— 与 puppeteer 的键表同款。
-// 坐标上限 20000 / 滚轮上限 5000:视口再大也到不了的值,只用来拦明显的垃圾输入(NaN、负数、乱填),不是精确边界。
-// 一个接管页事件 → 若干 { method, params };不认识 / 不合法 ⇒ null(调用方跳过,不报错,免得一个坏事件卡住整批)
-function inputToCdp(ev) {
-  if (!ev || typeof ev !== 'object') return null
-  const t = ev.t
-  if (t === 'text') {
-    const text = String(ev.text == null ? '' : ev.text)
-    if (!text || text.length > MAX_TEXT) return null
-    return [{ method: 'Input.insertText', params: { text } }]
-  }
-  if (t === 'key') {
-    const k = Object.prototype.hasOwnProperty.call(KEYS, String(ev.key)) ? KEYS[ev.key] : null // hasOwn:'__proto__' 之类的键名不能摸到原型
-    if (!k) return null
-    const mods = (ev.shift ? 8 : 0) | (ev.ctrl ? 2 : 0) | (ev.alt ? 1 : 0) | (ev.meta ? 4 : 0)
-    // Enter 的 text 让输入框真的换行 / 提交:keyDown 带 text 才触发 keypress 语义(与 puppeteer 同款)
-    const down = { type: k.text ? 'keyDown' : 'rawKeyDown', key: k.key, code: k.code, windowsVirtualKeyCode: k.windowsVirtualKeyCode, modifiers: mods }
-    if (k.text) down.text = k.text
-    return [{ method: 'Input.dispatchKeyEvent', params: down }, { method: 'Input.dispatchKeyEvent', params: { type: 'keyUp', key: k.key, code: k.code, windowsVirtualKeyCode: k.windowsVirtualKeyCode, modifiers: mods } }]
-  }
-  const x = num(ev.x), y = num(ev.y)
-  if (x == null || y == null || x < 0 || y < 0 || x > 20000 || y > 20000) return null
-  if (t === 'move') return [{ method: 'Input.dispatchMouseEvent', params: { type: 'mouseMoved', x, y, button: ev.down ? 'left' : 'none', buttons: ev.down ? 1 : 0 } }]
-  if (t === 'down') return [{ method: 'Input.dispatchMouseEvent', params: { type: 'mousePressed', x, y, button: 'left', buttons: 1, clickCount: 1 } }]
-  if (t === 'up') return [{ method: 'Input.dispatchMouseEvent', params: { type: 'mouseReleased', x, y, button: 'left', buttons: 0, clickCount: 1 } }]
-  if (t === 'tap') return [
-    { method: 'Input.dispatchMouseEvent', params: { type: 'mouseMoved', x, y, button: 'none', buttons: 0 } },
-    { method: 'Input.dispatchMouseEvent', params: { type: 'mousePressed', x, y, button: 'left', buttons: 1, clickCount: 1 } },
-    { method: 'Input.dispatchMouseEvent', params: { type: 'mouseReleased', x, y, button: 'left', buttons: 0, clickCount: 1 } },
-  ]
-  if (t === 'wheel') {
-    const dx = num(ev.dx) || 0, dy = num(ev.dy) || 0
-    if (Math.abs(dx) > 5000 || Math.abs(dy) > 5000) return null
-    return [{ method: 'Input.dispatchMouseEvent', params: { type: 'mouseWheel', x, y, deltaX: dx, deltaY: dy } }]
-  }
-  return null
-}
-
-// 一批事件按序下发;坏事件跳过(计入 skipped),CDP 报错(页面正在导航之类)记下继续,不中断整批。
-// 超过 max 时只丢 move / wheel(丢掉中间几步无伤),**down / up / key / text 一个都不能丢** —— 丢了 up 鼠标就卡在按下态
-// (对抗审查 🟡7);丢了多少报 dropped,让页面知道。
-function trimEvents(events, max) {
-  const list = Array.isArray(events) ? events : []
-  if (list.length <= max) return { list, dropped: 0 }
-  const must = list.filter((e) => e && e.t !== 'move' && e.t !== 'wheel')
-  const room = Math.max(0, max - must.length)
-  const soft = list.filter((e) => e && (e.t === 'move' || e.t === 'wheel'))
-  const keepSoft = new Set(soft.slice(soft.length - room)) // 留最近的几步,老的丢
-  const out = list.filter((e) => e && (e.t !== 'move' && e.t !== 'wheel' ? true : keepSoft.has(e))).slice(0, Math.max(max, must.length))
-  return { list: out, dropped: list.length - out.length }
-}
-async function dispatchInputs(session, events, { max = 200 } = {}) {
-  const { list, dropped } = trimEvents(events, max)
-  let sent = 0, skipped = 0, failed = 0
-  for (const ev of list) {
-    const calls = inputToCdp(ev)
-    if (!calls) { skipped++; continue }
-    for (const c of calls) { try { await session.call(c.method, c.params); sent++ } catch { failed++ } }
-  }
-  return { sent, skipped, failed, dropped }
-}
-
-// 接管页 → 页面坐标:帧图片的像素坐标按帧元数据里的视口尺寸(CSS px)线性换算;越界夹回
-function pointerToCss({ px, py, imgW, imgH, cssW, cssH }) {
-  if (!(imgW > 0) || !(imgH > 0) || !(cssW > 0) || !(cssH > 0)) return null
-  const x = Math.min(cssW, Math.max(0, (px / imgW) * cssW))
-  const y = Math.min(cssH, Math.max(0, (py / imgH) * cssH))
-  return { x: Math.round(x * 10) / 10, y: Math.round(y * 10) / 10 }
-}
-
-module.exports = { DEFAULT_CDP_URL, httpJSON, versionInfo, listTargets, newTarget, activateTarget, closeTarget, CdpSession, startScreencast, seedFrame, captureTarget, inputToCdp, dispatchInputs, trimEvents, pointerToCss, KEYS, MAX_TEXT }

package/src/cli-secret.js

@@ -1,36 +0,0 @@
-// Mask characters echoed by a terminal readline prompt while a secret is being entered.
-// Readline's _writeToOutput is the single output path for terminal echo; prompts and
-// cursor-control sequences stay intact so paste, backspace and arrow-key editing work.
-
-const CONTROL = /(\x1b\[[0-?]*[ -/]*[@-~]|\x1b[()][A-Za-z0-9]|\x08 \x08|[\x00-\x1f\x7f])/g
-const CONTROL_TOKEN = /^(?:\x1b\[[0-?]*[ -/]*[@-~]|\x1b[()][A-Za-z0-9]|\x08 \x08|[\x00-\x1f\x7f])$/
-
-function maskReadlineEcho(text) {
-  return String(text).split(CONTROL).map((part) => {
-    if (!part || CONTROL_TOKEN.test(part)) return part
-    return '•'.repeat(Array.from(part).length)
-  }).join('')
-}
-
-function createReadlineSecretMask(rl) {
-  if (!rl || typeof rl._writeToOutput !== 'function') throw new TypeError('readline interface required')
-  const original = rl._writeToOutput
-  let activePrompt = null
-
-  rl._writeToOutput = function (text) {
-    if (activePrompt === null) return original.call(this, text)
-    text = String(text)
-    const promptAt = text.lastIndexOf(activePrompt)
-    if (promptAt < 0) return original.call(this, maskReadlineEcho(text))
-    const promptEnd = promptAt + activePrompt.length
-    return original.call(this, text.slice(0, promptEnd) + maskReadlineEcho(text.slice(promptEnd)))
-  }
-
-  return {
-    start(prompt) { activePrompt = String(prompt) },
-    stop() { activePrompt = null },
-    restore() { activePrompt = null; rl._writeToOutput = original },
-  }
-}
-
-module.exports = { maskReadlineEcho, createReadlineSecretMask }

package/src/clilang.js

@@ -1,31 +0,0 @@
-// 命令行输出语言(安装向导、服务安装这些新用户第一眼看到的输出;其余命令仍是中文)。
-// 判据与 install.sh 的 detect_lang 一致:SINTBOT_LANG=zh|en 优先;否则 locale(LC_ALL / LC_MESSAGES / LANG)
-// 或 macOS 系统语言(AppleLanguages 第一项)有一处是中文就用中文,其余英文。
-// 为什么看系统语言:不少人在 ~/.zshenv 里写死 LANG=en_US.UTF-8(工具链兼容),界面却是中文 ——
-// 1.0.11 实装时安装脚本因此出英文、向导是中文,同一屏两种语言。
-const { spawnSync } = require('node:child_process')
-
-let macCache
-function macLanguage({ platform = process.platform, run = spawnSync } = {}) {
-  if (platform !== 'darwin') return ''
-  if (macCache !== undefined) return macCache
-  try {
-    const r = run('defaults', ['read', '-g', 'AppleLanguages'], { encoding: 'utf8', timeout: 2000 })
-    const m = String((r && r.stdout) || '').match(/"?([A-Za-z]{2,3})[-_A-Za-z]*"?/)
-    macCache = m ? m[1].toLowerCase() : ''
-  } catch { macCache = '' }
-  return macCache
-}
-
-function cliLang({ env = process.env, platform = process.platform, run } = {}) {
-  const forced = String(env.SINTBOT_LANG || '').toLowerCase()
-  if (forced === 'zh' || forced === 'en') return forced
-  const locale = env.LC_ALL || env.LC_MESSAGES || env.LANG || ''
-  if (/^zh/i.test(locale)) return 'zh'
-  return macLanguage({ platform, run }) === 'zh' ? 'zh' : 'en'
-}
-
-// tr('中文', 'English') —— 按当前语言取一句
-const tr = (zh, en, lang = cliLang()) => (lang === 'zh' ? zh : en)
-
-module.exports = { cliLang, tr, _resetCache: () => { macCache = undefined } }

package/src/core/cron.js

@@ -1,182 +0,0 @@
-// Minimal cron parser + matcher (zero-dep) for the 定时任务 base skill.
-//
-// Standard 5-field cron — "minute hour day-of-month month day-of-week" — plus @aliases
-// (@daily/@hourly/…) and a few Chinese shorthands ("每天 09:00", "工作日 8:30"). Matching
-// uses PRODUCT-TIMEZONE parts (Asia/Shanghai default, see time.js) so a task fires at the
-// wall-clock the user meant, regardless of the host's system timezone.
-//
-// Field syntax per position: `*`, `a`, `a-b`, `*/n`, `a/n`, `a-b/n`, and comma lists thereof.
-// day-of-week: 0=Sunday..6=Saturday. dom+dow both restricted ⇒ match EITHER (standard cron quirk).
-
-const { tzParts } = require('./time')
-
-const ALIASES = {
-  '@yearly': '0 0 1 1 *', '@annually': '0 0 1 1 *',
-  '@monthly': '0 0 1 * *', '@weekly': '0 0 * * 0',
-  '@daily': '0 0 * * *', '@midnight': '0 0 * * *', '@hourly': '0 * * * *',
-}
-
-const ZH_DOW = { 一: 1, 二: 2, 三: 3, 四: 4, 五: 5, 六: 6, 日: 0, 天: 0 }
-
-// A few human shorthands → a 5-field cron string, or null if it isn't one we recognize.
-function zhShorthand(s) {
-  const t = String(s).trim()
-  let m
-  if ((m = t.match(/^每天\s*(\d{1,2})[:：](\d{1,2})$/))) return `${+m[2]} ${+m[1]} * * *`
-  if ((m = t.match(/^工作日\s*(\d{1,2})[:：](\d{1,2})$/))) return `${+m[2]} ${+m[1]} * * 1-5`
-  if ((m = t.match(/^每周([一二三四五六日天])\s*(\d{1,2})[:：](\d{1,2})$/))) return `${+m[3]} ${+m[2]} * * ${ZH_DOW[m[1]]}`
-  if (/^每小时$/.test(t)) return '0 * * * *'
-  return null
-}
-
-// Normalize any accepted form to a validated 5-field string, or throw with a human message.
-function normalizeCron(expr) {
-  if (typeof expr !== 'string' || !expr.trim()) throw new Error('cron 表达式为空')
-  let s = expr.trim()
-  if (ALIASES[s.toLowerCase()]) s = ALIASES[s.toLowerCase()]
-  else { const zh = zhShorthand(s); if (zh) s = zh }
-  const parts = s.split(/\s+/)
-  if (parts.length !== 5) throw new Error(`cron 需要 5 段(分 时 日 月 周),或 @别名/中文简写(如「每天 09:00」),得到:${expr}`)
-  const ranges = [[0, 59], [0, 23], [1, 31], [1, 12], [0, 6]]
-  parts.forEach((f, i) => parseField(f, ranges[i][0], ranges[i][1])) // throws on a bad field
-  return parts.join(' ')
-}
-
-// Parse ONE field into a Set of allowed integers, or null for '*' (matches anything).
-function parseField(f, min, max) {
-  if (f === '*') return null
-  const out = new Set()
-  for (const part of String(f).split(',')) {
-    const m = part.match(/^(\*|\d+)(?:-(\d+))?(?:\/(\d+))?$/)
-    if (!m) throw new Error(`cron 字段无法解析:${part}`)
-    const step = m[3] ? +m[3] : 1
-    let lo, hi
-    if (m[1] === '*') { lo = min; hi = max }
-    else { lo = +m[1]; hi = m[2] != null ? +m[2] : (m[3] ? max : +m[1]) } // `a/n` runs a→max
-    if (lo < min || hi > max || lo > hi || step < 1) throw new Error(`cron 字段越界/非法:${part}`)
-    for (let v = lo; v <= hi; v += step) out.add(v)
-  }
-  return out
-}
-
-// Does the (normalized-or-raw) expr fire at instant `ts` interpreted in timezone `tz`?
-function matchCron(expr, ts, tz) {
-  const [fMin, fHour, fDom, fMon, fDow] = normalizeCron(expr).split(' ')
-  const p = tzParts(ts, tz)
-  const has = (field, val, min, max) => { const set = parseField(field, min, max); return set === null || set.has(val) }
-  // day-of-week from the tz-local calendar date (weekday is timezone-agnostic once y/m/d fixed)
-  const dow = new Date(Date.UTC(+p.year, +p.month - 1, +p.day)).getUTCDay() // 0=Sun..6=Sat
-  const domOk = has(fDom, +p.day, 1, 31), dowOk = has(fDow, dow, 0, 6)
-  const dayOk = (fDom !== '*' && fDow !== '*') ? (domOk || dowOk) : (domOk && dowOk)
-  return has(fMin, +p.minute, 0, 59) && has(fHour, +p.hour, 0, 23) && has(fMon, +p.month, 1, 12) && dayOk
-}
-
-// Human-readable Chinese summary of a cron expr for the console list ("0 9 * * 1-5" → "工作日
-// 09:00"). Covers the common schedules; anything richer falls back to the normalized cron string.
-const ZH_DOW_NAME = ['日', '一', '二', '三', '四', '五', '六']
-function describeCron(expr) {
-  let norm
-  try { norm = normalizeCron(expr) } catch { return String(expr) }
-  const [mi, h, dom, mon, dow] = norm.split(' ')
-  const single = (f) => /^\d+$/.test(f)
-  const hhmm = (H, M) => `${String(H).padStart(2, '0')}:${String(M).padStart(2, '0')}`
-  if (norm === '0 * * * *') return '每小时整点'
-  if (/^\*\/\d+$/.test(mi) && h === '*' && dom === '*' && mon === '*' && dow === '*') return `每 ${mi.slice(2)} 分钟`
-  if (single(mi) && single(h) && mon === '*') {
-    const t = hhmm(+h, +mi)
-    if (dom === '*' && dow === '*') return `每天 ${t}`
-    if (dom === '*' && dow === '1-5') return `工作日 ${t}`
-    if (dom === '*' && (dow === '0,6' || dow === '6,0')) return `周末 ${t}`
-    if (dom === '*' && single(dow)) return `每周${ZH_DOW_NAME[+dow]} ${t}`
-    if (dom === '*' && /^[0-6](,[0-6])+$/.test(dow)) return `每周${dow.split(',').map((d) => ZH_DOW_NAME[+d]).join('、')} ${t}`
-    if (single(dom) && dow === '*') return `每月 ${+dom} 号 ${t}`
-  }
-  // Fixed month+day (e.g. "10 13 16 7 *"): standard cron has no year, so this recurs EVERY year.
-  if (single(mi) && single(h) && single(mon) && single(dom) && dow === '*') return `每年 ${+mon} 月 ${+dom} 日 ${hhmm(+h, +mi)}`
-  return norm // fallback: the normalized cron itself
-}
-
-// ── One-shot tasks (一次性): stored as `at: "YYYY-MM-DD HH:mm"`, interpreted in the group's
-// timezone. Standard cron has no year, so a true one-off needs an absolute datetime. The scheduler
-// fires it in the matching minute; the daemon deletes it right after (fire-once, then gone).
-function normalizeAt(s) {
-  const m = String(s).trim().match(/^(\d{4})-(\d{1,2})-(\d{1,2})[ T](\d{1,2}):(\d{2})$/)
-  if (!m) throw new Error('一次性时间格式应为 YYYY-MM-DD HH:mm(如 2026-07-16 13:10)')
-  const mo = +m[2], d = +m[3], h = +m[4], mi = +m[5]
-  if (mo < 1 || mo > 12 || d < 1 || d > 31 || h > 23 || mi > 59) throw new Error('一次性时间越界:' + s)
-  return `${m[1]}-${String(mo).padStart(2, '0')}-${String(d).padStart(2, '0')} ${String(h).padStart(2, '0')}:${String(mi).padStart(2, '0')}`
-}
-
-// Fires when the tz-local wall-clock minute equals `at`.
-function matchAt(at, ts, tz) {
-  const p = tzParts(ts, tz)
-  return normalizeAt(at) === `${p.year}-${p.month}-${p.day} ${p.hour}:${p.minute}`
-}
-
-// Human string for a one-off. Relative to `nowStr` (the group-tz present as "YYYY-MM-DD HH:mm"):
-// same day ⇒ just "13:10"; same year ⇒ "7月16日 13:10"; else full "2026年7月16日 13:10". Omit
-// `nowStr` ⇒ always full absolute (keeps the fn pure/testable; callers that know "now" pass it).
-// The "一次" tag is added by the UI badge to avoid duplication.
-function describeAt(at, nowStr) {
-  let m
-  try { m = normalizeAt(at).match(/^(\d{4})-(\d{2})-(\d{2}) (\d{2}:\d{2})$/) } catch { return String(at) }
-  const [, y, mo, d, hm] = m
-  const n = /^(\d{4})-(\d{2})-(\d{2}) /.exec(nowStr || '')
-  if (n) {
-    if (n[1] === y && n[2] === mo && n[3] === d) return hm          // 今天 → 只留时间
-    if (n[1] === y) return `${+mo}月${+d}日 ${hm}`                   // 今年 → 省年份
-  }
-  return `${y}年${+mo}月${+d}日 ${hm}`                               // 跨年 / 无 now → 完整
-}
-
-// Unified label: one-off (`at`, relative to nowStr) or recurring (`expr`, already relative-free).
-function describeTask(task, nowStr) {
-  if (!task) return ''
-  return task.at ? describeAt(task.at, nowStr) : describeCron(task.expr)
-}
-
-// Expand a one-off shorthand into an absolute "YYYY-MM-DD HH:mm", filling the missing leading
-// parts from the group-tz present (the mirror of describeAt's omission). Accepts:
-//   "HH:mm"                          → today (rolls to tomorrow if that minute already passed,
-//                                       so a one-off is never born already-expired)
-//   "MM-DD HH:mm" / "M月D日 HH:mm"    → this year, that month/day
-//   full "YYYY-MM-DD HH:mm" / "YYYY年M月D日 HH:mm" → taken as given
-// `nowMs`/`tz` locate today/tomorrow in the group timezone. Throws on unparseable input. The
-// STORED value is always absolute, so matchAt / expiry / scheduler stay unchanged.
-function expandAt(input, nowMs, tz) {
-  const s = String(input || '').trim()
-  if (/^\d{4}-\d{1,2}-\d{1,2}[ T]\d{1,2}:\d{2}$/.test(s)) return normalizeAt(s)
-  const full = s.match(/^(\d{4})年(\d{1,2})月(\d{1,2})日\s*(\d{1,2}):(\d{2})$/)
-  if (full) return normalizeAt(`${full[1]}-${full[2]}-${full[3]} ${full[4]}:${full[5]}`)
-  const now = tzParts(nowMs, tz)
-  const timeOnly = s.match(/^(\d{1,2}):(\d{2})$/)
-  if (timeOnly) {
-    const h = +timeOnly[1], mi = +timeOnly[2]
-    if (h > 23 || mi > 59) throw new Error('时间越界:' + s)
-    const hm = `${String(h).padStart(2, '0')}:${String(mi).padStart(2, '0')}`
-    let { year, month, day } = now
-    // 已过当前分钟 ⇒ 顺延到明天(+24h 后重取 tz 日期,跨月/跨年由 tzParts 正确处理)
-    if (hm <= `${now.hour}:${now.minute}`) { const t = tzParts(nowMs + 864e5, tz); year = t.year; month = t.month; day = t.day }
-    return normalizeAt(`${year}-${month}-${day} ${hm}`)
-  }
-  const md = s.match(/^(\d{1,2})-(\d{1,2})[ T](\d{1,2}):(\d{2})$/) || s.match(/^(\d{1,2})月(\d{1,2})日\s*(\d{1,2}):(\d{2})$/)
-  if (md) return normalizeAt(`${now.year}-${md[1]}-${md[2]} ${md[3]}:${md[4]}`)
-  throw new Error('时间无法识别:' + s + '(可填 10:20 / 07-16 10:20 / 2026-07-16 10:20)')
-}
-
-// Flatten per-group crons into a scheduler work-list, tagging each with its chatId. Shape on disk:
-// groups[chatId].crons = [{ id, expr|at, kind:'do'|'say'|'run', text, enabled, once?, note?, resetSession?, timeoutMin?, escalate? }].
-// kind:'run'(v0.11.103):text 是一条 shell 命令,到点由 daemon 在项目根直接跑,不起 agent(src/core/cronrun.js);
-//   timeoutMin 超时上限(默认 15 分钟)· escalate 失败时把输出交给 agent 排查(默认只在群里提示一句)。
-// resetSession(v0.11.19,operator 配置层字段):该任务的轮**成功结算后**开新会话 —— 给「整理
-// 落盘」类任务用,交接文书就是任务刚写完的文档;失败/被叫停不翻篇。engine 侧消费,这里只透传。
-function collectCrons(cfg) {
-  const out = []
-  for (const [chatId, g] of Object.entries((cfg && cfg.groups) || {})) {
-    const list = g && Array.isArray(g.crons) ? g.crons : []
-    for (const c of list) if (c && c.id) out.push({ ...c, chatId })
-  }
-  return out
-}
-
-module.exports = { normalizeCron, parseField, matchCron, zhShorthand, describeCron, normalizeAt, matchAt, describeAt, describeTask, expandAt, collectCrons, ALIASES }

package/src/core/cronfire.js

@@ -1,120 +0,0 @@
-// 定时任务到点做什么(v0.11.103 从 bin 的 scheduler.fire 抽出来):三种任务各走各的路,依赖全部注入 ⇒ 可单测。
-//   do  → 构造合成消息喂 engine(复用群路由 / 锁 / 权限 / 卡片全套管线,群间互不干扰)
-//   say → 直接发一条消息(过 redact),不起 agent
-//   run → daemon 直接跑命令(src/core/cronrun.js),不起 agent、不占群锁、不进会话;成功只留日志 + 账本一行,
-//         失败群里一句人话附输出末尾,task.escalate 时改为把输出交给 agent 排查
-// 直发的消息(say 正文 / 脚本失败提示)发不出去时**补发**,不是丢掉:09-17 21:00 一次约 5 分钟的断网里,脚本
-//   失败提示恰好也发不出去(平台层只记一行日志就把 null 吞了),群里对那次失败一无所知。断网正是失败最常见的
-//   原因 ⇒ 「失败提示」在最需要它的时候最容易丢。补发按 1 / 5 / 15 / 30 分钟四次,正文前加一行「补发 · 原定几点」,
-//   四次都不成才放弃并记日志;同一条消息再次触发时只换正文不叠加。
-// 为什么抽出来:这段判断原来写在调用方(bin)里,单测只测得到被它调用的纯函数 —— 「A 必须传到 B」的接线
-// 从来没被钉住(v0.11.54 那版逮到三条同形的漏)。现在 fire 本身就是被测对象。
-// ⚠ core 保持无感:这里不认平台名、不认 runner 名,只认注入进来的函数。
-const { runScriptTask, runOk, runReason, outputTail, runFailureNotice, escalationPrompt, DEFAULT_TIMEOUT_MS } = require('./cronrun')
-const { fmtStamp } = require('./time')
-
-// 直发消息发不出去时的补发间隔:1 / 5 / 15 / 30 分钟(累计约 51 分钟)。09-17 那次断网 5 分钟,第二次就能补上;
-// 更长的断网多半是机器本身出事,那时群里该由另一台的看门告警说话,不靠这里无限重试。
-const RETRY_DELAYS_MS = [60_000, 5 * 60_000, 15 * 60_000, 30 * 60_000]
-
-// deps:
-//   getGroup(chatId) → 群配置(paused / workdir);tz() → 产品时区;handleMessage(msg) → engine 入口;
-//   send(chatId, text) → 平台直发(已 redact);redact(s);log(s);ledger.append(row);removeTask(chatId, id) → 一次性任务触发后删;
-//   runScript(opts) → 可注入(测试用假 spawn);now();env → 脚本继承的环境(对象,或 (task) => 对象:按群注入 SBOT_CHAT_ID 等);
-//   cwdFallback → 群没配 workdir 时的 cwd;
-//   send 的返回值契约(interfaces.js):resolve 成 **null = 平台确认没送到**(抛错同义);其余值(message_id / undefined)= 已送到或不跟踪。
-//   retryDelaysMs → 补发间隔表(测试注入短的);setTimer / clearTimer → 定时器(测试注入假的)。
-function createCronFire(deps) {
-  const { getGroup, tz, handleMessage, send, redact = (s) => s, log = () => {}, ledger = null, removeTask = () => {}, runScript = runScriptTask, now = Date.now, env = process.env, cwdFallback = process.cwd(), retryDelaysMs = RETRY_DELAYS_MS, setTimer = setTimeout, clearTimer = clearTimeout } = deps
-  const running = new Set() // 正在跑的脚本任务(chatId:id):同一任务不并行(小时级巡检 + 挂死脚本 = 无限堆进程)
-  const children = new Map() // key → 子进程:关停时要能杀(审查逮到:daemon 退了脚本成孤儿,下次写 stdout 就 EPIPE 死、无人报)
-  const undelivered = new Map() // 待补发的直发消息:key(chatId:id:用途) → { chatId, text, firstAt, tries, timer }
-
-  // 直发一条,发不出去就排补发。key 按「任务 + 用途」去重:同一任务连着两次失败只留最新那条正文,不让群里收到一串。
-  const deliver = (key, chatId, text) => {
-    const prev = undelivered.get(key)
-    if (prev) { if (prev.timer) clearTimer(prev.timer); undelivered.delete(key) }
-    const rec = { chatId, text, firstAt: (prev && prev.firstAt) || now(), tries: 0, timer: null }
-    return attempt(key, rec)
-  }
-  const attempt = (key, rec) => {
-    // 补发时正文前加一行说明:读的人得知道这是几点的事,不然「没跑成功」四个字在 30 分钟后看到会误判成又失败了一次
-    const body = rec.tries > 0 ? `(补发 · 原定 ${fmtStamp(rec.firstAt, tz())} 发出,当时发不出去)\n` + rec.text : rec.text
-    return new Promise((resolve) => resolve(send(rec.chatId, body))).then((r) => r === null ? Promise.reject(new Error('平台没送到')) : r).then(() => {
-      undelivered.delete(key)
-      if (rec.tries > 0) log(`cron 消息补发成功(第 ${rec.tries} 次):${key}`)
-    }, (e) => {
-      const delay = retryDelaysMs[rec.tries]
-      if (delay === undefined) { undelivered.delete(key); log(`cron 消息放弃补发(${rec.tries} 次都发不出去):${key} — ` + (e && e.message)); return }
-      rec.tries++
-      undelivered.set(key, rec)
-      log(`cron 消息发不出去(${e && e.message}),${Math.round(delay / 60000)} 分钟后补发(第 ${rec.tries} 次):${key}`)
-      rec.timer = setTimer(() => { rec.timer = null; attempt(key, rec) }, delay)
-      if (rec.timer && typeof rec.timer.unref === 'function') rec.timer.unref() // 补发不该拖住进程退出
-    })
-  }
-
-  const synthetic = (task, text, extra = {}) => {
-    const t = now()
-    // cron:true ⇒ 群里正忙时的排队提示走定时任务那句(engine T.queuedCron)
-    return { chatId: task.chatId, userId: 'cron', senderName: '定时任务', synthetic: true, cron: true, text, msgId: `cron:${task.chatId}:${task.id}:${t}`, createTimeMs: t, replyCtx: { chatId: task.chatId }, ...extra }
-  }
-
-  const fireRun = (task, group) => {
-    const key = `${task.chatId}:${task.id}`
-    if (running.has(key)) { log(`cron 脚本跳过(上一次还没跑完): ${key}`); return Promise.resolve() }
-    running.add(key)
-    const startedAt = now()
-    const cwd = (group && group.workdir) || cwdFallback
-    const timeoutMs = task.timeoutMin > 0 ? task.timeoutMin * 60_000 : DEFAULT_TIMEOUT_MS
-    // ⚠ new Promise 包一层:runScript 同步抛(spawn 本身炸了)也要走下面的 catch 释放 running 占位 ——
-    //   Promise.resolve(f()) 那种写法里 f 同步抛会绕过 catch,占位永远不放,这个任务从此每次都「上一次还没跑完」。
-    // env:脚本要拿到与 agent 子进程同一组基础能力变量(SBOT_CHAT_ID / SBOT_CONFIG / …,bin 里传 engine.baseSkillEnv),
-    //   否则脚本里的 `sbot feishu send-msg` 不知道发到哪个群(09-17 18:00 实证:退出码 1「缺少目标群」)。
-    const scriptEnv = typeof env === 'function' ? env(task) : env
-    return new Promise((resolve) => resolve(runScript({ command: String(task.text || ''), cwd, env: { ...scriptEnv, TZ: tz() }, timeoutMs, onChild: (c) => children.set(key, c) }))).then((res) => {
-      running.delete(key); children.delete(key)
-      const ok = runOk(res)
-      log(`cron 脚本 ${key} ${ok ? 'ok' : '失败(' + runReason(res) + ')'} · ${Math.round(res.ms / 1000)}s` + (ok ? '' : '\n' + outputTail(res)))
-      // 账本一行(与轮次同一本;script:true 区分 —— 它没有模型、没有 token,读账本的人别把它当轮次算)
-      if (ledger) ledger.append({ ts: startedAt, chatId: task.chatId, provider: null, sender: '定时任务', text: String(task.text || '').slice(0, 200), status: ok ? 'ok' : 'error', ms: res.ms, tokens: null, script: true, ...(ok ? {} : { err: runReason(res) }) })
-      if (ok) return
-      if (task.escalate) return handleMessage(synthetic(task, escalationPrompt(task, res)))
-      return deliver(`${key}:fail`, task.chatId, redact(runFailureNotice(task, res)))
-    }).catch((e) => { running.delete(key); children.delete(key); log('cron 脚本执行异常: ' + (e && e.message)) })
-  }
-
-  // 返回 Promise 只为测试能等到收尾;调度器不等它(fire-and-forget)。
-  function fire(task) {
-    try {
-      // 暂停群到点跳过(不补触发,与「错过不触发」同语义)—— --do 烧额度、--say / --run 也是打扰
-      const group = getGroup(task.chatId)
-      if (group && group.paused) { log(`cron 跳过(群已暂停): ${task.chatId} ${task.id}`); return Promise.resolve() }
-      let p
-      if (task.kind === 'say') p = deliver(`${task.chatId}:${task.id}:say`, task.chatId, redact(String(task.text || '')))
-      else if (task.kind === 'run') p = fireRun(task, group)
-      else p = Promise.resolve(handleMessage(synthetic(task, String(task.text || ''), { resetSessionAfter: !!task.resetSession })))
-      if (task.once || task.at) removeTask(task.chatId, task.id) // 一次性:触发后即删,列表不堆积
-      return p
-    } catch (e) { log('cron fire 失败: ' + (e && e.message)); return Promise.resolve() }
-  }
-  // 关停用:在跑的脚本数 / 杀掉全部(整棵进程组)。探空闲按 daemon 子进程数已能看见它们(detached 只换进程组,父仍是 daemon)。
-  fire.inFlight = () => running.size
-  fire.undelivered = () => undelivered.size // 待补发的直发消息数(关停 / 排障看)
-  fire.abortAll = () => {
-    // 待补发的一并放弃:进程都要退了,定时器留着也没人执行;记日志让排障的人知道丢了几条
-    for (const [key, rec] of undelivered) { if (rec.timer) clearTimer(rec.timer); log(`关停:放弃补发 ${key}`) }
-    undelivered.clear()
-    let n = 0
-    for (const [key, c] of children) {
-      n++
-      try { if (process.platform === 'win32') require('node:child_process').spawn('taskkill', ['/pid', String(c.pid), '/t', '/f'], { stdio: 'ignore', windowsHide: true }); else process.kill(-c.pid, 'SIGKILL') } catch { try { c.kill('SIGKILL') } catch {} }
-      log(`关停:杀掉在跑的定时脚本 ${key}`)
-    }
-    children.clear(); running.clear()
-    return n
-  }
-  return fire
-}
-
-module.exports = { createCronFire, RETRY_DELAYS_MS }