openclaw-channel-dmwork 0.2.31 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-channel-dmwork",
-  "version": "0.2.31",
+  "version": "0.3.0",
   "description": "DMWork channel plugin for OpenClaw via WuKongIM WebSocket",
   "main": "index.ts",
   "type": "module",
@@ -43,5 +43,10 @@
     "crypto-js",
     "curve25519-js",
     "md5-typescript"
+  ],
+  "bundleDependencies": [
+    "crypto-js",
+    "curve25519-js",
+    "md5-typescript"
   ]
 }

package/src/api-fetch.ts

@@ -11,7 +11,7 @@ const DEFAULT_HEADERS = {
   "Content-Type": "application/json",
 };
 
-async function postJson<T>(
+export async function postJson<T>(
   apiUrl: string,
   botToken: string,
   path: string,
@@ -52,6 +52,7 @@ export async function sendMessage(params: {
   mentionUids?: string[];
   mentionAll?: boolean;
   streamNo?: string;
+  replyMsgId?: string;
   signal?: AbortSignal;
 }): Promise<void> {
   const payload: Record<string, unknown> = {
@@ -69,6 +70,10 @@ export async function sendMessage(params: {
     }
     payload.mention = mention;
   }
+  // Add reply field if replyMsgId is provided
+  if (params.replyMsgId) {
+    payload.reply = { message_id: params.replyMsgId };
+  }
   await postJson(params.apiUrl, params.botToken, "/v1/bot/sendMessage", {
     channel_id: params.channelId,
     channel_type: params.channelType,

package/src/channel.ts

@@ -16,6 +16,9 @@ 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";
 // HistoryEntry type - compatible with any version
 type HistoryEntry = { sender: string; body: string; timestamp: number };
 const DEFAULT_GROUP_HISTORY_LIMIT = 20;
@@ -108,6 +111,39 @@ function ensureCleanupTimer(): void {
   }
 }
 
+async function checkForUpdates(
+  apiUrl: string,
+  log?: { info?: (msg: string) => void; error?: (msg: string) => void; warn?: (msg: string) => void },
+): Promise<void> {
+  try {
+    // Check npm version
+    const localVersion = (await import("../package.json", { with: { type: "json" } })).default.version;
+    const resp = await fetch("https://registry.npmjs.org/openclaw-channel-dmwork/latest");
+    if (resp.ok) {
+      const data = await resp.json() as { version?: string };
+      if (data.version && data.version !== localVersion) {
+        log?.info?.(`dmwork: new version available: ${data.version} (current: ${localVersion}). Run: npm install openclaw-channel-dmwork@latest`);
+      }
+    }
+  } catch (err) {
+    log?.error?.(`dmwork: version check failed: ${String(err)}`);
+  }
+
+  try {
+    // Fetch skill.md
+    const skillResp = await fetch(`${apiUrl.replace(/\/+$/, "")}/v1/bot/skill.md`);
+    if (skillResp.ok) {
+      const skillContent = await skillResp.text();
+      const skillDir = path.join(os.homedir(), ".openclaw", "skills", "dmwork");
+      await mkdir(skillDir, { recursive: true });
+      await writeFile(path.join(skillDir, "SKILL.md"), skillContent, "utf-8");
+      log?.info?.("dmwork: updated SKILL.md");
+    }
+  } catch (err) {
+    log?.error?.(`dmwork: skill.md fetch failed: ${String(err)}`);
+  }
+}
+
 const meta = {
   id: "dmwork",
   label: "DMWork",
@@ -275,6 +311,9 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
         `[${account.accountId}] bot registered as ${credentials.robot_id}`,
       );
 
+      // Check for updates in background (fire-and-forget)
+      checkForUpdates(account.config.apiUrl, log).catch(() => {});
+
       ctx.setStatus({
         accountId: account.accountId,
         running: true,

package/src/inbound.ts

@@ -1,5 +1,5 @@
 import type { ChannelLogSink, OpenClawConfig } from "openclaw/plugin-sdk";
-import { sendMessage, sendReadReceipt, sendTyping, getChannelMessages, getGroupMembers } from "./api-fetch.js";
+import { sendMessage, sendReadReceipt, sendTyping, getChannelMessages, getGroupMembers, postJson } from "./api-fetch.js";
 import type { ResolvedDmworkAccount } from "./accounts.js";
 import type { BotMessage } from "./types.js";
 import { ChannelType, MessageType } from "./types.js";
@@ -46,39 +46,165 @@ export type DmworkStatusSink = (patch: {
   lastError?: string | null;
 }) => void;
 
+/** Extract media URLs from deliver payload */
+function resolveOutboundMediaUrls(payload: { mediaUrl?: string; mediaUrls?: string[] }): string[] {
+  return [
+    ...(payload.mediaUrls ?? []),
+    ...(payload.mediaUrl ? [payload.mediaUrl] : []),
+  ].filter(Boolean);
+}
+
+/** Extract filename from a URL path */
+function extractFilename(url: string): string {
+  try {
+    const pathname = new URL(url).pathname;
+    const parts = pathname.split("/");
+    return parts[parts.length - 1] || "file";
+  } catch {
+    return "file";
+  }
+}
+
+/** Upload media to MinIO and send as image/file message */
+async function uploadAndSendMedia(params: {
+  mediaUrl: string;
+  apiUrl: string;
+  botToken: string;
+  channelId: string;
+  channelType: ChannelType;
+  log?: ChannelLogSink;
+}): Promise<void> {
+  const { mediaUrl, apiUrl, botToken, channelId, channelType, log } = params;
+
+  // Fetch the media content
+  const resp = await fetch(mediaUrl);
+  if (!resp.ok) throw new Error(`Failed to fetch media: ${resp.status}`);
+  const buffer = Buffer.from(await resp.arrayBuffer());
+  const contentType = resp.headers.get("content-type") || "application/octet-stream";
+  const filename = extractFilename(mediaUrl);
+
+  // Upload to MinIO via multipart
+  const boundary = `----FormBoundary${Date.now()}`;
+  const bodyParts: Buffer[] = [];
+  const header = `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${filename}"\r\nContent-Type: ${contentType}\r\n\r\n`;
+  const footer = `\r\n--${boundary}--\r\n`;
+  bodyParts.push(Buffer.from(header, "utf-8"));
+  bodyParts.push(buffer);
+  bodyParts.push(Buffer.from(footer, "utf-8"));
+  const body = Buffer.concat(bodyParts);
+
+  const uploadUrl = `${apiUrl.replace(/\/+$/, "")}/v1/bot/upload?type=chat`;
+  const uploadResp = await fetch(uploadUrl, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${botToken}`,
+      "Content-Type": `multipart/form-data; boundary=${boundary}`,
+    },
+    body,
+  });
+  if (!uploadResp.ok) {
+    const text = await uploadResp.text().catch(() => "");
+    throw new Error(`Upload failed (${uploadResp.status}): ${text}`);
+  }
+  const uploadResult = await uploadResp.json() as { path?: string; url?: string };
+  const fileUrl = uploadResult.path ?? uploadResult.url ?? "";
+
+  // Determine message type from MIME
+  const msgType = contentType.startsWith("image/") ? MessageType.Image : MessageType.File;
+
+  log?.info?.(`dmwork: uploaded media as ${msgType === MessageType.Image ? "image" : "file"}: ${filename}`);
+
+  // Send via sendMessage payload
+  await postJson(apiUrl, botToken, "/v1/bot/sendMessage", {
+    channel_id: channelId,
+    channel_type: channelType,
+    payload: {
+      type: msgType,
+      url: fileUrl,
+      name: filename,
+    },
+  });
+}
+
 interface ResolvedContent {
   text: string;
   mediaUrl?: string;
   mediaType?: string;
 }
 
-function resolveContent(payload: BotMessage["payload"]): ResolvedContent {
+function resolveContent(payload: BotMessage["payload"], apiUrl?: string): ResolvedContent {
   if (!payload) return { text: "" };
+
+  const makeFullUrl = (relUrl?: string) => {
+    if (!relUrl) return undefined;
+    if (relUrl.startsWith("http")) return relUrl;
+    return `${apiUrl?.replace(/\/+$/, "")}/v1/bot/file/${relUrl}`;
+  };
+
   switch (payload.type) {
     case MessageType.Text:
       return { text: payload.content ?? "" };
     case MessageType.Image:
-      return { text: "[图片]", mediaUrl: payload.url, mediaType: "image" };
+      return { text: "[图片]", mediaUrl: makeFullUrl(payload.url), mediaType: "image" };
     case MessageType.GIF:
-      return { text: "[GIF]", mediaUrl: payload.url, mediaType: "image" };
+      return { text: "[GIF]", mediaUrl: makeFullUrl(payload.url), mediaType: "image" };
     case MessageType.Voice:
-      return { text: "[语音消息]" };
+      return { text: "[语音消息]", mediaUrl: makeFullUrl(payload.url), mediaType: "audio" };
     case MessageType.Video:
-      return { text: "[视频]", mediaUrl: payload.url, mediaType: "video" };
+      return { text: "[视频]", mediaUrl: makeFullUrl(payload.url), mediaType: "video" };
     case MessageType.File:
-      return { text: `[文件: ${payload.name ?? "未知文件"}]`, mediaUrl: payload.url };
-    case MessageType.Location:
-      return { text: "[位置信息]" };
-    case MessageType.Card:
-      return { text: "[名片]" };
+      return { text: `[文件: ${payload.name ?? "未知文件"}]`, mediaUrl: makeFullUrl(payload.url), mediaType: "file" };
+    case MessageType.Location: {
+      const lat = payload.latitude ?? payload.lat;
+      const lng = payload.longitude ?? payload.lng ?? payload.lon;
+      const locText = lat != null && lng != null ? `[位置信息: ${lat},${lng}]` : "[位置信息]";
+      return { text: locText };
+    }
+    case MessageType.Card: {
+      const cardName = payload.name ?? "未知";
+      const cardUid = payload.uid ?? "";
+      const cardText = cardUid ? `[名片: ${cardName} (${cardUid})]` : `[名片: ${cardName}]`;
+      return { text: cardText };
+    }
     default:
       return { text: payload.content ?? payload.url ?? "" };
   }
 }
 
 /** Extract text-only content for history/quotes (no mediaUrl) */
-function resolveContentText(payload: BotMessage["payload"]): string {
-  return resolveContent(payload).text;
+function resolveContentText(payload: BotMessage["payload"], apiUrl?: string): string {
+  return resolveContent(payload, apiUrl).text;
+}
+
+const TEXT_FILE_EXTENSIONS = new Set([
+  "txt", "html", "htm", "md", "csv", "json", "xml", "yaml", "yml",
+  "log", "py", "js", "ts", "go", "java",
+]);
+
+async function resolveFileContent(
+  url: string,
+  botToken: string,
+  maxBytes = 5 * 1024 * 1024,
+): Promise<string | null> {
+  try {
+    const ext = url.split(".").pop()?.toLowerCase() ?? "";
+    if (!TEXT_FILE_EXTENSIONS.has(ext)) return null;
+
+    const resp = await fetch(url, {
+      headers: { Authorization: `Bearer ${botToken}` },
+      signal: AbortSignal.timeout(30_000),
+    });
+    if (!resp.ok || !resp.body) return null;
+
+    const contentLength = resp.headers.get("content-length");
+    if (contentLength && parseInt(contentLength, 10) > maxBytes) return null;
+
+    const buffer = await resp.arrayBuffer();
+    if (buffer.byteLength > maxBytes) return null;
+    return new TextDecoder().decode(buffer);
+  } catch {
+    return null;
+  }
 }
 
 /** Placeholder text for non-text API history messages */
@@ -219,20 +345,46 @@ export async function handleInboundMessage(params: {
     message.channel_type === ChannelType.Group;
 
   // Parse space_id from channel_id (format: s{spaceId}_{peerId})
+  // For DM, channel_id is a fake channel: s{spaceId}_{uid1}@s{spaceId}_{uid2}
+  // Use LastIndex approach: spaceId is everything between 's' and the last '_' before peerId
   let spaceId = "";
   const effectiveChannelId = isGroup ? message.channel_id! : message.from_uid;
-  const spaceMatch = effectiveChannelId.match(/^s([^_]+)_(.+)$/);
-  if (spaceMatch) {
-    spaceId = spaceMatch[1];
+  if (effectiveChannelId.startsWith("s")) {
+    const lastUnderscore = effectiveChannelId.lastIndexOf("_");
+    if (lastUnderscore > 0) {
+      spaceId = effectiveChannelId.substring(1, lastUnderscore);
+    }
+  }
+  // Also try to extract spaceId from the WS channel_id (compound DM format)
+  if (!spaceId && message.channel_id && message.channel_id.startsWith("s")) {
+    // DM compound: s{spaceId}_{uid1}@s{spaceId}_{uid2}
+    const atIdx = message.channel_id.indexOf("@");
+    const firstPart = atIdx > 0 ? message.channel_id.substring(0, atIdx) : message.channel_id;
+    if (firstPart.startsWith("s")) {
+      const lastUnderscore = firstPart.lastIndexOf("_");
+      if (lastUnderscore > 0) {
+        spaceId = firstPart.substring(1, lastUnderscore);
+      }
+    }
   }
 
+  // Session ID: include spaceId for Space isolation (same user in different Spaces = different sessions)
   const sessionId = isGroup
     ? message.channel_id!
-    : message.from_uid;
+    : spaceId ? `${spaceId}:${message.from_uid}` : message.from_uid;
+
+  const resolved = resolveContent(message.payload, account.config.apiUrl);
+  let rawBody = resolved.text;
+  let inboundMediaUrl = resolved.mediaUrl;
+  // Inline text file content if possible
+  if (resolved.mediaType === "file" && resolved.mediaUrl) {
+    const fileContent = await resolveFileContent(resolved.mediaUrl, account.config.botToken ?? "");
+    if (fileContent) {
+      rawBody = `[文件: ${message.payload.name ?? "未知文件"}]\n\n--- 文件内容 ---\n${fileContent}\n--- 文件结束 ---`;
+      inboundMediaUrl = undefined;
+    }
+  }
 
-  const resolved = resolveContent(message.payload);
-  const rawBody = resolved.text;
-  const inboundMediaUrl = resolved.mediaUrl;
   if (!rawBody) {
     log?.info?.(
       `dmwork: inbound dropped session=${sessionId} reason=empty-content`,
@@ -245,7 +397,7 @@ export async function handleInboundMessage(params: {
   const replyData = message.payload?.reply;
   if (replyData) {
     const replyPayload = replyData.payload;
-    const replyContent = replyPayload?.content ?? (replyPayload ? resolveContentText(replyPayload) : "");
+    const replyContent = replyPayload?.content ?? (replyPayload ? resolveContentText(replyPayload, account.config.apiUrl) : "");
     const replyFrom = replyData.from_uid ?? replyData.from_name ?? "unknown";
     if (replyContent) {
       quotePrefix = `[Quoted message from ${replyFrom}]: ${replyContent}\n---\n`;
@@ -488,9 +640,55 @@ export async function handleInboundMessage(params: {
     .then(() => log?.info?.("dmwork: typing sent OK"))
     .catch((err) => log?.error?.(`dmwork: typing failed: ${String(err)}`));
 
+  const apiUrl = account.config.apiUrl;
+  const botToken = account.config.botToken ?? "";
+
+  // Keep sending typing indicator while AI is processing
+  const typingInterval = setInterval(() => {
+    sendTyping({ apiUrl, botToken, channelId: replyChannelId, channelType: replyChannelType }).catch(() => {});
+  }, 5000);
+
+  // Streaming state
+  let streamNo: string | undefined;
+  let streamFailed = false;
+
+  try {
   await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
     ctx: ctxPayload,
     cfg: config,
+    replyOptions: {
+      onPartialReply: async (partial: { text?: string; mediaUrls?: string[] }) => {
+        if (streamFailed) return;
+        const text = partial.text?.trim();
+        if (!text) return;
+        try {
+          if (!streamNo) {
+            // Start stream
+            const payloadB64 = Buffer.from(JSON.stringify({ type: 1, content: text })).toString("base64");
+            const result = await postJson<{ stream_no: string }>(apiUrl, botToken, "/v1/bot/stream/start", {
+              channel_id: replyChannelId,
+              channel_type: replyChannelType,
+              payload: payloadB64,
+            });
+            streamNo = result?.stream_no;
+            log?.info?.(`dmwork: stream started: ${streamNo}`);
+          } else {
+            // Continue stream
+            await sendMessage({
+              apiUrl,
+              botToken,
+              channelId: replyChannelId,
+              channelType: replyChannelType,
+              content: text,
+              streamNo,
+            });
+          }
+        } catch (err) {
+          log?.error?.(`dmwork: stream partial failed, falling back to deliver: ${String(err)}`);
+          streamFailed = true;
+        }
+      },
+    },
     dispatcherOptions: {
       deliver: async (payload: {
         text?: string;
@@ -498,14 +696,31 @@ export async function handleInboundMessage(params: {
         mediaUrl?: string;
         replyToId?: string | null;
       }) => {
-        const contentParts: string[] = [];
-        if (payload.text) contentParts.push(payload.text);
-        const mediaUrls = [
-          ...(payload.mediaUrls ?? []),
-          ...(payload.mediaUrl ? [payload.mediaUrl] : []),
-        ].filter(Boolean);
-        if (mediaUrls.length > 0) contentParts.push(...mediaUrls);
-        const content = contentParts.join("\n").trim();
+        // Resolve outbound media URLs
+        const outboundMediaUrls = resolveOutboundMediaUrls(payload);
+
+        // Upload and send each media file
+        for (const mediaUrl of outboundMediaUrls) {
+          try {
+            await uploadAndSendMedia({
+              mediaUrl,
+              apiUrl: account.config.apiUrl,
+              botToken: account.config.botToken ?? "",
+              channelId: replyChannelId,
+              channelType: replyChannelType,
+              log,
+            });
+          } catch (err) {
+            log?.error?.(`dmwork: media send failed for ${mediaUrl}: ${String(err)}`);
+          }
+        }
+
+        // If there are no media URLs, fall through to text logic; if there are, only send text if caption exists
+        const content = payload.text?.trim() ?? "";
+        if (!content && outboundMediaUrls.length > 0) {
+          statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+          return;
+        }
         if (!content) return;
 
         // Build mentionUids from @mentions in content, using memberMap to resolve displayName -> uid
@@ -613,9 +828,37 @@ export async function handleInboundMessage(params: {
 
         statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
       },
-      onError: (err, info) => {
+      onError: async (err: unknown, info: { kind: string }) => {
+        clearInterval(typingInterval);
         log?.error?.(`dmwork ${info.kind} reply failed: ${String(err)}`);
+        try {
+          await sendMessage({
+            apiUrl,
+            botToken,
+            channelId: replyChannelId,
+            channelType: replyChannelType,
+            content: "⚠️ 抱歉，处理您的消息时遇到了问题，请稍后重试。",
+          });
+        } catch (sendErr) {
+          log?.error?.(`dmwork: failed to send error message: ${String(sendErr)}`);
+        }
       },
     },
   });
+  } finally {
+    clearInterval(typingInterval);
+    // End stream if one was started (skip if stream failed — deliver handles final message)
+    if (streamNo && !streamFailed) {
+      try {
+        await postJson(apiUrl, botToken, "/v1/bot/stream/end", {
+          stream_no: streamNo,
+          channel_id: replyChannelId,
+          channel_type: replyChannelType,
+        });
+        log?.info?.(`dmwork: stream ended: ${streamNo}`);
+      } catch (err) {
+        log?.error?.(`dmwork: stream end failed: ${String(err)}`);
+      }
+    }
+  }
 }