@meet-im/meet 1.0.3

package/src/monitor.ts

@@ -0,0 +1,197 @@
+import type { ClawdbotConfig, RuntimeEnv, HistoryEntry } from "openclaw/plugin-sdk"
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk"
+import type { ResolvedMeetAccount } from "./types.js"
+import type { MsgContent } from "@meet-im/meet-bot-jssdk"
+import type { QuoteMsgMap } from "./sdk-bridge.js"
+import { resolveMeetAccount, listEnabledMeetAccounts } from "./accounts.js"
+import { createMeetClient, closeMeetClient, closeAllMeetClients, getPollingOptions } from "./client.js"
+import { handleMeetMessage } from "./bot.js"
+import { msgContentToContext } from "./sdk-bridge.js"
+
+export type MonitorMeetOpts = {
+  config?: ClawdbotConfig
+  runtime?: RuntimeEnv
+  abortSignal?: AbortSignal
+  accountId?: string
+}
+
+export async function monitorMeetProvider(opts: MonitorMeetOpts = {}): Promise<void> {
+  const cfg = opts.config
+  if (!cfg) {
+    throw new Error("Config is required for Meet monitor")
+  }
+
+  const log = opts.runtime?.log ?? console.log
+  const error = opts.runtime?.error ?? console.error
+
+  if (opts.accountId) {
+    const account = resolveMeetAccount({ cfg, accountId: opts.accountId })
+    if (!account.enabled || !account.configured) {
+      throw new Error(`Meet account "${opts.accountId}" not configured or disabled`)
+    }
+    return monitorSingleAccount({
+      cfg,
+      account,
+      runtime: opts.runtime,
+      abortSignal: opts.abortSignal,
+    })
+  }
+
+  const accounts = listEnabledMeetAccounts(cfg)
+  if (accounts.length === 0) {
+    throw new Error("No enabled Meet accounts configured")
+  }
+
+  log(`starting ${accounts.length} account(s): ${accounts.map((a) => a.accountId).join(", ")}`)
+
+  await Promise.all(
+    accounts.map((account) =>
+      monitorSingleAccount({
+        cfg,
+        account,
+        runtime: opts.runtime,
+        abortSignal: opts.abortSignal,
+      }),
+    ),
+  )
+}
+
+async function monitorSingleAccount(params: {
+  cfg: ClawdbotConfig
+  account: ResolvedMeetAccount
+  runtime?: RuntimeEnv
+  abortSignal?: AbortSignal
+}): Promise<void> {
+  const { cfg, account, runtime, abortSignal } = params
+  const { accountId } = account
+  const log = runtime?.log ?? console.log
+  const error = runtime?.error ?? console.error
+
+  const pollTimeoutMs = account.config.pollTimeout ?? 30000
+  log(`[${accountId}]: starting with pollTimeout=${pollTimeoutMs}ms`)
+
+  const bot = createMeetClient(account)
+  const botUserId = extractBotUserId(account.apiToken ?? "")
+  const groupHistories = new Map<string, HistoryEntry[]>()
+  const messageQueue = new KeyedAsyncQueue()
+
+  return new Promise((resolve, reject) => {
+    let isCleaningUp = false
+
+    const cleanup = () => {
+      if (isCleaningUp) return
+      isCleaningUp = true
+      bot.stopPolling()
+      closeMeetClient(accountId)
+    }
+
+    const handleAbort = () => {
+      log(`[${accountId}]: abort signal received, stopping`)
+      cleanup()
+      resolve()
+    }
+
+    if (abortSignal?.aborted) {
+      cleanup()
+      resolve()
+      return
+    }
+
+    abortSignal?.addEventListener("abort", handleAbort, { once: true })
+
+    // TODO: SDK 更新后移除类型断言
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    bot.on("message", ((data: { message: MsgContent; quoteMsgMap: QuoteMsgMap }) => {
+      const { message: msg, quoteMsgMap } = data
+      let queueKey: string
+      try {
+        const ctx = msgContentToContext(msg, botUserId, quoteMsgMap)
+        queueKey = ctx.chatId
+      } catch {
+        error(`[${accountId}]: failed to parse message for queue key`)
+        return
+      }
+
+      const tailMap = messageQueue.getTailMapForTesting()
+      const queueSize = tailMap.size
+      const pendingInQueue = tailMap.has(queueKey)
+      log(
+        `[${accountId}]: enqueue message to queue=${queueKey}, queues=${queueSize}, pending=${pendingInQueue}`,
+      )
+
+      messageQueue.enqueue(
+        queueKey,
+        async () => {
+          try {
+            await handleMeetMessage({
+              cfg,
+              msg,
+              botUserId,
+              runtime,
+              accountId,
+              account,
+              bot,
+              groupHistories,
+              quoteMsgMap,
+            })
+          } catch (err) {
+            error(`[${accountId}]: error handling message: ${String(err)}`)
+          }
+        },
+        {
+          onEnqueue: () => {
+            const size = messageQueue.getTailMapForTesting().size
+            log(`[${accountId}]: queue=${queueKey} enqueued, total_queues=${size}`)
+          },
+          onSettle: () => {
+            const size = messageQueue.getTailMapForTesting().size
+            log(`[${accountId}]: queue=${queueKey} settled, total_queues=${size}`)
+          },
+        },
+      )
+    }) as any)
+
+    bot.on("error", (err) => {
+      error(`[${accountId}]: polling error: ${String(err)}`)
+    })
+
+    bot.on("polling_start", () => {
+      log(`[${accountId}]: polling started`)
+    })
+
+    bot.on("polling_stop", () => {
+      if (!isCleaningUp) {
+        log(`[${accountId}]: polling stopped`)
+      }
+    })
+
+    const pollingOptions = getPollingOptions(account)
+
+    bot.startPolling(pollingOptions)
+      .then(() => {
+        log(`[${accountId}]: polling completed`)
+        cleanup()
+        abortSignal?.removeEventListener("abort", handleAbort)
+        resolve()
+      })
+      .catch((err) => {
+        error(`[${accountId}]: polling failed: ${String(err)}`)
+        cleanup()
+        abortSignal?.removeEventListener("abort", handleAbort)
+        reject(err)
+      })
+  })
+}
+
+export function stopMeetMonitor(accountId?: string): void {
+  if (accountId) {
+    closeMeetClient(accountId)
+  } else {
+    closeAllMeetClients()
+  }
+}
+
+function extractBotUserId(token: string): string {
+  const parts = token.split(":")
+  return parts[0] ?? ""
+}

package/src/outbound.ts

@@ -0,0 +1,35 @@
+import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk";
+import { getMeetRuntime } from "./runtime.js";
+import { sendMessageMeet, sendMediaMeet } from "./send.js";
+
+export const meetOutbound: ChannelOutboundAdapter = {
+  deliveryMode: "direct",
+  chunker: (text, limit) => {
+    const runtime = getMeetRuntime();
+    return runtime.channel.text.chunkText(text, limit);
+  },
+  chunkerMode: "text",
+  textChunkLimit: 4000,
+  sendText: async ({ cfg, to, text, accountId }) => {
+    const result = await sendMessageMeet({ cfg, to, text, accountId });
+    return { channel: "meet", ...result };
+  },
+  sendMedia: async ({
+    cfg,
+    to,
+    text,
+    mediaUrl,
+    mediaLocalRoots,
+    accountId,
+  }) => {
+    const result = await sendMediaMeet({
+      cfg,
+      to,
+      text: text || undefined,
+      mediaUrl,
+      mediaLocalRoots,
+      accountId,
+    });
+    return { channel: "meet", ...result };
+  },
+};

package/src/policy.ts

@@ -0,0 +1,131 @@
+import type { MeetConfig, MeetGroupConfig } from "./types.js"
+
+export function resolveMeetAllowlistMatch(params: {
+  allowFrom: Array<string | number>
+  senderId: string
+  senderName?: string
+}): { allowed: boolean } {
+  const { allowFrom, senderId } = params
+
+  if (allowFrom.length === 0) {
+    return { allowed: false }
+  }
+
+  if (allowFrom.includes("*")) {
+    return { allowed: true }
+  }
+
+  const normalizedSenderId = senderId.trim().toLowerCase()
+  const normalizedAllowFrom = allowFrom.map((entry) =>
+    String(entry).trim().toLowerCase(),
+  )
+
+  if (normalizedAllowFrom.includes(normalizedSenderId)) {
+    return { allowed: true }
+  }
+
+  return { allowed: false }
+}
+
+export function resolveMeetGroupPolicy(params: {
+  groupPolicy?: "open" | "allowlist" | "disabled"
+  groupAllowFrom: Array<string | number>
+  chatId: string
+  groups?: Record<string, MeetGroupConfig>
+}): { allowed: boolean } {
+  const { groupPolicy = "allowlist", groupAllowFrom, chatId, groups } = params
+
+  if (groupPolicy === "disabled") {
+    return { allowed: false }
+  }
+
+  // Normalize chatId for matching (strip "channel:" prefix if present)
+  const normalizedChatId = chatId.replace(/^channel:/, "")
+  const groupConfig = groups?.[chatId] ?? groups?.[normalizedChatId]
+
+  if (groupPolicy === "open") {
+    if (groupConfig?.enabled === false) {
+      return { allowed: false }
+    }
+    return { allowed: true }
+  }
+
+  // groupPolicy === "allowlist"
+  
+  // Check if group is explicitly configured in groups
+  if (groupConfig && groupConfig.enabled !== false) {
+    return { allowed: true }
+  }
+  
+  if (groupConfig?.enabled === false) {
+    return { allowed: false }
+  }
+
+  if (groupAllowFrom.length === 0) {
+    return { allowed: false }
+  }
+
+  if (groupAllowFrom.includes("*")) {
+    return { allowed: true }
+  }
+
+  const normalizedAllowFrom = groupAllowFrom.map((entry) =>
+    String(entry).trim().toLowerCase(),
+  )
+
+  // Match both full chatId and normalized chatId
+  const fullChatIdLower = chatId.trim().toLowerCase()
+  const shortChatIdLower = normalizedChatId.trim().toLowerCase()
+
+  if (normalizedAllowFrom.includes(fullChatIdLower) || 
+      normalizedAllowFrom.includes(shortChatIdLower)) {
+    return { allowed: true }
+  }
+
+  return { allowed: false }
+}
+
+export function resolveMeetGroupConfig(params: {
+  meetConfig: MeetConfig
+  chatId: string
+}): {
+  requireMention: boolean
+  systemPrompt?: string
+  groupConfig?: MeetGroupConfig
+} {
+  const { meetConfig, chatId } = params
+  const normalizedChatId = chatId.replace(/^channel:/, "")
+  const groupConfig = meetConfig.groups?.[chatId] ?? meetConfig.groups?.[normalizedChatId]
+
+  return {
+    requireMention: groupConfig?.requireMention ?? meetConfig.requireMention ?? true,
+    systemPrompt: groupConfig?.systemPrompt ?? meetConfig.systemPrompt,
+    groupConfig,
+  }
+}
+
+export function resolveMeetGroupUserPolicy(params: {
+  groupConfig?: MeetGroupConfig
+  senderId: string
+}): { allowed: boolean } {
+  const { groupConfig, senderId } = params
+
+  if (!groupConfig?.users || groupConfig.users.length === 0) {
+    return { allowed: true }
+  }
+
+  if (groupConfig.users.includes("*")) {
+    return { allowed: true }
+  }
+
+  const normalizedSenderId = senderId.trim().toLowerCase()
+  const normalizedUsers = groupConfig.users.map((entry) =>
+    String(entry).trim().toLowerCase(),
+  )
+
+  if (normalizedUsers.includes(normalizedSenderId)) {
+    return { allowed: true }
+  }
+
+  return { allowed: false }
+}

package/src/probe.ts

@@ -0,0 +1,76 @@
+import type { RuntimeEnv } from "openclaw/plugin-sdk"
+import type { ResolvedMeetAccount } from "./types.js"
+import { getMeetClient } from "./client.js"
+
+let _logger: RuntimeEnv | null = null
+
+export function setProbeLogger(logger: RuntimeEnv): void {
+  _logger = logger
+}
+
+function log(message: string): void {
+  if (_logger) {
+    _logger.log(message)
+  } else {
+    console.log(message)
+  }
+}
+
+export type MeetProbeResult = {
+  ok: boolean
+  error?: string
+  botId?: string
+}
+
+const probeCache = new Map<string, { result: MeetProbeResult; timestamp: number }>()
+const PROBE_CACHE_TTL_MS = 5 * 60 * 1000
+
+export async function probeMeet(
+  account: ResolvedMeetAccount,
+): Promise<MeetProbeResult> {
+  if (!account.configured) {
+    return { ok: false, error: "Not configured" }
+  }
+
+  const cacheKey = account.accountId
+  const cached = probeCache.get(cacheKey)
+  if (cached && Date.now() - cached.timestamp < PROBE_CACHE_TTL_MS) {
+    return cached.result
+  }
+
+  try {
+    // 尝试获取 bot 实例或创建
+    let bot = getMeetClient(account.accountId)
+    if (!bot) {
+      const { createMeetClient } = await import("./client.js")
+      bot = createMeetClient(account)
+    }
+
+    // 尝试获取一次更新来验证连接
+    const updates = await bot.getUpdates({ limit: 1, timeout: 1 })
+
+    const result: MeetProbeResult = {
+      ok: true,
+      // 从 token 中提取 bot id (格式: bot_id:secret)
+      botId: account.apiToken?.split(":")[0],
+    }
+
+    if (updates && updates.length > 0) {
+      log(`[${account.accountId}] probe: received ${updates.length} update(s)`)
+    }
+
+    probeCache.set(cacheKey, { result, timestamp: Date.now() })
+    return result
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    return { ok: false, error: errorMessage }
+  }
+}
+
+export function clearProbeCache(accountId?: string): void {
+  if (accountId) {
+    probeCache.delete(accountId)
+  } else {
+    probeCache.clear()
+  }
+}

package/src/reply-dispatcher.ts

@@ -0,0 +1,130 @@
+import type { MeetBot } from "@meet-im/meet-bot-jssdk"
+import type { ClawdbotConfig, RuntimeEnv, ReplyPayload } from "openclaw/plugin-sdk"
+import { createReplyPrefixContext } from "openclaw/plugin-sdk"
+import { getMeetRuntime } from "./runtime.js"
+import { sendMessageMeet } from "./send.js"
+
+/**
+ * 匹配完整的 mention 格式: <@userId>
+ */
+const COMPLETE_MENTION_REGEX = /<@(-?\d+)>/g
+
+/**
+ * 匹配末尾不完整的 mention 开始: <@ 或 <@xxx (没有闭合的 >)
+ */
+const INCOMPLETE_MENTION_START = /<@(-?\d*)$/
+
+/**
+ * 匹配开头不完整的 mention 结束: xxx> (没有开始的 <@)
+ */
+const INCOMPLETE_MENTION_END = /^(-?\d+)>/
+
+/**
+ * 保护 mention 格式在分片后不被截断
+ *
+ * 当文本被分片后，`<@userId>` 格式可能被截断成：
+ * - 第一个 chunk 末尾: `<@123`
+ * - 第二个 chunk 开头: `456>`
+ *
+ * 此函数检测并修复这种情况，确保 mention 格式完整。
+ */
+export function protectMentionsInChunks(chunks: string[]): string[] {
+  if (chunks.length <= 1) {
+    return chunks
+  }
+
+  const result: string[] = []
+  let pendingSuffix = ""
+
+  for (let i = 0; i < chunks.length; i++) {
+    let chunk = pendingSuffix + chunks[i]
+    pendingSuffix = ""
+
+    // 检测末尾是否有不完整的 mention 开始 (<@ 或 <@xxx)
+    const startMatch = chunk.match(INCOMPLETE_MENTION_START)
+    if (startMatch) {
+      // 检查下一个 chunk 是否有对应的结束部分
+      const nextChunk = chunks[i + 1]
+      if (nextChunk !== undefined) {
+        const endMatch = nextChunk.match(INCOMPLETE_MENTION_END)
+        if (endMatch) {
+          // 将不完整的部分移到下一个 chunk 前面
+          const splitIndex = chunk.lastIndexOf("<@")
+          if (splitIndex > 0) {
+            result.push(chunk.slice(0, splitIndex))
+            pendingSuffix = chunk.slice(splitIndex)
+            continue
+          }
+        }
+      }
+    }
+
+    result.push(chunk)
+  }
+
+  return result
+}
+
+export type CreateMeetReplyDispatcherOpts = {
+  cfg: ClawdbotConfig
+  agentId: string
+  runtime: RuntimeEnv
+  chatId: string
+  replyToMessageId?: string
+  accountId: string
+  bot: MeetBot
+  botUserId: string
+}
+
+export async function createMeetReplyDispatcher(
+  opts: CreateMeetReplyDispatcherOpts,
+) {
+  const { cfg, agentId, chatId, replyToMessageId, accountId } = opts
+  const core = getMeetRuntime()
+
+  const textChunkLimit = core.channel.text.resolveTextChunkLimit(cfg, "meet", accountId, {
+    fallbackLimit: 4000,
+  })
+
+  const chunkMode = core.channel.text.resolveChunkMode(cfg, "meet", accountId)
+
+  const prefixContext = createReplyPrefixContext({ cfg, agentId })
+
+  const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
+    responsePrefix: prefixContext.responsePrefix,
+    responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+    humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, agentId),
+    onReplyStart: async () => {
+    },
+    deliver: async (payload: ReplyPayload, info) => {
+      const text = payload.text ?? ""
+      if (!text.trim()) {
+        return
+      }
+
+      const rawChunks = core.channel.text.chunkTextWithMode(text, textChunkLimit, chunkMode)
+      const protectedChunks = protectMentionsInChunks(rawChunks)
+
+      for (const chunk of protectedChunks) {
+        await sendMessageMeet({
+          cfg,
+          to: chatId,
+          text: chunk,
+          accountId,
+          replyToMessageId,
+        })
+      }
+    },
+    onError: async (error, info) => {
+      opts.runtime.error?.(`meet[${accountId}] ${info.kind} reply failed: ${String(error)}`)
+    },
+    onIdle: async () => {
+    },
+  })
+
+  return {
+    dispatcher,
+    replyOptions,
+    markDispatchIdle,
+  }
+}

package/src/runtime.ts

@@ -0,0 +1,14 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk"
+
+let meetRuntime: OpenClawPluginApi["runtime"] | null = null
+
+export function setMeetRuntime(runtime: OpenClawPluginApi["runtime"]): void {
+  meetRuntime = runtime
+}
+
+export function getMeetRuntime(): OpenClawPluginApi["runtime"] {
+  if (!meetRuntime) {
+    throw new Error("Meet runtime not initialized. Call setMeetRuntime first.")
+  }
+  return meetRuntime
+}