@zeyiy/openclaw-channel 0.3.4

package/dist/inbound.js

@@ -0,0 +1,461 @@
+import { SessionType } from "@openim/client-sdk";
+import { appendFileSync } from "node:fs";
+import { sendTextToTarget } from "./media";
+import { formatSdkError } from "./utils";
+/** 写入 /tmp/openim-debug.log，用于排查消息路由问题 */
+function debugLog(msg) {
+    const ts = new Date().toISOString();
+    try {
+        appendFileSync("/tmp/openim-debug.log", `${ts} ${msg}\n`);
+    }
+    catch { }
+}
+const inboundDedup = new Map();
+const INBOUND_DEDUP_TTL_MS = 5 * 60 * 1000;
+const MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+const IMAGE_FETCH_TIMEOUT_MS = 15000;
+function normalizeImageMimeType(value) {
+    const mime = String(value ?? "").trim().toLowerCase();
+    return mime.startsWith("image/") ? mime : undefined;
+}
+function normalizeMimeType(value) {
+    const mime = String(value ?? "").trim().toLowerCase();
+    return mime.includes("/") ? mime : undefined;
+}
+function normalizeString(value) {
+    const text = String(value ?? "").trim();
+    return text || undefined;
+}
+function normalizeSize(value) {
+    const n = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+function summarizeMedia(item) {
+    if (item.kind === "image") {
+        return item.url ? `[Image] ${item.url}` : "[Image message]";
+    }
+    if (item.kind === "video") {
+        const parts = ["[Video]"];
+        if (item.fileName)
+            parts.push(`name=${item.fileName}`);
+        if (item.url)
+            parts.push(`video=${item.url}`);
+        if (item.snapshotUrl)
+            parts.push(`snapshot=${item.snapshotUrl}`);
+        if (item.size)
+            parts.push(`size=${item.size}`);
+        return parts.join(" ");
+    }
+    const parts = ["[File]"];
+    if (item.fileName)
+        parts.push(`name=${item.fileName}`);
+    if (item.mimeType)
+        parts.push(`type=${item.mimeType}`);
+    if (item.url)
+        parts.push(`url=${item.url}`);
+    if (item.size)
+        parts.push(`size=${item.size}`);
+    return parts.join(" ");
+}
+function mergeInboundResults(parts) {
+    const valid = parts.filter(Boolean);
+    if (valid.length === 0)
+        return { body: "", kind: "unknown" };
+    const bodies = valid.map((item) => item.body).filter(Boolean);
+    const media = valid.flatMap((item) => item.media ?? []);
+    if (valid.length === 1) {
+        return {
+            body: bodies[0] || "",
+            kind: valid[0].kind,
+            media: media.length > 0 ? media : undefined,
+        };
+    }
+    return {
+        body: bodies.join("\n"),
+        kind: "mixed",
+        media: media.length > 0 ? media : undefined,
+    };
+}
+async function fetchImageAsContentPart(url, hintedMimeType) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), IMAGE_FETCH_TIMEOUT_MS);
+    let response;
+    try {
+        response = await fetch(url, { signal: controller.signal });
+    }
+    catch (err) {
+        if (controller.signal.aborted) {
+            throw new Error(`image fetch timeout after ${IMAGE_FETCH_TIMEOUT_MS}ms`);
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (!response.ok) {
+        throw new Error(`image fetch failed: ${response.status} ${response.statusText}`);
+    }
+    const contentLength = Number(response.headers.get("content-length") || 0);
+    if (contentLength > MAX_IMAGE_BYTES) {
+        throw new Error(`image too large: ${contentLength} bytes`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    if (buffer.byteLength > MAX_IMAGE_BYTES) {
+        throw new Error(`image too large: ${buffer.byteLength} bytes`);
+    }
+    const mimeType = normalizeImageMimeType(response.headers.get("content-type")) ?? normalizeImageMimeType(hintedMimeType) ?? "image/jpeg";
+    return {
+        type: "image",
+        data: buffer.toString("base64"),
+        mimeType,
+    };
+}
+function buildTextEnvelope(runtime, cfg, fromLabel, senderId, timestamp, bodyText, chatType) {
+    const envelopeOptions = runtime.channel.reply?.resolveEnvelopeFormatOptions?.(cfg) ?? {};
+    const formatted = runtime.channel.reply?.formatInboundEnvelope?.({
+        channel: "OpenIM",
+        from: fromLabel,
+        timestamp,
+        body: bodyText,
+        chatType,
+        sender: { name: fromLabel, id: senderId },
+        envelope: envelopeOptions,
+    });
+    return typeof formatted === "string" ? formatted : bodyText;
+}
+async function materializeInboundMedia(media) {
+    if (!Array.isArray(media) || media.length === 0) {
+        return { images: [], warnings: [] };
+    }
+    const images = [];
+    const warnings = [];
+    for (const item of media) {
+        try {
+            if (item.kind === "image" && item.url) {
+                images.push(await fetchImageAsContentPart(item.url, item.mimeType));
+                continue;
+            }
+            if (item.kind === "video" && item.snapshotUrl) {
+                images.push(await fetchImageAsContentPart(item.snapshotUrl));
+                continue;
+            }
+        }
+        catch (err) {
+            warnings.push(`${summarizeMedia(item)} => ${formatSdkError(err)}`);
+        }
+    }
+    return { images, warnings };
+}
+function extractPictureMedia(msg) {
+    const pic = msg.pictureElem;
+    if (!pic)
+        return [];
+    const source = pic.sourcePicture;
+    const big = pic.bigPicture;
+    const snapshot = pic.snapshotPicture;
+    const url = normalizeString(source?.url) || normalizeString(big?.url) || normalizeString(snapshot?.url);
+    const mimeType = normalizeImageMimeType(source?.type) || normalizeImageMimeType(big?.type) || normalizeImageMimeType(snapshot?.type);
+    return [{ kind: "image", url, mimeType }];
+}
+function extractVideoMedia(msg) {
+    const video = msg.videoElem;
+    if (!video)
+        return [];
+    return [
+        {
+            kind: "video",
+            url: normalizeString(video.videoUrl),
+            snapshotUrl: normalizeString(video.snapshotUrl),
+            fileName: normalizeString(video.videoName ?? video.fileName ?? video.snapshotName),
+            size: normalizeSize(video.videoSize ?? video.duration),
+            mimeType: normalizeMimeType(video.videoType ?? video.type),
+        },
+    ];
+}
+function extractFileMedia(msg) {
+    const file = msg.fileElem;
+    if (!file)
+        return [];
+    return [
+        {
+            kind: "file",
+            url: normalizeString(file.sourceUrl),
+            fileName: normalizeString(file.fileName),
+            size: normalizeSize(file.fileSize),
+            mimeType: normalizeMimeType(file.fileType ?? file.type),
+        },
+    ];
+}
+function extractInboundBody(msg, depth = 0) {
+    const text = String(msg.textElem?.content ?? msg.atTextElem?.text ?? "").trim();
+    const imageMedia = extractPictureMedia(msg);
+    const videoMedia = extractVideoMedia(msg);
+    const fileMedia = extractFileMedia(msg);
+    if (msg.quoteElem?.quoteMessage) {
+        const quotedMsg = msg.quoteElem.quoteMessage;
+        const quotedSender = String(quotedMsg.senderNickname || quotedMsg.sendID || "unknown");
+        const quoted = depth < 2 ? extractInboundBody(quotedMsg, depth + 1) : { body: "[quoted message]", kind: "mixed" };
+        const currentParts = [];
+        if (text)
+            currentParts.push(`Reply: ${text}`);
+        for (const item of [...imageMedia, ...videoMedia, ...fileMedia]) {
+            currentParts.push(`Reply attachment: ${summarizeMedia(item)}`);
+        }
+        const bodyLines = [`[Quote] ${quotedSender}: ${quoted.body || "[empty message]"}`];
+        if (currentParts.length > 0)
+            bodyLines.push(currentParts.join("\n"));
+        return {
+            body: bodyLines.join("\n"),
+            kind: currentParts.length > 0 ? "mixed" : quoted.kind,
+            media: [...imageMedia, ...videoMedia, ...fileMedia],
+        };
+    }
+    const parts = [];
+    if (text)
+        parts.push({ body: text, kind: "text" });
+    for (const item of imageMedia) {
+        parts.push({ body: summarizeMedia(item), kind: "image", media: [item] });
+    }
+    for (const item of videoMedia) {
+        parts.push({ body: summarizeMedia(item), kind: "video", media: [item] });
+    }
+    for (const item of fileMedia) {
+        parts.push({ body: summarizeMedia(item), kind: "file", media: [item] });
+    }
+    if (msg.customElem?.data || msg.customElem?.description || msg.customElem?.extension) {
+        const customText = msg.customElem.description || msg.customElem.data || msg.customElem.extension || "[Custom message]";
+        parts.push({ body: `[Custom message] ${customText}`, kind: "mixed" });
+    }
+    return mergeInboundResults(parts);
+}
+function shouldProcessInboundMessage(accountId, msg) {
+    const idPart = String(msg.clientMsgID || msg.serverMsgID || `${msg.sendID}-${msg.seq || msg.createTime || 0}`);
+    if (!idPart)
+        return true;
+    const key = `${accountId}:${idPart}`;
+    const now = Date.now();
+    const last = inboundDedup.get(key);
+    inboundDedup.set(key, now);
+    if (inboundDedup.size > 2000) {
+        for (const [k, ts] of inboundDedup.entries()) {
+            if (now - ts > INBOUND_DEDUP_TTL_MS)
+                inboundDedup.delete(k);
+        }
+    }
+    return !(last && now - last < INBOUND_DEDUP_TTL_MS);
+}
+function isGroupMessage(msg) {
+    return msg.sessionType === SessionType.Group && !!msg.groupID;
+}
+function isMentionedInGroup(msg, selfUserID) {
+    // Use SDK-provided isAtSelf flag (most reliable, computed server-side)
+    if (msg.atTextElem?.isAtSelf === true)
+        return true;
+    // Fallback: check atUserList manually
+    const list = msg.atTextElem?.atUserList;
+    if (!Array.isArray(list) || list.length === 0)
+        return false;
+    const id = String(selfUserID);
+    return list.some((item) => String(item) === id);
+}
+function isWhitelistedSender(client, msg) {
+    const whitelist = client.config.inboundWhitelist;
+    if (!Array.isArray(whitelist) || whitelist.length === 0)
+        return true;
+    const senderId = String(msg.sendID || "").trim();
+    if (!senderId)
+        return false;
+    return whitelist.some((id) => id === senderId);
+}
+function shouldIgnoreSelfSentMessage(client, msg) {
+    const selfUserID = String(client.config.userID);
+    if (String(msg.sendID) !== selfUserID)
+        return false;
+    // Allow direct self-chat messages only when they come from another platform.
+    const isDirectSelfChat = msg.sessionType !== SessionType.Group && String(msg.recvID) === selfUserID;
+    if (!isDirectSelfChat)
+        return true;
+    const localPlatformID = Number(client.config.platformID);
+    const senderPlatformID = Number(msg.senderPlatformID);
+    if (!Number.isFinite(localPlatformID) || !Number.isFinite(senderPlatformID))
+        return true;
+    return localPlatformID === senderPlatformID;
+}
+async function sendReplyFromInbound(client, msg, text) {
+    const isGroup = isGroupMessage(msg);
+    const target = isGroup ? { kind: "group", id: String(msg.groupID) } : { kind: "user", id: String(msg.sendID) };
+    await sendTextToTarget(client, target, text);
+}
+/**
+ * 标记私聊会话为已读。
+ * conversationID 格式：si_{自己的userID}_{对方的userID}
+ */
+async function markDirectMessageAsRead(client, msg) {
+    const selfID = client.config.userID;
+    const peerID = String(msg.sendID);
+    const conversationID = `si_${selfID}_${peerID}`;
+    try {
+        await client.sdk.markConversationMessageAsRead(conversationID);
+        debugLog(`[已读] 私聊已标记已读 conversation=${conversationID}`);
+    }
+    catch (e) {
+        debugLog(`[已读] 标记已读失败 conversation=${conversationID} error=${e}`);
+    }
+}
+export async function processInboundMessage(api, client, msg) {
+    const runtime = api.runtime;
+    if (!runtime?.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
+        api.logger?.warn?.("[openim] runtime.channel.reply not available");
+        return;
+    }
+    if (shouldIgnoreSelfSentMessage(client, msg)) {
+        api.logger?.debug?.(`[openim] ignore self-sent message: clientMsgID=${msg.clientMsgID || "unknown"}`);
+        return;
+    }
+    if (!shouldProcessInboundMessage(client.config.accountId, msg)) {
+        api.logger?.debug?.(`[openim] ignore duplicate message: clientMsgID=${msg.clientMsgID || "unknown"}`);
+        return;
+    }
+    const group = isGroupMessage(msg);
+    api.logger?.debug?.(`[openim] inbound message: sessionType=${msg.sessionType}, contentType=${msg.contentType}, group=${group}, groupID=${msg.groupID || ""}, sendID=${msg.sendID}, clientMsgID=${msg.clientMsgID || "unknown"}`);
+    // 私聊消息：标记为已读，让对方看到已读回执
+    if (!group) {
+        markDirectMessageAsRead(client, msg).catch(() => { });
+    }
+    const inbound = extractInboundBody(msg);
+    if (!inbound.body) {
+        api.logger?.info?.(`[openim] ignore unsupported message: contentType=${msg.contentType}, clientMsgID=${msg.clientMsgID || "unknown"}`);
+        return;
+    }
+    const mentioned = group && isMentionedInGroup(msg, client.config.userID);
+    const hasWhitelist = client.config.inboundWhitelist.length > 0;
+    if (hasWhitelist) {
+        if (!isWhitelistedSender(client, msg)) {
+            api.logger?.debug?.(`[openim] ignore message: sender ${msg.sendID} not in whitelist`);
+            return;
+        }
+        if (group && !mentioned) {
+            api.logger?.debug?.(`[openim] ignore group message: bot not mentioned (whitelist mode), groupID=${msg.groupID}`);
+            return;
+        }
+    }
+    else if (group && client.config.requireMention && !mentioned) {
+        api.logger?.debug?.(`[openim] ignore group message: requireMention=true but bot not mentioned, groupID=${msg.groupID}`);
+        return;
+    }
+    // 会话隔离：群聊按 groupID 分 session，私聊按发送者 ID 分 session
+    const baseSessionKey = group ? `openim:group:${msg.groupID}`.toLowerCase() : `openim:dm:${msg.sendID}`.toLowerCase();
+    const cfg = api.config;
+    const route = runtime.channel.routing?.resolveAgentRoute?.({
+        cfg,
+        sessionKey: baseSessionKey,
+        channel: "openim",
+        accountId: client.config.accountId,
+    }) ?? { agentId: "main", sessionKey: baseSessionKey };
+    // 将来源信息附加到路由 key 上，防止不同群/不同用户的会话被合并
+    const routeSessionKey = String(route?.sessionKey ?? "").trim();
+    const sessionKey = routeSessionKey ? `${routeSessionKey}:${baseSessionKey}` : baseSessionKey;
+    debugLog(`[route] ${group ? "群聊" : "私聊"} from=${msg.sendID} group=${msg.groupID || "-"} session=${sessionKey} agent=${route.agentId}`);
+    const storePath = runtime.channel.session?.resolveStorePath?.(cfg?.session?.store, {
+        agentId: route.agentId,
+    }) ?? "";
+    const chatType = group ? "group" : "direct";
+    const fromLabel = String(msg.senderNickname || msg.sendID);
+    const senderId = String(msg.sendID);
+    const timestamp = msg.sendTime || Date.now();
+    const mediaResult = await materializeInboundMedia(inbound.media);
+    const warningText = mediaResult.warnings.map((warning) => `[Media fetch failed] ${warning}`).join("\n");
+    const rawBody = warningText ? `${inbound.body}\n${warningText}` : inbound.body;
+    const body = buildTextEnvelope(runtime, cfg, fromLabel, senderId, timestamp, rawBody, chatType);
+    if (mediaResult.warnings.length > 0) {
+        for (const warning of mediaResult.warnings) {
+            api.logger?.warn?.(`[openim] inbound media fetch failed: ${warning}`);
+        }
+    }
+    const ctxPayload = {
+        Body: body,
+        RawBody: rawBody,
+        From: group ? `openim:group:${msg.groupID}` : `openim:${msg.sendID}`,
+        To: `openim:${client.config.userID}`,
+        SessionKey: sessionKey,
+        AccountId: client.config.accountId,
+        ChatType: chatType,
+        ConversationLabel: group ? `openim:g-${msg.groupID}` : `openim:${senderId}`, // 会话标签：群聊用群ID，私聊用用户ID
+        SenderName: fromLabel,
+        SenderId: senderId,
+        Provider: "openim",
+        Surface: "openim",
+        MessageSid: msg.clientMsgID || `openim-${Date.now()}`,
+        Timestamp: timestamp,
+        OriginatingChannel: "openim",
+        OriginatingTo: `openim:${client.config.userID}`,
+        CommandAuthorized: true,
+        _openim: {
+            accountId: client.config.accountId,
+            isGroup: group,
+            senderId,
+            groupId: String(msg.groupID || ""),
+            messageKind: inbound.kind,
+            mediaCount: inbound.media?.length ?? 0,
+        },
+    };
+    if (runtime.channel.session?.recordInboundSession) {
+        await runtime.channel.session.recordInboundSession({
+            storePath,
+            sessionKey,
+            ctx: ctxPayload,
+            updateLastRoute: !group
+                ? {
+                    sessionKey,
+                    channel: "openim",
+                    to: String(msg.sendID),
+                    accountId: client.config.accountId,
+                }
+                : undefined,
+            onRecordError: (err) => api.logger?.warn?.(`[openim] recordInboundSession: ${String(err)}`),
+        });
+    }
+    if (runtime.channel.activity?.record) {
+        runtime.channel.activity.record({
+            channel: "openim",
+            accountId: client.config.accountId,
+            direction: "inbound",
+        });
+    }
+    try {
+        await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: ctxPayload,
+            cfg,
+            dispatcherOptions: {
+                deliver: async (payload) => {
+                    if (!payload.text)
+                        return;
+                    try {
+                        await sendReplyFromInbound(client, msg, payload.text);
+                    }
+                    catch (e) {
+                        api.logger?.error?.(`[openim] deliver failed: ${formatSdkError(e)}`);
+                    }
+                },
+                onError: (err, info) => {
+                    api.logger?.error?.(`[openim] ${info?.kind || "reply"} failed: ${String(err)}`);
+                },
+            },
+            replyOptions: {
+                disableBlockStreaming: true,
+                images: mediaResult.images,
+            },
+        });
+    }
+    catch (err) {
+        api.logger?.error?.(`[openim] dispatch failed: ${formatSdkError(err)}`);
+        try {
+            const errMsg = formatSdkError(err);
+            await sendReplyFromInbound(client, msg, `Processing failed: ${errMsg.slice(0, 80)}`);
+        }
+        catch {
+            // ignore secondary send errors
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * OpenClaw OpenIM Channel Plugin
+ *
+ * Integrates OpenIM into OpenClaw Gateway using @openim/client-sdk.
+ * Supports multi-account concurrency, direct/group text messaging, and mention-gated group triggering.
+ */
+import "./polyfills";
+export default function register(api: any): void;

package/dist/index.js

@@ -0,0 +1,52 @@
+/**
+ * OpenClaw OpenIM Channel Plugin
+ *
+ * Integrates OpenIM into OpenClaw Gateway using @openim/client-sdk.
+ * Supports multi-account concurrency, direct/group text messaging, and mention-gated group triggering.
+ */
+import "./polyfills";
+import { OpenIMChannelPlugin } from "./channel";
+import { connectedClientCount, startAccountClient, stopAllClients } from "./clients";
+import { listEnabledAccountConfigs } from "./config";
+import { registerOpenIMTools } from "./tools";
+export default function register(api) {
+    globalThis.__openimApi = api;
+    globalThis.__openimGatewayConfig = api.config;
+    api.registerChannel({ plugin: OpenIMChannelPlugin });
+    if (typeof api.registerCli === "function") {
+        api.registerCli((ctx) => {
+            const prog = ctx.program;
+            if (prog && typeof prog.command === "function") {
+                const openim = prog.command("openim").description("OpenIM channel configuration");
+                openim.command("setup").description("Interactive setup for the OpenIM default account").action(async () => {
+                    const { runOpenIMSetup } = await import("./setup");
+                    await runOpenIMSetup();
+                });
+            }
+        }, { commands: ["openim"] });
+    }
+    registerOpenIMTools(api);
+    api.registerService({
+        id: "openim-sdk",
+        start: async () => {
+            if (connectedClientCount() > 0) {
+                api.logger?.info?.("[openim] service already started");
+                return;
+            }
+            const accounts = listEnabledAccountConfigs(api);
+            if (accounts.length === 0) {
+                api.logger?.warn?.("[openim] no enabled account config found");
+                return;
+            }
+            for (const account of accounts) {
+                await startAccountClient(api, account);
+            }
+            api.logger?.info?.(`[openim] service started with ${connectedClientCount()}/${accounts.length} connected accounts`);
+        },
+        stop: async () => {
+            await stopAllClients(api);
+            api.logger?.info?.("[openim] service stopped");
+        },
+    });
+    api.logger?.info?.("[openim] plugin loaded");
+}

package/dist/media.d.ts

@@ -0,0 +1,12 @@
+import type { OpenIMClientState, ParsedTarget } from "./types";
+/**
+ * 发送文本消息到指定目标（用户或群组）。
+ *
+ * 群聊场景下，会自动识别文本中的 @提及（支持 <@ID> 和 @ID 两种格式），
+ * 将其转换为 OpenIM 的 at-text 消息（contentType=106），使接收方能正确
+ * 识别 @提及并触发 requireMention 回复机制。
+ */
+export declare function sendTextToTarget(client: OpenIMClientState, target: ParsedTarget, text: string): Promise<void>;
+export declare function sendImageToTarget(client: OpenIMClientState, target: ParsedTarget, image: string): Promise<void>;
+export declare function sendVideoToTarget(client: OpenIMClientState, target: ParsedTarget, video: string, name?: string): Promise<void>;
+export declare function sendFileToTarget(client: OpenIMClientState, target: ParsedTarget, filePathOrUrl: string, name?: string): Promise<void>;