@dcrays/dcgchat 0.1.4 → 0.1.5

package/package.json

@@ -1,22 +1,35 @@
 {
   "name": "@dcrays/dcgchat",
-  "version": "0.1.4",
+  "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.2.13",
+    "tsx": "^4.19.0",
     "typescript": "^5.7.0"
   },
   "peerDependencies": {

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

@@ -192,9 +192,10 @@ export async function handleDcgchatMessage(params: {
         humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, route.agentId),
         onReplyStart: async () => {},
         deliver: async (payload) => {
-          log(`dcgchat[chunk]: ${payload.text}`);
+          log(`dcgchat[${accountId}][deliver]: received chunk, text length=${payload.text?.length || 0}`);
           const t = payload.text?.trim();
           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,
@@ -207,6 +208,9 @@ export async function handleDcgchatMessage(params: {
                 state: 'chunk',
               },
             });
+            log(`dcgchat[${accountId}][deliver]: chunk sent successfully`);
+          } else {
+            log(`dcgchat[${accountId}][deliver]: skipping empty chunk`);
           }
         },
         onError: (err, info) => {
@@ -227,7 +231,7 @@ export async function handleDcgchatMessage(params: {
       },
     });
 
-    log(`dcgchat[chunk]: all_finished`);
+    log(`dcgchat[${accountId}]: dispatch complete, sending final state`);
     params.onChunk({
       messageType: "openclaw_bot_chat",
       _userId: msg._userId,
@@ -240,9 +244,10 @@ export async function handleDcgchatMessage(params: {
         state: 'final',
       },
     });
+    log(`dcgchat[${accountId}]: final state sent`);
 
     markDispatchIdle();
-    log(`dcgchat[${accountId}]: dispatch complete`);
+    log(`dcgchat[${accountId}]: message handling complete`);
 
   } catch (err) {
     error(`dcgchat[${accountId}]: handle message failed: ${String(err)}`);

package/src/channel.ts

@@ -3,6 +3,7 @@ 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;
@@ -49,6 +50,7 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
         wsUrl: { type: "string" },
         botToken: { type: "string" },
         userId: { type: "string" },
+        capabilities: { type: "array", items: { type: "string" } },
       },
     },
   },
@@ -88,7 +90,7 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
     textChunkLimit: 25,
     sendText: async (ctx) => {
       const target = ctx.to || "(implicit)";
-      logDcgchat.info(`[dcgchat][${ctx.accountId ?? DEFAULT_ACCOUNT_ID}] outbound -> : ${ctx.text}`);
+      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);
@@ -114,7 +116,42 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
     },
     sendMedia: async (ctx) => {
       const target = ctx.to || "(implicit)";
-      logDcgchat.info(`[dcgchat][${ctx.accountId ?? DEFAULT_ACCOUNT_ID}] outbound -> ${target}: ${ctx.text}`);
+      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()}`,

package/src/monitor.ts

@@ -1,9 +1,9 @@
-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 type { InboundMessage, OutboundReply } from "./types.js";
+import { resolveAccount } from "./channel.js";
 import { setWsConnection } from "./connection.js";
+import type { InboundMessage, OutboundReply } from "./types.js";
 
 export type MonitorDcgchatOpts = {
   config?: ClawdbotConfig;
@@ -66,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);
   };
@@ -86,7 +86,7 @@ export async function monitorDcgchatProvider(opts: MonitorDcgchatOpts): Promise<
 
     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 {
@@ -104,7 +104,7 @@ 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;
       await handleDcgchatMessage({
@@ -121,10 +121,12 @@ export async function monitorDcgchatProvider(opts: MonitorDcgchatOpts): Promise<
       });
     });
 
-    ws.on("close", () => {
+    ws.on("close", (code, reason) => {
       stopHeartbeat();
       setWsConnection(null);
-      log(`dcgchat[${account.accountId}]: disconnected`);
+      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,18 +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;
-        file_urls?: 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机器人对话"}
 
@@ -54,15 +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; // ""
-        state: string; // final, chunk
-    }
+  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,
+  };
+}