@kirigaya/openclaw-onebot 1.0.1 → 1.0.3

package/dist/handlers/process-inbound.js

@@ -2,12 +2,38 @@
  * 入站消息处理
  */
 import { getOneBotConfig } from "../config.js";
-import { getRawText, isMentioned } from "../message.js";
-import { sendPrivateMsg, sendGroupMsg, sendPrivateImage, sendGroupImage, setMsgEmojiLike, } from "../connection.js";
-import { setActiveReplyTarget, clearActiveReplyTarget } from "../reply-context.js";
+import { getRawText, getTextFromSegments, getReplyMessageId, getTextFromMessageContent, isMentioned, } from "../message.js";
+import { getRenderMarkdownToPlain, getCollapseDoubleNewlines, getWhitelistUserIds } from "../config.js";
+import { markdownToPlain, collapseDoubleNewlines } from "../markdown.js";
+import { markdownToImage } from "../og-image.js";
+import { sendPrivateMsg, sendGroupMsg, sendPrivateImage, sendGroupImage, sendGroupForwardMsg, sendPrivateForwardMsg, setMsgEmojiLike, getMsg, } from "../connection.js";
+import { setActiveReplyTarget, clearActiveReplyTarget, setActiveReplySessionId, setForwardSuppressDelivery, setActiveReplySelfId } from "../reply-context.js";
 import { loadPluginSdk, getSdk } from "../sdk.js";
+import { handleGroupIncrease } from "./group-increase.js";
 const DEFAULT_HISTORY_LIMIT = 20;
 export const sessionHistories = new Map();
+/** forward 模式下待处理的会话，用于定期清理未完成的缓冲 */
+const forwardPendingSessions = new Map();
+/** 每个 replySessionId 已发送的 chunk 数量，用于支持多次 final（如工具调用后追加内容） */
+const lastSentChunkCountBySession = new Map();
+const FORWARD_PENDING_TTL_MS = 5 * 60 * 1000; // 5 分钟
+const FORWARD_CLEANUP_INTERVAL_MS = 60 * 1000; // 每分钟清理一次
+function cleanupForwardPendingSessions() {
+    const now = Date.now();
+    const toDelete = [];
+    for (const [id, ts] of forwardPendingSessions) {
+        if (now - ts > FORWARD_PENDING_TTL_MS)
+            toDelete.push(id);
+    }
+    for (const id of toDelete)
+        forwardPendingSessions.delete(id);
+}
+let forwardCleanupTimer = null;
+export function startForwardCleanupTimer() {
+    if (forwardCleanupTimer)
+        return;
+    forwardCleanupTimer = setInterval(cleanupForwardPendingSessions, FORWARD_CLEANUP_INTERVAL_MS);
+}
 export async function processInboundMessage(api, msg) {
     await loadPluginSdk();
     const { buildPendingHistoryContextFromMap, recordPendingHistoryEntry, clearHistoryEntriesIfEnabled } = getSdk();
@@ -21,20 +47,70 @@ export async function processInboundMessage(api, msg) {
         api.logger?.warn?.("[onebot] not configured");
         return;
     }
-    const cfg = api.config;
-    const messageText = getRawText(msg);
+    const selfId = msg.self_id ?? 0;
+    if (msg.user_id != null && Number(msg.user_id) === Number(selfId)) {
+        return;
+    }
+    const replyId = getReplyMessageId(msg);
+    let messageText;
+    if (replyId != null) {
+        const userText = getTextFromSegments(msg);
+        try {
+            const quoted = await getMsg(replyId);
+            const quotedText = quoted ? getTextFromMessageContent(quoted.message) : "";
+            const senderLabel = quoted?.sender?.nickname ?? quoted?.sender?.user_id ?? "某人";
+            messageText = quotedText.trim()
+                ? `[引用 ${String(senderLabel)} 的消息：${quotedText.trim()}]\n${userText}`
+                : userText;
+        }
+        catch {
+            messageText = userText;
+        }
+    }
+    else {
+        messageText = getRawText(msg);
+    }
     if (!messageText?.trim()) {
         api.logger?.info?.(`[onebot] ignoring empty message`);
         return;
     }
     const isGroup = msg.message_type === "group";
-    const selfId = msg.self_id ?? 0;
+    const cfg = api.config;
     const requireMention = cfg?.channels?.onebot?.requireMention ?? true;
     if (isGroup && requireMention && !isMentioned(msg, selfId)) {
         api.logger?.info?.(`[onebot] ignoring group message without @mention`);
         return;
     }
+    const gi = cfg?.channels?.onebot?.groupIncrease;
+    // 测试欢迎：@ 机器人并发送 /group-increase，模拟当前发送者入群，触发欢迎（使用该人的 id、nickname 等）
+    // 使用 getTextFromSegments 提取纯文本，避免 raw_message 中 [CQ:at,qq=xxx] 等 CQ 码导致匹配失败
+    const cmdText = getTextFromSegments(msg).trim() || messageText.trim();
+    const groupIncreaseTrigger = isGroup && isMentioned(msg, selfId) && /^\/group-increase\s*$/i.test(cmdText) && gi?.enabled;
+    if (groupIncreaseTrigger) {
+        const fakeMsg = {
+            post_type: "notice",
+            notice_type: "group_increase",
+            group_id: msg.group_id,
+            user_id: msg.user_id,
+        };
+        await handleGroupIncrease(api, fakeMsg);
+        return;
+    }
     const userId = msg.user_id;
+    const whitelist = getWhitelistUserIds(cfg);
+    if (whitelist.length > 0 && !whitelist.includes(Number(userId))) {
+        const denyMsg = "权限不足，请向管理员申请权限";
+        const getConfig = () => getOneBotConfig(api);
+        try {
+            if (msg.message_type === "group" && msg.group_id)
+                await sendGroupMsg(msg.group_id, denyMsg, getConfig);
+            else
+                await sendPrivateMsg(userId, denyMsg, getConfig);
+        }
+        catch (_) { }
+        api.logger?.info?.(`[onebot] user ${userId} not in whitelist, denied`);
+        return;
+    }
     const groupId = msg.group_id;
     const sessionId = isGroup
         ? `onebot:group:${groupId}`.toLowerCase()
@@ -153,7 +229,32 @@ export async function processInboundMessage(api, msg) {
         }
     }
     api.logger?.info?.(`[onebot] dispatching message for session ${sessionId}`);
+    const longMessageMode = onebotCfg.longMessageMode ?? "normal";
+    const longMessageThreshold = onebotCfg.longMessageThreshold ?? 300;
+    const replySessionId = `onebot-reply-${Date.now()}-${sessionId}`;
     setActiveReplyTarget(replyTarget);
+    setActiveReplySessionId(replySessionId);
+    setActiveReplySelfId(selfId);
+    if (longMessageMode === "forward")
+        setForwardSuppressDelivery(true);
+    const deliveredChunks = [];
+    let chunkIndex = 0;
+    const getConfig = () => getOneBotConfig(api);
+    const onReplySessionEnd = onebotCfg.onReplySessionEnd;
+    const doSendChunk = async (effectiveIsGroup, effectiveGroupId, uid, text, mediaUrl) => {
+        if (text) {
+            if (effectiveIsGroup && effectiveGroupId)
+                await sendGroupMsg(effectiveGroupId, text, getConfig);
+            else if (uid)
+                await sendPrivateMsg(uid, text, getConfig);
+        }
+        if (mediaUrl) {
+            if (effectiveIsGroup && effectiveGroupId)
+                await sendGroupImage(effectiveGroupId, mediaUrl, api.logger, getConfig);
+            else if (uid)
+                await sendPrivateImage(uid, mediaUrl, api.logger, getConfig);
+        }
+    };
     try {
         await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
             ctx: ctxPayload,
@@ -168,30 +269,145 @@ export async function processInboundMessage(api, msg) {
                     if ((!trimmed || trimmed === "NO_REPLY" || trimmed.endsWith("NO_REPLY")) && !mediaUrl)
                         return;
                     const { userId: uid, groupId: gid, isGroup: ig } = ctxPayload._onebot || {};
-                    // 兜底：sessionId 格式 onebot:group:群号 为权威来源，某些实现 _onebot.groupId 可能为空
                     const sessionKey = String(ctxPayload.SessionKey ?? sessionId);
                     const groupMatch = sessionKey.match(/^onebot:group:(\d+)$/i);
                     const effectiveIsGroup = groupMatch != null || Boolean(ig);
                     const effectiveGroupId = (groupMatch ? parseInt(groupMatch[1], 10) : undefined) ?? gid;
+                    const usePlain = getRenderMarkdownToPlain(cfg);
+                    let textPlain = usePlain ? markdownToPlain(trimmed) : trimmed;
+                    if (getCollapseDoubleNewlines(cfg))
+                        textPlain = collapseDoubleNewlines(textPlain);
+                    deliveredChunks.push({
+                        index: chunkIndex++,
+                        text: textPlain || undefined,
+                        rawText: trimmed || undefined,
+                        mediaUrl: mediaUrl || undefined,
+                    });
+                    const shouldSendNow = longMessageMode === "normal";
+                    // forward 模式且非最后一条：仅暂存，绝不发送，等 final 时再统一处理
+                    if (longMessageMode === "forward" && info.kind !== "final") {
+                        forwardPendingSessions.set(replySessionId, Date.now());
+                        return;
+                    }
+                    if (info.kind === "final" && longMessageMode === "forward") {
+                        forwardPendingSessions.delete(replySessionId);
+                    }
                     try {
-                        if (trimmed) {
-                            if (effectiveIsGroup && effectiveGroupId)
-                                await sendGroupMsg(effectiveGroupId, trimmed);
-                            else if (uid)
-                                await sendPrivateMsg(uid, trimmed);
-                        }
-                        if (mediaUrl) {
-                            if (effectiveIsGroup && effectiveGroupId)
-                                await sendGroupImage(effectiveGroupId, mediaUrl);
-                            else if (uid)
-                                await sendPrivateImage(uid, mediaUrl);
+                        if (shouldSendNow) {
+                            await doSendChunk(effectiveIsGroup, effectiveGroupId, uid, textPlain, mediaUrl);
                         }
-                        if (info.kind === "final" && clearHistoryEntriesIfEnabled) {
-                            clearHistoryEntriesIfEnabled({
-                                historyMap: sessionHistories,
-                                historyKey: sessionId,
-                                limit: DEFAULT_HISTORY_LIMIT,
-                            });
+                        if (info.kind === "final") {
+                            const lastSentCount = lastSentChunkCountBySession.get(replySessionId) ?? 0;
+                            const chunksToSend = deliveredChunks.slice(lastSentCount);
+                            if (chunksToSend.length === 0)
+                                return;
+                            const totalLen = deliveredChunks.reduce((s, c) => s + (c.rawText ?? c.text ?? "").length, 0);
+                            const isLong = totalLen > longMessageThreshold;
+                            const isIncremental = lastSentCount > 0;
+                            if (isIncremental) {
+                                setForwardSuppressDelivery(false);
+                                for (const c of chunksToSend) {
+                                    if (c.text || c.mediaUrl)
+                                        await doSendChunk(effectiveIsGroup, effectiveGroupId, uid, c.text ?? "", c.mediaUrl);
+                                }
+                            }
+                            else if (!shouldSendNow && (longMessageMode === "og_image" || longMessageMode === "forward")) {
+                                if (isLong && longMessageMode === "og_image") {
+                                    const fullRaw = deliveredChunks.map((c) => c.rawText ?? c.text ?? "").join("\n\n");
+                                    if (fullRaw.trim()) {
+                                        try {
+                                            const imgUrl = await markdownToImage(fullRaw);
+                                            if (imgUrl) {
+                                                if (effectiveIsGroup && effectiveGroupId)
+                                                    await sendGroupImage(effectiveGroupId, imgUrl, api.logger, getConfig);
+                                                else if (uid)
+                                                    await sendPrivateImage(uid, imgUrl, api.logger, getConfig);
+                                            }
+                                            else {
+                                                api.logger?.warn?.("[onebot] og_image: node-html-to-image not installed, falling back to normal send");
+                                                setForwardSuppressDelivery(false);
+                                                for (const c of deliveredChunks) {
+                                                    if (c.text || c.mediaUrl)
+                                                        await doSendChunk(effectiveIsGroup, effectiveGroupId, uid, c.text ?? "", c.mediaUrl);
+                                                }
+                                            }
+                                        }
+                                        catch (e) {
+                                            api.logger?.error?.(`[onebot] og_image failed: ${e?.message}`);
+                                            setForwardSuppressDelivery(false);
+                                            for (const c of deliveredChunks) {
+                                                if (c.text || c.mediaUrl)
+                                                    await doSendChunk(effectiveIsGroup, effectiveGroupId, uid, c.text ?? "", c.mediaUrl);
+                                            }
+                                        }
+                                    }
+                                }
+                                else if (isLong && longMessageMode === "forward") {
+                                    try {
+                                        const nodes = [];
+                                        for (const c of deliveredChunks) {
+                                            if (c.mediaUrl) {
+                                                const mid = await sendPrivateImage(selfId, c.mediaUrl, api.logger, getConfig);
+                                                if (mid)
+                                                    nodes.push({ type: "node", data: { id: String(mid) } });
+                                            }
+                                            else if (c.text) {
+                                                const mid = await sendPrivateMsg(selfId, c.text, getConfig);
+                                                if (mid)
+                                                    nodes.push({ type: "node", data: { id: String(mid) } });
+                                            }
+                                        }
+                                        if (nodes.length > 0) {
+                                            if (effectiveIsGroup && effectiveGroupId)
+                                                await sendGroupForwardMsg(effectiveGroupId, nodes, getConfig);
+                                            else if (uid)
+                                                await sendPrivateForwardMsg(uid, nodes, getConfig);
+                                        }
+                                    }
+                                    catch (e) {
+                                        api.logger?.error?.(`[onebot] forward failed: ${e?.message}`);
+                                        setForwardSuppressDelivery(false);
+                                        for (const c of deliveredChunks) {
+                                            if (c.text || c.mediaUrl)
+                                                await doSendChunk(effectiveIsGroup, effectiveGroupId, uid, c.text ?? "", c.mediaUrl);
+                                        }
+                                    }
+                                }
+                                else {
+                                    setForwardSuppressDelivery(false);
+                                    for (const c of deliveredChunks) {
+                                        if (c.text || c.mediaUrl)
+                                            await doSendChunk(effectiveIsGroup, effectiveGroupId, uid, c.text ?? "", c.mediaUrl);
+                                    }
+                                }
+                            }
+                            lastSentChunkCountBySession.set(replySessionId, deliveredChunks.length);
+                            if (clearHistoryEntriesIfEnabled) {
+                                clearHistoryEntriesIfEnabled({
+                                    historyMap: sessionHistories,
+                                    historyKey: sessionId,
+                                    limit: DEFAULT_HISTORY_LIMIT,
+                                });
+                            }
+                            if (onReplySessionEnd) {
+                                const ctx = {
+                                    replySessionId,
+                                    sessionId,
+                                    to: replyTarget,
+                                    chunks: deliveredChunks.map(({ index, text: t, mediaUrl: m }) => ({ index, text: t, mediaUrl: m })),
+                                    userMessage: messageText,
+                                };
+                                if (typeof onReplySessionEnd === "function") {
+                                    await onReplySessionEnd(ctx);
+                                }
+                                else if (typeof onReplySessionEnd === "string" && onReplySessionEnd.trim()) {
+                                    const { loadScript } = await import("../load-script.js");
+                                    const mod = await loadScript(onReplySessionEnd.trim());
+                                    const fn = mod?.default ?? mod?.onReplySessionEnd;
+                                    if (typeof fn === "function")
+                                        await fn(ctx);
+                                }
+                            }
                         }
                     }
                     catch (e) {
@@ -219,6 +435,11 @@ export async function processInboundMessage(api, msg) {
         catch (_) { }
     }
     finally {
+        setForwardSuppressDelivery(false);
+        setActiveReplySelfId(null);
+        lastSentChunkCountBySession.delete(replySessionId);
+        forwardPendingSessions.delete(replySessionId);
+        setActiveReplySessionId(null);
         clearActiveReplyTarget();
     }
 }

package/dist/index.js

@@ -11,10 +11,12 @@
 import { OneBotChannelPlugin } from "./channel.js";
 import { registerService } from "./service.js";
 import { startImageTempCleanup } from "./connection.js";
+import { startForwardCleanupTimer } from "./handlers/process-inbound.js";
 export default function register(api) {
     globalThis.__onebotApi = api;
     globalThis.__onebotGatewayConfig = api.config;
     startImageTempCleanup();
+    startForwardCleanupTimer();
     api.registerChannel({ plugin: OneBotChannelPlugin });
     if (typeof api.registerCli === "function") {
         api.registerCli((ctx) => {

package/dist/load-script.d.ts

@@ -2,4 +2,8 @@
  * 动态加载用户脚本（支持 .js/.mjs/.ts/.mts）
  * .ts/.mts 依赖 tsx 运行时
  */
-export declare function loadScript(scriptPath: string): Promise<Record<string, unknown>>;
+export interface LoadScriptOptions {
+    /** 脚本执行时的 CWD 绝对路径，用于解析相对路径及脚本内 process.cwd() */
+    cwd?: string;
+}
+export declare function loadScript(scriptPath: string, options?: LoadScriptOptions): Promise<Record<string, unknown>>;

package/dist/load-script.js

@@ -6,8 +6,11 @@ import { resolve } from "path";
 import { pathToFileURL } from "url";
 import { extname } from "path";
 const TS_EXT = [".ts", ".mts"];
-export async function loadScript(scriptPath) {
-    const absPath = resolve(process.cwd(), scriptPath.trim());
+export async function loadScript(scriptPath, options) {
+    const baseDir = options?.cwd?.trim() ? resolve(options.cwd) : process.cwd();
+    const absPath = scriptPath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(scriptPath)
+        ? resolve(scriptPath.trim())
+        : resolve(baseDir, scriptPath.trim());
     const ext = extname(absPath).toLowerCase();
     if (TS_EXT.includes(ext)) {
         try {
@@ -17,6 +20,7 @@ export async function loadScript(scriptPath) {
             throw new Error("执行 .ts/.mts 脚本需要安装 tsx 依赖：npm install tsx");
         }
     }
+    // 使用 pathToFileURL 确保 file:// URL 格式正确（Windows 反斜杠会转为正斜杠）
     const url = pathToFileURL(absPath).href;
-    return import(url);
+    return (await import(url));
 }

package/dist/markdown-to-html.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Markdown 转 HTML（保留格式，含代码高亮）
+ * 用于 OG 图片模式下的 Markdown 渲染
+ */
+export declare function markdownToHtml(md: string): string;
+export declare function getMarkdownStyles(): string;

package/dist/markdown-to-html.js

@@ -0,0 +1,75 @@
+/**
+ * Markdown 转 HTML（保留格式，含代码高亮）
+ * 用于 OG 图片模式下的 Markdown 渲染
+ */
+import { marked } from "marked";
+import hljs from "highlight.js";
+const HIGHLIGHT_CSS = `
+.hljs{display:block;overflow-x:auto;padding:1em;background:#1e1e1e;color:#d4d4d4;border-radius:6px;font-family:Consolas,Monaco,monospace;font-size:13px;line-height:1.5}
+.hljs-keyword{color:#569cd6}
+.hljs-string{color:#ce9178}
+.hljs-number{color:#b5cea8}
+.hljs-comment{color:#6a9955}
+.hljs-function{color:#dcdcaa}
+.hljs-title{color:#4ec9b0}
+.hljs-params{color:#9cdcfe}
+.hljs-built_in{color:#4ec9b0}
+.hljs-class{color:#4ec9b0}
+.hljs-variable{color:#9cdcfe}
+.hljs-attr{color:#9cdcfe}
+.hljs-tag{color:#569cd6}
+.hljs-name{color:#569cd6}
+.hljs-meta{color:#808080}
+`;
+function highlightCode(code, lang) {
+    if (lang && hljs.getLanguage(lang)) {
+        try {
+            return hljs.highlight(code, { language: lang }).value;
+        }
+        catch {
+            return hljs.highlightAuto(code).value;
+        }
+    }
+    return hljs.highlightAuto(code).value;
+}
+marked.use({
+    breaks: true,
+    gfm: true,
+    renderer: {
+        code({ text, lang }) {
+            const escaped = highlightCode(text, lang);
+            return `<pre><code class="hljs language-${lang || ""}">${escaped}</code></pre>`;
+        },
+    },
+});
+const WRAPPER_STYLE = `
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;font-size:15px;line-height:1.6;color:#24292e;background:#fff;padding:24px;max-width:800px}
+h1,h2,h3,h4,h5,h6{margin:16px 0 8px;font-weight:600;line-height:1.25}
+h1{font-size:1.5em}
+h2{font-size:1.3em}
+h3{font-size:1.15em}
+p{margin:8px 0}
+ul,ol{margin:8px 0;padding-left:24px}
+li{margin:4px 0}
+code{background:#f6f8fa;padding:2px 6px;border-radius:4px;font-size:0.9em;font-family:Consolas,Monaco,monospace}
+pre{margin:12px 0;overflow-x:auto}
+pre code{background:transparent;padding:0}
+blockquote{border-left:4px solid #dfe2e5;padding-left:16px;margin:8px 0;color:#6a737d}
+a{color:#0366d6;text-decoration:none}
+a:hover{text-decoration:underline}
+table{border-collapse:collapse;margin:12px 0}
+th,td{border:1px solid #dfe2e5;padding:8px 12px;text-align:left}
+th{background:#f6f8fa;font-weight:600}
+${HIGHLIGHT_CSS}
+</style>
+`;
+export function markdownToHtml(md) {
+    if (!md || typeof md !== "string")
+        return "";
+    return marked.parse(md, { async: false });
+}
+export function getMarkdownStyles() {
+    return WRAPPER_STYLE;
+}

package/dist/markdown.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Markdown 转纯文本（去除 **、#、` 等标记）
+ * 用于将 AI 的 Markdown 回复渲染为 QQ 可读的纯文本
+ */
+export declare function markdownToPlain(text: string): string;
+/** 将连续多个换行压缩为单个，减少 AI 输出中的多余空行 */
+export declare function collapseDoubleNewlines(text: string): string;

package/dist/markdown.js

@@ -0,0 +1,43 @@
+/**
+ * Markdown 转纯文本（去除 **、#、` 等标记）
+ * 用于将 AI 的 Markdown 回复渲染为 QQ 可读的纯文本
+ */
+export function markdownToPlain(text) {
+    if (!text || typeof text !== "string")
+        return "";
+    let s = text;
+    // 代码块 ```...```
+    s = s.replace(/```[\s\S]*?```/g, (m) => {
+        const inner = m.slice(3, -3).trim();
+        return inner ? `${inner}\n` : "";
+    });
+    // 行内代码 `...`
+    s = s.replace(/`([^`]+)`/g, "$1");
+    // 粗体 **...** 或 __...__
+    s = s.replace(/\*\*([^*]+)\*\*/g, "$1");
+    s = s.replace(/__([^_]+)__/g, "$1");
+    // 斜体 *...* 或 _..._（在粗体之后处理）
+    s = s.replace(/\*([^*]+)\*/g, "$1");
+    s = s.replace(/_([^_]+)_/g, "$1");
+    // 标题 # ## ### ...
+    s = s.replace(/^#{1,6}\s+/gm, "");
+    // 链接 [text](url) -> text
+    s = s.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+    // 图片 ![alt](url) -> alt 或 [图片]
+    s = s.replace(/!\[([^\]]*)\]\([^)]+\)/g, (_, alt) => (alt?.trim() ? alt : "[图片]"));
+    // 删除线 ~~...~~
+    s = s.replace(/~~([^~]+)~~/g, "$1");
+    // 引用 > 行首
+    s = s.replace(/^>\s*/gm, "");
+    // 无序列表 - * +
+    s = s.replace(/^[\s]*[-*+]\s+/gm, "");
+    // 有序列表 1. 2.
+    s = s.replace(/^[\s]*\d+\.\s+/gm, "");
+    return s.trim();
+}
+/** 将连续多个换行压缩为单个，减少 AI 输出中的多余空行 */
+export function collapseDoubleNewlines(text) {
+    if (!text || typeof text !== "string")
+        return "";
+    return text.replace(/\n{2,}/g, "\n");
+}

package/dist/message.d.ts

@@ -2,5 +2,11 @@
  * OneBot 消息解析
  */
 import type { OneBotMessage } from "./types.js";
+/** 从消息段数组中提取引用/回复的消息 ID（OneBot reply 段） */
+export declare function getReplyMessageId(msg: OneBotMessage): number | undefined;
+/** 从 get_msg 返回的 message 字段中提取文本和图片链接（供 AI 理解引用内容） */
+export declare function getTextFromMessageContent(content: string | unknown[] | undefined): string;
+/** 仅从 message 段数组提取 text 段（不含 raw_message，用于有引用时避免 CQ 码） */
+export declare function getTextFromSegments(msg: OneBotMessage): string;
 export declare function getRawText(msg: OneBotMessage): string;
 export declare function isMentioned(msg: OneBotMessage, selfId: number): boolean;

package/dist/message.js

@@ -1,13 +1,45 @@
 /**
  * OneBot 消息解析
  */
-export function getRawText(msg) {
-    if (!msg)
+/** 从消息段数组中提取引用/回复的消息 ID（OneBot reply 段） */
+export function getReplyMessageId(msg) {
+    if (!msg?.message || !Array.isArray(msg.message))
+        return undefined;
+    const replySeg = msg.message.find((m) => m?.type === "reply");
+    if (!replySeg?.data)
+        return undefined;
+    const id = replySeg.data?.id;
+    if (id == null)
+        return undefined;
+    const num = typeof id === "number" ? id : parseInt(String(id), 10);
+    return Number.isNaN(num) ? undefined : num;
+}
+/** 从 get_msg 返回的 message 字段中提取文本和图片链接（供 AI 理解引用内容） */
+export function getTextFromMessageContent(content) {
+    if (!content)
         return "";
-    if (typeof msg.raw_message === "string" && msg.raw_message) {
-        return msg.raw_message;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const m of content) {
+        const seg = m;
+        if (seg?.type === "text") {
+            const t = seg.data?.text ?? "";
+            if (t)
+                parts.push(t);
+        }
+        else if (seg?.type === "image") {
+            const url = seg.data?.url ?? seg.data?.file ?? "";
+            parts.push(url ? `[图片: ${url}]` : "[图片]");
+        }
     }
-    const arr = msg.message;
+    return parts.join("");
+}
+/** 仅从 message 段数组提取 text 段（不含 raw_message，用于有引用时避免 CQ 码） */
+export function getTextFromSegments(msg) {
+    const arr = msg?.message;
     if (!Array.isArray(arr))
         return "";
     return arr
@@ -15,6 +47,14 @@ export function getRawText(msg) {
         .map((m) => m?.data?.text ?? "")
         .join("");
 }
+export function getRawText(msg) {
+    if (!msg)
+        return "";
+    if (typeof msg.raw_message === "string" && msg.raw_message) {
+        return msg.raw_message;
+    }
+    return getTextFromSegments(msg);
+}
 export function isMentioned(msg, selfId) {
     const arr = msg.message;
     if (!Array.isArray(arr))

package/dist/og-image.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Markdown 转 OG 图片
+ * 依赖可选的 node-html-to-image（需安装：npm install node-html-to-image）
+ */
+export declare function markdownToImage(md: string): Promise<string | null>;

package/dist/og-image.js

@@ -0,0 +1,45 @@
+/**
+ * Markdown 转 OG 图片
+ * 依赖可选的 node-html-to-image（需安装：npm install node-html-to-image）
+ */
+import { unlinkSync, mkdirSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { markdownToHtml, getMarkdownStyles } from "./markdown-to-html.js";
+const OG_TEMP_DIR = join(tmpdir(), "openclaw-onebot-og");
+export async function markdownToImage(md) {
+    if (!md?.trim())
+        return null;
+    let nodeHtmlToImage;
+    try {
+        const mod = await import("node-html-to-image");
+        nodeHtmlToImage = mod.default;
+    }
+    catch {
+        return null;
+    }
+    if (!nodeHtmlToImage)
+        return null;
+    const bodyHtml = markdownToHtml(md);
+    const styles = getMarkdownStyles();
+    const fullHtml = `<!DOCTYPE html><html><head><meta charset="utf-8">${styles}</head><body>${bodyHtml}</body></html>`;
+    mkdirSync(OG_TEMP_DIR, { recursive: true });
+    const outPath = join(OG_TEMP_DIR, `og-${Date.now()}-${Math.random().toString(36).slice(2)}.png`);
+    try {
+        await nodeHtmlToImage({
+            output: outPath,
+            html: fullHtml,
+            type: "png",
+            quality: 90,
+            puppeteerArgs: { headless: true, args: ["--no-sandbox", "--disable-setuid-sandbox"] },
+        });
+        return `file://${outPath.replace(/\\/g, "/")}`;
+    }
+    catch (e) {
+        try {
+            unlinkSync(outPath);
+        }
+        catch { }
+        throw e;
+    }
+}