@dcrays/dcgchat 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcrays/dcgchat",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "description": "OpenClaw channel plugin for DCG Chat (WebSocket)",
   "main": "index.ts",
@@ -16,11 +16,11 @@
   "devDependencies": {
     "@types/node": "^22.0.0",
     "@types/ws": "^8.5.0",
-    "openclaw": "2026.1.29",
+    "openclaw": "2026.2.13",
     "typescript": "^5.7.0"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.1.29"
+    "openclaw": ">=2026.2.13"
   },
   "openclaw": {
     "extensions": [

package/src/bot.ts

@@ -1,9 +1,97 @@
+import path from "node:path";
 import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
 import { createReplyPrefixContext } from "openclaw/plugin-sdk";
 import type { InboundMessage, OutboundReply } from "./types.js";
 import { getDcgchatRuntime } from "./runtime.js";
 import { resolveAccount } from "./channel.js";
 
+type MediaInfo = {
+  path: string;
+  contentType: string;
+  placeholder: string;
+};
+
+async function resolveMediaFromUrls(
+  fileUrls: string[],
+  maxBytes: number,
+  log?: (msg: string) => void,
+): Promise<MediaInfo[]> {
+  const core = getDcgchatRuntime();
+  const out: MediaInfo[] = [];
+
+  log?.(`dcgchat media: starting resolve for ${fileUrls.length} file(s): ${JSON.stringify(fileUrls)}`);
+
+  for (let i = 0; i < fileUrls.length; i++) {
+    const url = fileUrls[i];
+    log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] fetching ${url}`);
+    try {
+      const response = await fetch(url);
+      log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] fetch response status=${response.status}, content-type=${response.headers.get("content-type")}, content-length=${response.headers.get("content-length")}`);
+      if (!response.ok) {
+        log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] fetch failed with HTTP ${response.status}, skipping`);
+        continue;
+      }
+      const buffer = Buffer.from(await response.arrayBuffer());
+      log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] downloaded buffer size=${buffer.length} bytes`);
+
+      let contentType = response.headers.get("content-type") || "";
+      if (!contentType) {
+        log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] no content-type header, detecting mime...`);
+        contentType = await core.media.detectMime({ buffer });
+      }
+      log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] resolved contentType=${contentType}`);
+
+      const fileName = path.basename(new URL(url).pathname) || "file";
+      log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] fileName=${fileName}, saving to disk (maxBytes=${maxBytes})...`);
+
+      const saved = await core.channel.media.saveMediaBuffer(
+        buffer,
+        contentType,
+        "inbound",
+        maxBytes,
+        fileName,
+      );
+
+      const isImage = contentType.startsWith("image/");
+      out.push({
+        path: saved.path,
+        contentType: saved.contentType,
+        placeholder: isImage ? "<media:image>" : "<media:file>",
+      });
+
+      log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] saved to ${saved.path} (contentType=${saved.contentType}, isImage=${isImage})`);
+    } catch (err) {
+      log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] FAILED to process ${url}: ${String(err)}`);
+    }
+  }
+
+  log?.(`dcgchat media: resolve complete, ${out.length}/${fileUrls.length} file(s) succeeded`);
+
+  return out;
+}
+
+function buildMediaPayload(mediaList: MediaInfo[]): {
+  MediaPath?: string;
+  MediaType?: string;
+  MediaUrl?: string;
+  MediaPaths?: string[];
+  MediaUrls?: string[];
+  MediaTypes?: string[];
+} {
+  if (mediaList.length === 0) return {};
+  const first = mediaList[0];
+  const mediaPaths = mediaList.map((m) => m.path);
+  const mediaTypes = mediaList.map((m) => m.contentType).filter(Boolean);
+  return {
+    MediaPath: first?.path,
+    MediaType: first?.contentType,
+    MediaUrl: first?.path,
+    MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+    MediaUrls: mediaPaths.length > 0 ? mediaPaths : undefined,
+    MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
+  };
+}
+
 /**
  * 处理一条用户消息，调用 Agent 并返回回复
  */
@@ -12,7 +100,8 @@ export async function handleDcgchatMessage(params: {
   msg: InboundMessage;
   accountId: string;
   runtime?: RuntimeEnv;
-}): Promise<OutboundReply> {
+  onChunk: (reply: OutboundReply) => void;
+}): Promise<void> {
   const { cfg, msg, accountId, runtime } = params;
   const log = runtime?.log ?? console.log;
   const error = runtime?.error ?? console.error;
@@ -23,7 +112,18 @@ export async function handleDcgchatMessage(params: {
   const text = msg.content.text?.trim();
 
   if (!userId || !text) {
-    return { type: "reply", userId: userId || "unknown", text: "[错误] 消息格式不正确" };
+    params.onChunk({
+      messageType: "openclaw_bot_chat",
+      _userId: msg._userId,
+      source: "client",
+      content: {
+        bot_token: msg.content.bot_token,
+        session_id: msg.content.session_id,
+        message_id: msg.content.message_id,
+        response: "[错误] 消息格式不正确",
+      },
+    });
+    return;
   }
 
   try {
@@ -36,6 +136,18 @@ export async function handleDcgchatMessage(params: {
       peer: { kind: "direct", id: userId },
     });
 
+    // 处理用户上传的文件
+    const fileUrls = msg.content.file_urls ?? [];
+    log(`dcgchat[${accountId}]: incoming message from user=${userId}, text="${text?.slice(0, 80)}", file_urls count=${fileUrls.length}`);
+    let mediaPayload: Record<string, unknown> = {};
+    if (fileUrls.length > 0) {
+      log(`dcgchat[${accountId}]: processing ${fileUrls.length} file(s): ${JSON.stringify(fileUrls)}`);
+      const mediaMaxBytes = 30 * 1024 * 1024;
+      const mediaList = await resolveMediaFromUrls(fileUrls, mediaMaxBytes, log);
+      mediaPayload = buildMediaPayload(mediaList);
+      log(`dcgchat[${accountId}]: media resolved ${mediaList.length}/${fileUrls.length} file(s), payload=${JSON.stringify(mediaPayload)}`);
+    }
+
     const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
     // const messageBody = `${userId}: ${text}`;
     const messageBody = text;
@@ -52,24 +164,26 @@ export async function handleDcgchatMessage(params: {
       RawBody: text,
       CommandBody: text,
       From: userId,
-      To: `user:${userId}`,
+      To: userId,
       SessionKey: route.sessionKey,
-      AccountId: route.accountId,
+      AccountId: msg.content.session_id,
       ChatType: "direct",
       SenderName: userId,
       SenderId: userId,
       Provider: "dcgchat" as const,
       Surface: "dcgchat" as const,
-      MessageSid: `dcg-${Date.now()}-${userId}`,
+      MessageSid: msg.content.message_id,
       Timestamp: Date.now(),
       WasMentioned: true,
       CommandAuthorized: true,
       OriginatingChannel: "dcgchat" as const,
       OriginatingTo: `user:${userId}`,
+      ...mediaPayload,
     });
 
+    log(`dcgchat[${accountId}]: ctxPayload=${JSON.stringify(ctxPayload)}`);
+
     const prefixContext = createReplyPrefixContext({ cfg, agentId: route.agentId });
-    const replyChunks: string[] = [];
 
     const { dispatcher, replyOptions, markDispatchIdle } =
       core.channel.reply.createReplyDispatcherWithTyping({
@@ -78,8 +192,22 @@ export async function handleDcgchatMessage(params: {
         humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, route.agentId),
         onReplyStart: async () => {},
         deliver: async (payload) => {
+          log(`dcgchat[chunk]: ${payload.text}`);
           const t = payload.text?.trim();
-          if (t) replyChunks.push(t);
+          if (t) {
+            params.onChunk({
+              messageType: "openclaw_bot_chat",
+              _userId: msg._userId,
+              source: "client",
+              content: {
+                bot_token: msg.content.bot_token,
+                session_id: msg.content.session_id,
+                message_id: msg.content.message_id,
+                response: t,
+                state: 'chunk',
+              },
+            });
+          }
         },
         onError: (err, info) => {
           error(`dcgchat[${accountId}] ${info.kind} reply failed: ${String(err)}`);
@@ -99,13 +227,8 @@ export async function handleDcgchatMessage(params: {
       },
     });
 
-    markDispatchIdle();
-
-    const reply = replyChunks.join("\n\n").trim();
-    log(`dcgchat[${accountId}]: dispatch complete, reply length=${reply.length}`);
-
-    // return { type: "reply", userId, text: reply || "[无回复]" };
-    return {
+    log(`dcgchat[chunk]: all_finished`);
+    params.onChunk({
       messageType: "openclaw_bot_chat",
       _userId: msg._userId,
       source: "client",
@@ -113,12 +236,27 @@ export async function handleDcgchatMessage(params: {
         bot_token: msg.content.bot_token,
         session_id: msg.content.session_id,
         message_id: msg.content.message_id,
-        response: reply,
-      }
-    }
+        response: '',
+        state: 'final',
+      },
+    });
+
+    markDispatchIdle();
+    log(`dcgchat[${accountId}]: dispatch complete`);
 
   } catch (err) {
     error(`dcgchat[${accountId}]: handle message failed: ${String(err)}`);
-    return { type: "reply", userId, text: `[错误] ${err instanceof Error ? err.message : String(err)}` };
+    params.onChunk({
+      messageType: "openclaw_bot_chat",
+      _userId: msg._userId,
+      source: "client",
+      content: {
+        bot_token: msg.content.bot_token,
+        session_id: msg.content.session_id,
+        message_id: msg.content.message_id,
+        response: `[错误] ${err instanceof Error ? err.message : String(err)}`,
+        state: 'final',
+      },
+    });
   }
 }

package/src/channel.ts

@@ -1,6 +1,8 @@
 import type { ChannelPlugin, OpenClawConfig } from "openclaw/plugin-sdk";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk";
 import type { ResolvedDcgchatAccount, DcgchatConfig } from "./types.js";
+import { logDcgchat } from "./log.js";
+import { getWsConnection } from "./connection.js";
 
 export function resolveAccount(cfg: OpenClawConfig, accountId?: string | null): ResolvedDcgchatAccount {
   const id = accountId ?? DEFAULT_ACCOUNT_ID;
@@ -29,11 +31,13 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
   capabilities: {
     chatTypes: ["direct"],
     polls: false,
-    threads: false,
-    media: false,
+    threads: true,
+    media: true,
+    nativeCommands: true,
     reactions: false,
     edit: false,
     reply: true,
+    blockStreaming: true,
   },
   reload: { configPrefixes: ["channels.dcgchat"] },
   configSchema: {
@@ -81,16 +85,42 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
   },
   outbound: {
     deliveryMode: "direct",
-    textChunkLimit: 4000,
-    sendText: async ({ text, to, accountId }) => {
-      const target = to || "(implicit)";
-      console.log(`[dcgchat][${accountId ?? DEFAULT_ACCOUNT_ID}] outbound -> ${target}: ${text?.slice(0, 100)}`);
+    textChunkLimit: 25,
+    sendText: async (ctx) => {
+      const target = ctx.to || "(implicit)";
+      logDcgchat.info(`[dcgchat][${ctx.accountId ?? DEFAULT_ACCOUNT_ID}] outbound -> : ${ctx.text}`);
+      const ws = getWsConnection()
+       if (ws?.readyState === WebSocket.OPEN) {
+        const {botToken} = resolveAccount(ctx.cfg, ctx.accountId);
+        const content = {
+          messageType: "openclaw_bot_chat",
+          _userId: target,
+          source: "client",
+          content: {
+            bot_token: botToken,
+            response: ctx.text,
+            session_id:ctx.accountId ||  Date.now().toString(),
+            message_id: Date.now().toString(),
+          },
+        };
+        ws.send(JSON.stringify(content));
+        logDcgchat.info(`dcgchat[${ctx.accountId}]: sendText to ${target}, ${JSON.stringify(content)}`);
+      }
       return {
         channel: "dcgchat",
         messageId: `dcg-${Date.now()}`,
         chatId: target,
       };
     },
+    sendMedia: async (ctx) => {
+      const target = ctx.to || "(implicit)";
+      logDcgchat.info(`[dcgchat][${ctx.accountId ?? DEFAULT_ACCOUNT_ID}] outbound -> ${target}: ${ctx.text}`);
+      return {
+        channel: "dcgchat",
+        messageId: `dcg-${Date.now()}`,
+        chatId: target,
+      };  
+    },
   },
   gateway: {
     startAccount: async (ctx) => {

package/src/connection.ts

@@ -0,0 +1,11 @@
+import type WebSocket from "ws";
+
+let ws: WebSocket | null = null;
+
+export function setWsConnection(next: WebSocket | null) {
+  ws = next;
+}
+
+export function getWsConnection(): WebSocket | null {
+  return ws;
+}

package/src/log.ts

@@ -0,0 +1,46 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const logsDir = path.resolve(__dirname, "../logs");
+
+function getLogFilePath(): string {
+  const date = new Date();
+  const yyyy = date.getFullYear();
+  const mm = String(date.getMonth() + 1).padStart(2, "0");
+  const dd = String(date.getDate()).padStart(2, "0");
+  return path.join(logsDir, `${yyyy}-${mm}-${dd}.log`);
+}
+
+function formatLine(level: string, message: string, extra?: unknown): string {
+  const now = new Date().toISOString();
+  const suffix = extra !== undefined ? " " + JSON.stringify(extra) : "";
+  return `[${now}] [${level}] ${message}${suffix}\n`;
+}
+
+function writeLog(level: string, message: string, extra?: unknown): void {
+  try {
+    if (!fs.existsSync(logsDir)) {
+      fs.mkdirSync(logsDir, { recursive: true });
+    }
+    fs.appendFileSync(getLogFilePath(), formatLine(level, message, extra), "utf-8");
+  } catch {
+    // 写日志失败时静默处理，避免影响主流程
+  }
+}
+
+export const logDcgchat = {
+  info(message: string, extra?: unknown): void {
+    writeLog("INFO", message, extra);
+  },
+  warn(message: string, extra?: unknown): void {
+    writeLog("WARN", message, extra);
+  },
+  error(message: string, extra?: unknown): void {
+    writeLog("ERROR", message, extra);
+  },
+  debug(message: string, extra?: unknown): void {
+    writeLog("DEBUG", message, extra);
+  },
+};

package/src/monitor.ts

@@ -3,6 +3,7 @@ import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
 import { resolveAccount } from "./channel.js";
 import { handleDcgchatMessage } from "./bot.js";
 import type { InboundMessage, OutboundReply } from "./types.js";
+import { setWsConnection } from "./connection.js";
 
 export type MonitorDcgchatOpts = {
   config?: ClawdbotConfig;
@@ -79,6 +80,7 @@ export async function monitorDcgchatProvider(opts: MonitorDcgchatOpts): Promise<
 
     ws.on("open", () => {
       log(`dcgchat[${account.accountId}]: connected`);
+      setWsConnection(ws);
       startHeartbeat();
     });
 
@@ -105,24 +107,23 @@ export async function monitorDcgchatProvider(opts: MonitorDcgchatOpts): Promise<
       parsed.content = JSON.parse(parsed.content)
 
       const msg = parsed as unknown as InboundMessage;
-      const reply = await handleDcgchatMessage({
+      await handleDcgchatMessage({
         cfg,
         msg,
         accountId: account.accountId,
         runtime,
+        onChunk: (reply) => {
+          if (ws?.readyState === WebSocket.OPEN) {
+            const res = { ...reply, content: JSON.stringify(reply.content) };
+            ws.send(JSON.stringify(res));
+          }
+        },
       });
-
-      if (ws?.readyState === WebSocket.OPEN) {
-        const res = {
-          ...reply,
-          content: JSON.stringify(reply.content)
-        }
-        ws.send(JSON.stringify(res));
-      }
     });
 
     ws.on("close", () => {
       stopHeartbeat();
+      setWsConnection(null);
       log(`dcgchat[${account.accountId}]: disconnected`);
       if (shouldReconnect) {
         log(`dcgchat[${account.accountId}]: reconnecting in ${RECONNECT_DELAY_MS}ms...`);

package/src/types.ts

@@ -38,6 +38,7 @@ export type InboundMessage = {
         session_id: string;
         message_id: string;
         text: string;
+        file_urls?: string[];
     }
 }
 
@@ -62,5 +63,6 @@ export type OutboundReply = {
         session_id: string; // ""
         message_id: string; // ""
         response: string; // ""
+        state: string; // final, chunk
     }
 }