dsh-team-bots 0.2.393 → 0.2.455
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +4 -1
- package/scripts/doctor.mjs +14 -3
- package/src/api.js +30 -3
- package/src/config.js +105 -0
- package/src/db-migrations.js +20 -0
- package/src/db.js +4 -0
- package/src/feishu/channel.js +702 -0
- package/src/feishu/commands.js +20 -0
- package/src/feishu/format.js +56 -0
- package/src/feishu/index.js +19 -0
- package/src/feishu/store.js +205 -0
- package/src/service.js +7 -0
- package/src/services/bots.js +42 -0
- package/src/services/chat.js +6 -4
- package/src/services/core.js +153 -8
- package/src/services/external-trigger-schema.js +61 -0
- package/src/services/feishu.js +181 -0
- package/src/services/github-source.js +157 -0
- package/src/services/memory.js +122 -34
- package/src/services/projects.js +2 -0
- package/src/services/reason-codes.js +63 -0
- package/src/services/review-watchdog.js +30 -8
- package/src/services/run-finish.js +33 -9
- package/src/services/runs.js +48 -7
- package/src/services/runtime/context-window.js +53 -0
- package/src/services/runtime/prompt.js +149 -134
- package/src/services/runtime/sandbox-policy.js +65 -0
- package/src/services/runtime/session-continuity.js +38 -0
- package/src/services/runtime/session.js +155 -5
- package/src/services/scheduler.js +9 -2
- package/src/services/system.js +50 -2
- package/src/services/task-dispatch.js +40 -4
- package/src/services/task-notify.js +13 -8
- package/src/services/task-review.js +27 -0
- package/src/services/wechat-trigger-schema.js +62 -0
- package/src/services/wechat.js +129 -19
- package/src/tools.js +11 -2
- package/src/wechat/channel.js +130 -26
- package/src/wechat/commands.js +13 -1
- package/src/wechat/store.js +69 -18
- package/ui/app.js +6 -2
- package/ui/i18n/en/chat.js +1 -0
- package/ui/i18n/en/nav.js +5 -0
- package/ui/i18n/en/settings.js +25 -5
- package/ui/i18n/en/tasks.js +4 -0
- package/ui/i18n/en/wechat.js +25 -3
- package/ui/i18n/zh/chat.js +1 -0
- package/ui/i18n/zh/nav.js +5 -0
- package/ui/i18n/zh/settings.js +25 -5
- package/ui/i18n/zh/tasks.js +4 -0
- package/ui/i18n/zh/wechat.js +25 -3
- package/ui/modules/api.js +23 -1
- package/ui/modules/cards.js +15 -0
- package/ui/modules/chat.js +43 -2
- package/ui/modules/dom-morph.js +14 -7
- package/ui/modules/events-board.js +73 -23
- package/ui/modules/events-click.js +11 -0
- package/ui/modules/global-pages.js +138 -10
- package/ui/modules/settings.js +51 -9
- package/ui/modules/state.js +2 -0
- package/ui/styles/chat-cards.css +28 -0
- package/ui/styles/frame.css +27 -3
- package/ui/styles/global-config.css +28 -3
- package/ui/styles/surfaces.css +2 -0
|
@@ -0,0 +1,702 @@
|
|
|
1
|
+
import { outboundChunks, failureText, welcomeAdmin } from './format.js'
|
|
2
|
+
import { handleCommand, NON_OWNER_NOTICE } from './commands.js'
|
|
3
|
+
|
|
4
|
+
/** 出站最大尝试次数(含首次):达到上限废弃,永不补发(与微信通道同治理口径)。 */
|
|
5
|
+
const OUTBOX_MAX_ATTEMPTS = 3
|
|
6
|
+
/** 合批窗口:窗口内到达的多条推送合并到同一次 flush(每条仍独立带幂等键发送)。 */
|
|
7
|
+
const OUTBOX_BATCH_WINDOW_MS = 1500
|
|
8
|
+
/** 已发送/已废弃出站记录保留 7 天。 */
|
|
9
|
+
const OUTBOX_RETENTION_DAYS = 7
|
|
10
|
+
/** 入站去重 LRU:TTL 10 分钟、上限 1000 条,重连不清空(对齐 cindy 口径)。 */
|
|
11
|
+
export const INBOUND_DEDUP_TTL_MS = 10 * 60 * 1000
|
|
12
|
+
export const INBOUND_DEDUP_LIMIT = 1000
|
|
13
|
+
/** 群聊非 owner @bot 的礼貌回应冷却:同一发送者 60s 至多一条,不起 turn。 */
|
|
14
|
+
export const NON_OWNER_COOLDOWN_MS = 60_000
|
|
15
|
+
/** 出站单条同幂等键的有界重试:超时/传输类不确定失败重发同键(飞书侧同键至多一条)。 */
|
|
16
|
+
const SEND_RETRY_MAX_ATTEMPTS = 2
|
|
17
|
+
const SEND_RETRY_DELAY_MS = 250
|
|
18
|
+
/** 退避/重试定时器一律 unref:通道重连节奏不得阻止宿主进程退出(与 flushTimer 同口径)。 */
|
|
19
|
+
const sleep = ms => new Promise(resolve => {
|
|
20
|
+
const timer = setTimeout(resolve, ms)
|
|
21
|
+
timer.unref?.()
|
|
22
|
+
})
|
|
23
|
+
|
|
24
|
+
/** 飞书接口错误:code 为飞书业务错误码(无码=传输/本地失败,可重试)。 */
|
|
25
|
+
export class FeishuError extends Error {
|
|
26
|
+
|
|
27
|
+
constructor(message, code = undefined) {
|
|
28
|
+
super(message)
|
|
29
|
+
this.name = 'FeishuError'
|
|
30
|
+
this.code = code
|
|
31
|
+
}
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
/**
|
|
35
|
+
* gone 判定:飞书侧永久拒绝回复——目标消息已被撤回(230011 / withdrawn)或
|
|
36
|
+
* 2300xx not found。只有带这些码的 FeishuError 才算 gone;本地超时/网络失败不算。
|
|
37
|
+
*/
|
|
38
|
+
export function isGone(error) {
|
|
39
|
+
if (!(error instanceof FeishuError) || error.code === undefined) return false
|
|
40
|
+
return error.code === 230011
|
|
41
|
+
|| /withdrawn/i.test(error.message)
|
|
42
|
+
|| (Math.floor(error.code / 100) === 2300 && /not found/i.test(error.message))
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
/** 传输/执行类错误可重试;带飞书错误码的业务拒绝不可重试(重试也不会变对)。 */
|
|
46
|
+
export function isRetryable(error) {
|
|
47
|
+
if (!error) return false
|
|
48
|
+
if (error instanceof FeishuError) return error.code === undefined
|
|
49
|
+
if (error?.permanent === true) return false
|
|
50
|
+
if (error instanceof SyntaxError || error instanceof RangeError || error instanceof ReferenceError) return false
|
|
51
|
+
return true
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
/** 飞书连接数冲突:1000040350=本应用事件已有别的消费者在长连接(SDK 报错文案带此码)。 */
|
|
55
|
+
export function isConnLimit(error) {
|
|
56
|
+
if (error?.code === 1000040350) return true
|
|
57
|
+
return /exceed[_\s-]?conn[_\s-]?limit|1000040350/i.test(String(error?.message ?? ''))
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
/** im.message.receive_v1 事件体的入站解析:SDK 回调为顶层 sender/message 字段。 */
|
|
61
|
+
export function parseInboundEvent(payload) {
|
|
62
|
+
const message = payload?.message
|
|
63
|
+
if (!message?.message_id) return null
|
|
64
|
+
let text = ''
|
|
65
|
+
if (message.message_type === 'text' && message.content) {
|
|
66
|
+
try {
|
|
67
|
+
text = String(JSON.parse(message.content)?.text ?? '')
|
|
68
|
+
} catch {
|
|
69
|
+
text = ''
|
|
70
|
+
}
|
|
71
|
+
}
|
|
72
|
+
const senderOpenId = payload?.sender?.sender_id?.open_id
|
|
73
|
+
return {
|
|
74
|
+
messageId: String(message.message_id),
|
|
75
|
+
chatId: message.chat_id ? String(message.chat_id) : null,
|
|
76
|
+
chatType: message.chat_type === 'group' ? 'group' : 'p2p',
|
|
77
|
+
senderOpenId: senderOpenId ? String(senderOpenId) : null,
|
|
78
|
+
rootId: message.root_id ? String(message.root_id) : null,
|
|
79
|
+
text,
|
|
80
|
+
mentions: Array.isArray(message.mentions) ? message.mentions : [],
|
|
81
|
+
}
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
/** lane 编码(对齐 cindy):群= g/{chatId}[/{threadId}](话题挂 root),p2p=发送者 open_id。 */
|
|
85
|
+
export function laneOf(parsed) {
|
|
86
|
+
if (parsed?.chatType === 'group') {
|
|
87
|
+
return `g/${parsed.chatId}${parsed.rootId ? `/${parsed.rootId}` : ''}`
|
|
88
|
+
}
|
|
89
|
+
return parsed?.senderOpenId ?? null
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
/** 剥掉群消息里的 @占位符(@_user_N),剩下的才是指令/正文。 */
|
|
93
|
+
export function stripMentionPlaceholders(text) {
|
|
94
|
+
return String(text ?? '').replace(/@_user_\d+/g, ' ').replace(/\s+/g, ' ').trim()
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
/** 传输层接口:进程内官方 SDK 实现(见 createSdkTransport),测试全 stub。
|
|
98
|
+
* - botInfo(): 取机器人身份(appId/botId)。
|
|
99
|
+
* - reply(messageId, text, uuid): 回复一条消息,uuid 即幂等键。
|
|
100
|
+
* - startEvents({onEvent,onReady,onError}): 起长连接收事件。
|
|
101
|
+
* - stop(): 断开长连接。 */
|
|
102
|
+
|
|
103
|
+
|
|
104
|
+
|
|
105
|
+
|
|
106
|
+
|
|
107
|
+
|
|
108
|
+
|
|
109
|
+
|
|
110
|
+
|
|
111
|
+
|
|
112
|
+
|
|
113
|
+
/** SDK 日志适配:把 SDK 内部日志转发到宿主 logger,并把 app secret 从日志里抹掉。 */
|
|
114
|
+
function sdkLogger(log , secret ) {
|
|
115
|
+
const emit = (level , args ) => {
|
|
116
|
+
let text = ''
|
|
117
|
+
try {
|
|
118
|
+
text = args.map(item => (typeof item === 'string' ? item : JSON.stringify(item))).join(' ')
|
|
119
|
+
} catch {
|
|
120
|
+
text = String(args?.[0] ?? '')
|
|
121
|
+
}
|
|
122
|
+
if (secret && text.includes(secret)) text = text.split(secret).join('***')
|
|
123
|
+
log?.[level]?.(text)
|
|
124
|
+
}
|
|
125
|
+
return {
|
|
126
|
+
info: (...args) => emit('info', args),
|
|
127
|
+
warn: (...args) => emit('warn', args),
|
|
128
|
+
error: (...args) => emit('error', args),
|
|
129
|
+
debug: (...args) => emit('debug', args),
|
|
130
|
+
trace: (...args) => emit('trace', args),
|
|
131
|
+
}
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
/** 出站载荷:含 markdown 记号走交互卡片(飞书卡片 markdown 元素原生渲染),纯文本走 text 消息。 */
|
|
135
|
+
function outboundPayload(text) {
|
|
136
|
+
const body = String(text ?? '')
|
|
137
|
+
if (/[*#`_]|\n\s*[-*]\s|\[[^\]]+\]\(/.test(body)) {
|
|
138
|
+
const card = {
|
|
139
|
+
config: { wide_screen_mode: true },
|
|
140
|
+
elements: [{ tag: 'markdown', content: body }],
|
|
141
|
+
}
|
|
142
|
+
return { msgType: 'interactive', content: JSON.stringify(card) }
|
|
143
|
+
}
|
|
144
|
+
return { msgType: 'text', content: JSON.stringify({ text: body }) }
|
|
145
|
+
}
|
|
146
|
+
|
|
147
|
+
/** SDK 抛出的错误归一:尽量取出飞书业务错误码(axios 响应体 code / 错误文案里的 code),
|
|
148
|
+
* 便于 gone(230011/2300xx)与可重试判定按业务码分流。 */
|
|
149
|
+
export function toFeishuError(error) {
|
|
150
|
+
if (error instanceof FeishuError) return error
|
|
151
|
+
const raw = Number(
|
|
152
|
+
error?.response?.data?.code
|
|
153
|
+
?? error?.code
|
|
154
|
+
?? /code[:=]\s*(\d+)/.exec(String(error?.message ?? ''))?.[1]
|
|
155
|
+
?? NaN,
|
|
156
|
+
)
|
|
157
|
+
const message = String(error?.response?.data?.msg ?? error?.msg ?? error?.message ?? error)
|
|
158
|
+
return new FeishuError(message, Number.isFinite(raw) ? raw : undefined)
|
|
159
|
+
}
|
|
160
|
+
|
|
161
|
+
/**
|
|
162
|
+
* 进程内官方 SDK 传输层(@larksuiteoapi/node-sdk):
|
|
163
|
+
* - 入站:WSClient 长连接 + EventDispatcher 订阅 im.message.receive_v1
|
|
164
|
+
* (autoReconnect/ping 由 SDK 内建,token 由 SDK 自管,无外部二进制依赖);
|
|
165
|
+
* - 出站:im.v1.message.reply,data.uuid 作幂等键(飞书侧同 uuid 至多一条);
|
|
166
|
+
* - 身份:GET /open-apis/bot/v3/info 取 bot open_id。
|
|
167
|
+
* SDK 缺席(依赖未安装)时抛错,由调用方降级为 unbound。
|
|
168
|
+
*/
|
|
169
|
+
export async function createSdkTransport({ appId, appSecret, log = console }) {
|
|
170
|
+
const lark = await import('@larksuiteoapi/node-sdk')
|
|
171
|
+
const logger = sdkLogger(log, appSecret)
|
|
172
|
+
const client = new lark.Client({ appId, appSecret, logger, loggerLevel: lark.LoggerLevel.warn })
|
|
173
|
+
let wsClient = null
|
|
174
|
+
return {
|
|
175
|
+
async botInfo() {
|
|
176
|
+
let res
|
|
177
|
+
try {
|
|
178
|
+
res = await client.request({ url: '/open-apis/bot/v3/info', method: 'GET' })
|
|
179
|
+
} catch (error) {
|
|
180
|
+
throw toFeishuError(error)
|
|
181
|
+
}
|
|
182
|
+
const code = Number(res?.code ?? 0)
|
|
183
|
+
if (code !== 0) throw new FeishuError(res?.msg || `bot/v3/info 返回错误码 ${code}`, code)
|
|
184
|
+
const botId = res?.bot?.open_id
|
|
185
|
+
if (!botId) throw new FeishuError('bot/v3/info 未返回 open_id(feishuNoBot)')
|
|
186
|
+
return { appId: String(res?.bot?.app_id ?? appId), botId: String(botId), brand: 'feishu' }
|
|
187
|
+
},
|
|
188
|
+
async reply(messageId, text, uuid) {
|
|
189
|
+
const { msgType, content } = outboundPayload(text)
|
|
190
|
+
let res
|
|
191
|
+
try {
|
|
192
|
+
res = await client.im.v1.message.reply({
|
|
193
|
+
path: { message_id: String(messageId) },
|
|
194
|
+
data: { content, msg_type: msgType, uuid: String(uuid) },
|
|
195
|
+
})
|
|
196
|
+
} catch (error) {
|
|
197
|
+
throw toFeishuError(error)
|
|
198
|
+
}
|
|
199
|
+
const code = Number(res?.code ?? 0)
|
|
200
|
+
if (code !== 0) throw new FeishuError(res?.msg || `飞书回复失败(错误码 ${code})`, code)
|
|
201
|
+
return { messageId: res?.data?.message_id ?? null }
|
|
202
|
+
},
|
|
203
|
+
async startEvents({ onEvent, onReady, onError }) {
|
|
204
|
+
const dispatcher = new lark.EventDispatcher({ logger, loggerLevel: lark.LoggerLevel.warn })
|
|
205
|
+
dispatcher.register({
|
|
206
|
+
'im.message.receive_v1': async (data ) => {
|
|
207
|
+
onEvent(data)
|
|
208
|
+
},
|
|
209
|
+
})
|
|
210
|
+
wsClient = new lark.WSClient({
|
|
211
|
+
appId,
|
|
212
|
+
appSecret,
|
|
213
|
+
logger,
|
|
214
|
+
loggerLevel: lark.LoggerLevel.warn,
|
|
215
|
+
onReady: () => onReady?.(),
|
|
216
|
+
onReconnected: () => onReady?.(),
|
|
217
|
+
onError: (error ) => onError?.(error),
|
|
218
|
+
})
|
|
219
|
+
await wsClient.start({ eventDispatcher: dispatcher })
|
|
220
|
+
},
|
|
221
|
+
stop() {
|
|
222
|
+
try {
|
|
223
|
+
wsClient?.close?.()
|
|
224
|
+
} catch {
|
|
225
|
+
// 关闭失败不影响进程退出
|
|
226
|
+
}
|
|
227
|
+
wsClient = null
|
|
228
|
+
},
|
|
229
|
+
}
|
|
230
|
+
}
|
|
231
|
+
|
|
232
|
+
/**
|
|
233
|
+
* 飞书机器人通道宿主(DSHBOTS-333:传输层换进程内官方 SDK)。
|
|
234
|
+
* 架构:传输层=进程内 @larksuiteoapi/node-sdk(WSClient 长连接收事件 +
|
|
235
|
+
* im.v1.message.reply 出站,uuid 幂等),入站模型(LRU 去重/TOFU 认主/群@门禁/
|
|
236
|
+
* lane 编码/generation 门禁)与传输无关,原样保留。
|
|
237
|
+
* 凭据生效优先级(DSHBOTS-334):通道页保存(secrets 表 SecretBox 加密)> 服务端
|
|
238
|
+
* 注入(cordis.patch.yml / env);secret 明文只在内存交给 SDK,日志/状态一律不回显。
|
|
239
|
+
*/
|
|
240
|
+
export class FeishuChannel {
|
|
241
|
+
constructor({ store, config, log: logger = console , batchWindowMs = OUTBOX_BATCH_WINDOW_MS, transport = null }) {
|
|
242
|
+
this.store = store
|
|
243
|
+
this.config = config
|
|
244
|
+
this.log = logger
|
|
245
|
+
this.service = null
|
|
246
|
+
this.phase = 'disabled'
|
|
247
|
+
this.error = null
|
|
248
|
+
/** 传输层(测试注入桩);缺省按凭据创建进程内 SDK 传输。 */
|
|
249
|
+
this.transport = transport
|
|
250
|
+
/** 构造时注入的传输桩是测试缝:rebind 不丢弃(生产自建传输才会按新凭据重建)。 */
|
|
251
|
+
this.injectedTransport = Boolean(transport)
|
|
252
|
+
this.batchWindowMs = batchWindowMs
|
|
253
|
+
this.flushTimer = null
|
|
254
|
+
/** flushOutbox 串行化链:并发 flush 会重复读取同一批 pending 造成重复发送。 */
|
|
255
|
+
this.flushChain = Promise.resolve()
|
|
256
|
+
/** 入站去重 LRU(重连不清空)与连接 generation 门禁。 */
|
|
257
|
+
this.inboundSeen = new Map()
|
|
258
|
+
this.consumeGeneration = 0
|
|
259
|
+
this.consumeAbort = new AbortController()
|
|
260
|
+
/** 群聊非 owner @bot 礼貌回应的冷却表(发送者 open_id → 上次回应时间)。 */
|
|
261
|
+
this.politeAt = new Map()
|
|
262
|
+
/** 同幂等键发送调用计数(send 层重试与 outbox 层重试共享 3 次总预算)。 */
|
|
263
|
+
this.sendAttempts = new Map()
|
|
264
|
+
}
|
|
265
|
+
|
|
266
|
+
setService(service) {
|
|
267
|
+
this.service = service
|
|
268
|
+
}
|
|
269
|
+
|
|
270
|
+
enabled() {
|
|
271
|
+
return Boolean(this.config.feishu?.enabled)
|
|
272
|
+
}
|
|
273
|
+
|
|
274
|
+
/**
|
|
275
|
+
* phase 迁移(DSHBOTS-334 日志去噪):置相位并返回是否发生变化(相位或错误文案
|
|
276
|
+
* 任一变动)。调用方只在变化时打日志——宿主 HMR 反复重载/重连轮次里同一状态
|
|
277
|
+
* 不再刷屏;重新进入(如 ready→unbound)仍会各打一次。
|
|
278
|
+
*/
|
|
279
|
+
setPhase(phase, error = this.error) {
|
|
280
|
+
const changed = this.phase !== phase || this.error !== error
|
|
281
|
+
this.phase = phase
|
|
282
|
+
this.error = error
|
|
283
|
+
return changed
|
|
284
|
+
}
|
|
285
|
+
|
|
286
|
+
/**
|
|
287
|
+
* 生效凭据(DSHBOTS-334):通道页保存(secrets 表)> 服务端注入(patch.yml/env)。
|
|
288
|
+
* 解析收敛在 service.feishuEffectiveCredentials;无 service(单测桩)时回退 config。
|
|
289
|
+
*/
|
|
290
|
+
resolveCredentials() {
|
|
291
|
+
const viaService = this.service?.feishuEffectiveCredentials?.()
|
|
292
|
+
if (viaService) return viaService
|
|
293
|
+
return {
|
|
294
|
+
appId: String(this.config.feishu?.appId ?? '').trim(),
|
|
295
|
+
appSecret: String(this.config.feishu?.appSecret ?? '').trim(),
|
|
296
|
+
}
|
|
297
|
+
}
|
|
298
|
+
|
|
299
|
+
/**
|
|
300
|
+
* 重绑(凭据变更后,DSHBOTS-334):断开旧传输,按当前生效凭据重走启动自检。
|
|
301
|
+
* 生产路径 this.transport=null 强制按新凭据重建 SDK 传输;测试注入桩保留复用。
|
|
302
|
+
*/
|
|
303
|
+
async rebind() {
|
|
304
|
+
await this.stop()
|
|
305
|
+
if (!this.injectedTransport) this.transport = null
|
|
306
|
+
await this.start()
|
|
307
|
+
}
|
|
308
|
+
|
|
309
|
+
/**
|
|
310
|
+
* 启动:凭据齐备即连(开关+凭据=开箱即用)——先用 bot/v3/info 自检身份,
|
|
311
|
+
* 再起 WSClient 长连接。任一步失败:phase='unbound' + error 留痕,绝不抛出。
|
|
312
|
+
*/
|
|
313
|
+
async start() {
|
|
314
|
+
if (!this.enabled()) return
|
|
315
|
+
this.store.purgeSentOutbox?.(OUTBOX_RETENTION_DAYS)
|
|
316
|
+
// 重连前先换新中止器:stop() 已 abort 旧信号,旧连接轮次的事件按旧信号丢弃。
|
|
317
|
+
this.consumeAbort = new AbortController()
|
|
318
|
+
const { appId, appSecret } = this.resolveCredentials()
|
|
319
|
+
if (!appId || !appSecret) {
|
|
320
|
+
const message = '未配置飞书应用凭据(feishuAppId / feishuAppSecret)'
|
|
321
|
+
if (this.setPhase('unbound', message)) this.log.warn?.(`[feishu] ${message}`)
|
|
322
|
+
return
|
|
323
|
+
}
|
|
324
|
+
try {
|
|
325
|
+
const transport = this.transport ?? await createSdkTransport({ appId, appSecret, log: this.log })
|
|
326
|
+
this.transport = transport
|
|
327
|
+
const bot = await transport.botInfo()
|
|
328
|
+
this.store.saveBot({ appId: bot.appId || appId, botId: bot.botId, brand: bot.brand ?? 'feishu' })
|
|
329
|
+
// 重新绑定完成:此前的待发堆积一律作废不补发(与微信通道同治理口径)
|
|
330
|
+
const voided = this.store.giveUpAllPending?.() ?? 0
|
|
331
|
+
if (voided > 0) this.log.info?.(`[feishu] 绑定完成,作废此前待发堆积 ${voided} 条(不补发)`)
|
|
332
|
+
if (this.setPhase('ready', null)) this.log.info?.(`[feishu] 绑定完成 app=${bot.appId ?? appId} bot=${bot.botId}`)
|
|
333
|
+
await transport.startEvents({
|
|
334
|
+
onEvent: payload => this.onEvent(payload),
|
|
335
|
+
onReady: () => {
|
|
336
|
+
// 每次(重)连接就绪即换代 generation:旧连接轮次里未完成的事件整体丢弃
|
|
337
|
+
this.consumeGeneration += 1
|
|
338
|
+
if (this.phase !== 'conflict' && this.setPhase('ready', null)) {
|
|
339
|
+
this.log.info?.('[feishu] 长连接已就绪')
|
|
340
|
+
}
|
|
341
|
+
},
|
|
342
|
+
onError: error => this.onTransportError(error),
|
|
343
|
+
})
|
|
344
|
+
} catch (error) {
|
|
345
|
+
const message = this.errorText(error)
|
|
346
|
+
if (this.setPhase('unbound', message)) this.log.warn?.(`[feishu] 绑定失败,通道未绑定(不 crash): ${message}`)
|
|
347
|
+
}
|
|
348
|
+
}
|
|
349
|
+
|
|
350
|
+
/** 长连接异常:连接数冲突(1000040350)是确定性冲突,置 conflict;其余按重连中处理。 */
|
|
351
|
+
onTransportError(error) {
|
|
352
|
+
if (isConnLimit(error)) {
|
|
353
|
+
const message = 'exceed_conn_limit(1000040350):已有其他实例在消费本应用事件'
|
|
354
|
+
if (this.setPhase('conflict', message)) this.log.warn?.(`[feishu] ${message}`)
|
|
355
|
+
return
|
|
356
|
+
}
|
|
357
|
+
const message = this.errorText(error)
|
|
358
|
+
if (this.setPhase('reconnecting', message)) this.log.warn?.(`[feishu] 长连接异常:${message}`)
|
|
359
|
+
}
|
|
360
|
+
|
|
361
|
+
async stop() {
|
|
362
|
+
if (this.flushTimer) {
|
|
363
|
+
clearTimeout(this.flushTimer)
|
|
364
|
+
this.flushTimer = null
|
|
365
|
+
}
|
|
366
|
+
this.consumeAbort?.abort()
|
|
367
|
+
try {
|
|
368
|
+
await this.transport?.stop?.()
|
|
369
|
+
} catch (error) {
|
|
370
|
+
this.log.warn?.(`[feishu] 传输层关闭失败: ${this.errorText(error)}`)
|
|
371
|
+
}
|
|
372
|
+
}
|
|
373
|
+
|
|
374
|
+
status() {
|
|
375
|
+
const state = this.store.getState()
|
|
376
|
+
return {
|
|
377
|
+
phase: this.phase,
|
|
378
|
+
enabled: this.enabled(),
|
|
379
|
+
error: this.error,
|
|
380
|
+
appId: state?.app_id ?? null,
|
|
381
|
+
botId: state?.bot_id ?? null,
|
|
382
|
+
brand: state?.brand ?? null,
|
|
383
|
+
adminOuId: state?.admin_ou_id ?? null,
|
|
384
|
+
}
|
|
385
|
+
}
|
|
386
|
+
|
|
387
|
+
/**
|
|
388
|
+
* 出站底层原语:回复目标消息所在话题。飞书同一 uuid 至多产生一条回复,
|
|
389
|
+
* uuid 即 outbox 行 id——重试/进程重启后重复发送也不会在飞书侧重复落消息。
|
|
390
|
+
* 超时/传输类不确定失败:同 uuid 有界重试(1 次),飞书侧幂等命中时从响应取回
|
|
391
|
+
* 原 message_id,既不双发也不丢发。多块文本第 2 块起 uuid 尾加 `#序号`
|
|
392
|
+
* (同 uuid 多块会被飞书幂等吞掉,块间必须可区分)。
|
|
393
|
+
* gone(目标消息已撤回/不存在)返回 'gone',其余失败抛出由调用方记账。
|
|
394
|
+
*/
|
|
395
|
+
async sendFeishu(messageId, text, idempotencyKey) {
|
|
396
|
+
if (!messageId) throw new Error('缺少飞书回复目标消息 id')
|
|
397
|
+
if (!idempotencyKey) throw new Error('缺少幂等键(应为 outbox 行 id)')
|
|
398
|
+
const chunks = outboundChunks(text)
|
|
399
|
+
for (let index = 0; index < chunks.length; index++) {
|
|
400
|
+
const key = index > 0 ? `${idempotencyKey}#${index}` : idempotencyKey
|
|
401
|
+
for (let attempt = 1; ; attempt++) {
|
|
402
|
+
// 同键发送总预算 = OUTBOX_MAX_ATTEMPTS(与 outbox 尝试计数同一口径):
|
|
403
|
+
// send 层重试与 flush 层重试共享预算,总调用数恒 ≤ 3,不放大消息额度。
|
|
404
|
+
const used = Number(this.sendAttempts.get(key) ?? 0)
|
|
405
|
+
if (used >= OUTBOX_MAX_ATTEMPTS) throw new Error(`同键 ${key} 发送尝试已达上限(${OUTBOX_MAX_ATTEMPTS})`)
|
|
406
|
+
this.sendAttempts.set(key, used + 1)
|
|
407
|
+
if (this.sendAttempts.size > INBOUND_DEDUP_LIMIT) this.sendAttempts.delete(this.sendAttempts.keys().next().value)
|
|
408
|
+
try {
|
|
409
|
+
const result = await this.transport.reply(String(messageId), chunks[index], key)
|
|
410
|
+
this.sendAttempts.delete(key)
|
|
411
|
+
if (attempt > 1) {
|
|
412
|
+
const recovered = result?.messageId
|
|
413
|
+
this.log.info?.(`[feishu] 同键重试发送成功${recovered ? `,取回原消息 ${recovered}` : ''}`)
|
|
414
|
+
}
|
|
415
|
+
break
|
|
416
|
+
} catch (error) {
|
|
417
|
+
if (isGone(error)) {
|
|
418
|
+
this.sendAttempts.delete(key)
|
|
419
|
+
return 'gone'
|
|
420
|
+
}
|
|
421
|
+
const budgetLeft = Number(this.sendAttempts.get(key) ?? 0) < OUTBOX_MAX_ATTEMPTS
|
|
422
|
+
if (!isRetryable(error) || attempt >= SEND_RETRY_MAX_ATTEMPTS || !budgetLeft) throw error
|
|
423
|
+
await sleep(SEND_RETRY_DELAY_MS)
|
|
424
|
+
}
|
|
425
|
+
}
|
|
426
|
+
}
|
|
427
|
+
return 'sent'
|
|
428
|
+
}
|
|
429
|
+
|
|
430
|
+
/**
|
|
431
|
+
* 对外事件推送入口:入队(receiptKey 幂等吸收)后经合批窗口合并一次 flush;
|
|
432
|
+
* 未绑定时仅落盘,绑定后由新事件触发。与微信 notify 同形。
|
|
433
|
+
*/
|
|
434
|
+
notify(text, { receiptKey = null } = {}) {
|
|
435
|
+
if (!this.enabled()) return
|
|
436
|
+
const body = String(text ?? '').trim()
|
|
437
|
+
if (!body) {
|
|
438
|
+
this.log.warn?.('[feishu] 空文本不入队')
|
|
439
|
+
return
|
|
440
|
+
}
|
|
441
|
+
try {
|
|
442
|
+
const outcome = this.store.enqueue(body, receiptKey)
|
|
443
|
+
if (outcome === 'duplicate') {
|
|
444
|
+
this.log.warn?.(`[feishu] 重复推送已按收据键吸收(${receiptKey})`)
|
|
445
|
+
return
|
|
446
|
+
}
|
|
447
|
+
} catch (error) {
|
|
448
|
+
this.log.warn?.(`[feishu] 推送入队失败: ${this.errorText(error)}`)
|
|
449
|
+
return
|
|
450
|
+
}
|
|
451
|
+
if (this.phase === 'ready') this.scheduleOutboxFlush()
|
|
452
|
+
}
|
|
453
|
+
|
|
454
|
+
/** 合批窗口:窗口内的多次推送合并到同一次 flush(每条仍独立幂等发送)。 */
|
|
455
|
+
scheduleOutboxFlush() {
|
|
456
|
+
if (this.flushTimer) return
|
|
457
|
+
this.flushTimer = setTimeout(() => {
|
|
458
|
+
this.flushTimer = null
|
|
459
|
+
if (this.phase !== 'ready') return
|
|
460
|
+
void this.flushOutbox().catch(error => {
|
|
461
|
+
this.log.warn?.(`[feishu] 推送刷新失败: ${this.errorText(error)}`)
|
|
462
|
+
})
|
|
463
|
+
}, this.batchWindowMs)
|
|
464
|
+
this.flushTimer.unref?.()
|
|
465
|
+
}
|
|
466
|
+
|
|
467
|
+
/** 刷出全部待发:串行化(防并发重复发送);每条独立发送,幂等键=outbox 行 id。 */
|
|
468
|
+
async flushOutbox(signal = new AbortController().signal) {
|
|
469
|
+
const previous = this.flushChain
|
|
470
|
+
let release
|
|
471
|
+
this.flushChain = new Promise(resolve => {
|
|
472
|
+
release = resolve
|
|
473
|
+
})
|
|
474
|
+
await previous.catch(() => {})
|
|
475
|
+
try {
|
|
476
|
+
return await this.flushOutboxLocked(signal)
|
|
477
|
+
} finally {
|
|
478
|
+
release()
|
|
479
|
+
}
|
|
480
|
+
}
|
|
481
|
+
|
|
482
|
+
async flushOutboxLocked(signal) {
|
|
483
|
+
const target = this.store.getState()?.reply_message_id
|
|
484
|
+
// 尚无回复目标(管理员未发过消息):可恢复状态,条目保留待发,绑定后由新事件触发
|
|
485
|
+
if (!target) return
|
|
486
|
+
const pending = this.store.pendingOutbox()
|
|
487
|
+
for (const item of pending) {
|
|
488
|
+
if (signal?.aborted) return
|
|
489
|
+
try {
|
|
490
|
+
const outcome = await this.sendFeishu(target, item.text, String(item.id))
|
|
491
|
+
if (outcome === 'sent') this.store.markSent([item.id])
|
|
492
|
+
else this.store.giveUp([item.id], 'gone')
|
|
493
|
+
} catch (error) {
|
|
494
|
+
if (signal?.aborted) return
|
|
495
|
+
this.recordOutboxFailure(item, error)
|
|
496
|
+
}
|
|
497
|
+
}
|
|
498
|
+
}
|
|
499
|
+
|
|
500
|
+
/** 失败记账:可重试错误计一次尝试,达到上限(3 次)废弃;不可重试错误直接废弃。废弃后永不补发。 */
|
|
501
|
+
recordOutboxFailure(item, error) {
|
|
502
|
+
const retryable = isRetryable(error)
|
|
503
|
+
const reason = this.errorText(error)
|
|
504
|
+
const attempts = retryable ? this.store.markAttempt(item.id, reason) : null
|
|
505
|
+
if (!retryable || (attempts ?? 0) >= OUTBOX_MAX_ATTEMPTS) {
|
|
506
|
+
this.store.giveUp([item.id], reason)
|
|
507
|
+
this.log.warn?.(
|
|
508
|
+
`[feishu] 推送废弃(不再补发) id=${item.id}${retryable ? `(尝试 ${attempts}/${OUTBOX_MAX_ATTEMPTS} 次超限)` : '(不可重试)'}: ${reason}`,
|
|
509
|
+
)
|
|
510
|
+
return
|
|
511
|
+
}
|
|
512
|
+
this.log.warn?.(
|
|
513
|
+
`[feishu] 推送失败(可重试 ${attempts}/${OUTBOX_MAX_ATTEMPTS},保留待发) id=${item.id}: ${reason}`,
|
|
514
|
+
)
|
|
515
|
+
}
|
|
516
|
+
|
|
517
|
+
/** 长连接收到事件:按当前 generation 打标后交给入站模型处理。 */
|
|
518
|
+
onEvent(payload) {
|
|
519
|
+
const generation = this.consumeGeneration
|
|
520
|
+
void this.handleEvent(payload, generation, this.consumeAbort.signal).catch(error => {
|
|
521
|
+
this.log.warn?.(`[feishu] 事件处理异常: ${this.errorText(error)}`)
|
|
522
|
+
})
|
|
523
|
+
}
|
|
524
|
+
|
|
525
|
+
/** JSON 行事件入口(守门与日志回放用):解析后走 SDK 形状的入站模型。 */
|
|
526
|
+
async handleEventLine(line, generation, signal = new AbortController().signal) {
|
|
527
|
+
let payload = null
|
|
528
|
+
try {
|
|
529
|
+
payload = JSON.parse(String(line ?? ''))
|
|
530
|
+
} catch {
|
|
531
|
+
return
|
|
532
|
+
}
|
|
533
|
+
await this.handleEvent(payload, generation, signal)
|
|
534
|
+
}
|
|
535
|
+
|
|
536
|
+
/** 单事件入口:解析 → (appId, message_id) LRU 去重 → 会话门禁分发。 */
|
|
537
|
+
async handleEvent(payload, generation, signal = new AbortController().signal) {
|
|
538
|
+
const parsed = parseInboundEvent(payload)
|
|
539
|
+
if (!parsed?.messageId || !parsed.text) {
|
|
540
|
+
this.recordTrigger(parsed, 'filtered', 'no-text')
|
|
541
|
+
return
|
|
542
|
+
}
|
|
543
|
+
const appId = this.store.getState()?.app_id ?? 'unknown'
|
|
544
|
+
if (this.seenInbound(`${appId}:${parsed.messageId}`)) {
|
|
545
|
+
this.recordTrigger(parsed, 'duplicate', 'lru')
|
|
546
|
+
return
|
|
547
|
+
}
|
|
548
|
+
await this.dispatchInbound(parsed, generation, signal)
|
|
549
|
+
}
|
|
550
|
+
|
|
551
|
+
/**
|
|
552
|
+
* 入站 LRU 去重闸(对齐 cindy):键 (appId, message_id),TTL 10 分钟、上限 1000 条、
|
|
553
|
+
* 重连不清空(飞书事件可能重投)。命中返回 true;未命中记录后返回 false。
|
|
554
|
+
*/
|
|
555
|
+
seenInbound(key) {
|
|
556
|
+
const now = Date.now()
|
|
557
|
+
const seen = this.inboundSeen.get(key)
|
|
558
|
+
if (seen !== undefined) {
|
|
559
|
+
if (now - seen < INBOUND_DEDUP_TTL_MS) {
|
|
560
|
+
this.inboundSeen.delete(key)
|
|
561
|
+
this.inboundSeen.set(key, seen)
|
|
562
|
+
return true
|
|
563
|
+
}
|
|
564
|
+
this.inboundSeen.delete(key)
|
|
565
|
+
}
|
|
566
|
+
this.inboundSeen.set(key, now)
|
|
567
|
+
if (this.inboundSeen.size > INBOUND_DEDUP_LIMIT) {
|
|
568
|
+
this.inboundSeen.delete(this.inboundSeen.keys().next().value)
|
|
569
|
+
}
|
|
570
|
+
return false
|
|
571
|
+
}
|
|
572
|
+
|
|
573
|
+
/**
|
|
574
|
+
* 会话门禁分发(对齐 cindy TOFU/群@门禁):
|
|
575
|
+
* - p2p:无 owner 时首名发送者 TOFU 成 owner(按 bot-app 持久化);非 owner 私聊丢弃留痕;
|
|
576
|
+
* - 群聊绝不 TOFU:必须 @本 bot——非 owner @bot 走 60s 冷却礼貌回应(不起 turn),
|
|
577
|
+
* owner @bot 剥占位符后正常起 turn。
|
|
578
|
+
*/
|
|
579
|
+
async dispatchInbound(parsed, generation, signal) {
|
|
580
|
+
const state = this.store.getState()
|
|
581
|
+
const adminOu = state?.admin_ou_id ?? null
|
|
582
|
+
const botId = state?.bot_id ?? null
|
|
583
|
+
const stale = () => Boolean(signal?.aborted) || generation !== this.consumeGeneration
|
|
584
|
+
|
|
585
|
+
if (parsed.chatType === 'group') {
|
|
586
|
+
const mentioned = Boolean(botId) && parsed.mentions.some(item => String(item?.id?.open_id ?? '') === String(botId))
|
|
587
|
+
if (!mentioned) {
|
|
588
|
+
this.recordTrigger(parsed, 'filtered', 'no-mention', '群聊未 @本 bot')
|
|
589
|
+
return
|
|
590
|
+
}
|
|
591
|
+
const text = stripMentionPlaceholders(parsed.text)
|
|
592
|
+
if (!text) {
|
|
593
|
+
this.recordTrigger(parsed, 'filtered', 'mention-only')
|
|
594
|
+
return
|
|
595
|
+
}
|
|
596
|
+
if (!adminOu || parsed.senderOpenId !== adminOu) {
|
|
597
|
+
const last = Number(this.politeAt.get(parsed.senderOpenId) ?? 0)
|
|
598
|
+
if (Date.now() - last < NON_OWNER_COOLDOWN_MS) {
|
|
599
|
+
this.recordTrigger(parsed, 'filtered', 'cooldown', '非 owner @bot 冷却中')
|
|
600
|
+
return
|
|
601
|
+
}
|
|
602
|
+
this.politeAt.set(parsed.senderOpenId, Date.now())
|
|
603
|
+
this.recordTrigger(parsed, 'handled', 'polite')
|
|
604
|
+
try {
|
|
605
|
+
await this.sendFeishu(parsed.messageId, NON_OWNER_NOTICE, `polite:${parsed.messageId}`)
|
|
606
|
+
} catch (error) {
|
|
607
|
+
this.log.warn?.(`[feishu] 礼貌回应发送失败: ${this.errorText(error)}`)
|
|
608
|
+
}
|
|
609
|
+
return
|
|
610
|
+
}
|
|
611
|
+
await this.adminTurn(parsed, text, generation, signal, stale)
|
|
612
|
+
return
|
|
613
|
+
}
|
|
614
|
+
|
|
615
|
+
// p2p:TOFU 认主只认首个私聊者
|
|
616
|
+
if (!parsed.senderOpenId) {
|
|
617
|
+
this.recordTrigger(parsed, 'filtered', 'no-sender')
|
|
618
|
+
return
|
|
619
|
+
}
|
|
620
|
+
if (!adminOu) {
|
|
621
|
+
this.store.saveAdminOu(parsed.senderOpenId)
|
|
622
|
+
this.store.saveReplyMessageId(parsed.messageId, parsed.senderOpenId)
|
|
623
|
+
this.log.info?.(`[feishu] 管理员已绑定(TOFU 首个私聊者): ${parsed.senderOpenId}`)
|
|
624
|
+
this.recordTrigger(parsed, 'handled', 'tofu')
|
|
625
|
+
try {
|
|
626
|
+
await this.sendFeishu(parsed.messageId, welcomeAdmin(), `welcome:${parsed.messageId}`)
|
|
627
|
+
} catch (error) {
|
|
628
|
+
this.log.warn?.(`[feishu] 欢迎语发送失败: ${this.errorText(error)}`)
|
|
629
|
+
}
|
|
630
|
+
return
|
|
631
|
+
}
|
|
632
|
+
if (parsed.senderOpenId !== adminOu) {
|
|
633
|
+
this.log.info?.(`[feishu] 忽略非管理员私聊来自 ${parsed.senderOpenId}`)
|
|
634
|
+
this.recordTrigger(parsed, 'filtered', 'non-admin', '发送者不是已绑定管理员')
|
|
635
|
+
return
|
|
636
|
+
}
|
|
637
|
+
await this.adminTurn(parsed, parsed.text, generation, signal, stale)
|
|
638
|
+
}
|
|
639
|
+
|
|
640
|
+
/**
|
|
641
|
+
* owner/admin 消息起 turn:复用微信通道无关命令层(/指令 + 答/批 token + 自由文本
|
|
642
|
+
* 直达 director),回复经 reply 锚点挂回触发消息。事件处理中的每个 await 之后复查
|
|
643
|
+
* generation:旧连接轮次整体丢弃(双连接防重)。
|
|
644
|
+
*/
|
|
645
|
+
async adminTurn(parsed, text, generation, signal, stale) {
|
|
646
|
+
const ctx = {
|
|
647
|
+
boundKey: null,
|
|
648
|
+
bind: () => {},
|
|
649
|
+
// 上方已过 owner/admin 门,显式带过命令层的 fail-closed 管理员门
|
|
650
|
+
isAdmin: true,
|
|
651
|
+
}
|
|
652
|
+
let reply = ''
|
|
653
|
+
try {
|
|
654
|
+
reply = await handleCommand(this.service, text, ctx)
|
|
655
|
+
} catch (caught) {
|
|
656
|
+
const error = caught
|
|
657
|
+
const business = error?.permanent === true || error?.name === 'WechatBusinessError' || error?.name === 'AppError'
|
|
658
|
+
this.recordTrigger(parsed, business ? 'rejected' : 'failed', 'command', this.errorText(error))
|
|
659
|
+
reply = business ? String(error?.message ?? '指令无法执行') : failureText()
|
|
660
|
+
}
|
|
661
|
+
if (stale()) {
|
|
662
|
+
this.recordTrigger(parsed, 'dropped', 'stale-generation', '事件处理中连接换代,旧轮次整体丢弃')
|
|
663
|
+
return
|
|
664
|
+
}
|
|
665
|
+
const trigger = (ctx ).trigger ?? { kind: 'chat', verb: null }
|
|
666
|
+
this.recordTrigger(parsed, 'handled', `${trigger.kind}${trigger.verb ? `:${trigger.verb}` : ''}`)
|
|
667
|
+
// 回复锚点:管理员/owner 最近一条触发消息(后续出站 notify 也挂到这里)
|
|
668
|
+
this.store.saveReplyMessageId(parsed.messageId, parsed.senderOpenId)
|
|
669
|
+
if (reply) {
|
|
670
|
+
try {
|
|
671
|
+
await this.sendFeishu(parsed.messageId, reply, `reply:${parsed.messageId}`)
|
|
672
|
+
} catch (error) {
|
|
673
|
+
this.log.warn?.(`[feishu] 回复发送失败: ${this.errorText(error)}`)
|
|
674
|
+
}
|
|
675
|
+
}
|
|
676
|
+
}
|
|
677
|
+
|
|
678
|
+
/**
|
|
679
|
+
* 入站 Trigger 留痕(对齐微信 B4-① 观测面):每条入站事件的处置经
|
|
680
|
+
* service.recordFeishuTrigger 落库,稳定 id=feishu:<messageId>(channel='feishu'),
|
|
681
|
+
* peer_id 记 lane 编码。service 不在场(测试桩)时静默跳过。
|
|
682
|
+
*/
|
|
683
|
+
recordTrigger(parsed, disposition, route, reason = null) {
|
|
684
|
+
try {
|
|
685
|
+
this.service?.recordFeishuTrigger?.({
|
|
686
|
+
nativeId: parsed?.messageId ?? null,
|
|
687
|
+
senderId: laneOf(parsed),
|
|
688
|
+
text: parsed?.text ?? '',
|
|
689
|
+
disposition,
|
|
690
|
+
route,
|
|
691
|
+
reason,
|
|
692
|
+
})
|
|
693
|
+
} catch (error) {
|
|
694
|
+
this.log.warn?.(`[feishu] 触发留痕失败: ${this.errorText(error)}`)
|
|
695
|
+
}
|
|
696
|
+
}
|
|
697
|
+
|
|
698
|
+
errorText(error) {
|
|
699
|
+
if (error instanceof FeishuError) return error.code !== undefined ? `飞书 ${error.code}: ${error.message}` : `飞书: ${error.message}`
|
|
700
|
+
return String(error?.message ?? error)
|
|
701
|
+
}
|
|
702
|
+
}
|