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

package/dist/src/send.js

@@ -0,0 +1,317 @@
+import { resolveMeetAccount } from "./accounts.js";
+import { getMeetClient, createMeetClient } from "./client.js";
+import { parseTargetToSessionInfo } from "./sdk-bridge.js";
+import { getMeetRuntime } from "./runtime.js";
+const MENTION_PATTERN = /<@(-?\d+)>|@(-?\d+)(?![\d])/g;
+/**
+ * 根据文件扩展名推断 MIME 类型
+ * 支持常见图片格式，包括现代格式如 avif, webp, heic
+ */
+export function inferContentTypeFromFileName(fileName) {
+    const ext = fileName.toLowerCase().split(".").pop();
+    if (!ext)
+        return undefined;
+    const mimeMap = {
+        // 常见图片格式
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        png: "image/png",
+        gif: "image/gif",
+        webp: "image/webp",
+        avif: "image/avif",
+        heic: "image/heic",
+        heif: "image/heif",
+        bmp: "image/bmp",
+        ico: "image/x-icon",
+        svg: "image/svg+xml",
+        tiff: "image/tiff",
+        tif: "image/tiff",
+        // 视频格式
+        mp4: "video/mp4",
+        webm: "video/webm",
+        mov: "video/quicktime",
+        avi: "video/x-msvideo",
+        mkv: "video/x-matroska",
+        // 音频格式
+        mp3: "audio/mpeg",
+        wav: "audio/wav",
+        ogg: "audio/ogg",
+        flac: "audio/flac",
+        m4a: "audio/mp4",
+        // 文档格式
+        pdf: "application/pdf",
+        json: "application/json",
+        xml: "application/xml",
+    };
+    return mimeMap[ext];
+}
+/**
+ * 根据 MIME 类型获取文件扩展名
+ */
+function getExtensionFromContentType(contentType) {
+    const mimeToExt = {
+        "image/jpeg": ".jpg",
+        "image/png": ".png",
+        "image/gif": ".gif",
+        "image/webp": ".webp",
+        "image/avif": ".avif",
+        "image/heic": ".heic",
+        "image/heif": ".heif",
+        "image/bmp": ".bmp",
+        "image/x-icon": ".ico",
+        "image/svg+xml": ".svg",
+        "image/tiff": ".tiff",
+        "video/mp4": ".mp4",
+        "video/webm": ".webm",
+        "video/quicktime": ".mov",
+        "video/x-msvideo": ".avi",
+        "video/x-matroska": ".mkv",
+        "audio/mpeg": ".mp3",
+        "audio/wav": ".wav",
+        "audio/ogg": ".ogg",
+        "audio/flac": ".flac",
+        "audio/mp4": ".m4a",
+        "application/pdf": ".pdf",
+        "application/json": ".json",
+        "application/xml": ".xml",
+    };
+    return mimeToExt[contentType];
+}
+/**
+ * 确保文件名有正确的扩展名
+ * 如果文件名没有扩展名，根据 contentType 添加
+ */
+function ensureFileNameExtension(fileName, contentType) {
+    // 检查是否已有扩展名
+    const hasExtension = /\.[a-zA-Z0-9]+$/.test(fileName);
+    if (hasExtension) {
+        return fileName;
+    }
+    // 根据 contentType 添加扩展名
+    const ext = getExtensionFromContentType(contentType);
+    if (ext) {
+        return fileName + ext;
+    }
+    return fileName;
+}
+/**
+ * 获取最终的 contentType
+ * 如果原始 contentType 缺失或为通用二进制流，则根据文件名推断
+ */
+export function resolveContentType(fileName, originalContentType) {
+    // 如果有明确的 MIME 类型（非通用二进制流），直接使用
+    if (originalContentType && originalContentType !== "application/octet-stream") {
+        return originalContentType;
+    }
+    // 根据文件名推断
+    const inferred = inferContentTypeFromFileName(fileName);
+    return inferred || originalContentType || "application/octet-stream";
+}
+let _logger = null;
+export function setSendMessageLogger(logger) {
+    _logger = logger;
+}
+function log(message) {
+    if (_logger) {
+        _logger.log(message);
+        return;
+    }
+    console.log(message);
+}
+function logError(message) {
+    if (_logger) {
+        _logger.error(message);
+    }
+    else {
+        console.error(message);
+    }
+}
+export function extractAtIds(text) {
+    const atIds = [];
+    text.replace(MENTION_PATTERN, (_, id1, id2) => {
+        const id = id1 ?? id2;
+        if (id) {
+            atIds.push(Number(id));
+        }
+        return _;
+    });
+    return { text: text.trim(), atIds };
+}
+export async function sendMessageMeet(opts) {
+    const { cfg, to, text, accountId, atIds: explicitAtIds } = opts;
+    const account = resolveMeetAccount({ cfg, accountId });
+    if (!account.configured) {
+        throw new Error(`Meet account not configured: ${accountId ?? "default"}`);
+    }
+    // logLevel: info 时记录 AI 输出的原始内容，方便调试 mention 格式问题
+    // 默认为 silent，只有显式设置为 info 时才输出
+    if (account.config.logLevel === "info") {
+        console.log(`[${account.accountId}] AI output raw text: ${JSON.stringify(text)}`);
+    }
+    const token = account.apiToken;
+    if (!token) {
+        throw new Error("Meet API token not configured");
+    }
+    // 检查 token 是否未解析（仍是 secret ref 格式）
+    if (token.startsWith("${secret:")) {
+        const accountArg = accountId ? ` --account ${accountId}` : "";
+        throw new Error(`Meet API token not resolved (still a secret reference).\n` +
+            `\n` +
+            `This usually means:\n` +
+            `1. Gateway is not running in this workspace, or\n` +
+            `2. Token is already in use by another process (Meet only allows single login)\n` +
+            `\n` +
+            `Solutions:\n` +
+            `- If Gateway is running elsewhere: use \`message\` tool (OpenClaw will route through Gateway)\n` +
+            `- If you need to send files: put them in a shared location and ask someone with Gateway access to send\n` +
+            `- To start Gateway: openclaw gateway start${accountArg}\n` +
+            `\n` +
+            `AccountId: ${account.accountId}`);
+    }
+    const botUserId = token.split(":")[0];
+    if (!botUserId) {
+        throw new Error("Invalid Meet API token format");
+    }
+    // 如果 client 不存在则自动创建（支持 message tool 直接发送消息）
+    let bot = getMeetClient(account.accountId);
+    if (!bot) {
+        bot = createMeetClient(account);
+    }
+    const { text: cleanText, atIds: extractedAtIds } = extractAtIds(text);
+    const finalAtIds = explicitAtIds
+        ? [...explicitAtIds, ...extractedAtIds]
+        : extractedAtIds;
+    log(`send message to=${to} atIds=${finalAtIds.join(",") || "none"}`);
+    const sessionInfo = parseTargetToSessionInfo(to, Number(botUserId));
+    try {
+        const result = await bot.sendMessage(sessionInfo, {
+            content: cleanText,
+            atIds: finalAtIds,
+        });
+        return {
+            messageId: String(result.msgContent?.seqId ?? 0),
+            chatId: to,
+        };
+    }
+    catch (error) {
+        logError(`send message error: ${String(error)}`);
+        throw error;
+    }
+}
+export async function sendMediaMeet(opts) {
+    const { cfg, to, text, mediaUrl, mediaLocalRoots, accountId, onProgress } = opts;
+    const account = resolveMeetAccount({ cfg, accountId });
+    if (!account.configured) {
+        throw new Error(`Meet account not configured: ${accountId ?? "default"}`);
+    }
+    const token = account.apiToken;
+    if (!token) {
+        throw new Error("Meet API token not configured");
+    }
+    // 检查 token 是否未解析（仍是 secret ref 格式）
+    if (token.startsWith("${secret:")) {
+        const accountArg = accountId ? ` --account ${accountId}` : "";
+        throw new Error(`Meet API token not resolved (still a secret reference).\n` +
+            `\n` +
+            `This usually means:\n` +
+            `1. Gateway is not running in this workspace, or\n` +
+            `2. Token is already in use by another process (Meet only allows single login)\n` +
+            `\n` +
+            `Solutions:\n` +
+            `- If Gateway is running elsewhere: use \`message\` tool (OpenClaw will route through Gateway)\n` +
+            `- If you need to send files: put them in a shared location and ask someone with Gateway access to send\n` +
+            `- To start Gateway: openclaw gateway start${accountArg}\n` +
+            `\n` +
+            `AccountId: ${account.accountId}`);
+    }
+    const botUserId = token.split(":")[0];
+    if (!botUserId) {
+        throw new Error("Invalid Meet API token format");
+    }
+    // 如果 client 不存在则自动创建（支持 message tool 直接发送消息）
+    let bot = getMeetClient(account.accountId);
+    if (!bot) {
+        bot = createMeetClient(account);
+    }
+    const runtime = getMeetRuntime();
+    const maxBytes = account.config.mediaMaxMb
+        ? account.config.mediaMaxMb * 1024 * 1024
+        : undefined;
+    log(`loading media: ${mediaUrl}`);
+    const media = await runtime.media.loadWebMedia(mediaUrl, {
+        maxBytes,
+        localRoots: mediaLocalRoots,
+    });
+    // 检查媒体大小限制
+    if (maxBytes && media.buffer.length > maxBytes) {
+        throw new Error(`Media file too large: ${media.buffer.length} bytes (max: ${maxBytes})`);
+    }
+    const sessionInfo = parseTargetToSessionInfo(to, Number(botUserId));
+    const rawFileName = media.fileName || "file";
+    const contentType = resolveContentType(rawFileName, media.contentType);
+    // 确保文件名有正确的扩展名
+    const fileName = ensureFileNameExtension(rawFileName, contentType);
+    log(`sending media to=${to} fileName=${fileName} size=${media.buffer.length} contentType=${contentType}`);
+    // 包装进度回调
+    const progressCallback = onProgress
+        ? (progress) => {
+            onProgress({
+                percent: progress.percent,
+                loaded: progress.loaded,
+                total: progress.total,
+                speedPerSecond: progress.speedPerSecond,
+            });
+        }
+        : undefined;
+    try {
+        const result = await bot.sendMedia(sessionInfo, {
+            buffer: media.buffer,
+            fileName,
+            contentType,
+            content: text || "",
+            onProgress: progressCallback,
+        });
+        return {
+            messageId: String(result.msgContent?.seqId ?? 0),
+            chatId: to,
+        };
+    }
+    catch (error) {
+        logError(`send media error: ${String(error)}`);
+        throw error;
+    }
+}
+export async function resolveMeetMedia(mediaUrl, opts) {
+    const runtime = getMeetRuntime();
+    let maxBytes;
+    if (opts?.cfg) {
+        const account = resolveMeetAccount({
+            cfg: opts.cfg,
+            accountId: opts.accountId,
+        });
+        if (account.config.mediaMaxMb) {
+            maxBytes = account.config.mediaMaxMb * 1024 * 1024;
+        }
+    }
+    const media = await runtime.media.loadWebMedia(mediaUrl, {
+        maxBytes,
+        localRoots: opts?.mediaLocalRoots,
+    });
+    return {
+        path: media.fileName || "file",
+        contentType: media.contentType,
+        placeholder: `[Meet file: ${media.fileName || "file"}]`,
+    };
+}
+export async function getMessageMeet(opts) {
+    const { cfg, accountId } = opts;
+    const account = resolveMeetAccount({ cfg, accountId });
+    if (!account.configured) {
+        return null;
+    }
+    const bot = getMeetClient(account.accountId);
+    if (!bot) {
+        return null;
+    }
+    return null;
+}

package/dist/src/targets.d.ts

@@ -0,0 +1,15 @@
+export type MeetTargetKind = "user" | "channel";
+export type MeetTarget = {
+    kind: MeetTargetKind;
+    id: string;
+    raw: string;
+    normalized: string;
+};
+export type MeetTargetParseOptions = {
+    defaultKind?: MeetTargetKind;
+    ambiguousMessage?: string;
+};
+export declare function parseMeetTarget(raw: string, options?: MeetTargetParseOptions): MeetTarget | undefined;
+export declare function resolveMeetChannelId(raw: string): string;
+export declare function formatMeetTarget(target: MeetTarget): string;
+export declare function looksLikeMeetId(input: string): boolean;

package/dist/src/targets.js

@@ -0,0 +1,63 @@
+function buildMessagingTarget(kind, id, raw) {
+    return { kind, id, raw, normalized: `${kind}:${id}` };
+}
+function parseMentionPrefixOrAtUserTarget(params) {
+    const { raw, mentionPattern, prefixes, atUserPattern } = params;
+    const mentionMatch = raw.match(mentionPattern);
+    if (mentionMatch) {
+        return buildMessagingTarget("user", mentionMatch[2], raw);
+    }
+    for (const { prefix, kind } of prefixes) {
+        if (raw.startsWith(prefix)) {
+            const id = raw.slice(prefix.length);
+            if (id) {
+                return buildMessagingTarget(kind, id, raw);
+            }
+        }
+    }
+    if (atUserPattern.test(raw)) {
+        return buildMessagingTarget("user", raw, raw);
+    }
+    return undefined;
+}
+export function parseMeetTarget(raw, options = {}) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const userTarget = parseMentionPrefixOrAtUserTarget({
+        raw: trimmed,
+        mentionPattern: /^@\[([^\]]+)\]\((\d+)\)$/,
+        prefixes: [
+            { prefix: "user:", kind: "user" },
+            { prefix: "channel:", kind: "channel" },
+            { prefix: "meet:", kind: "user" },
+        ],
+        atUserPattern: /^\d+$/,
+        atUserErrorMessage: "Meet DMs require a user id (use user:<id>)",
+    });
+    if (userTarget) {
+        return userTarget;
+    }
+    if (/^\d+$/.test(trimmed)) {
+        if (options.defaultKind) {
+            return buildMessagingTarget(options.defaultKind, trimmed, trimmed);
+        }
+        throw new Error(options.ambiguousMessage ??
+            `Ambiguous Meet recipient "${trimmed}". Use "user:${trimmed}" for DMs or "channel:${trimmed}" for channel messages.`);
+    }
+    return buildMessagingTarget("channel", trimmed, trimmed);
+}
+export function resolveMeetChannelId(raw) {
+    const target = parseMeetTarget(raw, { defaultKind: "channel" });
+    if (!target) {
+        throw new Error(`Invalid Meet channel: ${raw}`);
+    }
+    return target.id;
+}
+export function formatMeetTarget(target) {
+    return `${target.kind}:${target.id}`;
+}
+export function looksLikeMeetId(input) {
+    return /^\d+$/.test(input) || /^(user:|channel:|meet:)/.test(input);
+}

package/dist/src/types.d.ts

@@ -0,0 +1,76 @@
+import type { SessionInfo, AttachmentInfo, UploadProgress } from "@meet-im/meet-bot-jssdk";
+import type { z } from "zod";
+import { MeetConfigSchema, MeetAccountConfigSchema, MeetChannelConfigSchema, MeetGroupConfigSchema } from "./config-schema.js";
+export type MeetConfig = z.infer<typeof MeetConfigSchema>;
+export type MeetAccountConfig = z.infer<typeof MeetAccountConfigSchema>;
+export type MeetChannelConfig = z.infer<typeof MeetChannelConfigSchema>;
+export type MeetGroupConfig = z.infer<typeof MeetGroupConfigSchema>;
+export type { AttachmentInfo, UploadProgress };
+export type ResolvedMeetAccount = {
+    accountId: string;
+    enabled: boolean;
+    configured: boolean;
+    name?: string;
+    apiEndpoint?: string;
+    apiToken?: string;
+    config: MeetConfig;
+};
+export type MeetReplyContext = {
+    messageId: string;
+    senderId?: string;
+    senderName?: string;
+    content?: string;
+    timestamp?: number;
+    mediaPaths?: string[];
+};
+export type MeetMessageContext = {
+    chatId: string;
+    messageId: string;
+    senderId: string;
+    senderOpenId: string;
+    senderName?: string;
+    chatType: "direct" | "channel";
+    mentionedBot: boolean;
+    hasAnyMention?: boolean;
+    content: string;
+    contentType: string;
+    placeholder?: string;
+    rawPayload?: string;
+    sessionInfo: SessionInfo;
+    timestamp?: number;
+    atIds?: number[];
+    replyContext?: MeetReplyContext;
+    media?: MeetMediaAttachment[];
+};
+export type MeetSendResult = {
+    messageId: string;
+    chatId: string;
+};
+export type MeetProbeResult = {
+    ok: boolean;
+    error?: string;
+    botId?: string;
+};
+export type MeetMediaInfo = {
+    path: string;
+    contentType?: string;
+    placeholder: string;
+};
+/**
+ * 入站消息中的媒体附件信息
+ */
+export type MeetMediaAttachment = {
+    fileId: string | number;
+    fileName?: string;
+    fileSize?: number;
+    mimeType?: string;
+    fileUrl?: string;
+};
+/**
+ * 文件上传结果
+ */
+export type MeetUploadResult = {
+    fileID: number;
+    path: string;
+    size: number;
+};

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/vitest.config.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    test: {
+        globals: boolean;
+        environment: string;
+        include: string[];
+    };
+};
+export default _default;

package/dist/vitest.config.js

@@ -0,0 +1,7 @@
+export default {
+    test: {
+        globals: true,
+        environment: "node",
+        include: ["src/**/*.test.ts"],
+    },
+};

package/openclaw.plugin.json

@@ -2,6 +2,122 @@
   "id": "meet",
   "channels": ["meet"],
   "skills": ["./skills"],
+  "channelConfigs": {
+    "meet": {
+      "label": "Meet",
+      "description": "Meet channel configuration",
+      "schema": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "enabled": { "type": "boolean" },
+          "defaultAccount": { "type": "string" },
+          "apiEndpoint": { "type": "string" },
+          "token": { "type": "string" },
+          "apiToken": { "type": "string" },
+          "pollTimeout": { "type": "number", "minimum": 1000, "maximum": 300000 },
+          "pollLimit": { "type": "number", "minimum": 1, "maximum": 1000 },
+          "logLevel": { "type": "string", "enum": ["silent", "info"] },
+          "dmPolicy": { "type": "string", "enum": ["open", "pairing", "allowlist"] },
+          "allowFrom": {
+            "type": "array",
+            "items": { "anyOf": [{ "type": "string" }, { "type": "number" }] }
+          },
+          "groupPolicy": { "type": "string", "enum": ["open", "allowlist", "disabled"] },
+          "groupAllowFrom": {
+            "type": "array",
+            "items": { "anyOf": [{ "type": "string" }, { "type": "number" }] }
+          },
+          "requireMention": { "type": "boolean" },
+          "systemPrompt": { "type": "string" },
+          "channels": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "enabled": { "type": "boolean" },
+                "systemPrompt": { "type": "string" },
+                "requireMention": { "type": "boolean" }
+              }
+            }
+          },
+          "groups": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "enabled": { "type": "boolean" },
+                "name": { "type": "string" },
+                "requireMention": { "type": "boolean" },
+                "systemPrompt": { "type": "string" },
+                "users": {
+                  "type": "array",
+                  "items": { "anyOf": [{ "type": "string" }, { "type": "number" }] }
+                }
+              }
+            }
+          },
+          "historyLimit": { "type": "number", "minimum": 0 },
+          "dmHistoryLimit": { "type": "number", "minimum": 0 },
+          "textChunkLimit": { "type": "number", "minimum": 1 },
+          "mediaMaxMb": { "type": "number", "minimum": 0 },
+          "accounts": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "enabled": { "type": "boolean" },
+                "name": { "type": "string" },
+                "apiEndpoint": { "type": "string" },
+                "token": { "type": "string" },
+                "apiToken": { "type": "string" },
+                "pollTimeout": { "type": "number", "minimum": 1000, "maximum": 300000 },
+                "pollLimit": { "type": "number", "minimum": 1, "maximum": 1000 },
+                "logLevel": { "type": "string", "enum": ["silent", "info"] },
+                "dmPolicy": { "type": "string", "enum": ["open", "pairing", "allowlist"] },
+                "allowFrom": {
+                  "type": "array",
+                  "items": { "anyOf": [{ "type": "string" }, { "type": "number" }] }
+                },
+                "groupPolicy": { "type": "string", "enum": ["open", "allowlist", "disabled"] },
+                "groupAllowFrom": {
+                  "type": "array",
+                  "items": { "anyOf": [{ "type": "string" }, { "type": "number" }] }
+                },
+                "requireMention": { "type": "boolean" },
+                "systemPrompt": { "type": "string" },
+                "historyLimit": { "type": "number", "minimum": 0 },
+                "dmHistoryLimit": { "type": "number", "minimum": 0 },
+                "textChunkLimit": { "type": "number", "minimum": 1 },
+                "mediaMaxMb": { "type": "number", "minimum": 0 },
+                "groups": {
+                  "type": "object",
+                  "additionalProperties": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "properties": {
+                      "enabled": { "type": "boolean" },
+                      "name": { "type": "string" },
+                      "requireMention": { "type": "boolean" },
+                      "systemPrompt": { "type": "string" },
+                      "users": {
+                        "type": "array",
+                        "items": { "anyOf": [{ "type": "string" }, { "type": "number" }] }
+                      },
+                      "groupPolicy": { "type": "string", "enum": ["open", "allowlist", "disabled"] }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
   "configSchema": {
     "type": "object",
     "additionalProperties": false,