@dcrays/dcgchat 0.1.3 → 0.1.5

package/package.json

@@ -1,26 +1,39 @@
 {
   "name": "@dcrays/dcgchat",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "description": "OpenClaw channel plugin for DCG Chat (WebSocket)",
   "main": "index.ts",
   "license": "MIT",
-  "files": ["index.ts", "src", "openclaw.plugin.json"],
-  "keywords": ["openclaw", "dcgchat", "websocket", "ai"],
+  "files": [
+    "index.ts",
+    "src",
+    "openclaw.plugin.json"
+  ],
+  "keywords": [
+    "openclaw",
+    "dcgchat",
+    "websocket",
+    "ai"
+  ],
   "scripts": {
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "ali-oss": "^6.23.0",
+    "axios": "^1.13.6",
+    "md5": "^2.3.0",
     "ws": "^8.18.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "@types/ws": "^8.5.0",
-    "openclaw": "2026.1.29",
+    "openclaw": "2026.2.13",
+    "tsx": "^4.19.0",
     "typescript": "^5.7.0"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.1.29"
+    "openclaw": ">=2026.2.13"
   },
   "openclaw": {
     "extensions": [

package/src/api.ts

@@ -0,0 +1,62 @@
+import { post } from "./request.js";
+import type { IStsToken, IStsTokenReq } from "./types.js";
+import { getUserTokenCache, setUserTokenCache } from "./userInfo.js";
+
+export const getStsToken = async (name: string, botToken: string) => {
+  // 确保 userToken 已缓存（如果未缓存会自动获取并缓存）
+  await getUserToken(botToken);
+
+  const response = await post<IStsTokenReq, IStsToken>(
+    "/user/getStsToken",
+    {
+      sourceFileName: name,
+      isPrivate: 0,
+    },
+    { botToken },
+  );
+
+  if (!response || !response.data || !response.data.bucket) {
+    throw new Error("获取 OSS 临时凭证失败");
+  }
+
+  return response.data;
+};
+
+/**
+ * 通过 botToken 查询 userToken
+ * @param botToken 机器人 token
+ * @returns userToken
+ */
+export const queryUserTokenByBotToken = async (botToken: string): Promise<string> => {
+  const response = await post<{botToken: string}, {token: string}>("/organization/queryUserTokenByBotToken", {
+    botToken,
+  });
+
+  if (!response || !response.data || !response.data.token) {
+    throw new Error("获取绑定的用户信息失败");
+  }
+
+  return response.data.token;
+};
+
+/**
+ * 获取 userToken（优先从缓存获取，缓存未命中则调用 API）
+ * @param botToken 机器人 token
+ * @returns userToken
+ */
+export const getUserToken = async (botToken: string): Promise<string> => {
+  // 1. 尝试从缓存获取
+  const cachedToken = getUserTokenCache(botToken);
+  if (cachedToken) {
+    return cachedToken;
+  }
+
+  // 2. 缓存未命中，调用 API 获取
+  console.log(`[api] cache miss, fetching userToken for botToken=${botToken.slice(0, 10)}...`);
+  const userToken = await queryUserTokenByBotToken(botToken);
+
+  // 3. 缓存新获取的 token
+  setUserTokenCache(botToken, userToken);
+
+  return userToken;
+};

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,26 @@ export async function handleDcgchatMessage(params: {
         humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, route.agentId),
         onReplyStart: async () => {},
         deliver: async (payload) => {
+          log(`dcgchat[${accountId}][deliver]: received chunk, text length=${payload.text?.length || 0}`);
           const t = payload.text?.trim();
-          if (t) replyChunks.push(t);
+          if (t) {
+            log(`dcgchat[${accountId}][deliver]: sending chunk to user ${msg._userId}, text="${t.slice(0, 50)}..."`);
+            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',
+              },
+            });
+            log(`dcgchat[${accountId}][deliver]: chunk sent successfully`);
+          } else {
+            log(`dcgchat[${accountId}][deliver]: skipping empty chunk`);
+          }
         },
         onError: (err, info) => {
           error(`dcgchat[${accountId}] ${info.kind} reply failed: ${String(err)}`);
@@ -99,13 +231,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[${accountId}]: dispatch complete, sending final state`);
+    params.onChunk({
       messageType: "openclaw_bot_chat",
       _userId: msg._userId,
       source: "client",
@@ -113,12 +240,28 @@ 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',
+      },
+    });
+    log(`dcgchat[${accountId}]: final state sent`);
+
+    markDispatchIdle();
+    log(`dcgchat[${accountId}]: message handling 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,9 @@
 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";
+import { ossUpload } from "./oss.js";
 
 export function resolveAccount(cfg: OpenClawConfig, accountId?: string | null): ResolvedDcgchatAccount {
   const id = accountId ?? DEFAULT_ACCOUNT_ID;
@@ -29,11 +32,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: {
@@ -45,6 +50,7 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
         wsUrl: { type: "string" },
         botToken: { type: "string" },
         userId: { type: "string" },
+        capabilities: { type: "array", items: { type: "string" } },
       },
     },
   },
@@ -81,16 +87,77 @@ 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 -> sendText ${target}: ${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 -> sendMedia ${target}: ${ctx.text + ctx.mediaUrl}`);
+      const ws = getWsConnection()
+       if (ws?.readyState === WebSocket.OPEN) {
+        const {botToken} = resolveAccount(ctx.cfg, ctx.accountId);
+        try {
+          const url = ctx.mediaUrl ? await ossUpload(ctx.mediaUrl, botToken) : '';
+          const fileName = ctx.mediaUrl?.split(/[\\/]/).pop() || ''
+          const content = {
+            messageType: "openclaw_bot_chat",
+            _userId: target,
+            source: "client",
+            content: {
+              bot_token: botToken,
+              response: ctx.text + '\n' +  `[${fileName}](${url})`,
+              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)}`);
+        } catch (error) {
+         const content = {
+            messageType: "openclaw_bot_chat",
+            _userId: target,
+            source: "client",
+            content: {
+              bot_token: botToken,
+              response: ctx.text + '\n' +  ctx.mediaUrl,
+              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,
+      };  
+    },
   },
   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

@@ -1,7 +1,8 @@
-import WebSocket from "ws";
 import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
-import { resolveAccount } from "./channel.js";
+import WebSocket from "ws";
 import { handleDcgchatMessage } from "./bot.js";
+import { resolveAccount } from "./channel.js";
+import { setWsConnection } from "./connection.js";
 import type { InboundMessage, OutboundReply } from "./types.js";
 
 export type MonitorDcgchatOpts = {
@@ -65,7 +66,7 @@ export async function monitorDcgchatProvider(opts: MonitorDcgchatOpts): Promise<
           },
         };
         ws.send(JSON.stringify(heartbeat));
-        log(`dcgchat[${account.accountId}]: heartbeat sent, ${JSON.stringify(heartbeat)}`);
+        // log(`dcgchat[${account.accountId}]: heartbeat sent, ${JSON.stringify(heartbeat)}`);
       }
     }, HEARTBEAT_INTERVAL_MS);
   };
@@ -79,12 +80,13 @@ export async function monitorDcgchatProvider(opts: MonitorDcgchatOpts): Promise<
 
     ws.on("open", () => {
       log(`dcgchat[${account.accountId}]: connected`);
+      setWsConnection(ws);
       startHeartbeat();
     });
 
     ws.on("message", async (data) => {
       log(`dcgchat[${account.accountId}]: on message, ${data.toString()}`);
-      let parsed: { messageType?: string, content: string };
+      let parsed: { messageType?: string; content: string };
       try {
         parsed = JSON.parse(data.toString());
       } catch {
@@ -102,28 +104,29 @@ export async function monitorDcgchatProvider(opts: MonitorDcgchatOpts): Promise<
         return;
       }
 
-      parsed.content = JSON.parse(parsed.content)
+      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", () => {
+    ws.on("close", (code, reason) => {
       stopHeartbeat();
-      log(`dcgchat[${account.accountId}]: disconnected`);
+      setWsConnection(null);
+      log(
+        `dcgchat[${account.accountId}]: disconnected (code=${code}, reason=${reason?.toString() || ""})`,
+      );
       if (shouldReconnect) {
         log(`dcgchat[${account.accountId}]: reconnecting in ${RECONNECT_DELAY_MS}ms...`);
         setTimeout(connect, RECONNECT_DELAY_MS);

package/src/oss.ts

@@ -0,0 +1,72 @@
+import { createReadStream } from "node:fs";
+import OSS from "ali-oss";
+import { getStsToken, getUserToken } from "./api";
+
+
+/** 将 File/路径/Buffer 转为 ali-oss put 所需的 Buffer 或 ReadableStream */
+async function toUploadContent(
+  input: File | string | Buffer,
+): Promise<{ content: Buffer | ReturnType<typeof createReadStream>; fileName: string }> {
+  if (Buffer.isBuffer(input)) {
+    return { content: input, fileName: "file" };
+  }
+  if (typeof input === "string") {
+    return {
+      content: createReadStream(input),
+      fileName: input.split("/").pop() ?? "file",
+    };
+  }
+  // File: ali-oss 需要 Buffer/Stream，用 arrayBuffer 转 Buffer
+  const buf = Buffer.from(await input.arrayBuffer());
+  return { content: buf, fileName: input.name };
+}
+
+export const ossUpload = async (file: File | string | Buffer, botToken: string) => {
+  await getUserToken(botToken);
+
+  const { content, fileName } = await toUploadContent(file);
+  const data = await getStsToken(fileName, botToken);
+
+  const options: OSS.Options = {
+    // 从STS服务获取的临时访问密钥（AccessKey ID和AccessKey Secret）。
+    accessKeyId: data.tempAccessKeyId,
+    accessKeySecret: data.tempAccessKeySecret,
+    // 从STS服务获取的安全令牌（SecurityToken）。
+    stsToken: data.tempSecurityToken,
+    // 填写Bucket名称。
+    bucket: data.bucket,
+    endpoint: data.endPoint,
+    region: data.region,
+    secure: true,
+    // refreshSTSToken: async () => {
+    //   const tokenResponse = await getStsToken(fileName);
+    //   return {
+    //     accessKeyId: tokenResponse.tempAccessKeyId,
+    //     accessKeySecret: tokenResponse.tempAccessKeySecret,
+    //     stsToken: tokenResponse.tempSecurityToken,
+    //   }
+    // },
+    // // 5 seconds
+    // refreshSTSTokenInterval: 5 * 1000,
+    // // // 5 minutes
+    // // refreshSTSTokenInterval: 5 * 60 * 1000,
+  };
+
+  const client = new OSS(options);
+
+  const name = `${data.uploadDir}${data.ossFileKey}`;
+
+  try {
+    const objectResult = await client.put(name, content);
+  if (objectResult?.res?.status !== 200) {
+    throw new Error("OSS 上传失败");
+  }
+  console.log(objectResult.url);
+  // const url = `${data.protocol || 'http'}://${data.bucket}.${data.endPoint}/${data.uploadDir}${data.ossFileKey}`
+  return objectResult.url;
+  } catch (error) {
+    console.error("OSS 上传失败:", error);
+    throw error;
+  }
+};
+

package/src/request.ts

@@ -0,0 +1,194 @@
+import axios from "axios";
+import md5 from "md5";
+import type { IResponse } from "./types.js";
+import { getUserTokenCache } from "./userInfo.js";
+
+export const apiUrlMap = {
+  production: "https://api-gateway.shuwenda.com",
+  test: "https://api-gateway.shuwenda.icu",
+  develop: "https://shenyu-dev.shuwenda.icu",
+};
+
+export const appKey = {
+  production: "2A1C74D315CB4A01BF3DA8983695AFE2",
+  test: "7374A073CCBD4C8CA84FAD33896F0B69",
+  develop: "7374A073CCBD4C8CA84FAD33896F0B69",
+};
+
+export const signKey = {
+  production: "34E9023008EA445AAE6CC075CC954F46",
+  test: "FE93D3322CB94E978CE95BD4AA2A37D7",
+  develop: "FE93D3322CB94E978CE95BD4AA2A37D7",
+};
+
+const env = "test";
+export const version = "1.0.0";
+
+/**
+ * 根据 axios 请求配置生成等价 curl，便于复制给后端排查
+ */
+function toCurl(config: {
+  baseURL?: string;
+  url?: string;
+  method?: string;
+  headers?: Record<string, string | number | undefined>;
+  data?: unknown;
+}): string {
+  const base = config.baseURL ?? "";
+  const path = config.url ?? "";
+  const url = path.startsWith("http")
+    ? path
+    : `${base.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
+  const method = (config.method ?? "GET").toUpperCase();
+  const headers = config.headers ?? {};
+  const parts = ["curl", "-X", method, `'${url}'`];
+  for (const [k, v] of Object.entries(headers)) {
+    if (v !== undefined && v !== "") {
+      parts.push("-H", `'${k}: ${v}'`);
+    }
+  }
+  if (method !== "GET" && config.data !== undefined) {
+    const body = typeof config.data === "string" ? config.data : JSON.stringify(config.data);
+    parts.push("-d", `'${body.replace(/'/g, "'\\''")}'`);
+  }
+  return parts.join(" ");
+}
+
+/**
+ * 生成签名
+ * @param {Object} body 请求体
+ * @param {number} timestamp 时间戳
+ * @param {string} path 请求地址
+ * @param {'production' | 'test' | 'develop'} env 请求环境
+ * @param {string} version 版本号
+ * @returns {string} 大写 MD5 签名
+ */
+export function getSignature(
+  body: Record<string, unknown>,
+  timestamp: number,
+  path: string,
+  env: "production" | "test" | "develop",
+  version: string = "1.0.0",
+) {
+  // 1. 构造 map
+  const map = {
+    timestamp,
+    path,
+    version,
+    ...body,
+  };
+  // 2. 按 key 进行自然排序
+  const sortedKeys = Object.keys(map).sort();
+
+  // 3. 拼接 key + value
+  const signStr =
+    sortedKeys
+      .map((key) => {
+        const val = map[key as keyof typeof map];
+        return val === undefined
+          ? ""
+          : `${key}${typeof val === "object" ? JSON.stringify(val) : val}`;
+      })
+      .join("") + signKey[env];
+
+  // 4. MD5 加密并转大写
+  return md5(signStr).toUpperCase();
+}
+
+function buildHeaders(data: Record<string, unknown>, url: string, userToken?: string) {
+  const timestamp = Date.now();
+
+  const headers: Record<string, string | number> = {
+    "Content-Type": "application/json",
+    appKey: appKey[env],
+    sign: getSignature(data, timestamp, url, env, version),
+    timestamp,
+    version,
+  };
+
+  // 如果提供了 userToken，添加到 headers
+  if (userToken) {
+    headers.authorization = userToken;
+  }
+
+  return headers;
+}
+
+const axiosInstance = axios.create({
+  baseURL: apiUrlMap[env],
+  timeout: 10000,
+});
+
+// 请求拦截器：自动注入 userToken
+axiosInstance.interceptors.request.use(
+  (config) => {
+    // 如果请求配置中已经有 authorization，优先使用
+    if (config.headers?.authorization) {
+      return config;
+    }
+
+    // 从请求上下文中获取 botToken（需要在调用时设置）
+    const botToken = (config as any).__botToken as string | undefined;
+    if (botToken) {
+      const cachedToken = getUserTokenCache(botToken);
+      if (cachedToken) {
+        config.headers = config.headers || {};
+        config.headers.authorization = cachedToken;
+        console.log(`[request] auto-injected userToken from cache for botToken=${botToken.slice(0, 10)}...`);
+      }
+    }
+
+    return config;
+  },
+  (error) => {
+    return Promise.reject(error);
+  },
+);
+
+// 响应拦截器：打印 curl 便于调试
+axiosInstance.interceptors.response.use(
+  (response) => {
+    const curl = toCurl(response.config);
+    console.log("[request] curl for backend:", curl);
+    return response.data;
+  },
+  (error) => {
+    const config = error.config ?? {};
+    const curl = toCurl(config);
+    console.log("[request] curl for backend (failed request):", curl);
+    return Promise.reject(error);
+  },
+);
+
+
+
+/**
+ * POST 请求（支持可选的 userToken 和 botToken）
+ * @param url 请求路径
+ * @param data 请求体
+ * @param options 可选配置
+ * @param options.userToken 直接提供的 userToken（优先级最高）
+ * @param options.botToken 用于从缓存获取 userToken 的 botToken
+ */
+export function post<T = Record<string, unknown>, R = unknown>(
+  url: string,
+  data: T,
+  options?: {
+    userToken?: string;
+    botToken?: string;
+  },
+): Promise<IResponse<R>> {
+  const config: any = {
+    method: "POST",
+    url,
+    data,
+    headers: buildHeaders(data as Record<string, unknown>, url, options?.userToken),
+  };
+
+  // 将 botToken 附加到配置中，供请求拦截器使用
+  if (options?.botToken) {
+    config.__botToken = options.botToken;
+  }
+
+  return axiosInstance.request(config);
+}

package/src/types.ts

@@ -29,17 +29,18 @@ export type ResolvedDcgchatAccount = {
 //   text: string;
 // };
 export type InboundMessage = {
-    messageType: string; // "openclaw_bot_chat",
-    _userId: number;
-    source: string; // 'server',
-    // content: string;
-    content: {
-        bot_token: string;
-        session_id: string;
-        message_id: string;
-        text: string;
-    }
-}
+  messageType: string; // "openclaw_bot_chat",
+  _userId: number;
+  source: string; // 'server',
+  // content: string;
+  content: {
+    bot_token: string;
+    session_id: string;
+    message_id: string;
+    text: string;
+    file_urls?: string[];
+  };
+};
 
 //  {"_userId":40,"content":"{\"bot_token\":\"sk_b7f8a3e1c5d24e6f8a1b3c4d5e6f7a8b\",\"session_id\":\"1\",\"message_id\":\"1\",\"text\":\"你好\"}","messageType":"openclaw_bot_chat","msgId":398599,"source":"server","title":"OPENCLAW机器人对话"}
 
@@ -53,14 +54,46 @@ export type InboundMessage = {
 // };
 
 export type OutboundReply = {
-    messageType: string; // "openclaw_bot_chat",
-    _userId: number; // 100
-    source: string; // 'client',
-    // content: string;
-    content:{
-        bot_token: string; // ""
-        session_id: string; // ""
-        message_id: string; // ""
-        response: string; // ""
-    }
+  messageType: string; // "openclaw_bot_chat",
+  _userId: number; // 100
+  source: string; // 'client',
+  // content: string;
+  content: {
+    bot_token: string; // ""
+    session_id: string; // ""
+    message_id: string; // ""
+    response: string; // ""
+    state: string; // final, chunk
+  };
+};
+
+export interface IResponse<T = unknown> {
+  /** 响应状态码 */
+  code?: number | string;
+  /** 响应数据 */
+  data?: T;
+  /** 响应消息 */
+  message?: string;
+}
+
+export interface IStsToken {
+  bucket: string;
+  endPoint: string;
+  expiration: string;
+  ossFileKey: string;
+  policy: string;
+  region: string;
+  signature: string;
+  sourceFileName: string;
+  stsEndPoint: string;
+  tempAccessKeyId: string;
+  tempAccessKeySecret: string;
+  tempSecurityToken: string;
+  uploadDir: string;
+  protocol: string;
+}
+
+export interface IStsTokenReq {
+  sourceFileName: string
+  isPrivate: number
 }

package/src/userInfo.ts

@@ -0,0 +1,97 @@
+/**
+ * userToken 缓存管理模块
+ * 负责维护 botToken -> userToken 的映射关系，支持自动过期
+ */
+
+// userToken 缓存配置
+const TOKEN_CACHE_DURATION = 60 * 60 * 1000; // 1小时
+
+type TokenCacheEntry = {
+  token: string;
+  expiresAt: number;
+};
+
+// 内存缓存：botToken -> { token, expiresAt }
+const tokenCache = new Map<string, TokenCacheEntry>();
+
+/**
+ * 设置 userToken 缓存
+ * @param botToken 机器人 token
+ * @param userToken 用户 token
+ */
+export function setUserTokenCache(botToken: string, userToken: string): void {
+  const expiresAt = Date.now() + TOKEN_CACHE_DURATION;
+  tokenCache.set(botToken, { token: userToken, expiresAt });
+  console.log(
+    `[token-cache] cached userToken for botToken=${botToken.slice(0, 10)}..., expires at ${new Date(expiresAt).toISOString()}`,
+  );
+}
+
+/**
+ * 获取 userToken 缓存（自动检查过期）
+ * @param botToken 机器人 token
+ * @returns userToken 或 null（未找到或已过期）
+ */
+export function getUserTokenCache(botToken: string): string | null {
+  const entry = tokenCache.get(botToken);
+  if (!entry) {
+    console.log(`[token-cache] no cache found for botToken=${botToken.slice(0, 10)}...`);
+    return null;
+  }
+
+  // 检查是否过期
+  if (Date.now() >= entry.expiresAt) {
+    console.log(`[token-cache] cache expired for botToken=${botToken.slice(0, 10)}..., removing`);
+    tokenCache.delete(botToken);
+    return null;
+  }
+
+  console.log(
+    `[token-cache] cache hit for botToken=${botToken.slice(0, 10)}..., valid until ${new Date(entry.expiresAt).toISOString()}`,
+  );
+  return entry.token;
+}
+
+/**
+ * 清除指定 botToken 的缓存
+ * @param botToken 机器人 token
+ */
+export function clearUserTokenCache(botToken: string): void {
+  tokenCache.delete(botToken);
+  console.log(`[token-cache] cleared cache for botToken=${botToken.slice(0, 10)}...`);
+}
+
+/**
+ * 清除所有缓存
+ */
+export function clearAllUserTokenCache(): void {
+  tokenCache.clear();
+  console.log(`[token-cache] cleared all token cache`);
+}
+
+/**
+ * 获取缓存统计信息（用于调试）
+ */
+export function getTokenCacheStats(): {
+  total: number;
+  valid: number;
+  expired: number;
+} {
+  const now = Date.now();
+  let valid = 0;
+  let expired = 0;
+
+  for (const entry of tokenCache.values()) {
+    if (now < entry.expiresAt) {
+      valid++;
+    } else {
+      expired++;
+    }
+  }
+
+  return {
+    total: tokenCache.size,
+    valid,
+    expired,
+  };
+}