@meet-im/meet 2.0.5 → 3.0.0-beta.0

package/src/bot.ts

@@ -1,418 +0,0 @@
-import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk"
-import type { HistoryEntry } from "openclaw/plugin-sdk/reply-history"
-import {
-  buildPendingHistoryContextFromMap,
-  clearHistoryEntriesIfEnabled,
-  recordPendingHistoryEntryIfEnabled,
-} from "openclaw/plugin-sdk/reply-history"
-import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id"
-import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime"
-import type { MeetBot, MsgContent } from "@meet-im/meet-bot-jssdk"
-import type { ResolvedMeetAccount, MeetMessageContext } from "./types.js"
-import { msgContentToContext, extractQuoteMessageMedia } from "./sdk-bridge.js"
-import { getMeetRuntime } from "./runtime.js"
-import { resolveMeetAllowlistMatch, resolveMeetGroupPolicy, resolveMeetGroupConfig, resolveMeetGroupUserPolicy } from "./policy.js"
-import { sendMessageMeet } from "./send.js"
-import { resolveMediaAttachments, setMediaDebugLogger } from "./media.js"
-
-const DEFAULT_GROUP_SYSTEM_PROMPT =
-  "你正在 Meet 群组中对话。请保持回复简洁明了，适合群聊场景。如需回复特定用户，请使用 <@USER_ID> 格式提及对方，例如 <@553>。注意：Meet 不支持用反引号包住 Markdown 语法标记，描述语法时直接写符号，不要加反引号。发送图片或文件时，使用 message 工具的 media 参数，不要用 Markdown 图片语法 ![](path)。"
-
-const DEFAULT_DM_SYSTEM_PROMPT =
-  "你正在 Meet 私聊中对话。注意：Meet 不支持用反引号包住 Markdown 语法标记，描述语法时直接写符号，不要加反引号。发送图片或文件时，使用 message 工具的 media 参数，不要用 Markdown 图片语法 ![](path)。"
-
-function formatHistoryEntry(entry: HistoryEntry): string {
-  return `${entry.sender}: ${entry.body}`
-}
-
-export async function handleMeetMessage(params: {
-  cfg: ClawdbotConfig
-  msg: MsgContent
-  botUserId: string
-  runtime?: RuntimeEnv
-  accountId: string
-  account: ResolvedMeetAccount
-  bot: MeetBot
-  groupHistories: Map<string, HistoryEntry[]>
-  quoteMsgMap?: Record<string, MsgContent>
-}): Promise<void> {
-  const { cfg, msg, botUserId, runtime, accountId, account, bot, groupHistories, quoteMsgMap } = params
-  const log = runtime?.log ?? console.log
-  const error = runtime?.error ?? console.error
-
-  let ctx: MeetMessageContext
-  try {
-    ctx = msgContentToContext(msg, botUserId, quoteMsgMap)
-  } catch (err) {
-    error(`[${accountId}]: failed to parse message: ${String(err)}`)
-    return
-  }
-
-  const isGroup = ctx.chatType === "channel"
-
-  if (ctx.senderId === botUserId) {
-    log(`[${accountId}]: skipping own message ${ctx.messageId}`)
-    return
-  }
-
-  log(
-    `[${accountId}]: received message from ${ctx.senderId} in ${ctx.chatId} (${ctx.chatType})`,
-  )
-
-  const meetCfg = account.config
-  const dmPolicy = meetCfg.dmPolicy ?? "pairing"
-  const allowFrom = meetCfg.allowFrom ?? []
-  const historyLimit = isGroup
-    ? Math.max(0, meetCfg.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? 20)
-    : Math.max(0, meetCfg.dmHistoryLimit ?? 0)
-  const speaker = ctx.senderName ?? ctx.senderId
-  // Discord 做法：文字优先，无文字时用媒体占位符
-  const messageBody = ctx.content.trim()
-    ? `${speaker}: ${ctx.content.trim()}`
-    : `${speaker}: ${ctx.placeholder || ""}`
-
-  const pendingEntry: HistoryEntry = {
-    sender: speaker,
-    body: ctx.content.trim() || ctx.placeholder || "",
-    timestamp: ctx.timestamp,
-    messageId: ctx.messageId,
-  }
-
-    try {
-    const core = getMeetRuntime()
-
-    if (!isGroup) {
-      // pairing 模式：需要从 pairing store 读取已授权用户列表
-      // allowlist 模式：只使用配置中的 allowFrom
-      let effectiveAllowFrom = allowFrom
-      if (dmPolicy === "pairing") {
-        try {
-          const storeAllowFrom = await core.channel.pairing.readAllowFromStore({
-            channel: "meet",
-            accountId,
-          })
-          // 合并配置中的 allowFrom 和 store 中的授权列表
-          effectiveAllowFrom = [...allowFrom, ...storeAllowFrom]
-        } catch (err) {
-          error(`[${accountId}]: failed to read pairing store: ${String(err)}`)
-        }
-      }
-
-      const dmAllowed = resolveMeetAllowlistMatch({
-        allowFrom: effectiveAllowFrom,
-        senderId: ctx.senderId,
-      }).allowed
-
-      // pairing 模式：创建配对请求并发送授权码给用户
-      // allowlist 模式：直接拒绝未授权用户
-      if (dmPolicy !== "open" && !dmAllowed) {
-        if (dmPolicy === "pairing") {
-          log(`[${accountId}]: pairing request from ${ctx.senderId}`)
-
-          // 创建或更新配对请求
-          const { code, created } = await core.channel.pairing.upsertPairingRequest({
-            channel: "meet",
-            id: ctx.senderId,
-            accountId,
-            meta: {
-              name: ctx.senderName,
-            },
-          })
-
-          // 发送配对码给用户（新创建或已存在都发送）
-          if (code) {
-            const accountArg = accountId === DEFAULT_ACCOUNT_ID ? "" : ` --account ${accountId}`
-            const lines = [
-              "OpenClaw: 尚未授权访问。",
-              "",
-              `您的 Meet 用户 ID: ${ctx.senderId}`,
-              "",
-              `配对码: ${code}`,
-              "",
-              "请联系机器人管理员审批：",
-              `openclaw pairing approve meet ${code}${accountArg}`,
-            ]
-            // 如果是已存在的请求，添加提示
-            if (!created) {
-              lines.splice(2, 0, "（您的配对请求已在等待审批中）")
-            }
-            const replyText = lines.join("\n")
-            try {
-              await sendMessageMeet({
-                cfg,
-                to: `user:${ctx.senderId}`,
-                text: replyText,
-                accountId,
-              })
-            } catch (err) {
-              error(`[${accountId}]: failed to send pairing reply to ${ctx.senderId}: ${String(err)}`)
-            }
-          }
-        } else {
-          log(
-            `[${accountId}]: blocked unauthorized sender ${ctx.senderId} (dmPolicy=${dmPolicy})`,
-          )
-        }
-        return
-      }
-    }
-
-    if (isGroup) {
-      const groupPolicy = resolveMeetGroupPolicy({
-        groupPolicy: meetCfg.groupPolicy,
-        groupAllowFrom: meetCfg.groupAllowFrom ?? [],
-        chatId: ctx.chatId,
-        groups: meetCfg.groups,
-      })
-
-      if (!groupPolicy.allowed) {
-        log(
-          `[${accountId}]: group ${ctx.chatId} not allowed (groupPolicy=${meetCfg.groupPolicy})`,
-        )
-        return
-      }
-
-      const groupConfig = resolveMeetGroupConfig({
-        meetConfig: meetCfg,
-        chatId: ctx.chatId,
-      })
-
-      const groupUserPolicy = resolveMeetGroupUserPolicy({
-        groupConfig: groupConfig.groupConfig,
-        senderId: ctx.senderId,
-      })
-
-      if (!groupUserPolicy.allowed) {
-        log(`[${accountId}]: user ${ctx.senderId} not allowed in group ${ctx.chatId}`)
-        return
-      }
-
-      if (groupConfig.requireMention && !ctx.mentionedBot) {
-        log(`[${accountId}]: message in group ${ctx.chatId} skipped (mention required)`)
-        recordPendingHistoryEntryIfEnabled({
-          historyMap: groupHistories,
-          historyKey: ctx.chatId,
-          entry: pendingEntry,
-          limit: historyLimit,
-        })
-        return
-      }
-    }
-
-    const meetFrom = `meet:${ctx.senderId}`
-    const meetTo = ctx.chatId
-
-    const peerId = isGroup ? ctx.chatId : ctx.senderId
-
-    const route = core.channel.routing.resolveAgentRoute({
-      cfg,
-      channel: "meet",
-      accountId,
-      peer: {
-        kind: isGroup ? "group" : "direct",
-        id: peerId,
-      },
-    })
-
-    // 处理媒体附件
-    let mediaContext = ""
-    let mediaPaths: string[] = []
-    if (ctx.media && ctx.media.length > 0) {
-      log(`[${accountId}]: processing ${ctx.media.length} media attachment(s)`)
-      // 初始化媒体调试日志
-      setMediaDebugLogger(log, error)
-      try {
-        const maxBytes = meetCfg.mediaMaxMb ? meetCfg.mediaMaxMb * 1024 * 1024 : undefined
-        const mediaInfos = await resolveMediaAttachments({
-          accountId,
-          attachments: ctx.media,
-          sessionInfo: {
-            firstId: ctx.sessionInfo.firstID,
-            secondId: ctx.sessionInfo.secondID,
-            sessionType: ctx.sessionInfo.sessionType,
-            companyId: ctx.sessionInfo.companyID,
-          },
-          seqId: Number(ctx.messageId),
-          maxBytes,
-        })
-        log(`[${accountId}]: resolved ${mediaInfos.length} media, paths=${mediaInfos.map(m => m.path).join(",")}`)
-        mediaPaths = mediaInfos.map((m) => m.path)
-        if (mediaInfos.length > 0) {
-          // 为 BodyForAgent 生成详细媒体描述（包含路径）
-          mediaContext = "\n\n" + mediaInfos.map((m) => {
-            const typeLabel = m.contentType?.startsWith("image/") ? "<media:image>"
-              : m.contentType?.startsWith("video/") ? "<media:video>"
-              : m.contentType?.startsWith("audio/") ? "<media:audio>"
-              : "<media:document>"
-            return `${typeLabel}: ${m.path}`
-          }).join("\n")
-        }
-      } catch (err) {
-        error(`[${accountId}]: failed to resolve media: ${String(err)}`)
-      }
-    }
-
-    // 处理引用消息的媒体附件
-    if (quoteMsgMap && ctx.replyContext) {
-      const quoteMedia = extractQuoteMessageMedia(msg, quoteMsgMap)
-      if (quoteMedia && quoteMedia.length > 0) {
-        log(`[${accountId}]: processing ${quoteMedia.length} quote message media attachment(s)`)
-        try {
-          const maxBytes = meetCfg.mediaMaxMb ? meetCfg.mediaMaxMb * 1024 * 1024 : undefined
-          const quoteMediaInfos = await resolveMediaAttachments({
-            accountId,
-            attachments: quoteMedia,
-            sessionInfo: {
-              firstId: ctx.sessionInfo.firstID,
-              secondId: ctx.sessionInfo.secondID,
-              sessionType: ctx.sessionInfo.sessionType,
-              companyId: ctx.sessionInfo.companyID,
-            },
-            seqId: Number(ctx.replyContext.messageId),
-            maxBytes,
-          })
-          log(`[${accountId}]: resolved ${quoteMediaInfos.length} quote media, paths=${quoteMediaInfos.map(m => m.path).join(",")}`)
-          // 将引用消息的媒体路径合并到 mediaPaths
-          mediaPaths = [...mediaPaths, ...quoteMediaInfos.map((m) => m.path)]
-        } catch (err) {
-          error(`[${accountId}]: failed to resolve quote media: ${String(err)}`)
-        }
-      }
-    }
-
-    // 构建最终的消息内容
-    // Discord 做法：文字优先，无文字时用媒体占位符
-    // 媒体路径通过 MediaPaths 传递，mediaContext 仅作为 BodyForAgent 的补充描述
-    const finalContent = ctx.content.trim()
-      ? `${ctx.content.trim()}${mediaContext}`
-      : (ctx.placeholder || "") + mediaContext
-
-    // Discord 做法：跳过空内容消息
-    if (!finalContent.trim() && mediaPaths.length === 0) {
-      log(`[${accountId}]: skip message ${ctx.messageId} (empty content)`)
-      return
-    }
-
-    const preview = finalContent.replace(/\s+/g, " ").slice(0, 160)
-    const inboundLabel = isGroup
-      ? `Meet[${accountId}] message in group ${ctx.chatId}`
-      : `Meet[${accountId}] DM from ${ctx.senderId}`
-
-    core.system.enqueueSystemEvent(`${inboundLabel}: ${preview}`, {
-      sessionKey: route.sessionKey,
-      contextKey: `meet:message:${ctx.chatId}:${ctx.messageId}`,
-    })
-
-    const envelopeFrom = isGroup ? `${ctx.chatId}:${ctx.senderId}` : ctx.senderId
-
-    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg)
-
-    // 将当前消息添加到历史（在确认要处理消息之后）
-    const historyEntries = isGroup && historyLimit > 0
-      ? (() => {
-          const entries = groupHistories.get(ctx.chatId) ?? []
-          entries.push(pendingEntry)
-          while (entries.length > historyLimit) {
-            entries.shift()
-          }
-          groupHistories.set(ctx.chatId, entries)
-          return entries
-        })()
-      : []
-
-    const bodyWithContext = buildPendingHistoryContextFromMap({
-      historyMap: groupHistories,
-      historyKey: ctx.chatId,
-      limit: historyLimit,
-      currentMessage: messageBody,
-      formatEntry: formatHistoryEntry,
-    })
-
-    const body = core.channel.reply.formatAgentEnvelope({
-      channel: "Meet",
-      from: envelopeFrom,
-      timestamp: new Date(),
-      envelope: envelopeOptions,
-      body: bodyWithContext,
-    })
-
-    const inboundHistory =
-      isGroup && historyLimit > 0
-        ? historyEntries.map((entry) => ({
-            sender: entry.sender,
-            body: entry.body,
-            timestamp: entry.timestamp,
-          }))
-        : undefined
-
-    const channelConfig = isGroup ? meetCfg.channels?.[ctx.chatId] : undefined
-    const groupConfig = isGroup ? resolveMeetGroupConfig({ meetConfig: meetCfg, chatId: ctx.chatId }) : undefined
-    const systemPrompt = isGroup
-      ? (groupConfig?.systemPrompt ?? channelConfig?.systemPrompt ?? meetCfg.systemPrompt ?? DEFAULT_GROUP_SYSTEM_PROMPT)
-      : (meetCfg.systemPrompt ?? DEFAULT_DM_SYSTEM_PROMPT)
-
-    const inboundCtx = core.channel.reply.finalizeInboundContext({
-      Body: body,
-      BodyForAgent: finalContent,
-      RawBody: ctx.content,
-      CommandBody: ctx.content,
-      From: meetFrom,
-      To: meetTo,
-      SessionKey: route.sessionKey,
-      AccountId: route.accountId,
-      ChatType: isGroup ? "group" : "direct",
-      GroupSubject: isGroup ? ctx.chatId : undefined,
-      GroupSystemPrompt: systemPrompt,
-      SenderName: ctx.senderName,
-      SenderId: ctx.senderId,
-      Provider: "meet" as const,
-      Surface: "meet" as const,
-      MessageSid: ctx.messageId,
-      Timestamp: ctx.timestamp ?? Date.now(),
-      WasMentioned: ctx.mentionedBot,
-      ReplyToId: ctx.replyContext?.messageId,
-      ReplyToBody: ctx.replyContext?.content,
-      ReplyToSender: ctx.replyContext?.senderId,
-      InboundHistory: inboundHistory,
-      CommandAuthorized: true,
-      OriginatingChannel: "meet" as const,
-      OriginatingTo: meetTo,
-      MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
-    })
-
-    const { createMeetReplyDispatcher } = await import("./reply-dispatcher.js")
-    const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, route.agentId)
-    const { dispatcher, replyOptions, markDispatchIdle } = await createMeetReplyDispatcher({
-      cfg,
-      agentId: route.agentId,
-      runtime: runtime as RuntimeEnv,
-      chatId: ctx.chatId,
-      replyToMessageId: ctx.messageId,
-      accountId,
-      bot,
-      botUserId,
-      mediaLocalRoots,
-    })
-
-    log(`[${accountId}]: dispatching to AI agent=${route.agentId} session=${route.sessionKey} history=${inboundHistory?.length ?? 0}`)
-
-    await core.channel.reply.dispatchReplyFromConfig({
-      ctx: inboundCtx,
-      cfg,
-      dispatcher,
-      replyOptions,
-    })
-
-    log(`[${accountId}]: AI response completed for message ${ctx.messageId}`)
-
-    markDispatchIdle()
-
-    clearHistoryEntriesIfEnabled({
-      historyMap: groupHistories,
-      historyKey: ctx.chatId,
-      limit: historyLimit,
-    })
-  } catch (err) {
-    error(`[${accountId}]: error processing message: ${String(err)}`)
-  }
-}