@kirigaya/openclaw-onebot 1.0.2 → 1.0.4

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, getOgImageRenderTheme, getNormalModeFlushIntervalMs, getNormalModeFlushChars, } 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,99 @@ 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;
+    api.logger?.info?.(`[onebot] longMessageMode=${longMessageMode}, threshold=${longMessageThreshold}`);
+    const normalModeFlushIntervalMs = getNormalModeFlushIntervalMs(cfg);
+    const normalModeFlushChars = getNormalModeFlushChars(cfg);
+    const replySessionId = `onebot-reply-${Date.now()}-${sessionId}`;
     setActiveReplyTarget(replyTarget);
+    setActiveReplySessionId(replySessionId);
+    setActiveReplySelfId(selfId);
+    if (longMessageMode === "forward")
+        setForwardSuppressDelivery(true);
+    const deliveredChunks = [];
+    let chunkIndex = 0;
+    let normalModeBufferedText = "";
+    let normalModeBufferedRawText = "";
+    let normalModeFlushTimer = null;
+    let normalModeFlushChain = Promise.resolve();
+    const getConfig = () => getOneBotConfig(api);
+    const onReplySessionEnd = onebotCfg.onReplySessionEnd;
+    const normalModePunctuationFlushMinChars = 24;
+    const clearNormalModeFlushTimer = () => {
+        if (normalModeFlushTimer) {
+            clearTimeout(normalModeFlushTimer);
+            normalModeFlushTimer = null;
+        }
+    };
+    const hasBufferedNormalModeText = () => normalModeBufferedText.length > 0 || normalModeBufferedRawText.length > 0;
+    const queueNormalModeFlush = (action) => {
+        normalModeFlushChain = normalModeFlushChain
+            .then(action)
+            .catch((e) => {
+            api.logger?.error?.(`[onebot] normal-mode flush failed: ${e?.message ?? e}`);
+        });
+        return normalModeFlushChain;
+    };
+    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);
+        }
+    };
+    const flushBufferedNormalModeText = async (effectiveIsGroup, effectiveGroupId, uid) => {
+        clearNormalModeFlushTimer();
+        if (!hasBufferedNormalModeText())
+            return;
+        const text = normalModeBufferedText;
+        const rawText = normalModeBufferedRawText;
+        normalModeBufferedText = "";
+        normalModeBufferedRawText = "";
+        await doSendChunk(effectiveIsGroup, effectiveGroupId, uid, text, undefined);
+        deliveredChunks.push({
+            index: chunkIndex++,
+            text: text || undefined,
+            rawText: rawText || undefined,
+        });
+    };
+    const scheduleNormalModeFlush = (effectiveIsGroup, effectiveGroupId, uid) => {
+        if (normalModeFlushTimer)
+            return;
+        normalModeFlushTimer = setTimeout(() => {
+            void queueNormalModeFlush(() => flushBufferedNormalModeText(effectiveIsGroup, effectiveGroupId, uid));
+        }, normalModeFlushIntervalMs);
+    };
+    const shouldFlushNormalModeBuffer = () => {
+        const rawText = normalModeBufferedRawText || normalModeBufferedText;
+        if (!rawText)
+            return false;
+        if (normalModeBufferedText.length >= normalModeFlushChars)
+            return true;
+        if (rawText.length < normalModePunctuationFlushMinChars)
+            return false;
+        return /[.!?。！？]\s*$/.test(rawText);
+    };
+    const appendNormalModeText = (current, next) => {
+        if (!current)
+            return next;
+        if (!next)
+            return current;
+        const lastChar = current[current.length - 1];
+        const firstChar = next[0];
+        if (/[A-Za-z0-9]/.test(lastChar) && /[A-Za-z0-9]/.test(firstChar)) {
+            return `${current} ${next}`;
+        }
+        return `${current}${next}`;
+    };
     try {
         await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
             ctx: ctxPayload,
@@ -168,30 +336,251 @@ 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);
+                    const shouldSendNow = longMessageMode === "normal";
+                    if (!shouldSendNow) {
+                        deliveredChunks.push({
+                            index: chunkIndex++,
+                            text: textPlain || undefined,
+                            rawText: trimmed || undefined,
+                            mediaUrl: mediaUrl || undefined,
+                        });
+                    }
+                    // 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) {
+                            if (mediaUrl) {
+                                await queueNormalModeFlush(async () => {
+                                    await flushBufferedNormalModeText(effectiveIsGroup, effectiveGroupId, uid);
+                                    await doSendChunk(effectiveIsGroup, effectiveGroupId, uid, textPlain, mediaUrl);
+                                    deliveredChunks.push({
+                                        index: chunkIndex++,
+                                        text: textPlain || undefined,
+                                        rawText: trimmed || undefined,
+                                        mediaUrl: mediaUrl || undefined,
+                                    });
+                                });
+                            }
+                            else {
+                                normalModeBufferedText = appendNormalModeText(normalModeBufferedText, textPlain);
+                                normalModeBufferedRawText = appendNormalModeText(normalModeBufferedRawText, trimmed);
+                                if (shouldFlushNormalModeBuffer()) {
+                                    await queueNormalModeFlush(() => flushBufferedNormalModeText(effectiveIsGroup, effectiveGroupId, uid));
+                                }
+                                else {
+                                    scheduleNormalModeFlush(effectiveIsGroup, effectiveGroupId, uid);
+                                }
+                            }
                         }
-                        if (info.kind === "final" && clearHistoryEntriesIfEnabled) {
-                            clearHistoryEntriesIfEnabled({
-                                historyMap: sessionHistories,
-                                historyKey: sessionId,
-                                limit: DEFAULT_HISTORY_LIMIT,
-                            });
+                        if (info.kind === "final") {
+                            if (shouldSendNow) {
+                                await queueNormalModeFlush(() => flushBufferedNormalModeText(effectiveIsGroup, effectiveGroupId, uid));
+                            }
+                            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 incrementalLen = chunksToSend.reduce((s, c) => s + (c.rawText ?? c.text ?? "").length, 0);
+                            const isLong = totalLen > longMessageThreshold;
+                            const isIncrementalLong = incrementalLen > longMessageThreshold;
+                            const isIncremental = lastSentCount > 0;
+                            api.logger?.info?.(`[onebot] final check: totalLen=${totalLen}, threshold=${longMessageThreshold}, isLong=${isLong}, isIncremental=${isIncremental}, deliveredChunks=${deliveredChunks.length}`);
+                            if (isIncremental) {
+                                setForwardSuppressDelivery(false);
+                                // normal 模式下增量 chunk 已在 deliver 中实时发出；这里不能在 final 再补发一次。
+                                if (!shouldSendNow && isIncrementalLong && (longMessageMode === "og_image" || longMessageMode === "forward")) {
+                                    const fullRaw = chunksToSend.map((c) => c.rawText ?? c.text ?? "").join("\n\n");
+                                    if (fullRaw.trim()) {
+                                        if (longMessageMode === "og_image") {
+                                            try {
+                                                const imgUrl = await markdownToImage(fullRaw, { theme: getOgImageRenderTheme(api?.config) });
+                                                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 (incremental): node-html-to-image not installed, falling back to normal send");
+                                                    for (const c of chunksToSend) {
+                                                        if (c.text || c.mediaUrl)
+                                                            await doSendChunk(effectiveIsGroup, effectiveGroupId, uid, c.text ?? "", c.mediaUrl);
+                                                    }
+                                                }
+                                            }
+                                            catch (e) {
+                                                api.logger?.error?.(`[onebot] og_image (incremental) failed: ${e?.message}`);
+                                                for (const c of chunksToSend) {
+                                                    if (c.text || c.mediaUrl)
+                                                        await doSendChunk(effectiveIsGroup, effectiveGroupId, uid, c.text ?? "", c.mediaUrl);
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            try {
+                                                const nodes = [];
+                                                for (const c of chunksToSend) {
+                                                    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);
+                                                }
+                                                else {
+                                                    for (const c of chunksToSend) {
+                                                        if (c.text || c.mediaUrl)
+                                                            await doSendChunk(effectiveIsGroup, effectiveGroupId, uid, c.text ?? "", c.mediaUrl);
+                                                    }
+                                                }
+                                            }
+                                            catch (e) {
+                                                api.logger?.error?.(`[onebot] forward (incremental) failed: ${e?.message}`);
+                                                for (const c of chunksToSend) {
+                                                    if (c.text || c.mediaUrl)
+                                                        await doSendChunk(effectiveIsGroup, effectiveGroupId, uid, c.text ?? "", c.mediaUrl);
+                                                }
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        for (const c of chunksToSend) {
+                                            if (c.text || c.mediaUrl)
+                                                await doSendChunk(effectiveIsGroup, effectiveGroupId, uid, c.text ?? "", c.mediaUrl);
+                                        }
+                                    }
+                                }
+                                else if (!shouldSendNow) {
+                                    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")) {
+                                api.logger?.info?.(`[onebot] checking og_image: isLong=${isLong}, mode=${longMessageMode}`);
+                                if (isLong && longMessageMode === "og_image") {
+                                    api.logger?.info?.(`[onebot] triggering og_image for ${totalLen} chars`);
+                                    const fullRaw = deliveredChunks.map((c) => c.rawText ?? c.text ?? "").join("\n\n");
+                                    if (fullRaw.trim()) {
+                                        try {
+                                            const imgUrl = await markdownToImage(fullRaw, { theme: getOgImageRenderTheme(api?.config) });
+                                            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) {
@@ -203,7 +592,7 @@ export async function processInboundMessage(api, msg) {
                     await clearEmojiReaction();
                 },
             },
-            replyOptions: { disableBlockStreaming: true },
+            replyOptions: { disableBlockStreaming: longMessageMode !== "normal" },
         });
     }
     catch (err) {
@@ -219,6 +608,12 @@ export async function processInboundMessage(api, msg) {
         catch (_) { }
     }
     finally {
+        clearNormalModeFlushTimer();
+        setForwardSuppressDelivery(false);
+        setActiveReplySelfId(null);
+        lastSentChunkCountBySession.delete(replySessionId);
+        forwardPendingSessions.delete(replySessionId);
+        setActiveReplySessionId(null);
         clearActiveReplyTarget();
     }
 }

package/dist/index.js

@@ -11,20 +11,24 @@
 import { OneBotChannelPlugin } from "./channel.js";
 import { registerService } from "./service.js";
 import { startImageTempCleanup } from "./connection.js";
+import { startForwardCleanupTimer } from "./handlers/process-inbound.js";
+import { registerOneBotCli } from "./cli-commands.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) => {
             const prog = ctx.program;
             if (prog && typeof prog.command === "function") {
-                const onebot = prog.command("onebot").description("OneBot 渠道配置");
+                const onebot = prog.command("onebot").description("OneBot 渠道配置与工具");
                 onebot.command("setup").description("交互式配置 OneBot 连接参数").action(async () => {
                     const { runOneBotSetup } = await import("./setup.js");
                     await runOneBotSetup();
                 });
+                registerOneBotCli(onebot, api);
             }
         }, { commands: ["onebot"] });
     }

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,10 @@
+/**
+ * Markdown 转 HTML（保留格式，含代码高亮）
+ * 用于 OG 图片模式下的 Markdown 渲染
+ */
+export declare function markdownToHtml(md: string): string;
+/**
+ * 获取用于 OG 图片的完整样式（基础 + 主题）
+ * @param theme "default" 无额外样式；"dust" 内置 dust 主题；或 custom 时的 CSS 文件绝对路径
+ */
+export declare function getMarkdownStyles(theme?: string): string;