sintbot 1.4.15 → 1.4.17

package/src/modelcatalog.js

@@ -0,0 +1,122 @@
+'use strict'
+// 「这张模型卡能选什么」(;两家都改成实时清单)。bin 注入给 engine.modelCatalog,控制台同一份;core 只认返回形状:
+//   { ok, models: [{ id, name?, efforts?, defEffort? }] | null, aliases: [], aliasOf?: { 别名: 具体型号 }, efforts: [],
+//     recommended: { model, effort }, source: 'live' | 'saved' | 'builtin' }
+//   models === null ⇒ 这家没有可选清单(第三方端点):群里只能调深度,型号到后台改 —— 打错一个字下一轮就报错,
+//   比让人在群里瞎试更稳。ok === false ⇒ 有清单但这会儿取不到(codex 探测失败、也没存过):型号这一项整条拒绝,不猜。
+//
+// 清单与名称一律取两家 CLI 的**实时数据**:
+//   Codex = app-server model/list(官方显示名 GPT-6.1-Sol、★ 默认型号、各型号支持与默认的深度);
+//   Claude 订阅 = Claude Code 初始化握手报的 /model 选单(claudemodels.probeModels:官方显示名、各型号支持的深度、
+//     default 指向的推荐型号;别名 opus / sonnet … 打进来存成它此刻指向的具体型号)。
+//   都是 10 分钟缓存、过期先给旧的后台再刷(模型卡按钮回调要 3 秒内回包,现场探测要好几秒);每次拿到就存盘(cacheFile),
+//   重启后 / 探测失败时先用存盘的(source 'saved')—— 不再退回写死在代码里、早已过时的候选。Claude 从没拿到过才用内置候选。
+//   拿到的显示名登记进 core/modelname.js(群里回执、卡片、控制台都按官方名称显示)。
+// recommended(没有「模型卡默认」):新绑的群、换到没选过的后端、模型卡「测试」预填 / 兜底用的推荐项 ——
+//   Codex = ★ 型号 + 它自带的默认深度;Claude 订阅 = 握手里 default 指向的型号 + xhigh(Claude Code 自己的默认档);
+//   第三方 = 型号由模型卡定(空)+ xhigh。只用于预填与迁移,运行时不拿它悄悄兜底。
+
+const fs = require('node:fs')
+const path = require('node:path')
+const { recommendEffort } = require('./core/modelcmd') // 推荐深度的口径只此一份(engine 的 /model 与模型卡同用)
+const { setModelNames } = require('./core/modelname')
+
+const CLAUDE_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max'] // Claude Code 的五档(code.claude.com model-config)
+// Codex 服务端真正接受的档(与控制台 RE_LEGAL 同一份口径):model/list 会过报(把 ultra 列进去),先过一道
+const CODEX_LEGAL = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']
+const CLAUDE_ALIASES = ['opus', 'sonnet', 'haiku'] // 只在拿不到实时清单、退回内置候选时用(原样交给 CLI)
+const CLAUDE_EFFORT = 'xhigh'
+const TTL = 600_000
+
+function createModelCatalog({ codexstatus, claudemodels, claudeBin = 'claude', cacheFile = null, now = () => Date.now(), log = () => {} } = {}) {
+  const live = { codex: null, claude: null } // { at, data }
+  const inflight = { codex: null, claude: null }
+  const fetchers = {
+    codex: async () => { const l = await codexstatus.listModels('codex'); return Array.isArray(l) && l.length ? l : null },
+    claude: async () => (claudemodels && typeof claudemodels.probeModels === 'function' ? claudemodels.probeModels(claudeBin) : null),
+  }
+  const register = (kind, data) => {
+    try {
+      if (kind === 'codex') setModelNames(data.map((m) => ({ id: m.model, name: m.name })))
+      else setModelNames(data.models)
+    } catch { /* 名称登记失败只影响显示 */ }
+  }
+  // 存盘的上次结果:at 记 0 ⇒ 第一次用到就后台再刷一次
+  if (cacheFile) {
+    try {
+      const saved = JSON.parse(fs.readFileSync(cacheFile, 'utf8'))
+      for (const k of ['codex', 'claude']) if (saved && saved[k] && saved[k].data) { live[k] = { at: 0, data: saved[k].data, saved: true }; register(k, saved[k].data) }
+    } catch { /* 没有 / 坏了就当没有 */ }
+  }
+  const persist = () => {
+    if (!cacheFile) return
+    try {
+      const out = {}
+      for (const k of ['codex', 'claude']) if (live[k]) out[k] = { at: live[k].at || now(), data: live[k].data }
+      fs.mkdirSync(path.dirname(cacheFile), { recursive: true })
+      const tmp = cacheFile + '.tmp'
+      fs.writeFileSync(tmp, JSON.stringify(out))
+      fs.renameSync(tmp, cacheFile)
+    } catch (e) { log('可选型号存盘失败: ' + (e && e.message)) }
+  }
+  const refresh = (kind) => {
+    if (!inflight[kind]) {
+      inflight[kind] = Promise.resolve().then(() => fetchers[kind]()).catch(() => null)
+        .then((data) => {
+          if (data) { live[kind] = { at: now(), data }; register(kind, data); persist() }
+          else log(`${kind === 'codex' ? 'codex' : 'Claude'} 可选型号探测失败 —— 沿用上次结果(如有)`)
+        })
+        .finally(() => { inflight[kind] = null })
+    }
+    return inflight[kind]
+  }
+  // 有结果就先用、过期了后台再刷;从没取到过(也没存盘)才等这一次
+  async function get(kind) {
+    const c = live[kind]
+    if (c) { if (now() - c.at >= TTL) refresh(kind); return c.data }
+    await refresh(kind)
+    return live[kind] ? live[kind].data : null
+  }
+  const sourceOf = (kind) => (live[kind] && live[kind].saved && !live[kind].at ? 'saved' : 'live')
+
+  async function catalog(name, provider) {
+    const p = provider || {}
+    if (p.runner === 'codex') {
+      const list = await get('codex')
+      if (!list) return { ok: false, models: [], aliases: [], efforts: CODEX_LEGAL.slice(1), recommended: { model: '', effort: '' } }
+      const models = list.map((m) => ({
+        id: m.model,
+        ...(m.name ? { name: m.name } : {}),
+        efforts: (m.efforts || []).filter((e) => CODEX_LEGAL.includes(e)),
+        ...(m.defEffort && CODEX_LEGAL.includes(m.defEffort) ? { defEffort: m.defEffort } : {}),
+      }))
+      const star = list.find((m) => m.isDefault) || list[0]
+      const cat = { ok: true, models, aliases: [], efforts: CODEX_LEGAL.slice(1), source: sourceOf('codex') }
+      cat.recommended = { model: star.model, effort: '' }
+      cat.recommended.effort = recommendEffort(cat, star.model)
+      return cat
+    }
+    if (!p.baseUrl) {
+      const d = await get('claude')
+      if (d && Array.isArray(d.models) && d.models.length) {
+        const models = d.models.map((m) => ({ id: m.id, name: m.name, ...(m.effort !== false && m.efforts && m.efforts.length ? { efforts: m.efforts.slice() } : {}) }))
+        const cat = { ok: true, models, aliases: [], aliasOf: { ...(d.aliasOf || {}) }, efforts: CLAUDE_EFFORTS.slice(), source: sourceOf('claude') }
+        cat.recommended = { model: d.recommended || models[0].id, effort: CLAUDE_EFFORT }
+        cat.recommended.effort = recommendEffort(cat, cat.recommended.model) // xhigh 不在这型号的档里才换
+        return cat
+      }
+      // 从没拿到过实时清单(没登录 / CLI 太老 / 超时)⇒ 内置候选 + 本机账号额外项 + 官方别名
+      let ids = []
+      try { ids = claudemodels.mergeModels(claudemodels.readExtraModels()).map((m) => m.id).filter(Boolean) } catch { ids = claudemodels.BUILTIN.map((m) => m.id).filter(Boolean) }
+      return { ok: true, models: ids.map((id) => ({ id })), aliases: CLAUDE_ALIASES.slice(), efforts: CLAUDE_EFFORTS.slice(), recommended: { model: ids[0] || '', effort: CLAUDE_EFFORT }, source: 'builtin' }
+    }
+    return { ok: true, models: null, aliases: [], efforts: CLAUDE_EFFORTS.slice(), recommended: { model: '', effort: CLAUDE_EFFORT } }
+  }
+  // 守护进程启动时预热(有哪家的卡才探哪家):第一张模型卡 / 第一次打开群卡就不用等探测
+  catalog.warm = (kinds = ['codex']) => Promise.all(kinds.filter((k) => fetchers[k]).map((k) => refresh(k)))
+  // 原始清单(控制台 /api/codex/models · /api/claude/models 用:要 isDefault / 说明这些字段)+ 它是不是实时的
+  catalog.raw = async (kind) => ({ data: fetchers[kind] ? await get(kind) : null, source: live[kind] ? sourceOf(kind) : 'none' })
+  return catalog
+}
+
+module.exports = { createModelCatalog, CLAUDE_EFFORTS, CODEX_LEGAL, CLAUDE_ALIASES }

package/src/platform/feishu.js

@@ -569,22 +569,37 @@ function createFeishuPlatform({ appId, appSecret, botOpenId = null, onlyWhenMent
   // scope) is cached as null so we don't hammer the API, and callers fall back.
   const nameCache = new Map() // openId -> name | null
   let nameScopeWarned = false
-  async function senderNameOf(openId) {
+  let memberNameWarned = false
+  async function senderNameOf(openId, chatId = null) {
     if (!openId) return null
     if (nameCache.has(openId)) return nameCache.get(openId)
+    let name = null
     try {
       const r = await client.contact.user.get({ params: { user_id_type: 'open_id' }, path: { user_id: openId } })
-      const name = (r && r.data && r.data.user && (r.data.user.name || r.data.user.nickname)) || null
-      nameCache.set(openId, name)
-      return name
+      name = (r && r.data && r.data.user && (r.data.user.name || r.data.user.nickname)) || null
     } catch (e) {
-      nameCache.set(openId, null)
       if (!nameScopeWarned) {
         nameScopeWarned = true
         log('feishu: 拉取用户名失败(需要 contact:contact.base:readonly scope?),发送者标注回退为 open_id — ' + larkErrMsg(e))
       }
-      return null
     }
+    // 通讯录查不到(缺 scope、或发送者不在应用的通讯录范围内 —— 基础版多人群常见)时,退到当前群的
+    // 成员列表:名字随成员一起返回,顺带把同群其他人也写进同一份缓存。
+    if (!name && chatId) {
+      try {
+        for (const m of await fetchChatMembers(client, chatId)) {
+          if (m.name && m.name !== m.openId && !nameCache.get(m.openId)) nameCache.set(m.openId, m.name)
+        }
+        name = nameCache.get(openId) || null
+      } catch (e) {
+        if (!memberNameWarned) {
+          memberNameWarned = true
+          log('feishu: 群成员列表取名失败 — ' + larkErrMsg(e))
+        }
+      }
+    }
+    nameCache.set(openId, name)
+    return name
   }
 
   async function sendText(chatId, content) {
@@ -737,7 +752,7 @@ function createFeishuPlatform({ appId, appSecret, botOpenId = null, onlyWhenMent
             let senderName = openId || 'user'
             if (openId) {
               if (nameCache.has(openId)) senderName = nameCache.get(openId) || openId
-              else senderNameOf(openId).catch(() => {}) // background warm; does not reorder onMessage
+              else senderNameOf(openId, message.chat_id).catch(() => {}) // background warm; does not reorder onMessage
             }
             // Fire-and-forget into the engine (NFR1): a turn can run for minutes,
             // and whether the SDK serializes pending handlers is not contractual —
@@ -848,6 +863,23 @@ function createFeishuPlatform({ appId, appSecret, botOpenId = null, onlyWhenMent
       return sendText(chatId, content)
     },
 
+    // One interactive reply under a group command (the /model card). Like
+    // replyOnce it is best-effort and never retried; the caller falls back
+    // to the text reply when this does not confirm.
+    async replyCardOnce(replyCtx, card) {
+      const mid = replyCtx && replyCtx.messageId
+      if (typeof mid !== 'string' || !/^om_[A-Za-z0-9_-]{1,124}$/.test(mid) ||
+          !card || typeof card !== 'object') {
+        throw new TypeError('Feishu card reply needs exact message target and a card')
+      }
+      return client.im.message.reply({ path: { message_id: mid },
+        data: { msg_type: 'interactive', content: JSON.stringify(card) } })
+    },
+
+    // open_id → display name (cached; null when unknown). The model card's
+    // receipt says who changed it; a card callback only carries the open_id.
+    nameOf: (openId) => senderNameOf(openId),
+
     // 发一张静态富卡,返回 { msgId, cardId }(msgId=按钮/表情命中锚点;cardId=实体更新回填用)。
     // 文本已由调用方在构卡时逐字段 redact(卡是 JSON 不能整体脱敏),故这里不再包 redact。
     async sendCard(chatId, cardJson) {

package/src/platform/modelcard.js

@@ -0,0 +1,103 @@
+'use strict'
+// 群里 /model 的「模型卡」。发 /model 不带参数 ⇒ 一张能点的卡:
+//   后端一排按钮 · 型号一个下拉 · 思考深度一排按钮 + 「确认更新」「关闭」;确认后卡片收成一行回执(卡片本身就是回执,不另发消息);
+//   10 分钟后过期翻只读(防止往上翻聊天记录时误点到几天前的老卡)。
+// 纯函数、零依赖:飞书卡片 schema 2.0 的 JSON 形状只在此一处;样式与通知卡同一套(撑满宽 · 标题栏底色说类别 ·
+//   注意事项与右下角小字用 notation 灰字;⚠ 2.0 不认 note 组件)。没有这种卡的平台(企微)由调用方退回文本回执。
+// ⚠ 脱敏:型号 / 后端名来自配置与清单,没有用户输入;结果行里的人名来自平台,同样经 opts.redact。
+
+const esc = (s) => String(s == null ? '' : s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+const DEFAULT_VALUE = '__default__' // 下拉里「跟随默认」那一项的值(选项值不能是空串)
+
+const grey = (s, size = 'notation') => ({ tag: 'markdown', text_size: size, content: `<font color='grey'>${esc(s)}</font>` })
+
+function button(label, { selected = false, value, disabled = false } = {}) {
+  const b = { tag: 'button', text: { tag: 'plain_text', content: label }, type: selected ? 'primary_filled' : 'default', size: 'small', width: 'default' }
+  if (disabled) b.disabled = true
+  if (value) b.behaviors = [{ type: 'callback', value }]
+  return b
+}
+
+// 一排按钮:flow 布局,窄屏自动折行
+function buttonRow(buttons) {
+  return { tag: 'column_set', flex_mode: 'flow', horizontal_spacing: '6px', horizontal_align: 'left', columns: buttons.map((b) => ({ tag: 'column', width: 'auto', elements: [b] })) }
+}
+
+/**
+ * 「先选、再确认」(点一下就生效容易点错):
+ *   点后端 / 选型号 / 点深度只改**卡上的草稿**(卡片重画选中状态,什么都没生效);草稿与当前不同时出一行「将改为 … —— 会不会开新对话」,
+ *   「确认更新」一次生效(只写一次、最多开一次新对话、审计一条),卡片收成一行回执;「关闭」什么都不改,卡片原地变成灰色「已关闭」。
+ *   草稿随每个回调值带回去(无状态,守护进程重启也不丢):{ a:'mc', f:'p'|'m'|'e'|'ok'|'x', v?, d:{p,m,e}, t }
+ *   —— p 后端 · m 型号 · e 深度('' = 跟随默认);下拉的选中值在回调的 action.option 里。
+ * @param s {
+ *   mode: 'edit' | 'receipt' | 'closed' | 'expired',  current: 'claude · claude-opus-5 · xhigh'(当前生效的)
+ *   failover: '', quota: '',                          —— 额度临时切换那一句 / 缓存额度(有才给)
+ *   draft: { p, m, e },                               —— edit:卡上正在选的
+ *   backends: [{ name, selected }], model: { options: [{ value, label }], selected } | null(null = 这家型号到后台改),
+ *   efforts: [{ value, label, selected }],            —— label 里由调用方标「(默认)」
+ *   preview: { to, note } | null,                     —— 草稿与当前不同才有;null ⇒「确认更新」灰着
+ *   receipt: { line, before },                        —— receipt:谁改成了什么 · 之前是什么
+ *   issuedAt: 发卡 / 上次操作的时刻(写进回调值,10 分钟过期)
+ * }
+ */
+function buildModelCard(s, { redact } = {}) {
+  const r = typeof redact === 'function' ? (x) => String(redact(String(x))) : (x) => String(x)
+  const mode = s.mode || (s.expired ? 'expired' : 'edit')
+  const t = s.issuedAt || 0
+  const d = { p: '', m: '', e: '', ...(s.draft || {}) }
+  const cb = (f, v) => ({ a: 'mc', f, ...(v !== undefined ? { v } : {}), d, t })
+  const els = []
+  const head = (title, template, tag, tagColor) => ({
+    title: { tag: 'plain_text', content: title },
+    subtitle: { tag: 'plain_text', content: r(s.current || '') },
+    template, text_tag_list: [{ tag: 'text_tag', text: { tag: 'plain_text', content: tag }, color: tagColor }],
+    padding: '12px 12px 12px 12px',
+  })
+  let header
+  if (mode === 'receipt') {
+    // 确认之后:收成一行回执 —— 控件全收起(卡片就此「关闭」),群里留一条谁改成了什么
+    header = head('模型已更新', 'green', '已更新', 'green')
+    const rc = s.receipt || {}
+    els.push({ tag: 'markdown', text_size: 'normal', content: esc(r(rc.line || '')) })
+    if (rc.before) els.push(grey(r(rc.before)))
+  } else if (mode === 'closed') {
+    header = head('本群模型', 'grey', '已关闭', 'neutral')
+    els.push(grey('已关闭 · 模型没变', 'normal'))
+  } else if (mode === 'expired') {
+    header = head('本群模型', 'grey', '已过期', 'neutral')
+    els.push(grey('这张卡已过期,没有改任何东西 —— 发 /model 重新打开', 'normal'))
+  } else {
+    header = head('本群模型', 'indigo', '模型', 'indigo')
+    const info = []
+    if (s.failover) info.push(`**额度切换** ${esc(s.failover)}`)
+    if (s.quota) info.push(`**额度** ${esc(s.quota)}`)
+    if (info.length) els.push({ tag: 'markdown', text_size: 'normal', content: info.join('\n') })
+    const backendBtns = buttonRow((s.backends || []).map((b) => button(b.name, { selected: b.selected, value: b.selected ? null : cb('p', b.name) })))
+    let modelCtl
+    if (s.model) {
+      modelCtl = {
+        tag: 'select_static', width: 'fill', type: 'default',
+        placeholder: { tag: 'plain_text', content: '选一个型号' },
+        initial_option: s.model.selected || DEFAULT_VALUE,
+        options: s.model.options.map((o) => ({ text: { tag: 'plain_text', content: o.label }, value: o.value || DEFAULT_VALUE })),
+        behaviors: [{ type: 'callback', value: cb('m') }],
+      }
+    } else modelCtl = grey('这个后端的型号在控制台改', 'normal')
+    const effortBtns = buttonRow((s.efforts || []).map((e) => button(e.label || e.value, { selected: e.selected, value: e.selected ? null : cb('e', e.value || DEFAULT_VALUE) })))
+    // 标签在上、控件在下(手机上五个深度按钮一排放得下)
+    for (const [label, ctl] of [['后端', backendBtns], ['型号', modelCtl], ['思考深度', effortBtns]]) els.push(grey(label), ctl)
+    els.push({ tag: 'hr' })
+    if (s.preview) {
+      els.push({ tag: 'markdown', text_size: 'normal', content: `**将改为** ${esc(s.preview.to)}` })
+      if (s.preview.note) els.push(grey(s.preview.note))
+    }
+    els.push(buttonRow([
+      button('确认更新', { selected: !!s.preview, value: s.preview ? cb('ok') : null, disabled: !s.preview }),
+      button('关闭', { value: { a: 'mc', f: 'x', t } }),
+    ]))
+    els.push(grey('选好后点「确认更新」才生效 · 换后端会开新对话，换型号或调深度接着当前对话 · 要等手头任务结束 · 10 分钟内有效 · 点不动时可直接发 /model high 这类文字'))
+  }
+  return { schema: '2.0', config: { width_mode: 'fill', update_multi: true }, header, body: { padding: '12px 12px 12px 12px', vertical_spacing: '8px', elements: els } }
+}
+
+module.exports = { buildModelCard, DEFAULT_VALUE }