@meet-im/meet 2.0.6 → 3.0.0-beta.1

package/dist/src/media.js

@@ -0,0 +1,140 @@
+import { getMeetClient } from "./client.js";
+import { getMeetRuntime } from "./runtime.js";
+let _debugLog = null;
+let _debugError = null;
+export function setMediaDebugLogger(log, error) {
+    _debugLog = log;
+    _debugError = error;
+}
+function log(msg) {
+    if (_debugLog)
+        _debugLog(msg);
+}
+function logError(msg) {
+    if (_debugError)
+        _debugError(msg);
+}
+/**
+ * 获取文件下载 URL
+ */
+export async function getFileAccessUrl(params) {
+    const { accountId, sessionInfo, seqId, fileId, ossProcess } = params;
+    const bot = getMeetClient(accountId);
+    if (!bot) {
+        logError(`[meet] getFileAccessUrl: bot client not found for account=${accountId}`);
+        return null;
+    }
+    try {
+        log(`[meet] getFileAccessUrl: calling getAccessURL fileId=${fileId} seqId=${seqId} companyId=${sessionInfo.companyId}`);
+        const result = await bot.getAccessURL({
+            firstId: sessionInfo.firstId,
+            secondId: sessionInfo.secondId,
+            sessionType: sessionInfo.sessionType,
+            seqId,
+            fileId: Number(fileId),
+            companyId: sessionInfo.companyId,
+            "x-oss-process": ossProcess,
+        });
+        log(`[meet] getFileAccessUrl: got URL ${result.fileUrl?.slice(0, 80)}...`);
+        return result.fileUrl;
+    }
+    catch (err) {
+        logError(`[meet] getFileAccessUrl: getAccessURL failed: ${String(err)}`);
+        return null;
+    }
+}
+/**
+ * 下载媒体文件到本地 media store
+ * 与 Discord 保持一致的处理流程
+ */
+export async function downloadAndSaveMedia(params) {
+    const { accountId, attachment, sessionInfo, seqId, maxBytes } = params;
+    const runtime = getMeetRuntime();
+    log(`[meet] downloadAndSaveMedia: fileId=${attachment.fileId} fileName=${attachment.fileName} fileUrl=${attachment.fileUrl?.slice(0, 60)}...`);
+    // 确定下载 URL
+    let url;
+    // fileUrl 可能是完整 URL 或相对路径，只有完整 URL 才能直接使用
+    if (attachment.fileUrl && /^https?:\/\//i.test(attachment.fileUrl)) {
+        url = attachment.fileUrl;
+        log(`[meet] downloadAndSaveMedia: using complete fileUrl`);
+    }
+    else {
+        log(`[meet] downloadAndSaveMedia: fileUrl is not complete URL, calling getFileAccessUrl`);
+        const accessUrl = await getFileAccessUrl({
+            accountId,
+            sessionInfo,
+            seqId,
+            fileId: attachment.fileId,
+        });
+        if (!accessUrl) {
+            logError(`[meet] downloadAndSaveMedia: getFileAccessUrl returned null`);
+            return null;
+        }
+        url = accessUrl;
+    }
+    try {
+        // 下载媒体
+        log(`[meet] downloadAndSaveMedia: fetching remote media from ${url.slice(0, 80)}...`);
+        const fetched = await runtime.channel.media.fetchRemoteMedia({
+            url,
+            filePathHint: attachment.fileName,
+            maxBytes,
+        });
+        log(`[meet] downloadAndSaveMedia: fetched ${fetched.buffer.length} bytes, contentType=${fetched.contentType}`);
+        // 保存到本地 media store
+        const saved = await runtime.channel.media.saveMediaBuffer(fetched.buffer, fetched.contentType, "inbound", maxBytes, attachment.fileName);
+        log(`[meet] downloadAndSaveMedia: saved to ${saved.path}`);
+        const typeLabel = inferMediaType(fetched.contentType);
+        return {
+            path: saved.path,
+            contentType: saved.contentType,
+            placeholder: `[${typeLabel}: ${attachment.fileName || "文件"}]`,
+            url,
+        };
+    }
+    catch (err) {
+        logError(`[meet] downloadAndSaveMedia: download/save failed: ${String(err)}`);
+        // 下载失败时，返回 URL 作为 fallback
+        const typeLabel = inferMediaType(attachment.mimeType);
+        return {
+            path: url,
+            contentType: attachment.mimeType,
+            placeholder: `[${typeLabel}: ${attachment.fileName || "文件"}]`,
+            url,
+        };
+    }
+}
+/**
+ * 批量处理媒体附件
+ */
+export async function resolveMediaAttachments(params) {
+    const results = [];
+    for (const attachment of params.attachments) {
+        const resolved = await downloadAndSaveMedia({
+            accountId: params.accountId,
+            attachment,
+            sessionInfo: params.sessionInfo,
+            seqId: params.seqId,
+            maxBytes: params.maxBytes,
+        });
+        if (resolved) {
+            results.push(resolved);
+        }
+    }
+    return results;
+}
+/**
+ * 根据 MIME 类型推断媒体类型标签
+ * 与 Discord 保持一致的格式
+ */
+function inferMediaType(mimeType) {
+    if (!mimeType)
+        return "<media:document>";
+    if (mimeType.startsWith("image/"))
+        return "<media:image>";
+    if (mimeType.startsWith("video/"))
+        return "<media:video>";
+    if (mimeType.startsWith("audio/"))
+        return "<media:audio>";
+    return "<media:document>";
+}

package/dist/src/monitor.d.ts

@@ -0,0 +1,9 @@
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+export type MonitorMeetOpts = {
+    config?: ClawdbotConfig;
+    runtime?: RuntimeEnv;
+    abortSignal?: AbortSignal;
+    accountId?: string;
+};
+export declare function monitorMeetProvider(opts?: MonitorMeetOpts): Promise<void>;
+export declare function stopMeetMonitor(accountId?: string): void;

package/dist/src/monitor.js

@@ -0,0 +1,153 @@
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+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 async function monitorMeetProvider(opts = {}) {
+    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) {
+    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();
+    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", ({ message, quoteMsgMap }) => {
+            let queueKey;
+            try {
+                const ctx = msgContentToContext(message, botUserId, quoteMsgMap);
+                queueKey = ctx.chatId;
+            }
+            catch (err) {
+                error(`[${accountId}]: failed to parse message for queue key: ${String(err)}`);
+                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: message,
+                        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) => {
+            const message = err instanceof Error ? err.message : String(err);
+            const name = err instanceof Error ? err.name : "Error";
+            if (name === "TimeoutError") {
+                log(`[${accountId}]: polling timeout, no new messages, retrying`);
+                return;
+            }
+            error(`[${accountId}]: polling error: ${name}: ${message}`);
+        });
+        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) {
+    if (accountId) {
+        closeMeetClient(accountId);
+    }
+    else {
+        closeAllMeetClients();
+    }
+}
+function extractBotUserId(token) {
+    const parts = token.split(":");
+    return parts[0] ?? "";
+}

package/dist/src/outbound.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk/channel-send-result";
+export declare const meetOutbound: ChannelOutboundAdapter;

package/dist/src/outbound.js

@@ -0,0 +1,34 @@
+import { getMeetRuntime } from "./runtime.js";
+import { sendMessageMeet, sendMediaMeet } from "./send.js";
+export const meetOutbound = {
+    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/dist/src/policy.d.ts

@@ -0,0 +1,30 @@
+import type { MeetConfig, MeetGroupConfig } from "./types.js";
+export declare function resolveMeetAllowlistMatch(params: {
+    allowFrom: Array<string | number>;
+    senderId: string;
+    senderName?: string;
+}): {
+    allowed: boolean;
+};
+export declare function resolveMeetGroupPolicy(params: {
+    groupPolicy?: "open" | "allowlist" | "disabled";
+    groupAllowFrom: Array<string | number>;
+    chatId: string;
+    groups?: Record<string, MeetGroupConfig>;
+}): {
+    allowed: boolean;
+};
+export declare function resolveMeetGroupConfig(params: {
+    meetConfig: MeetConfig;
+    chatId: string;
+}): {
+    requireMention: boolean;
+    systemPrompt?: string;
+    groupConfig?: MeetGroupConfig;
+};
+export declare function resolveMeetGroupUserPolicy(params: {
+    groupConfig?: MeetGroupConfig;
+    senderId: string;
+}): {
+    allowed: boolean;
+};

package/dist/src/policy.js

@@ -0,0 +1,78 @@
+export function resolveMeetAllowlistMatch(params) {
+    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) {
+    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) {
+    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) {
+    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/dist/src/probe.d.ts

@@ -0,0 +1,10 @@
+import type { RuntimeEnv } from "openclaw/plugin-sdk";
+import type { ResolvedMeetAccount } from "./types.js";
+export declare function setProbeLogger(logger: RuntimeEnv): void;
+export type MeetProbeResult = {
+    ok: boolean;
+    error?: string;
+    botId?: string;
+};
+export declare function probeMeet(account: ResolvedMeetAccount): Promise<MeetProbeResult>;
+export declare function clearProbeCache(accountId?: string): void;

package/dist/src/probe.js

@@ -0,0 +1,56 @@
+import { getMeetClient } from "./client.js";
+let _logger = null;
+export function setProbeLogger(logger) {
+    _logger = logger;
+}
+function log(message) {
+    if (_logger) {
+        _logger.log(message);
+    }
+    else {
+        console.log(message);
+    }
+}
+const probeCache = new Map();
+const PROBE_CACHE_TTL_MS = 5 * 60 * 1000;
+export async function probeMeet(account) {
+    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 = {
+            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) {
+    if (accountId) {
+        probeCache.delete(accountId);
+    }
+    else {
+        probeCache.clear();
+    }
+}

package/dist/src/reply-dispatcher.d.ts

@@ -0,0 +1,29 @@
+import type { MeetBot } from "@meet-im/meet-bot-jssdk";
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+/**
+ * 保护 mention 格式在分片后不被截断
+ *
+ * 当文本被分片后，`<@userId>` 格式可能被截断成：
+ * - 第一个 chunk 末尾: `<@123`
+ * - 第二个 chunk 开头: `456>`
+ *
+ * 此函数检测并修复这种情况，确保 mention 格式完整。
+ */
+export declare function protectMentionsInChunks(chunks: string[]): string[];
+export type CreateMeetReplyDispatcherOpts = {
+    cfg: ClawdbotConfig;
+    agentId: string;
+    runtime: RuntimeEnv;
+    chatId: string;
+    replyToMessageId?: string;
+    accountId: string;
+    bot: MeetBot;
+    botUserId: string;
+    mediaLocalRoots?: readonly string[];
+};
+export declare function createMeetReplyDispatcher(opts: CreateMeetReplyDispatcherOpts): Promise<{
+    dispatcher: import("node_modules/openclaw/dist/plugin-sdk/src/auto-reply/reply/reply-dispatcher.types.js").ReplyDispatcher;
+    replyOptions: Pick<import("node_modules/openclaw/dist/plugin-sdk/src/auto-reply/get-reply-options.types.js").GetReplyOptions, "onReplyStart" | "onTypingController" | "onTypingCleanup">;
+    markDispatchIdle: () => void;
+    markRunComplete: () => void;
+}>;