@dcrays/dcgchat 0.2.19 → 0.2.32

package/src/monitor.ts

@@ -1,196 +1,196 @@
-import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
-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";
-import { setMsgParams,setMsgStatus } from "./tool.js";
-import { installSkill, uninstallSkill } from "./skill.js";
+import type { ClawdbotConfig, RuntimeEnv } from 'openclaw/plugin-sdk'
+import WebSocket from 'ws'
+import { handleDcgchatMessage } from './bot.js'
+import { resolveAccount } from './channel.js'
+import { setWsConnection, getOpenClawConfig } from './utils/global.js'
+import type { InboundMessage } from './types.js'
+import { setMsgParams, setMsgStatus } from './utils/global.js'
+import { installSkill, uninstallSkill } from './skill.js'
+import { dcgLogger } from './utils/log.js'
+import { ignoreToolCommand } from './utils/constant.js'
 
 export type MonitorDcgchatOpts = {
-  config?: ClawdbotConfig;
-  runtime?: RuntimeEnv;
-  abortSignal?: AbortSignal;
-  accountId?: string;
-};
+  config?: ClawdbotConfig
+  runtime?: RuntimeEnv
+  abortSignal?: AbortSignal
+  accountId?: string
+}
 
-const RECONNECT_DELAY_MS = 3000;
-const HEARTBEAT_INTERVAL_MS = 30_000;
+const RECONNECT_DELAY_MS = 3000
+const HEARTBEAT_INTERVAL_MS = 30_000
 
 function buildConnectUrl(account: Record<string, string>): string {
-  const { wsUrl, botToken, userId, domainId, appId } = account;
-  const url = new URL(wsUrl);
-  if (botToken) url.searchParams.set("bot_token", botToken);
-  if (userId) url.searchParams.set("_userId", userId);
-  url.searchParams.set("_domainId", domainId || "1000");
-  url.searchParams.set("_appId", appId || "100");
-  return url.toString();
+  const { wsUrl, botToken, userId, domainId, appId } = account
+  const url = new URL(wsUrl)
+  if (botToken) url.searchParams.set('bot_token', botToken)
+  if (userId) url.searchParams.set('_userId', userId)
+  url.searchParams.set('_domainId', domainId || '1000')
+  url.searchParams.set('_appId', appId || '100')
+  return url.toString()
 }
 
 export async function monitorDcgchatProvider(opts: MonitorDcgchatOpts): Promise<void> {
-  const { config, runtime, abortSignal, accountId } = opts;
-  // @ts-ignore
-  const cfg = config ?? (runtime?.config?.() as ClawdbotConfig | undefined);
-  if (!cfg) {
-    runtime?.error?.("dcgchat: no config available");
-    return;
+  const { abortSignal, accountId } = opts
+
+  const config = getOpenClawConfig()
+  if (!config) {
+    dcgLogger('no config available', 'error')
+    return
   }
 
-  const account = resolveAccount(cfg, accountId ?? "default");
-  const log = runtime?.log ?? console.log;
-  const err = runtime?.error ?? console.error;
+  const account = resolveAccount(config, accountId ?? 'default')
 
   if (!account.wsUrl) {
-    err(`dcgchat[${account.accountId}]: wsUrl not configured`);
-    return;
+    dcgLogger(` wsUrl not configured`, 'error')
+    return
   }
 
-  let shouldReconnect = true;
-  let ws: WebSocket | null = null;
-  let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  let shouldReconnect = true
+  let ws: WebSocket | null = null
+  let heartbeatTimer: ReturnType<typeof setInterval> | null = null
 
   const stopHeartbeat = () => {
     if (heartbeatTimer) {
-      clearInterval(heartbeatTimer);
-      heartbeatTimer = null;
+      clearInterval(heartbeatTimer)
+      heartbeatTimer = null
     }
-  };
+  }
 
   const startHeartbeat = () => {
-    stopHeartbeat();
+    stopHeartbeat()
     heartbeatTimer = setInterval(() => {
       if (ws?.readyState === WebSocket.OPEN) {
         const heartbeat = {
-          messageType: "openclaw_bot_heartbeat",
+          messageType: 'openclaw_bot_heartbeat',
           _userId: Number(account.userId) || 0,
-          source: "client",
+          source: 'client',
           content: {
             bot_token: account.botToken,
-            status: "1",
-          },
-        };
-        ws.send(JSON.stringify(heartbeat));
-        // log(`dcgchat[${account.accountId}]: heartbeat sent, ${JSON.stringify(heartbeat)}`);
+            status: '1'
+          }
+        }
+        ws.send(JSON.stringify(heartbeat))
       }
-    }, HEARTBEAT_INTERVAL_MS);
-  };
+    }, HEARTBEAT_INTERVAL_MS)
+  }
 
   const connect = () => {
-    if (!shouldReconnect) return;
+    if (!shouldReconnect) return
 
-    const connectUrl = buildConnectUrl(account as Record<string, any>);
-    log(`dcgchat[${account.accountId}]: connecting to ${connectUrl}`);
-    ws = new WebSocket(connectUrl);
+    const connectUrl = buildConnectUrl(account as Record<string, any>)
+    dcgLogger(`connecting to ${connectUrl}`)
+    ws = new WebSocket(connectUrl)
 
-    ws.on("open", () => {
-      log(`dcgchat[${account.accountId}]: connected`);
-      setWsConnection(ws);
-      startHeartbeat();
-    });
+    ws.on('open', () => {
+      dcgLogger(`socket connected`)
+      setWsConnection(ws)
+      startHeartbeat()
+    })
 
-    ws.on("message", async (data) => {
-      log(`dcgchat[${account.accountId}]: on message, ${data.toString()}`);
-      let parsed: { messageType?: string; content: any };
+    ws.on('message', async (data) => {
+      let parsed: { messageType?: string; content: any }
       try {
-        parsed = JSON.parse(data.toString());
+        parsed = JSON.parse(data.toString())
       } catch {
-        err(`dcgchat[${account.accountId}]: invalid JSON received`);
-        return;
+        dcgLogger(`用户消息解析失败: invalid JSON received`, 'error')
+        return
       }
 
-      if (parsed.messageType === "openclaw_bot_heartbeat") {
-        log(`dcgchat[${account.accountId}]: heartbeat ack received, ${data.toString()}`);
-        return;
+      dcgLogger(`${parsed?.messageType}, ${data.toString()}`)
+      if (parsed.messageType === 'openclaw_bot_heartbeat') {
+        dcgLogger(`heartbeat ack received, ${data.toString()}`)
+        return
       }
       try {
-        parsed.content = JSON.parse(parsed.content);
+        parsed.content = JSON.parse(parsed.content)
       } catch {
-        err(`dcgchat[${account.accountId}]: invalid JSON received`);
-        return;
+        dcgLogger(`用户消息content字段解析失败: invalid JSON received`, 'error')
+        return
       }
-      
-      if (parsed.messageType == "openclaw_bot_chat") {
-        const msg = parsed as unknown as InboundMessage;
-        setMsgStatus('running');
-        log(`dcgchat[${account.accountId}]: openclaw_bot_chat received, ${JSON.stringify(msg)}`);
+
+      if (parsed.messageType == 'openclaw_bot_chat') {
+        const msg = parsed as unknown as InboundMessage
+        if (!ignoreToolCommand.includes(msg.content.text?.trim())) {
+          setMsgStatus('running')
+        }
+        // 设置获取用户消息消息参数
         setMsgParams({
           userId: msg._userId,
           token: msg.content.bot_token,
           sessionId: msg.content.session_id,
           messageId: msg.content.message_id,
-          domainId: account.domainId ||  1000,
+          domainId: account.domainId || 1000,
           appId: account.appId || '100',
           botId: msg.content.bot_id,
-          agentId: msg.content.agent_id,
-        });
-        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));
-            }
-          },
-        });
-      }  else if (parsed.messageType == "openclaw_bot_event") {
-        const { event_type, operation_type, skill_url, skill_code, skill_id, bot_token, websocket_trace_id } = parsed.content ? parsed.content : {} as Record<string, any>;
-        const content = { event_type, operation_type, skill_url, skill_code, skill_id, bot_token, websocket_trace_id };
-        if (event_type === "skill") {
-          if (operation_type === "install" || operation_type === "enable" || operation_type === "update") { 
-            installSkill({ path: skill_url, code: skill_code }, content, { cfg, accountId: account.accountId, runtime });
-          } else if (operation_type === "remove" || operation_type === "disable") {
-            uninstallSkill({ code: skill_code }, content);
+          agentId: msg.content.agent_id
+        })
+        msg.content.app_id = account.appId || '100'
+        msg.content.domain_id = account.domainId || '1000'
+
+        await handleDcgchatMessage(msg, account.accountId)
+      } else if (parsed.messageType == 'openclaw_bot_event') {
+        const { event_type, operation_type, skill_url, skill_code, skill_id, bot_token, websocket_trace_id } = parsed.content
+          ? parsed.content
+          : ({} as Record<string, any>)
+        const content = {
+          event_type,
+          operation_type,
+          skill_url,
+          skill_code,
+          skill_id,
+          bot_token,
+          websocket_trace_id
+        }
+        if (event_type === 'skill') {
+          if (operation_type === 'install' || operation_type === 'enable' || operation_type === 'update') {
+            installSkill({ path: skill_url, code: skill_code }, content)
+          } else if (operation_type === 'remove' || operation_type === 'disable') {
+            uninstallSkill({ code: skill_code }, content)
           } else {
-            log(`dcgchat[${account.accountId}]: openclaw_bot_event unknown event_type: ${event_type}, ${data.toString()}`);
+            dcgLogger(`openclaw_bot_event unknown event_type: ${event_type}, ${data.toString()}`)
           }
         } else {
-          log(`dcgchat[${account.accountId}]: openclaw_bot_event unknown operation_type: ${operation_type}, ${data.toString()}`);
+          dcgLogger(`openclaw_bot_event unknown operation_type: ${operation_type}, ${data.toString()}`)
         }
       } else {
-        log(`dcgchat[${account.accountId}]: ignoring unknown messageType: ${parsed.messageType}`);
+        dcgLogger(`ignoring unknown messageType: ${parsed.messageType}`, 'error')
       }
+    })
 
-    });
-
-    ws.on("close", (code, reason) => {
-      stopHeartbeat();
-      setWsConnection(null);
-      log(
-        `dcgchat[${account.accountId}]: disconnected (code=${code}, reason=${reason?.toString() || ""})`,
-      );
+    ws.on('close', (code, reason) => {
+      stopHeartbeat()
+      setWsConnection(null)
+      dcgLogger(`disconnected (code=${code}, reason=${reason?.toString() || ''})`, 'error')
       if (shouldReconnect) {
-        log(`dcgchat[${account.accountId}]: reconnecting in ${RECONNECT_DELAY_MS}ms...`);
-        setTimeout(connect, RECONNECT_DELAY_MS);
+        dcgLogger(`reconnecting in ${RECONNECT_DELAY_MS}ms...`)
+        setTimeout(connect, RECONNECT_DELAY_MS)
       }
-    });
+    })
 
-    ws.on("error", (e) => {
-      err(`dcgchat[${account.accountId}]: WebSocket error: ${String(e)}`);
-    });
-  };
+    ws.on('error', (e) => {
+      dcgLogger(`WebSocket error: ${String(e)}`, 'error')
+    })
+  }
 
-  connect();
+  connect()
 
   await new Promise<void>((resolve) => {
     if (abortSignal?.aborted) {
-      shouldReconnect = false;
-      ws?.close();
-      resolve();
-      return;
+      shouldReconnect = false
+      ws?.close()
+      resolve()
+      return
     }
     abortSignal?.addEventListener(
-      "abort",
+      'abort',
       () => {
-        log(`dcgchat[${account.accountId}]: stopping`);
-        stopHeartbeat();
-        shouldReconnect = false;
-        ws?.close();
-        resolve();
+        dcgLogger(`socket stopping`)
+        stopHeartbeat()
+        shouldReconnect = false
+        ws?.close()
+        resolve()
       },
-      { once: true },
-    );
-  });
+      { once: true }
+    )
+  })
 }

package/src/{api.ts → request/api.ts}

@@ -1,49 +1,46 @@
-import { post } from "./request.js";
-import type { IStsToken, IStsTokenReq } from "./types.js";
-import { getUserTokenCache, setUserTokenCache } from "./userInfo.js";
+import { post } from './request.js'
+import type { IStsToken, IStsTokenReq } from '../types.js'
+import { getUserTokenCache, setUserTokenCache } from './userInfo.js'
+import { dcgLogger } from '../utils/log.js'
 
 export const getStsToken = async (name: string, botToken: string) => {
   // 确保 userToken 已缓存（如果未缓存会自动获取并缓存）
-  await getUserToken(botToken);
+  await getUserToken(botToken)
 
   const response = await post<IStsTokenReq, IStsToken>(
-    "/user/getStsToken",
+    '/user/getStsToken',
     {
       sourceFileName: name,
-      isPrivate: 1,
+      isPrivate: 1
     },
-    { botToken },
-  );
+    { botToken }
+  )
 
   if (!response || !response.data || !response.data.bucket) {
-    throw new Error("获取 OSS 临时凭证失败");
+    throw new Error('获取 OSS 临时凭证失败')
   }
 
-  return response.data;
-};
+  return response.data
+}
 export const generateSignUrl = async (file_url: string, botToken: string) => {
   try {
     // 确保 userToken 已缓存（如果未缓存会自动获取并缓存）
-    await getUserToken(botToken);
-  
+    await getUserToken(botToken)
+
     const response = await post<any>(
-      "/user/generateSignUrl",
-      {
-        loudPlatform: 0,
-        fileName: file_url
-      },
-      { botToken },
-    );
+      '/user/generateSignUrl',
+      { loudPlatform: 0, fileName: file_url },
+      { botToken }
+    )
     if (response.code === 0 && response.data) {
       // @ts-ignore
       return response.data?.filePath
     }
     return ''
-    
   } catch (error) {
     return ''
   }
-};
+}
 
 /**
  * 通过 botToken 查询 userToken
@@ -51,16 +48,18 @@ export const generateSignUrl = async (file_url: string, botToken: string) => {
  * @returns userToken
  */
 export const queryUserTokenByBotToken = async (botToken: string): Promise<string> => {
-  const response = await post<{botToken: string}, {token: string}>("/organization/queryUserTokenByBotToken", {
-    botToken,
-  });
+  const response = await post<{ botToken: string }, { token: string }>(
+    '/organization/queryUserTokenByBotToken',
+    { botToken }
+  )
 
   if (!response || !response.data || !response.data.token) {
-    throw new Error("获取绑定的用户信息失败");
+    dcgLogger('获取绑定的用户信息失败', 'error')
+    return ''
   }
 
-  return response.data.token;
-};
+  return response.data.token
+}
 
 /**
  * 获取 userToken（优先从缓存获取，缓存未命中则调用 API）
@@ -69,17 +68,17 @@ export const queryUserTokenByBotToken = async (botToken: string): Promise<string
  */
 export const getUserToken = async (botToken: string): Promise<string> => {
   // 1. 尝试从缓存获取
-  const cachedToken = getUserTokenCache(botToken);
+  const cachedToken = getUserTokenCache(botToken)
   if (cachedToken) {
-    return cachedToken;
+    return cachedToken
   }
 
   // 2. 缓存未命中，调用 API 获取
-  console.log(`[api] cache miss, fetching userToken for botToken=${botToken.slice(0, 10)}...`);
-  const userToken = await queryUserTokenByBotToken(botToken);
+  dcgLogger(`[api] cache miss, fetching userToken for botToken=${botToken.slice(0, 10)}...`)
+  const userToken = await queryUserTokenByBotToken(botToken)
 
   // 3. 缓存新获取的 token
-  setUserTokenCache(botToken, userToken);
+  setUserTokenCache(botToken, userToken)
 
-  return userToken;
-};
+  return userToken
+}

package/src/request/oss.ts

@@ -0,0 +1,58 @@
+import { createReadStream } from 'node:fs'
+// @ts-ignore
+import OSS from 'ali-oss'
+import { getStsToken, getUserToken } from './api.js'
+import { dcgLogger } from '../utils/log.js'
+
+/** 将 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
+  }
+
+  const client = new OSS(options)
+
+  const name = `${data.uploadDir}${data.ossFileKey}`
+
+  try {
+    const objectResult = await client.put(name, content)
+    if (objectResult?.res?.status !== 200) {
+      dcgLogger(`OSS 上传失败, ${objectResult?.res?.status}`)
+    }
+    dcgLogger(JSON.stringify(objectResult))
+    return objectResult.name || objectResult.url
+  } catch (error) {
+    dcgLogger(`OSS 上传失败: ${error}`, 'error')
+  }
+}