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

package/src/monitor.ts

@@ -1,195 +0,0 @@
-import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk"
-import type { HistoryEntry } from "openclaw/plugin-sdk/reply-history"
-import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue"
-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
-
-  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 })
-
-    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}`)
-          },
-        },
-      )
-    })
-
-    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

@@ -1,43 +0,0 @@
-import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk/channel-send-result";
-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: text ?? "", 
-      accountId: accountId ?? undefined,
-    });
-    return { channel: "meet", messageId: result.messageId, chatId: result.chatId };
-  },
-  sendMedia: async ({
-    cfg,
-    to,
-    text,
-    mediaUrl,
-    mediaLocalRoots,
-    accountId,
-  }) => {
-    if (!mediaUrl) {
-      throw new Error("mediaUrl is required for sendMedia");
-    }
-    const result = await sendMediaMeet({
-      cfg,
-      to,
-      text: text ?? undefined,
-      mediaUrl,
-      mediaLocalRoots: mediaLocalRoots ?? undefined,
-      accountId: accountId ?? undefined,
-    });
-    return { channel: "meet", messageId: result.messageId, chatId: result.chatId };
-  },
-};

package/src/policy.ts

@@ -1,131 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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.getUpdatesV2({ limit: 1, timeout: 1 })
-
-    const result: MeetProbeResult = {
-      ok: true,
-      botId: account.apiToken?.split(":")[0],
-    }
-
-    if (updates && updates.msgs.length > 0) {
-      log(`[${account.accountId}] probe: received ${updates.msgs.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

@@ -1,207 +0,0 @@
-import type { MeetBot } from "@meet-im/meet-bot-jssdk"
-import type { ClawdbotConfig, RuntimeEnv, ReplyPayload } from "openclaw/plugin-sdk"
-import { createReplyPrefixContext } from "openclaw/plugin-sdk/channel-runtime"
-import { getMeetRuntime } from "./runtime.js"
-import { sendMessageMeet, sendMediaMeet } from "./send.js"
-
-/**
- * 匹配末尾不完整的 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("<@")
-          // splitIndex >= 0 时处理（包括 chunk 只有 "<@" 的情况）
-          if (splitIndex >= 0) {
-            // 如果 splitIndex 之前有内容，保留到 result
-            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
-  mediaLocalRoots?: readonly string[]
-}
-
-export async function createMeetReplyDispatcher(
-  opts: CreateMeetReplyDispatcherOpts,
-) {
-  const { cfg, agentId, chatId, replyToMessageId, accountId, mediaLocalRoots } = 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 ?? ""
-      const mediaUrls = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : [])
-      
-      // 如果既没有文本也没有媒体，直接返回
-      if (!text.trim() && mediaUrls.length === 0) {
-        return
-      }
-
-      // 处理媒体文件：先发送媒体，再发送文本
-      // 如果有媒体，第一个媒体带上文本作为 caption，后续媒体不带文本
-      if (mediaUrls.length > 0) {
-        // 第一个媒体带上 caption
-        await sendMediaMeet({
-          cfg,
-          to: chatId,
-          text: text.trim() || undefined,
-          mediaUrl: mediaUrls[0],
-          mediaLocalRoots,
-          accountId,
-        })
-        // 后续媒体不带文本
-        for (let i = 1; i < mediaUrls.length; i++) {
-          await sendMediaMeet({
-            cfg,
-            to: chatId,
-            text: undefined,
-            mediaUrl: mediaUrls[i],
-            mediaLocalRoots,
-            accountId,
-          })
-        }
-        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) => {
-      const errorMessage = String(error)
-      opts.runtime.error?.(`meet[${accountId}] ${info.kind} reply failed: ${errorMessage}`)
-      // 发送错误提示给用户，让 AI 也能看到错误并修正
-      // 根据错误类型生成友好提示
-      let userMessage: string
-      const lowerError = errorMessage.toLowerCase()
-      if (
-        lowerError.includes("not found") ||
-        lowerError.includes("enoent") ||
-        lowerError.includes("does not exist") ||
-        lowerError.includes("local media file not found")
-      ) {
-        userMessage = `发送失败: 文件不存在或无法访问。请提供有效的文件路径（建议使用绝对路径）。\n错误详情: ${errorMessage}`
-      } else if (
-        lowerError.includes("mediafetcherror") ||
-        lowerError.includes("fetch_failed") ||
-        lowerError.includes("failed to fetch")
-      ) {
-        userMessage = `发送失败: 无法获取媒体文件。请检查 URL 是否正确或网络是否可用。\n错误详情: ${errorMessage}`
-      } else if (
-        lowerError.includes("localmediaaccesserror") ||
-        lowerError.includes("path-not-allowed") ||
-        lowerError.includes("not safe to read") ||
-        lowerError.includes("network-path-not-allowed")
-      ) {
-        userMessage = `发送失败: 文件路径不在允许访问的目录内。请使用工作区内的文件路径，或联系管理员配置 mediaLocalRoots。\n错误详情: ${errorMessage}`
-      } else if (
-        lowerError.includes("max_bytes") ||
-        lowerError.includes("exceeds maxbytes") ||
-        lowerError.includes("exceeds") && lowerError.includes("limit")
-      ) {
-        userMessage = `发送失败: 文件大小超过限制。请使用较小的文件。\n错误详情: ${errorMessage}`
-      } else if (lowerError.includes("not a file")) {
-        userMessage = `发送失败: 路径不是文件。请提供文件路径而非目录。\n错误详情: ${errorMessage}`
-      } else {
-        userMessage = `发送失败: ${errorMessage}`
-      }
-      // 尝试发送错误消息，忽略发送失败（避免递归）
-      try {
-        await sendMessageMeet({
-          cfg,
-          to: chatId,
-          text: userMessage,
-          accountId,
-        })
-      } catch {
-        // 忽略错误消息发送失败
-      }
-    },
-    onIdle: async () => {
-    },
-  })
-
-  return {
-    dispatcher,
-    replyOptions,
-    markDispatchIdle,
-  }
-}

package/src/runtime.ts

@@ -1,14 +0,0 @@
-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
-}