sintbot 1.3.0 → 1.4.1

package/src/ui/sessions.js

@@ -0,0 +1,78 @@
+'use strict'
+// 控制台登录会话:落盘 + 过期 + 可按条件吊销,守护进程重启不再把人登出。
+//
+// 此前会话令牌只在内存 Set 里,每次发版重启都要重输密码 —— 那是「两道密码」体验里最频繁的一次输入。
+// 这里改成:令牌 → { exp, via, who, ip, at, …身份线索 } 存 JSON(权限 0600,原子写),默认 30 天固定有效期
+// (不滑动:拿到令牌的人最多用 30 天,登出即失效)。文件读坏就当空(登录一次就恢复,不阻断)。
+// 与密码 / 飞书登录两条路无关 —— 谁签发都进这里,鉴权只问 has(token)。
+//
+// ⚠ 落盘带来一个新义务:会话活得比进程久,**名单里删掉的人、换过的密码**必须能让旧会话立刻失效,
+//    否则被删的人最多还能再遥控这台机器 30 天(对抗审查 🔴)。所以每条会话记着签发时的身份线索
+//    (飞书:openId;密码:当时密码 hash 的前缀),由 server 在配置变化时调 revokeWhere 对齐。
+
+const fs = require('node:fs')
+const path = require('node:path')
+const crypto = require('node:crypto')
+
+const DEFAULT_TTL_MS = 30 * 24 * 3600_000
+
+function createSessionStore({ file, ttlMs = DEFAULT_TTL_MS, now = Date.now, log = () => {} } = {}) {
+  const map = new Map() // token -> meta
+
+  const prune = () => { const t = now(); for (const [k, m] of map) if (!m || !(m.exp > t)) map.delete(k) }
+  const persist = () => {
+    if (!file) return
+    try {
+      fs.mkdirSync(path.dirname(file), { recursive: true })
+      const tmp = `${file}.${process.pid}.tmp`
+      fs.writeFileSync(tmp, JSON.stringify({ v: 1, tokens: Object.fromEntries(map) }, null, 1) + '\n', { mode: 0o600 })
+      fs.renameSync(tmp, file)
+    } catch (e) { log(`ui sessions: 写不进 ${path.basename(file)}(${e.message})—— 会话只在内存里,重启后要重新登录`) }
+  }
+  const load = () => {
+    map.clear()
+    if (!file || !fs.existsSync(file)) return
+    try {
+      const j = JSON.parse(fs.readFileSync(file, 'utf8'))
+      const toks = j && j.tokens && typeof j.tokens === 'object' ? j.tokens : {}
+      // 文件虽是 0600、我们自己写的,但曾被手改 / 写坏过的可能永远存在:只认形状合法的令牌与带过期时间的项,其余当没有
+      for (const [k, m] of Object.entries(toks)) if (/^[0-9a-f]{16,128}$/.test(k) && m && typeof m.exp === 'number') map.set(k, m)
+      prune()
+    } catch (e) { log(`ui sessions: ${path.basename(file)} 读不出来(${e.message}),按没有会话处理`) }
+  }
+  load()
+
+  return {
+    // 签发:via = 'password' | 'feishu';who = 展示名;ip = TCP 对端;其余字段(openId / authRef / xff)原样存,
+    // 供吊销与审计用 —— 只存字符串,不存令牌以外的任何秘密。
+    add({ via = 'password', who = '', ip = '', ...extra } = {}) {
+      prune()
+      const token = crypto.randomBytes(24).toString('hex')
+      const meta = { exp: now() + ttlMs, via, who: String(who || ''), ip: String(ip || ''), at: now() }
+      for (const [k, v] of Object.entries(extra)) if (v != null && v !== '') meta[k] = String(v)
+      map.set(token, meta)
+      persist(); return token
+    },
+    // 读路径上也会写盘:撞见过期项就顺手删并落盘 —— 没有定时清理器,读到就是唯一的清理时机
+    has(token) {
+      if (!token || !map.has(token)) return false
+      const m = map.get(token)
+      if (!(m && m.exp > now())) { map.delete(token); persist(); return false }
+      return true
+    },
+    get(token) { return this.has(token) ? { ...map.get(token) } : null },
+    remove(token) { if (map.delete(token)) persist() },
+    // 按条件吊销(名单删人 / 换密码时由 server 调),返回吊销条数;一条都没吊销就不写盘
+    revokeWhere(pred) {
+      let n = 0
+      for (const [k, m] of map) if (pred({ ...m })) { map.delete(k); n++ }
+      if (n) persist()
+      return n
+    },
+    // 全部吊销(「退出所有设备」)
+    clear() { const n = map.size; map.clear(); persist(); return n },
+    get size() { prune(); return map.size },
+  }
+}
+
+module.exports = { createSessionStore, DEFAULT_TTL_MS }

package/src/ui/takeover.js

@@ -0,0 +1,108 @@
+'use strict'
+// 控制台「接管浏览器」的一次性链接(纯逻辑,可测)。
+//
+// 场景:群 agent 撞到登录墙 / 验证码 / 扫码,自己做不了 ⇒ 它在群里发一条链接,群成员在手机上打开就能
+// 直接操作 bot 的浏览器(登录态落在 bot 这边,以后它自己接着干)。群成员多半不是控制台管理员,所以
+// 链接本身就是门票 —— 由此三条硬约束:
+//   · **只能打开一次**:第一次打开换成一枚会话 cookie,链接立刻作废;被转发的人拿到的是一张已用过的票。
+//   · **短命**:默认 10 分钟(cfg.browser.takeoverMinutes 可调),会话与链接同一到期时刻,不滑动续期。
+//   · **只开这一扇门**:cookie 只对接管页与它的接口有效,控制台其它 /api/* 一律不认(server 那层裁决)。
+// 谁能签票:控制台管理员(已登录)与本机环回上的进程(群 agent 跑 `sbot browser link`)。接管者自己不能再签。
+
+const crypto = require('node:crypto')
+
+const COOKIE = 'sbot-takeover'
+const DEFAULT_TTL_MS = 10 * 60_000 // 够人从群里点开、登录、过一个验证码;再长就是给转发的人留窗口
+const MIN_TTL_MS = 60_000           // 少于 1 分钟,人还没点开就过期了
+const MAX_TTL_MS = 60 * 60_000      // 最多 1 小时:超过这个时长的「接管」应该去控制台用管理员身份做
+const MAX_UNUSED = 50               // 没用过的票封顶:本机任何进程都能签票,不封顶就是一个内存黑洞;超了丢最老的
+
+const rand = () => crypto.randomBytes(16).toString('hex')
+
+// onClaimed / onExpired / onEnded:票挂了元数据(群里那张卡的 cardId)时,兑换 / 没人来过期 / 会话结束各回调一次 —— daemon 拿它把卡翻成
+// 「正在接管中」/「已过期」/「接管已结束」。⚠ 结束那条是真机补的:v0.11.87 群里点了「结束接管」,卡还挂着「正在接管中」
+function createTakeoverStore({ ttlMs = DEFAULT_TTL_MS, now = Date.now, onClaimed = null, onExpired = null, onEnded = null } = {}) {
+  const links = new Map()    // token -> { id, exp, at, by, usedAt, sid, targetId, meta, timer }
+  const byId = new Map()     // id -> token(id 不是秘密,给 attach 用)
+  const sessions = new Map() // sid -> { exp, at, token, ip, targetId, meta, timer }
+  // 会话结束的唯一出口:主动结束(ended)/ 到期(expired)都走这里 ⇒ 每个会话只回调一次
+  const endSession = (sid, reason) => {
+    const s = sessions.get(sid); if (!s) return false
+    sessions.delete(sid); if (s.timer) clearTimeout(s.timer)
+    if (s.meta && onEnded) { try { onEnded(s.meta, { reason }) } catch {} }
+    return true
+  }
+  const prune = () => {
+    const t = now()
+    for (const [k, v] of links) if (!(v.exp > t)) links.delete(k)
+    for (const [k, v] of sessions) if (!(v.exp > t)) endSession(k, 'expired')
+  }
+  return {
+    // 签一张票。ttl 越界收编回 [1, 60] 分钟(不报错:签票方多半是 agent,报错它只会换个数再来)
+    // targetId:把票绑在某个标签页上,持票人只能碰那一页(不给 = 全部标签页)
+    mint({ by = '', ttl = ttlMs, targetId = '' } = {}) {
+      prune()
+      const unused = [...links.entries()].filter(([, l]) => !l.usedAt)
+      for (const [k] of unused.slice(0, Math.max(0, unused.length - MAX_UNUSED + 1))) links.delete(k)
+      const life = Math.min(MAX_TTL_MS, Math.max(MIN_TTL_MS, Number(ttl) || ttlMs))
+      const token = rand(); const id = rand().slice(0, 12); const at = now()
+      const link = { id, exp: at + life, at, by: String(by || ''), usedAt: null, sid: null, targetId: String(targetId || ''), meta: null, timer: null }
+      links.set(token, link); byId.set(id, token)
+      // 过期回调:只对挂了元数据且没被兑换的票(群里有张卡等着翻成「已过期」);daemon 重启定时器就没了,可接受
+      if (onExpired) { link.timer = setTimeout(() => { const l = links.get(token); if (l && !l.usedAt && l.meta) { try { onExpired(l.meta) } catch {} } }, life); if (link.timer.unref) link.timer.unref() }
+      return { token, id, exp: at + life, ttlMs: life, targetId: String(targetId || '') }
+    },
+    // 用票换会话:过期 / 用过 / 不存在 ⇒ null。同一张票第二次来,哪怕是同一个人也不再放行(单次即用完)
+    consume(token, { ip = '' } = {}) {
+      prune()
+      const l = links.get(String(token || ''))
+      if (!l || l.usedAt) return null
+      const sid = rand(); const at = now()
+      l.usedAt = at; l.sid = sid
+      if (l.timer) clearTimeout(l.timer)
+      const s = { exp: l.exp, at, token: String(token), ip: String(ip || ''), targetId: l.targetId || '', meta: l.meta, timer: null }
+      sessions.set(sid, s)
+      // 到点没人主动结束 ⇒ 也算结束(人来过,卡翻「已结束」而不是「已过期」);prune 是懒的,靠这个定时器按时翻
+      if (l.meta && onEnded) { s.timer = setTimeout(() => endSession(sid, 'expired'), Math.max(0, l.exp - now())); if (s.timer.unref) s.timer.unref() }
+      if (l.meta && onClaimed) { try { onClaimed(l.meta) } catch {} }
+      return { sid, exp: l.exp, targetId: l.targetId || '', meta: l.meta }
+    },
+    // 给票挂元数据(群里那张卡):按 id 找,票本身不用再传回来
+    attach(id, meta) { const tok = byId.get(String(id || '')); const l = tok && links.get(tok); if (!l || l.usedAt) return false; l.meta = meta || null; return true },
+    hasSession(sid) { prune(); return sessions.has(String(sid || '')) },
+    session(sid) { prune(); return sessions.get(String(sid || '')) || null },
+    revokeSession(sid) { return endSession(String(sid || ''), 'ended') },
+    revokeAll() { const n = sessions.size + links.size; for (const k of [...sessions.keys()]) endSession(k, 'ended'); for (const l of links.values()) if (l.timer) clearTimeout(l.timer); links.clear(); return n },
+    // 群里还挂着、没人来认领的票(控制台「需要你处理」用):只算挂了群卡的票 —— 那是 agent 在群里求助;
+    // 管理员自己在控制台签的没有卡,不算。只给元数据,不给令牌。
+    pending() {
+      prune()
+      return [...links.values()].filter((l) => !l.usedAt && l.meta && l.meta.chatId)
+        .map((l) => ({ id: l.id, at: l.at, exp: l.exp, chatId: l.meta.chatId, pageTitle: l.meta.pageTitle || '', pageUrl: l.meta.pageUrl || '' }))
+    },
+    // 摘要(测试与排障用,不暴露令牌本身)
+    stats() { prune(); return { links: links.size, unused: [...links.values()].filter((l) => !l.usedAt).length, sessions: sessions.size } },
+  }
+}
+
+// —— cookie ——
+function cookieValue(header, name = COOKIE) {
+  const h = String(header || '')
+  for (const part of h.split(';')) {
+    const i = part.indexOf('=')
+    if (i < 0) continue
+    if (part.slice(0, i).trim() === name) { try { return decodeURIComponent(part.slice(i + 1).trim()) } catch { return '' } } // 畸形 cookie 不能把整站打成 500(对抗审查 🟡5)
+  }
+  return ''
+}
+// HttpOnly:页面脚本拿不到,只随请求走;SameSite=Lax:别的站点发不了带它的跨站 POST;经 https 反代时加 Secure
+function setCookieHeader(sid, { maxAgeSec = 600, secure = false } = {}) {
+  return `${COOKIE}=${encodeURIComponent(sid)}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${Math.max(0, Math.floor(maxAgeSec))}${secure ? '; Secure' : ''}`
+}
+const clearCookieHeader = ({ secure = false } = {}) => `${COOKIE}=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0${secure ? '; Secure' : ''}`
+
+// 链接形状:<控制台根>/browser#k=<票>。票放在 URL 片段里:浏览器不会把它发给服务器 ⇒ 不进 nginx 访问日志、不被链接预览 / 安全扫描的裸 GET
+// 拿走;页面脚本读片段后由人点「开始接管」再 POST 兑换。根优先公网地址(群成员出了局域网也打得开),没配就退局域网地址
+const takeoverUrl = (base, token) => `${String(base || '').replace(/\/+$/, '')}/browser#k=${encodeURIComponent(token)}`
+
+module.exports = { COOKIE, DEFAULT_TTL_MS, MIN_TTL_MS, MAX_TTL_MS, MAX_UNUSED, createTakeoverStore, cookieValue, setCookieHeader, clearCookieHeader, takeoverUrl }

package/src/usage.js

@@ -0,0 +1,144 @@
+// Per-provider account balance / plan usage — the numbers cc-hud surfaces, for
+// the console. Server-side (keys never reach the browser), best-effort, cached
+// 5 min, 2.5s timeout. Endpoints mirror cc-hud (deepseek / glm / minimax); other
+// providers (volcano coding-plan, Claude) have no public balance API → skipped.
+
+const CACHE = new Map() // provider name -> { val, ts }
+const TTL = 5 * 60 * 1000
+
+async function fetchJson(url, key, ms = 2500) {
+  const ac = new AbortController()
+  const timer = setTimeout(() => ac.abort(), ms)
+  try {
+    const r = await fetch(url, { headers: { Authorization: `Bearer ${key}` }, signal: ac.signal })
+    if (!r.ok) return null
+    return await r.json()
+  } catch { return null } finally { clearTimeout(timer) }
+}
+
+// baseUrl → 哪一家的余额接口(null = 这家根本没有公开余额接口,如火山 coding plan)。
+// 抽出来是为了「能不能查」与「怎么查」共用同一份判定 —— 两处各写一份必然漂移,而漂移的
+// 后果正是群里那句错话:明明这家没接口,却说成「暂时没查到,稍后再试」让人白等。
+const balanceKind = (base = '') =>
+  base.includes('deepseek') ? 'deepseek'
+    : (base.includes('bigmodel.cn') || base.includes('api.z.ai')) ? 'glm'
+      : base.includes('minimax') ? 'minimax'
+        : null
+
+async function providerUsage(provider) {
+  const key = provider.apiKey
+  const base = provider.baseUrl || ''
+  // Claude 订阅登录形态(无 baseUrl、非 codex):额度走 oauth/usage(cc-hud 同源通道,
+  // v0.11.3;凭据取本机 Claude Code 登录态,拿不到/未登录 ⇒ null 不显示)。
+  if (!base && provider.runner !== 'codex') {
+    const v = await require('./agent/claudeusage').usageLine()
+    return v ? { label: '订阅额度', value: v } : null
+  }
+  if (!key) return null
+
+  const kind = balanceKind(base)
+  if (kind === 'deepseek') {
+    const d = await fetchJson('https://api.deepseek.com/user/balance', key)
+    const t = d && d.balance_infos && d.balance_infos[0] && d.balance_infos[0].total_balance
+    return t ? { label: '余额', value: `¥${t}` } : null
+  }
+  if (kind === 'glm') {
+    const host = base.includes('api.z.ai') ? 'https://api.z.ai' : 'https://open.bigmodel.cn'
+    const d = await fetchJson(`${host}/api/biz/account/query-customer-account-report`, key)
+    if (d && d.code && d.code !== 200) return null
+    const inner = (d && d.data) || d || {}
+    const v = inner.balance != null ? inner.balance : inner.total_balance != null ? inner.total_balance : inner.amount
+    if (v == null) return null
+    return { label: '余额', value: typeof v === 'number' ? `¥${v.toFixed(2)}` : `¥${String(v).replace(/^¥/, '')}` }
+  }
+  if (kind === 'minimax') {
+    const host = base.includes('minimaxi.com') ? 'https://api.minimaxi.com' : 'https://api.minimax.io'
+    const d = await fetchJson(`${host}/v1/token_plan/remains`, key)
+    const m = d && d.model_remains && (d.model_remains.find((x) => x.current_interval_status === 1) || d.model_remains[0])
+    if (!m) return null
+    return { label: '额度', value: `5h:${Math.min(100, Math.max(0, Math.round(100 - m.current_interval_remaining_percent)))}%` } // 口径统一为「已用」(v0.11.8);接口给的是剩余 ⇒ 换算
+  }
+  return null // volcano / claude: no public balance API
+}
+
+// 能不能给这个 provider 查额度 —— getUsage 与 refreshUsage 共用的单一判据(两处各写一份
+// 必然漂移:手点刷新放行了 hidden,就等于绕开「hidden ⇒ 零探测」)。
+//   hidden = operator 主动撤下 ⇒ 不拉(卡片都不显示,拉了白拉;生产机的 claude 标 hidden,
+//   不该为它去翻 Keychain)· codex 额度走自家 app-server 通道(codexstatus),不在这 ·
+//   第三方缺 key 查不了。剩下 = 第三方有 key / 登录态 claude(无 baseUrl 非 codex),都可查。
+const queryable = (p) => !!p && !p.hidden && p.runner !== 'codex' && !(p.baseUrl && !p.apiKey)
+
+// 登录态 claude(无 baseUrl、非 codex)—— 它的额度走 claudeusage 那条通道,自带 60s TTL。
+const isClaudeLogin = (p) => !!p && !p.baseUrl && p.runner !== 'codex'
+
+// 这个模型形态**本来**有没有额度可查(与 providerUsage 的分支一一对应)。
+// queryable 答的是「该不该去探」(撤下的、缺 key 的、走自家通道的都别探);这里答的是
+// 「探了本该有没有数」—— 两者不是一回事:火山这类第三方 key 齐全该探,但它没有公开余额接口,
+// 查不到是**结构性**的,不是网络抖动。分不开这两件事,群里就只能把偶发失败也说成「不支持」。
+//
+// ⚠ **不看 hidden**(2026-08-11 修回归):hidden 只是「控制台的模型页别列它」这一条收纳口径,
+// 群照样在用它 —— 生产机的 claude 正是 hidden。把 queryable 的 !hidden 混进来,群里 /hud 就会
+// 对着一个天天在跑的模型说「不支持查额度」,而它明明查得到。缺 key 仍算「不支持」(旧行为)。
+const hasUsageApi = (p) => !!p && p.runner !== 'codex' && !(p.baseUrl && !p.apiKey)
+  && (isClaudeLogin(p) || !!balanceKind(p.baseUrl || ''))
+
+// Fetch balances for all keyed providers (resolved apiKey). Returns { name: {label,value} }.
+async function getUsage(providers = {}) {
+  const out = {}
+  await Promise.all(Object.entries(providers).map(async ([name, p]) => {
+    if (!queryable(p)) return
+    const c = CACHE.get(name)
+    if (c && Date.now() - c.ts < TTL) { out[name] = c.val; return }
+    const v = await providerUsage(p)
+    if (v) { CACHE.set(name, { val: v, ts: Date.now() }); out[name] = v }
+    else if (c) out[name] = c.val // stale fallback
+  }))
+  return out
+}
+
+// 单个 provider 强制刷新(控制台额度行的「↻」)。**点按钮 = 要此刻的数**,所以两层缓存都得绕:
+// 本模块的 5 分钟 CACHE,以及登录态 claude 那条通道自己的 60s TTL(与 /api/claude/verify 同口径)。
+// ⚠ 拉不到时把上一次的值留在缓存里 —— 手点刷新失败不该让卡片上原本显示着的额度行凭空消失
+// (旧 ts 保留 ⇒ 它照样算过期,下一次 getUsage 仍会重拉)。probe/now 注入是为了可单测。
+async function refreshUsage(name, provider, { probe = providerUsage, now = Date.now } = {}) {
+  if (!queryable(provider)) { CACHE.delete(name); return null }
+  const prev = CACHE.get(name)
+  CACHE.delete(name)
+  if (isClaudeLogin(provider)) { try { require('./agent/claudeusage').clearCache() } catch { /* best-effort */ } }
+  const v = await probe(provider).catch(() => null)
+  if (v) CACHE.set(name, { val: v, ts: now() })
+  else if (prev) CACHE.set(name, prev)
+  return v
+}
+
+// /hud 的额度探针(daemon 注入给 engine —— core 不认具体 runner)。放这儿而不是内联在
+// 启动流程里,是为了它能被单测钉住:这层的两个判断都出过事。
+//
+// 返回 **{ supported, value }**,两件事分开答:
+//   supported = 这个模型形态本来能不能查(codex 走自家订阅通道 · 登录态 claude 与有余额接口的
+//               第三方走 providerUsage);value = 此刻真查到的串,查不到给 null。
+//   ⚠ 合成一个 null 就是本案的根因:群里于是把「接口超时/限流」一律说成「模型不支持查额度」,
+//     而这两句话给群成员的下一步完全相反(一个别再问,一个过会儿再问)。
+// 缓存:**成功压 60s,失败只压 10s**(与 claudeusage 同口径)—— 失败也压一分钟,等于一次
+// 偶发超时让整整一分钟查不到;完全不压又让连点 /hud 直捅端点限流。
+function createUsageProbe({ codexUsage = async () => null, probe = providerUsage, ttl = 60_000, failTtl = 10_000, now = Date.now } = {}) {
+  const cache = new Map() // provider name + '|' + baseUrl -> { v, ts }
+  return async (name, provider) => {
+    const isCodex = !!provider && provider.runner === 'codex'
+    if (!isCodex && !hasUsageApi(provider)) return { supported: false, value: null }
+    // 缓存键带上 baseUrl:控制台热改端点(deepseek → minimax)后名字没变,只按名字缓存会让
+    // 接下来 60 秒把上一家的余额当成这一家的报出去 —— 换了端点就是换了账,不许串味。
+    const key = name + '|' + ((provider && provider.baseUrl) || '')
+    const c = cache.get(key)
+    if (c && now() - c.ts < (c.v ? ttl : failTtl)) return { supported: true, value: c.v }
+    let v = null
+    try {
+      if (isCodex) v = await codexUsage(provider)
+      else { const u = await probe(provider); v = u ? `${u.label} ${u.value}` : null }
+    } catch { v = null }
+    cache.set(key, { v: v || null, ts: now() })
+    return { supported: true, value: v || null }
+  }
+}
+
+module.exports = { getUsage, providerUsage, refreshUsage, queryable, hasUsageApi, createUsageProbe }