openclaw-channel-dmwork 0.3.8 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-channel-dmwork",
-  "version": "0.3.8",
+  "version": "0.4.0",
   "description": "DMWork channel plugin for OpenClaw via WuKongIM WebSocket",
   "main": "index.ts",
   "type": "module",

package/src/api-fetch.ts

@@ -4,6 +4,7 @@
  */
 
 import { ChannelType, MessageType } from "./types.js";
+import path from "path";
 
 const DEFAULT_TIMEOUT_MS = 30_000;
 
@@ -43,6 +44,94 @@ export async function postJson<T>(
   }
 }
 
+/**
+ * Upload a file to DMWork backend via multipart/form-data.
+ * Returns the CDN URL of the uploaded file.
+ */
+export async function uploadFile(params: {
+  apiUrl: string;
+  botToken: string;
+  fileBuffer: Buffer;
+  filename: string;
+  contentType: string;
+  signal?: AbortSignal;
+}): Promise<{ url: string }> {
+  const url = `${params.apiUrl.replace(/\/+$/, "")}/v1/bot/upload`;
+  const formData = new FormData();
+  const blob = new Blob([new Uint8Array(params.fileBuffer)], { type: params.contentType });
+  formData.append("file", blob, params.filename);
+
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${params.botToken}`,
+    },
+    body: formData,
+    signal: params.signal,
+  });
+
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`DMWork API /v1/bot/upload failed (${response.status}): ${text || response.statusText}`);
+  }
+
+  const data = await response.json() as { url?: string };
+  if (!data.url) {
+    throw new Error("DMWork API /v1/bot/upload returned no url");
+  }
+  return { url: data.url };
+}
+
+/**
+ * Send a media message (image or file) to a channel.
+ */
+export async function sendMediaMessage(params: {
+  apiUrl: string;
+  botToken: string;
+  channelId: string;
+  channelType: ChannelType;
+  type: MessageType;
+  url: string;
+  name?: string;
+  size?: number;
+  mentionUids?: string[];
+  signal?: AbortSignal;
+}): Promise<void> {
+  const payload: Record<string, unknown> = {
+    type: params.type,
+    url: params.url,
+  };
+  if (params.name) payload.name = params.name;
+  if (params.size != null) payload.size = params.size;
+  if (params.mentionUids && params.mentionUids.length > 0) {
+    payload.mention = { uids: params.mentionUids };
+  }
+  await postJson(params.apiUrl, params.botToken, "/v1/bot/sendMessage", {
+    channel_id: params.channelId,
+    channel_type: params.channelType,
+    payload,
+  }, params.signal);
+}
+
+/**
+ * Infer MIME type from filename extension. Returns a sensible default if unknown.
+ */
+export function inferContentType(filename: string): string {
+  const ext = path.extname(filename).toLowerCase();
+  const map: Record<string, string> = {
+    ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png",
+    ".gif": "image/gif", ".webp": "image/webp", ".svg": "image/svg+xml",
+    ".bmp": "image/bmp", ".ico": "image/x-icon",
+    ".mp4": "video/mp4", ".webm": "video/webm", ".mov": "video/quicktime",
+    ".mp3": "audio/mpeg", ".wav": "audio/wav", ".ogg": "audio/ogg",
+    ".pdf": "application/pdf", ".zip": "application/zip",
+    ".doc": "application/msword", ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xls": "application/vnd.ms-excel", ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".txt": "text/plain", ".json": "application/json",
+  };
+  return map[ext] ?? "application/octet-stream";
+}
+
 export async function sendMessage(params: {
   apiUrl: string;
   botToken: string;
@@ -271,6 +360,7 @@ export async function getChannelMessages(params: {
         url: payload.url ?? undefined,
         name: payload.name ?? undefined,
         content: payload.content ?? "",
+        payload,  // preserve full payload for types that need nested data (e.g. MultipleForward)
         // Convert seconds to milliseconds (API returns seconds, internal standard is ms)
         timestamp: (m.timestamp ?? Math.floor(Date.now() / 1000)) * 1000,
       };

package/src/channel.ts

@@ -11,14 +11,14 @@ import {
   resolveDmworkAccount,
   type ResolvedDmworkAccount,
 } from "./accounts.js";
-import { registerBot, sendMessage, sendHeartbeat } from "./api-fetch.js";
+import { registerBot, sendMessage, sendHeartbeat, uploadFile, sendMediaMessage, inferContentType } from "./api-fetch.js";
 import { WKSocket } from "./socket.js";
 import { handleInboundMessage, type DmworkStatusSink } from "./inbound.js";
 import { ChannelType, MessageType, type BotMessage, type MessagePayload } from "./types.js";
 import { parseMentions } from "./mention-utils.js";
 import path from "path";
 import os from "os";
-import { mkdir, writeFile } from "fs/promises";
+import { mkdir, readFile, writeFile } from "fs/promises";
 // HistoryEntry type - compatible with any version
 type HistoryEntry = { sender: string; body: string; timestamp: number };
 const DEFAULT_GROUP_HISTORY_LIMIT = 20;
@@ -242,6 +242,85 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
         ...(mentionUids.length > 0 ? { mentionUids } : {}),
       });
 
+      return { channel: "dmwork", to: ctx.to, messageId: "" };
+    },
+    sendMedia: async (ctx) => {
+      const account = resolveDmworkAccount({
+        cfg: ctx.cfg as OpenClawConfig,
+        accountId: ctx.accountId ?? DEFAULT_ACCOUNT_ID,
+      });
+      if (!account.config.botToken) {
+        throw new Error("DMWork botToken is not configured");
+      }
+
+      const mediaUrl = ctx.mediaUrl;
+      if (!mediaUrl) {
+        throw new Error("sendMedia called without mediaUrl");
+      }
+
+      // 1. Download the file
+      let fileBuffer: Buffer;
+      let contentType: string | undefined;
+      let filename: string;
+
+      if (mediaUrl.startsWith("file://")) {
+        const filePath = decodeURIComponent(mediaUrl.slice(7));
+        fileBuffer = await readFile(filePath);
+        filename = path.basename(filePath);
+        contentType = inferContentType(filename);
+      } else {
+        const resp = await fetch(mediaUrl, { signal: AbortSignal.timeout(60_000) });
+        if (!resp.ok) {
+          throw new Error(`Failed to download media from ${mediaUrl}: ${resp.status}`);
+        }
+        fileBuffer = Buffer.from(await resp.arrayBuffer());
+        contentType = resp.headers.get("content-type") ?? undefined;
+        // Extract filename from URL path
+        const urlPath = new URL(mediaUrl).pathname;
+        filename = path.basename(urlPath) || "file";
+        if (!contentType) {
+          contentType = inferContentType(filename);
+        }
+      }
+
+      contentType = contentType || "application/octet-stream";
+
+      // 2. Upload to backend
+      const { url: cdnUrl } = await uploadFile({
+        apiUrl: account.config.apiUrl,
+        botToken: account.config.botToken,
+        fileBuffer,
+        filename,
+        contentType,
+      });
+
+      // 3. Parse target (same logic as sendText)
+      let channelId = ctx.to;
+      let channelType = ChannelType.DM;
+
+      if (ctx.to.startsWith("group:")) {
+        const groupPart = ctx.to.slice(6);
+        const atIdx = groupPart.indexOf("@");
+        channelId = atIdx >= 0 ? groupPart.slice(0, atIdx) : groupPart;
+        channelType = ChannelType.Group;
+      }
+
+      // 4. Determine message type and send
+      const msgType = contentType.startsWith("image/")
+        ? MessageType.Image
+        : MessageType.File;
+
+      await sendMediaMessage({
+        apiUrl: account.config.apiUrl,
+        botToken: account.config.botToken,
+        channelId,
+        channelType,
+        type: msgType,
+        url: cdnUrl,
+        name: filename,
+        size: fileBuffer.length,
+      });
+
       return { channel: "dmwork", to: ctx.to, messageId: "" };
     },
   },
@@ -380,11 +459,9 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
           // Skip self messages
           if (msg.from_uid === credentials.robot_id) return;
           // Skip messages from any other bot in this plugin instance (prevent bot-to-bot loops)
-          // But allow group messages through — bot-to-bot @mention in groups is legitimate;
-          // mention gating in inbound.ts ensures only @-targeted messages trigger AI.
-          if (_knownBotUids.has(msg.from_uid) && msg.channel_type === ChannelType.DM) return;
+          if (_knownBotUids.has(msg.from_uid)) return;
           // Skip unsupported message types (Location, Card)
-          const supportedTypes = [MessageType.Text, MessageType.Image, MessageType.GIF, MessageType.Voice, MessageType.Video, MessageType.File];
+          const supportedTypes = [MessageType.Text, MessageType.Image, MessageType.GIF, MessageType.Voice, MessageType.Video, MessageType.File, MessageType.MultipleForward];
           if (!msg.payload || !supportedTypes.includes(msg.payload.type)) return;
 
           // Defense-in-depth DM filter (kept for safety, though v0.2.28+ uses independent
@@ -429,6 +506,8 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
           statusSink({ lastError: null });
           startHeartbeat();
           // WS connected successfully = WuKongIM accepted the token
+          // Reset refresh flag so we can refresh again if kicked later (#92)
+          hasRefreshedToken = false;
         },
 
         onDisconnected: () => {

package/src/inbound.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect } from "vitest";
 import { ChannelType, MessageType, type MentionPayload } from "./types.js";
 import { DEFAULT_HISTORY_PROMPT_TEMPLATE } from "./config-schema.js";
+import { resolveInnerMessageText, resolveApiMessagePlaceholder, resolveMultipleForwardText } from "./inbound.js";
 
 /**
  * Tests for mention.all detection logic.
@@ -166,3 +167,124 @@ describe("timestamp standardization", () => {
     expect(String(secondsTimestamp * 1000).length).toBe(13);
   });
 });
+
+/**
+ * Tests for MultipleForward (type=11) message handling.
+ *
+ * MultipleForward is a merge-forwarded chat record containing:
+ * - users: array of {uid, name} for sender info
+ * - msgs: array of messages with payload
+ */
+describe("MultipleForward handling", () => {
+  it("should resolve MultipleForward with text messages", () => {
+    const payload = {
+      type: MessageType.MultipleForward,
+      users: [
+        { uid: "user1", name: "大棍子" },
+        { uid: "user2", name: "托马斯" },
+      ],
+      msgs: [
+        { from_uid: "user1", payload: { type: MessageType.Text, content: "你好" } },
+        { from_uid: "user2", payload: { type: MessageType.Text, content: "Hello" } },
+        { from_uid: "user1", payload: { type: MessageType.Text, content: "晚上好" } },
+      ],
+    };
+
+    const result = { text: resolveMultipleForwardText(payload) };
+    expect(result.text).toBe(
+      "[合并转发: 聊天记录]\n大棍子: 你好\n托马斯: Hello\n大棍子: 晚上好"
+    );
+    // mediaUrl is not part of the resolved text result
+  });
+
+  it("should resolve MultipleForward with mixed types", () => {
+    const payload = {
+      type: MessageType.MultipleForward,
+      users: [
+        { uid: "user1", name: "Alice" },
+        { uid: "user2", name: "Bob" },
+      ],
+      msgs: [
+        { from_uid: "user1", payload: { type: MessageType.Text, content: "Check this out" } },
+        { from_uid: "user2", payload: { type: MessageType.Image, url: "http://example.com/img.jpg" } },
+        { from_uid: "user1", payload: { type: MessageType.File, name: "document.pdf" } },
+        { from_uid: "user2", payload: { type: MessageType.Voice } },
+        { from_uid: "user1", payload: { type: MessageType.Video } },
+      ],
+    };
+
+    const result = { text: resolveMultipleForwardText(payload) };
+    expect(result.text).toContain("[合并转发: 聊天记录]");
+    expect(result.text).toContain("Alice: Check this out");
+    expect(result.text).toContain("Bob: [图片]");
+    expect(result.text).toContain("Alice: [文件: document.pdf]");
+    expect(result.text).toContain("Bob: [语音]");
+    expect(result.text).toContain("Alice: [视频]");
+  });
+
+  it("should resolve nested MultipleForward", () => {
+    const payload = {
+      type: MessageType.MultipleForward,
+      users: [{ uid: "user1", name: "张三" }],
+      msgs: [
+        { from_uid: "user1", payload: { type: MessageType.Text, content: "看这个" } },
+        {
+          from_uid: "user1",
+          payload: {
+            type: MessageType.MultipleForward,
+            users: [{ uid: "user2", name: "李四" }],
+            msgs: [{ from_uid: "user2", payload: { type: MessageType.Text, content: "内层消息" } }],
+          },
+        },
+      ],
+    };
+
+    const result = { text: resolveMultipleForwardText(payload) };
+    expect(result.text).toContain("[合并转发: 聊天记录]");
+    expect(result.text).toContain("张三: 看这个");
+    expect(result.text).toContain("张三: [合并转发]");
+  });
+
+  it("should handle empty msgs array", () => {
+    const payload = {
+      type: MessageType.MultipleForward,
+      users: [{ uid: "user1", name: "Test" }],
+      msgs: [],
+    };
+
+    const result = { text: resolveMultipleForwardText(payload) };
+    expect(result.text).toBe("[合并转发: 聊天记录]");
+  });
+
+  it("should handle missing users array", () => {
+    const payload = {
+      type: MessageType.MultipleForward,
+      msgs: [
+        { from_uid: "unknown_uid_123", payload: { type: MessageType.Text, content: "Hello" } },
+      ],
+    };
+
+    const result = { text: resolveMultipleForwardText(payload) };
+    expect(result.text).toContain("[合并转发: 聊天记录]");
+    expect(result.text).toContain("unknown_uid_123: Hello");
+  });
+
+  it("should return placeholder for resolveApiMessagePlaceholder", () => {
+    expect(resolveApiMessagePlaceholder(MessageType.MultipleForward)).toBe("[合并转发]");
+  });
+
+  it("resolveInnerMessageText should handle all message types", () => {
+    expect(resolveInnerMessageText({ type: MessageType.Text, content: "test" })).toBe("test");
+    expect(resolveInnerMessageText({ type: MessageType.Image })).toBe("[图片]");
+    expect(resolveInnerMessageText({ type: MessageType.GIF })).toBe("[GIF]");
+    expect(resolveInnerMessageText({ type: MessageType.Voice })).toBe("[语音]");
+    expect(resolveInnerMessageText({ type: MessageType.Video })).toBe("[视频]");
+    expect(resolveInnerMessageText({ type: MessageType.Location })).toBe("[位置信息]");
+    expect(resolveInnerMessageText({ type: MessageType.Card })).toBe("[名片]");
+    expect(resolveInnerMessageText({ type: MessageType.File, name: "doc.pdf" })).toBe("[文件: doc.pdf]");
+    expect(resolveInnerMessageText({ type: MessageType.File })).toBe("[文件]");
+    expect(resolveInnerMessageText({ type: MessageType.MultipleForward })).toBe("[合并转发]");
+    expect(resolveInnerMessageText({ type: 99 })).toBe("[消息]");
+    expect(resolveInnerMessageText({ type: 99, content: "fallback" })).toBe("fallback");
+  });
+});

package/src/inbound.ts

@@ -145,12 +145,75 @@ function guessMime(pathOrName?: string, fallback = "application/octet-stream"):
   return map[ext] ?? fallback;
 }
 
-interface ResolvedContent {
+export interface ResolvedContent {
   text: string;
   mediaUrl?: string;
   mediaType?: string;
 }
 
+export interface ForwardUser {
+  uid: string;
+  name: string;
+}
+
+export interface ForwardMessage {
+  message_id?: string;
+  from_uid: string;
+  timestamp?: number;
+  payload: {
+    type: number;
+    content?: string;
+    url?: string;
+    name?: string;
+    users?: ForwardUser[];
+    msgs?: ForwardMessage[];
+  };
+}
+
+/** Resolve inner message type to display text for MultipleForward */
+export function resolveInnerMessageText(payload: ForwardMessage["payload"]): string {
+  if (!payload) return "";
+  switch (payload.type) {
+    case MessageType.Text:
+      return payload.content ?? "";
+    case MessageType.Image:
+      return "[图片]";
+    case MessageType.GIF:
+      return "[GIF]";
+    case MessageType.Voice:
+      return "[语音]";
+    case MessageType.Video:
+      return "[视频]";
+    case MessageType.Location:
+      return "[位置信息]";
+    case MessageType.Card:
+      return "[名片]";
+    case MessageType.File:
+      return payload.name ? `[文件: ${payload.name}]` : "[文件]";
+    case MessageType.MultipleForward:
+      return "[合并转发]";
+    default:
+      return payload.content ?? "[消息]";
+  }
+}
+
+/** Resolve MultipleForward payload into readable text */
+export function resolveMultipleForwardText(payload: any): string {
+  const users: ForwardUser[] = payload?.users ?? [];
+  const msgs: ForwardMessage[] = payload?.msgs ?? [];
+  const userMap = new Map<string, string>();
+  for (const u of users) {
+    if (u.uid && u.name) userMap.set(u.uid, u.name);
+  }
+  const lines: string[] = ["[合并转发: 聊天记录]"];
+  for (const m of msgs) {
+    const senderName = userMap.get(m.from_uid) ?? m.from_uid;
+    const content = resolveInnerMessageText(m.payload);
+    lines.push(`${senderName}: ${content}`);
+  }
+  return lines.join("\n");
+}
+
 function resolveContent(payload: BotMessage["payload"], apiUrl?: string, log?: ChannelLogSink, cdnUrl?: string): ResolvedContent {
   if (!payload) return { text: "" };
 
@@ -216,6 +279,9 @@ function resolveContent(payload: BotMessage["payload"], apiUrl?: string, log?: C
       const cardText = cardUid ? `[名片: ${cardName} (${cardUid})]` : `[名片: ${cardName}]`;
       return { text: cardText };
     }
+    case MessageType.MultipleForward: {
+      return { text: resolveMultipleForwardText(payload) };
+    }
     default:
       return { text: payload.content ?? payload.url ?? "" };
   }
@@ -282,7 +348,7 @@ async function resolveFileContent(
 }
 
 /** Placeholder text for non-text API history messages */
-function resolveApiMessagePlaceholder(type?: number, name?: string): string {
+export function resolveApiMessagePlaceholder(type?: number, name?: string): string {
   switch (type) {
     case MessageType.Image: return "[图片]";
     case MessageType.GIF: return "[GIF]";
@@ -291,6 +357,7 @@ function resolveApiMessagePlaceholder(type?: number, name?: string): string {
     case MessageType.File: return `[文件: ${name ?? "未知文件"}]`;
     case MessageType.Location: return "[位置信息]";
     case MessageType.Card: return "[名片]";
+    case MessageType.MultipleForward: return "[合并转发]";
     default: return "[消息]";
   }
 }
@@ -588,9 +655,14 @@ export async function handleInboundMessage(params: {
           .filter((m: any) => m.from_uid !== botUid && (m.content || m.type !== 1))
           .slice(-historyLimit);
         entries = filteredApiMsgs.map((m: any) => {
+          let body = m.content || resolveApiMessagePlaceholder(m.type, m.name);
+          // For MultipleForward, expand the nested messages from full payload
+          if (m.type === MessageType.MultipleForward && m.payload) {
+            body = resolveMultipleForwardText(m.payload);
+          }
           const entry: any = {
             sender: m.from_uid,
-            body: m.content || resolveApiMessagePlaceholder(m.type, m.name),
+            body,
             timestamp: m.timestamp,
           };
           // For media message types, resolve the URL directly (storage is public-read)

package/src/types.ts

@@ -105,6 +105,7 @@ export enum MessageType {
   Location = 6,
   Card = 7,
   File = 8,
+  MultipleForward = 11,
 }
 
 /** Plugin config */