@dcrays/dcgchat-test 0.1.9

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

@@ -0,0 +1,190 @@
+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 } from "./tool.js";
+import { installSkill, uninstallSkill } from "./skill.js";
+
+export type MonitorDcgchatOpts = {
+  config?: ClawdbotConfig;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  accountId?: string;
+};
+
+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();
+}
+
+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 account = resolveAccount(cfg, accountId ?? "default");
+  const log = runtime?.log ?? console.log;
+  const err = runtime?.error ?? console.error;
+
+  if (!account.wsUrl) {
+    err(`dcgchat[${account.accountId}]: wsUrl not configured`);
+    return;
+  }
+
+  let shouldReconnect = true;
+  let ws: WebSocket | null = null;
+  let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+
+  const stopHeartbeat = () => {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+  };
+
+  const startHeartbeat = () => {
+    stopHeartbeat();
+    heartbeatTimer = setInterval(() => {
+      if (ws?.readyState === WebSocket.OPEN) {
+        const heartbeat = {
+          messageType: "openclaw_bot_heartbeat",
+          _userId: Number(account.userId) || 0,
+          source: "client",
+          content: {
+            bot_token: account.botToken,
+            status: "1",
+          },
+        };
+        ws.send(JSON.stringify(heartbeat));
+        // log(`dcgchat[${account.accountId}]: heartbeat sent, ${JSON.stringify(heartbeat)}`);
+      }
+    }, HEARTBEAT_INTERVAL_MS);
+  };
+
+  const connect = () => {
+    if (!shouldReconnect) return;
+
+    const connectUrl = buildConnectUrl(account as Record<string, any>);
+    log(`dcgchat[${account.accountId}]: connecting to ${connectUrl}`);
+    ws = new WebSocket(connectUrl);
+
+    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: any };
+      try {
+        parsed = JSON.parse(data.toString());
+      } catch {
+        err(`dcgchat[${account.accountId}]: invalid JSON received`);
+        return;
+      }
+
+      if (parsed.messageType === "openclaw_bot_heartbeat") {
+        log(`dcgchat[${account.accountId}]: heartbeat ack received, ${data.toString()}`);
+        return;
+      }
+      try {
+        parsed.content = JSON.parse(parsed.content);
+      } catch {
+        err(`dcgchat[${account.accountId}]: invalid JSON received`);
+        return;
+      }
+      
+      if (parsed.messageType == "openclaw_bot_chat") {
+        const msg = parsed as unknown as InboundMessage;
+        setMsgParams({
+          userId: msg._userId,
+          token: msg.content.bot_token,
+          sessionId: msg.content.session_id,
+          messageId: msg.content.message_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") {
+            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()}`);
+          }
+        } else {
+          log(`dcgchat[${account.accountId}]: openclaw_bot_event unknown operation_type: ${operation_type}, ${data.toString()}`);
+        }
+      } else {
+        log(`dcgchat[${account.accountId}]: ignoring unknown messageType: ${parsed.messageType}`);
+      }
+
+    });
+
+    ws.on("close", (code, reason) => {
+      stopHeartbeat();
+      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);
+      }
+    });
+
+    ws.on("error", (e) => {
+      err(`dcgchat[${account.accountId}]: WebSocket error: ${String(e)}`);
+    });
+  };
+
+  connect();
+
+  await new Promise<void>((resolve) => {
+    if (abortSignal?.aborted) {
+      shouldReconnect = false;
+      ws?.close();
+      resolve();
+      return;
+    }
+    abortSignal?.addEventListener(
+      "abort",
+      () => {
+        log(`dcgchat[${account.accountId}]: stopping`);
+        stopHeartbeat();
+        shouldReconnect = false;
+        ws?.close();
+        resolve();
+      },
+      { once: true },
+    );
+  });
+}

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/runtime.ts

@@ -0,0 +1,38 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+const path = require('path');
+const fs = require('fs');
+function getWorkspacePath() {
+  const current = process.cwd();
+  const workspacePath = path.join(current, '.openclaw/workspace');
+  if (fs.existsSync(workspacePath)) {
+    return workspacePath;
+  }
+  return null;
+}
+
+let runtime: PluginRuntime | null = null;
+let workspaceDir: string = getWorkspacePath();
+
+export function setWorkspaceDir(dir?: string) {
+  if (dir) {
+    workspaceDir = dir;
+  }
+}
+export function getWorkspaceDir(): string {
+  if (!workspaceDir) {
+    throw new Error("Workspace directory not initialized");
+  }
+  return workspaceDir;
+}
+
+export function setDcgchatRuntime(next: PluginRuntime) {
+  runtime = next;
+}
+
+export function getDcgchatRuntime(): PluginRuntime {
+  if (!runtime) {
+    throw new Error("DCG Chat runtime not initialized");
+  }
+  return runtime;
+}

package/src/skill.ts

@@ -0,0 +1,111 @@
+/**  skill utils */
+import axios from 'axios';
+/** @ts-ignore */
+import unzipper from 'unzipper';
+import fs from 'fs';
+import path from 'path';
+import { logDcgchat } from './log.js';
+import { getWorkspaceDir } from './runtime.js';
+import { getWsConnection } from './connection.js';
+
+type ISkillParams = {
+  path: string;
+  code: string;
+}
+
+function sendEvent(msgContent: Record<string, any>) {
+  const ws = getWsConnection()
+  if (ws?.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify({
+      messageType: "openclaw_bot_event",
+      source: "client",
+      content: msgContent
+    }));
+    logDcgchat.info(`技能安装: ${JSON.stringify(msgContent)}`);
+
+  }
+}
+
+export async function installSkill(params: ISkillParams, msgContent: Record<string, any>) {
+  const { path: cdnUrl, code } = params;
+  const workspacePath = getWorkspaceDir();
+  
+  const skillDir = path.join(workspacePath, 'skills', code);
+  
+  // 确保 skills 目录存在
+  const skillsDir = path.join(workspacePath, 'skills');
+  if (!fs.existsSync(skillsDir)) {
+    fs.mkdirSync(skillsDir, { recursive: true });
+  }
+  // 如果目标目录已存在，先删除
+  if (fs.existsSync(skillDir)) {
+    fs.rmSync(skillDir, { recursive: true, force: true });
+  }
+  
+  try {
+    // 下载 zip 文件
+    const response = await axios({
+      method: 'get',
+      url: cdnUrl,
+      responseType: 'stream'
+    });
+    // 创建目标目录
+    fs.mkdirSync(skillDir, { recursive: true });
+    // 解压文件到目标目录，跳过顶层文件夹
+    await new Promise((resolve, reject) => {
+      response.data
+        .pipe(unzipper.Parse())
+        .on('entry', (entry: any) => {
+          const entryPath = entry.path;
+          // 跳过顶层目录，只处理子文件和文件夹
+          const pathParts = entryPath.split('/');
+          if (pathParts.length > 1) {
+            // 移除第一级目录
+            const newPath = pathParts.slice(1).join('/');
+            const targetPath = path.join(skillDir, newPath);
+            
+            if (entry.type === 'Directory') {
+              fs.mkdirSync(targetPath, { recursive: true });
+              entry.autodrain();
+            } else {
+              // 确保父目录存在
+              const parentDir = path.dirname(targetPath);
+              if (!fs.existsSync(parentDir)) {
+                fs.mkdirSync(parentDir, { recursive: true });
+              }
+              entry.pipe(fs.createWriteStream(targetPath));
+            }
+          } else {
+            entry.autodrain();
+          }
+        })
+        .on('close', resolve)
+        .on('error', reject);
+    });
+    sendEvent({ ...msgContent, status: 'ok' })
+  } catch (error) {
+    // 如果安装失败，清理目录
+    if (fs.existsSync(skillDir)) {
+      fs.rmSync(skillDir, { recursive: true, force: true });
+    }
+    sendEvent({ ...msgContent, status: 'fail' })
+  }
+}
+
+export function uninstallSkill(params: Omit<ISkillParams, 'path'>, msgContent: Record<string, any>) {
+  const { code } = params;
+  
+  const workspacePath = getWorkspaceDir();
+  if (!workspacePath) {
+    throw new Error('未找到工作区路径');
+  }
+  
+  const skillDir = path.join(workspacePath, 'skills', code);
+  
+  if (fs.existsSync(skillDir)) {
+    fs.rmSync(skillDir, { recursive: true, force: true });
+    sendEvent({ ...msgContent, status: 'ok' })
+  } else {
+    sendEvent({ ...msgContent, status: 'fail' })
+  }
+}