@izhimu/qq 0.1.1 → 0.2.0

package/dist/src/adapters/message.d.ts

@@ -4,5 +4,5 @@
  * Optimized for maintainability with clear structure and minimal duplication.
  */
 import type { NapCatMessage, OpenClawMessage } from '../types/index.js';
-export declare function openClawToNapCatMessage(content: OpenClawMessage[], replyToId?: string): NapCatMessage[];
+export declare function openClawToNapCatMessage(content: OpenClawMessage[]): NapCatMessage[];
 export declare function napCatToOpenClawMessage(segments: NapCatMessage[] | string): Promise<OpenClawMessage[]>;

package/dist/src/adapters/message.js

@@ -117,20 +117,20 @@ function openClawSegmentToNapCat(content) {
             return { type: 'image', data: { file: content.url, url: content.url } };
         case 'reply':
             return { type: 'reply', data: { id: content.messageId } };
+        case 'file':
+            return { type: 'file', data: { file: content.file, url: content.url, file_size: content.fileSize } };
         case 'audio':
-            // These types are inbound-only for now
-            log.warn('adapters', `Unsupported outbound type: ${content.type}`);
-            return null;
+            return {
+                type: 'record',
+                data: { file: content.file, path: content.path, url: content.url, file_size: content.fileSize }
+            };
         default:
             log.warn('adapters', `Unknown content type (outbound): ${content.type}`);
             return null;
     }
 }
-export function openClawToNapCatMessage(content, replyToId) {
+export function openClawToNapCatMessage(content) {
     const segments = [];
-    if (replyToId) {
-        segments.push({ type: 'reply', data: { id: replyToId } });
-    }
     for (const item of content) {
         const segment = openClawSegmentToNapCat(item);
         if (segment) {

package/dist/src/channel.js

@@ -3,7 +3,7 @@
  * Main plugin entry point
  */
 import { buildChannelConfigSchema, DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk";
-import { messageIdToString, Logger as log } from "./utils/index.js";
+import { messageIdToString, getFileType, getFileName, Logger as log } from "./utils/index.js";
 import { setContext, setContextStatus, clearContext, setConnection, getConnection, clearConnection } from "./core/runtime.js";
 import { ConnectionManager } from "./core/connection.js";
 import { openClawToNapCatMessage } from "./adapters/message.js";
@@ -53,203 +53,8 @@ export const qqPlugin = {
     },
     outbound: {
         deliveryMode: "direct",
-        sendText: async (ctx) => {
-            const { to, text, accountId, cfg, replyToId } = ctx;
-            if (!accountId) {
-                return {
-                    channel: CHANNEL_ID,
-                    messageId: "",
-                    error: new Error("accountId is required"),
-                    deliveredAt: Date.now(),
-                };
-            }
-            const account = resolveQQAccount({ cfg });
-            if (!account) {
-                return {
-                    channel: CHANNEL_ID,
-                    messageId: "",
-                    error: new Error(`Account not found: ${accountId}`),
-                    deliveredAt: Date.now(),
-                };
-            }
-            const connection = getConnection();
-            if (!connection?.isConnected()) {
-                return {
-                    channel: CHANNEL_ID,
-                    messageId: "",
-                    error: new Error(`Not connected for account: ${accountId}`),
-                    deliveredAt: Date.now(),
-                };
-            }
-            // Parse target (format: private:xxx or group:xxx)
-            const parts = to.split(":");
-            const type = parts[0];
-            const id = parts[1];
-            const chatType = type === "group" ? "group" : "direct";
-            const chatId = id || to;
-            try {
-                const messageSegments = openClawToNapCatMessage([{ type: "text", text }], replyToId ?? undefined);
-                const response = await sendMsg({
-                    message_type: chatType === "direct" ? "private" : "group",
-                    user_id: chatType === "direct" ? chatId : undefined,
-                    group_id: chatType === "group" ? chatId : undefined,
-                    message: messageSegments,
-                });
-                // Update lastOutboundAt timestamp on successful send
-                if (response.status === "ok") {
-                    setContextStatus({
-                        lastOutboundAt: Date.now(),
-                    });
-                }
-                if (response.status === "ok" && response.data) {
-                    const data = response.data;
-                    return {
-                        channel: CHANNEL_ID,
-                        messageId: messageIdToString(data.message_id),
-                        deliveredAt: Date.now(),
-                    };
-                }
-                else {
-                    return {
-                        channel: CHANNEL_ID,
-                        messageId: "",
-                        error: new Error(response.msg || "Send failed"),
-                        deliveredAt: Date.now(),
-                    };
-                }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                return {
-                    channel: CHANNEL_ID,
-                    messageId: "",
-                    error: new Error(errorMessage),
-                    deliveredAt: Date.now(),
-                };
-            }
-        },
-        sendMedia: async (ctx) => {
-            const { to, mediaUrl, accountId, cfg, replyToId } = ctx;
-            log.debug("outbound", `sendMedia called - accountId: ${accountId}, to: ${to}, mediaUrl: ${mediaUrl ?? "null"}, replyToId: ${replyToId ?? "none"}`);
-            if (!accountId) {
-                log.warn("outbound", "sendMedia failed: accountId is required");
-                return {
-                    channel: CHANNEL_ID,
-                    messageId: "",
-                    error: new Error("accountId is required"),
-                    deliveredAt: Date.now(),
-                };
-            }
-            // Validate mediaUrl - check for null, undefined, empty string, or invalid URL
-            if (mediaUrl === null || mediaUrl === undefined || mediaUrl === "") {
-                log.warn("outbound", `sendMedia failed: mediaUrl is invalid (value: ${String(mediaUrl)})`);
-                return {
-                    channel: CHANNEL_ID,
-                    messageId: "",
-                    error: new Error(`mediaUrl is required but received: ${mediaUrl === null ? "null" : mediaUrl === undefined ? "undefined" : "empty string"}`),
-                    deliveredAt: Date.now(),
-                };
-            }
-            // Check if mediaUrl looks like a valid URL or file path
-            const trimmedUrl = String(mediaUrl).trim();
-            if (trimmedUrl === "" || trimmedUrl.length < 3) {
-                log.warn("outbound", `sendMedia failed: mediaUrl is too short or empty after trim`);
-                return {
-                    channel: CHANNEL_ID,
-                    messageId: "",
-                    error: new Error(`mediaUrl appears to be invalid: "${trimmedUrl}"`),
-                    deliveredAt: Date.now(),
-                };
-            }
-            const account = resolveQQAccount({ cfg });
-            if (!account) {
-                log.warn("outbound", `sendMedia failed: Account not found: ${accountId}`);
-                return {
-                    channel: CHANNEL_ID,
-                    messageId: "",
-                    error: new Error(`Account not found: ${accountId}`),
-                    deliveredAt: Date.now(),
-                };
-            }
-            const connection = getConnection();
-            if (!connection?.isConnected()) {
-                log.warn("outbound", `sendMedia failed: Not connected for account: ${accountId}`);
-                return {
-                    channel: CHANNEL_ID,
-                    messageId: "",
-                    error: new Error(`Not connected for account: ${accountId}`),
-                    deliveredAt: Date.now(),
-                };
-            }
-            // Parse target (format: private:xxx or group:xxx)
-            const parts = to.split(":");
-            const type = parts[0];
-            const id = parts[1];
-            const chatType = type === "group" ? "group" : "direct";
-            const chatId = id || to;
-            log.debug("outbound", `Sending media to ${chatType}:${chatId}, url: ${trimmedUrl.substring(0, 100)}${trimmedUrl.length > 100 ? "..." : ""}`);
-            try {
-                // Build media segment - NapCat requires 'file' field
-                // file can be: URL, file path, or base64
-                const mediaSegment = {
-                    type: "image",
-                    data: {
-                        file: trimmedUrl,
-                        url: trimmedUrl,
-                        summary: "[图片]",
-                    },
-                };
-                // Build message segments with optional reply
-                const messageSegments = [];
-                if (replyToId) {
-                    messageSegments.push({ type: "reply", data: { id: replyToId } });
-                }
-                messageSegments.push(mediaSegment);
-                log.debug("outbound", `Message segments: ${JSON.stringify(messageSegments)}`);
-                const response = await sendMsg({
-                    message_type: chatType === "direct" ? "private" : "group",
-                    user_id: chatType === "direct" ? chatId : undefined,
-                    group_id: chatType === "group" ? chatId : undefined,
-                    message: messageSegments,
-                });
-                log.debug("outbound", `NapCat response - status: ${response.status}, retcode: ${response.retcode}, msg: ${response.msg ?? "none"}, data: ${JSON.stringify(response.data)}`);
-                // Update lastOutboundAt timestamp on successful send
-                if (response.status === "ok") {
-                    setContextStatus({
-                        lastOutboundAt: Date.now(),
-                    });
-                }
-                if (response.status === "ok" && response.data) {
-                    const data = response.data;
-                    log.debug("outbound", `Media sent successfully, message_id: ${data.message_id}`);
-                    return {
-                        channel: CHANNEL_ID,
-                        messageId: messageIdToString(data.message_id),
-                        deliveredAt: Date.now(),
-                    };
-                }
-                else {
-                    const errorMsg = response.msg || "Send media failed";
-                    log.warn("outbound", `sendMedia failed - status: ${response.status}, retcode: ${response.retcode}, msg: ${errorMsg}`);
-                    return {
-                        channel: CHANNEL_ID,
-                        messageId: "",
-                        error: new Error(`NapCat error [${response.retcode ?? "unknown"}]: ${errorMsg}`),
-                        deliveredAt: Date.now(),
-                    };
-                }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                log.error("outbound", `sendMedia exception: ${errorMessage}`);
-                return {
-                    channel: CHANNEL_ID,
-                    messageId: "",
-                    error: new Error(`sendMedia error: ${errorMessage}`),
-                    deliveredAt: Date.now(),
-                };
-            }
-        },
+        sendText: outboundSend,
+        sendMedia: outboundSend,
     },
     status: {
         buildAccountSnapshot: ({ account, runtime }) => {
@@ -310,3 +115,65 @@ export const qqPlugin = {
         },
     },
 };
+async function outboundSend(ctx) {
+    const { to, text, mediaUrl, accountId, replyToId } = ctx;
+    log.debug("outbound", `send called - accountId: ${accountId}, to: ${to}, mediaUrl: ${mediaUrl ?? "null"}, replyToId: ${replyToId ?? "none"}`);
+    // Parse target (format: private:xxx or group:xxx)
+    const parts = to.split(":");
+    const [type, id] = parts.length > 1 ? parts : ["private", to];
+    const chatType = type === "group" ? "group" : "private";
+    const chatId = id || to;
+    const content = [];
+    if (text) {
+        content.push({ type: "text", text });
+    }
+    if (mediaUrl) {
+        switch (getFileType(mediaUrl)) {
+            case "image":
+                content.push({ type: "image", url: mediaUrl.trim() });
+                break;
+            case "audio":
+                content.push({ type: "audio", path: mediaUrl.trim(), url: mediaUrl.trim(), file: getFileName(mediaUrl.trim()) });
+                break;
+            default:
+                content.push({ type: "file", url: mediaUrl.trim(), file: getFileName(mediaUrl.trim()) });
+        }
+    }
+    if (replyToId) {
+        content.push({ type: "reply", messageId: replyToId });
+    }
+    if (content.length === 0) {
+        log.warn("outbound", `send called with no content - accountId: ${accountId}, to: ${to}, mediaUrl: ${mediaUrl ?? "null"}, replyToId: ${replyToId ?? "none"}`);
+        return {
+            channel: CHANNEL_ID,
+            messageId: "",
+            error: new Error(`No content to send`),
+            deliveredAt: Date.now(),
+        };
+    }
+    const response = await sendMsg({
+        message_type: chatType,
+        user_id: chatType === "private" ? chatId : undefined,
+        group_id: chatType === "group" ? chatId : undefined,
+        message: openClawToNapCatMessage(content),
+    });
+    if (response.status === "ok" && response.data) {
+        setContextStatus({ lastOutboundAt: Date.now() });
+        const data = response.data;
+        log.debug("outbound", `send successfully, messageId: ${data.message_id}`);
+        return {
+            channel: CHANNEL_ID,
+            messageId: messageIdToString(data.message_id),
+            deliveredAt: Date.now(),
+        };
+    }
+    else {
+        log.warn("outbound", `send failed, status: ${response.status}, retcode: ${response.retcode}, msg: ${response.msg ?? "none"}`);
+        return {
+            channel: CHANNEL_ID,
+            messageId: "",
+            error: new Error(response.msg || "Send failed"),
+            deliveredAt: Date.now(),
+        };
+    }
+}

package/dist/src/core/dispatch.js

@@ -18,7 +18,7 @@ async function contentToPlainText(content) {
         .map((c) => {
         switch (c.type) {
             case 'text':
-                return c.text;
+                return `[消息]\n${c.text}`;
             case 'at':
                 return c.isAll ? '@全体成员' : `@${c.userId}`;
             case 'json':
@@ -63,6 +63,7 @@ async function contextToMedia(content) {
     }
     return;
 }
+// TODO弃用
 async function contextToReply(content) {
     const hasReply = content.some(c => c.type === 'reply');
     if (!hasReply) {
@@ -86,6 +87,22 @@ async function contextToReply(content) {
         sender: String(response.data?.sender.user_id)
     };
 }
+async function sendText(isGroup, chatId, text) {
+    const cleanText = text.replace(/NO_REPLY\s*$/, '');
+    const messageSegments = [{ type: 'text', data: { text: markdownToText(cleanText) } }];
+    try {
+        await sendMsg({
+            message_type: isGroup ? 'group' : 'private',
+            group_id: isGroup ? chatId : undefined,
+            user_id: !isGroup ? chatId : undefined,
+            message: messageSegments,
+        });
+        log.info('dispatch', `Sent reply: ${text.slice(0, 100)}`);
+    }
+    catch (error) {
+        log.error('dispatch', `Send failed: ${error}`);
+    }
+}
 /**
  * Dispatch an incoming message to the AI for processing
  */
@@ -103,13 +120,7 @@ export async function dispatchMessage(params) {
     }
     const isGroup = chatType === 'group';
     const peerId = isGroup ? `group:${chatId}` : senderId;
-    if (!isGroup) {
-        // 输入状态
-        await setInputStatus({
-            user_id: senderId,
-            event_type: 1
-        });
-    }
+    const fullContent = `${content}\n\nFrom QQ(${senderId}) - Nickname: ${senderName}`;
     const route = runtime.channel.routing.resolveAgentRoute({
         cfg: context.cfg,
         channel: CHANNEL_ID,
@@ -122,7 +133,7 @@ export async function dispatchMessage(params) {
     const body = runtime.channel.reply.formatInboundEnvelope({
         channel: CHANNEL_ID,
         from: senderName || senderId,
-        body: content,
+        body: fullContent,
         timestamp,
         chatType: isGroup ? 'group' : 'direct',
         sender: {
@@ -135,8 +146,8 @@ export async function dispatchMessage(params) {
     const toAddress = `qq:${route.accountId}`;
     const ctxPayload = runtime.channel.reply.finalizeInboundContext({
         Body: body,
-        RawBody: content,
-        CommandBody: content,
+        RawBody: fullContent,
+        CommandBody: fullContent,
         From: fromAddress,
         To: toAddress,
         SessionKey: route.sessionKey,
@@ -159,24 +170,7 @@ export async function dispatchMessage(params) {
         OriginatingTo: toAddress,
     });
     log.info('dispatch', `Dispatching to agent ${route.agentId}, session: ${route.sessionKey}`);
-    const sendReply = async (text) => {
-        const messageSegments = [{ type: 'text', data: { text: markdownToText(text) } }];
-        try {
-            await sendMsg({
-                message_type: isGroup ? 'group' : 'private',
-                group_id: isGroup ? chatId : undefined,
-                user_id: !isGroup ? chatId : undefined,
-                message: messageSegments,
-            });
-            log.info('dispatch', `Sent reply: ${text.slice(0, 100)}`);
-        }
-        catch (error) {
-            log.error('dispatch', `Send failed: ${error}`);
-        }
-    };
     const messagesConfig = runtime.channel.reply.resolveEffectiveMessagesConfig(context.cfg, route.agentId);
-    log.info('dispatch', `Messages config: ${JSON.stringify(messagesConfig)}`);
-    let hasResponse = false;
     try {
         await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
             ctx: ctxPayload,
@@ -186,22 +180,29 @@ export async function dispatchMessage(params) {
                     mode: "off"
                 },
                 responsePrefix: messagesConfig.responsePrefix,
+                onReplyStart: async () => {
+                    if (!isGroup) {
+                        // 输入状态
+                        await setInputStatus({
+                            user_id: senderId,
+                            event_type: 1
+                        });
+                    }
+                },
                 deliver: async (payload, info) => {
-                    hasResponse = true;
                     log.info('dispatch', `deliver(${info.kind}): ${JSON.stringify(payload)}`);
                     if (payload.text) {
-                        await sendReply(payload.text);
+                        await sendText(isGroup, chatId, payload.text);
                     }
                 },
                 onError: async (err) => {
-                    hasResponse = true;
                     log.error('dispatch', `Dispatch error: ${err}`);
-                    await sendReply(`[错误] ${String(err)}`);
+                    await sendText(isGroup, chatId, `[错误]\n${String(err)}`);
                 },
             },
             replyOptions: {},
         });
-        log.info('dispatch', `Dispatch completed, hasResponse: ${hasResponse}`);
+        log.info('dispatch', `Dispatch completed`);
     }
     catch (error) {
         log.error('dispatch', `Message processing failed: ${error}`);
@@ -279,7 +280,7 @@ export async function handlePokeEvent(event) {
         senderId: String(event.user_id),
         senderName: String(event.user_id),
         messageId: `poke_${event.user_id}_${Date.now()}`,
-        content: `[动作] ${pokeMessage}`,
+        content: `[动作]\n${pokeMessage}`,
         timestamp: Date.now(),
     });
 }

package/dist/src/types/index.d.ts

@@ -141,7 +141,9 @@ export interface OpenClawJsonContent {
 }
 export interface OpenClawFileContent {
     type: 'file';
-    fileId: string;
+    fileId?: string;
+    file?: string;
+    url?: string;
     fileSize?: number;
 }
 export type OpenClawMessage = OpenClawTextContent | OpenClawAtContent | OpenClawImageContent | OpenClawReplyContent | OpenClawAudioContent | OpenClawJsonContent | OpenClawFileContent;

package/dist/src/utils/index.d.ts

@@ -46,6 +46,9 @@ export declare function chunk<T>(array: T[], size: number): T[][];
  * Get a human-readable message for a WebSocket close code
  */
 export declare function getCloseCodeMessage(code: number): string;
+export type FileCategory = 'image' | 'audio' | 'file';
+export declare function getFileType(pathOrUrl: string): FileCategory;
+export declare function getFileName(pathOrUrl: string): string;
 export { CQCodeUtils, CQNode } from './cqcode.js';
 export { Logger } from './log.js';
 export { MarkdownToText, markdownToText, } from './markdown.js';

package/dist/src/utils/index.js

@@ -236,6 +236,65 @@ export function getCloseCodeMessage(code) {
     };
     return messages[code] ?? `Unknown close code: ${code}`;
 }
+const IMAGE_EXTENSIONS = new Set([
+    'jpg', 'jpeg', 'png', 'gif', 'bmp',
+    'webp', 'svg', 'tiff', 'ico', 'heic'
+]);
+const AUDIO_EXTENSIONS = new Set([
+    'mp3', // 最通用
+    'wav', // 无损/未压缩
+    'ogg', // 开源/Web常用
+    'm4a', // Apple/MPEG-4 音频
+    'aac', // 高级音频编码
+    'flac', // 无损压缩
+    'wma', // Windows Media
+    'aiff', // Apple Interchange
+    'amr', // 移动端录音
+    'opus' // 现代Web流媒体
+]);
+export function getFileType(pathOrUrl) {
+    if (!pathOrUrl)
+        return 'file';
+    try {
+        const cleanPath = pathOrUrl.split(/[?#]/)[0];
+        const lastDotIndex = cleanPath.lastIndexOf('.');
+        if (lastDotIndex === -1) {
+            return 'file';
+        }
+        const extension = cleanPath.substring(lastDotIndex + 1).toLowerCase();
+        if (IMAGE_EXTENSIONS.has(extension)) {
+            return 'image';
+        }
+        if (AUDIO_EXTENSIONS.has(extension)) {
+            return 'audio';
+        }
+        return 'file';
+    }
+    catch (error) {
+        return 'file';
+    }
+}
+export function getFileName(pathOrUrl) {
+    if (!pathOrUrl)
+        return '';
+    try {
+        let cleanPath = pathOrUrl.split(/[?#]/)[0];
+        try {
+            cleanPath = decodeURIComponent(cleanPath);
+        }
+        catch (e) {
+        }
+        cleanPath = cleanPath.replace(/\\/g, '/');
+        if (cleanPath.endsWith('/')) {
+            cleanPath = cleanPath.slice(0, -1);
+        }
+        const fileName = cleanPath.split('/').pop();
+        return fileName || '';
+    }
+    catch (error) {
+        return '';
+    }
+}
 // =============================================================================
 // CQ Code Utilities
 // =============================================================================

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izhimu/qq",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "A QQ channel plugin for OpenClaw using NapCat WebSocket",
   "type": "module",
   "main": "dist/index.js",