openclaw-dcgchat 0.1.0

package/README.md

@@ -0,0 +1,83 @@
+# OpenClaw DCG Chat 插件
+
+连接 OpenClaw 与 DCG Chat 产品的通道插件。
+
+## 架构
+
+```
+┌──────────┐      WebSocket       ┌──────────────┐      WebSocket      ┌─────────────────────┐
+│ Web 前端 │  ←───────────────→   │  公司后端服务  │  ←───────────────→  │ OpenClaw（工作电脑） │
+└──────────┘                      └──────────────┘   (OpenClaw 主动连)   └─────────────────────┘
+```
+
+- OpenClaw 插件**主动连接**后端的 WebSocket 服务（不需要公网 IP）
+- 后端收到用户消息后转发给 OpenClaw，OpenClaw 回复后发回后端
+
+## 快速开始
+
+### 1. 安装插件
+
+```bash
+pnpm openclaw plugins install -l /path/to/openclaw-dcgchat
+```
+
+### 2. 配置
+
+```bash
+openclaw config set channels.dcgchat.enabled true
+openclaw config set channels.dcgchat.wsUrl "ws://your-backend:8080/openclaw/ws"
+```
+
+### 3. 启动
+
+```bash
+pnpm openclaw gateway
+```
+
+## 消息协议（MVP）
+
+### 下行：后端 → OpenClaw（用户消息）
+
+```json
+{ "type": "message", "userId": "user_001", "text": "你好" }
+```
+
+### 上行：OpenClaw → 后端（Agent 回复）
+
+```json
+{ "type": "reply", "userId": "user_001", "text": "你好！有什么可以帮你的？" }
+```
+
+## 配置项
+
+| 配置键 | 类型 | 说明 |
+|--------|------|------|
+| `channels.dcgchat.enabled` | boolean | 是否启用 |
+| `channels.dcgchat.wsUrl` | string | 后端 WebSocket 地址 |
+
+## 开发
+
+```bash
+# 安装依赖
+pnpm install
+
+# 类型检查
+pnpm typecheck
+```
+
+## 文件结构
+
+- `index.ts` - 插件入口
+- `src/channel.ts` - ChannelPlugin 定义
+- `src/runtime.ts` - 插件 runtime
+- `src/types.ts` - 类型定义
+- `src/monitor.ts` - WebSocket 连接与断线重连
+- `src/bot.ts` - 消息处理与 Agent 调用
+
+## 后续迭代
+
+- [ ] Token 认证
+- [ ] 流式输出
+- [ ] Typing 指示
+- [ ] messageId 去重
+- [ ] 错误消息类型

package/index.ts

@@ -0,0 +1,17 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+import { dcgchatPlugin } from "./src/channel.js";
+import { setDcgchatRuntime } from "./src/runtime.js";
+
+const plugin = {
+  id: "dcgchat",
+  name: "DCG Chat",
+  description: "连接 OpenClaw 与 DCG Chat 产品（WebSocket）",
+  configSchema: emptyPluginConfigSchema(),
+  register(api: OpenClawPluginApi) {
+    setDcgchatRuntime(api.runtime);
+    api.registerChannel({ plugin: dcgchatPlugin });
+  },
+};
+
+export default plugin;

package/openclaw.plugin.json

@@ -0,0 +1,9 @@
+{
+  "id": "dcgchat",
+  "channels": ["dcgchat"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "openclaw-dcgchat",
+  "version": "0.1.0",
+  "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"],
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.5.0",
+    "openclaw": "2026.1.29",
+    "typescript": "^5.7.0"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.1.29"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "channel": {
+      "id": "dcgchat",
+      "label": "DCG Chat",
+      "selectionLabel": "DCG Chat",
+      "docsPath": "/channels/dcgchat",
+      "docsLabel": "dcgchat",
+      "blurb": "连接 OpenClaw 与 DCG Chat 产品",
+      "order": 80
+    },
+    "install": {
+      "npmSpec": "openclaw-dcgchat",
+      "localPath": ".",
+      "defaultChoice": "local"
+    }
+  }
+}

package/src/bot.ts

@@ -0,0 +1,123 @@
+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";
+
+/**
+ * 处理一条用户消息，调用 Agent 并返回回复
+ */
+export async function handleDcgchatMessage(params: {
+  cfg: ClawdbotConfig;
+  msg: InboundMessage;
+  accountId: string;
+  runtime?: RuntimeEnv;
+}): Promise<OutboundReply> {
+  const { cfg, msg, accountId, runtime } = params;
+  const log = runtime?.log ?? console.log;
+  const error = runtime?.error ?? console.error;
+
+  const account = resolveAccount(cfg, accountId);
+  const userId = msg._userId.toString();
+  // const text = msg.text?.trim();
+  const text = msg.content.text?.trim();
+
+  if (!userId || !text) {
+    return { type: "reply", userId: userId || "unknown", text: "[错误] 消息格式不正确" };
+  }
+
+  try {
+    const core = getDcgchatRuntime();
+
+    const route = core.channel.routing.resolveAgentRoute({
+      cfg,
+      channel: "dcgchat",
+      accountId: account.accountId,
+      peer: { kind: "direct", id: userId },
+    });
+
+    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+    const messageBody = `${userId}: ${text}`;
+    const bodyFormatted = core.channel.reply.formatAgentEnvelope({
+      channel: "DCG Chat",
+      from: userId,
+      timestamp: new Date(),
+      envelope: envelopeOptions,
+      body: messageBody,
+    });
+
+    const ctxPayload = core.channel.reply.finalizeInboundContext({
+      Body: bodyFormatted,
+      RawBody: text,
+      CommandBody: text,
+      From: userId,
+      To: `user:${userId}`,
+      SessionKey: route.sessionKey,
+      AccountId: route.accountId,
+      ChatType: "direct",
+      SenderName: userId,
+      SenderId: userId,
+      Provider: "dcgchat" as const,
+      Surface: "dcgchat" as const,
+      MessageSid: `dcg-${Date.now()}-${userId}`,
+      Timestamp: Date.now(),
+      WasMentioned: true,
+      CommandAuthorized: true,
+      OriginatingChannel: "dcgchat" as const,
+      OriginatingTo: `user:${userId}`,
+    });
+
+    const prefixContext = createReplyPrefixContext({ cfg, agentId: route.agentId });
+    const replyChunks: string[] = [];
+
+    const { dispatcher, replyOptions, markDispatchIdle } =
+      core.channel.reply.createReplyDispatcherWithTyping({
+        responsePrefix: prefixContext.responsePrefix,
+        responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+        humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, route.agentId),
+        onReplyStart: async () => {},
+        deliver: async (payload) => {
+          const t = payload.text?.trim();
+          if (t) replyChunks.push(t);
+        },
+        onError: (err, info) => {
+          error(`dcgchat[${accountId}] ${info.kind} reply failed: ${String(err)}`);
+        },
+        onIdle: () => {},
+      });
+
+    log(`dcgchat[${accountId}]: dispatching to agent (session=${route.sessionKey})`);
+
+    await core.channel.reply.dispatchReplyFromConfig({
+      ctx: ctxPayload,
+      cfg,
+      dispatcher,
+      replyOptions: {
+        ...replyOptions,
+        onModelSelected: prefixContext.onModelSelected,
+      },
+    });
+
+    markDispatchIdle();
+
+    const reply = replyChunks.join("\n\n").trim();
+    log(`dcgchat[${accountId}]: dispatch complete, reply length=${reply.length}`);
+
+    // return { type: "reply", userId, text: reply || "[无回复]" };
+    return {
+      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: reply,
+      }
+    }
+
+  } catch (err) {
+    error(`dcgchat[${accountId}]: handle message failed: ${String(err)}`);
+    return { type: "reply", userId, text: `[错误] ${err instanceof Error ? err.message : String(err)}` };
+  }
+}

package/src/channel.ts

@@ -0,0 +1,112 @@
+import type { ChannelPlugin, OpenClawConfig } from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk";
+import type { ResolvedDcgchatAccount, DcgchatConfig } from "./types.js";
+
+export function resolveAccount(cfg: OpenClawConfig, accountId?: string | null): ResolvedDcgchatAccount {
+  const id = accountId ?? DEFAULT_ACCOUNT_ID;
+  const raw = (cfg.channels?.["dcgchat"] as DcgchatConfig | undefined) ?? {};
+  return {
+    accountId: id,
+    enabled: raw.enabled !== false,
+    configured: Boolean(raw.wsUrl),
+    wsUrl: raw.wsUrl ?? "",
+    botToken: raw.botToken ?? "",
+    userId: raw.userId ?? "",
+  };
+}
+
+export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
+  id: "dcgchat",
+  meta: {
+    id: "dcgchat",
+    label: "DCG Chat",
+    selectionLabel: "DCG Chat",
+    docsPath: "/channels/dcgchat",
+    docsLabel: "dcgchat",
+    blurb: "连接 OpenClaw 与 DCG Chat 产品",
+    order: 80,
+  },
+  capabilities: {
+    chatTypes: ["direct"],
+    polls: false,
+    threads: false,
+    media: false,
+    reactions: false,
+    edit: false,
+    reply: true,
+  },
+  reload: { configPrefixes: ["channels.dcgchat"] },
+  configSchema: {
+    schema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        enabled: { type: "boolean" },
+        wsUrl: { type: "string" },
+        botToken: { type: "string" },
+        userId: { type: "string" },
+      },
+    },
+  },
+  config: {
+    listAccountIds: () => [DEFAULT_ACCOUNT_ID],
+    resolveAccount: (cfg, accountId) => resolveAccount(cfg, accountId),
+    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+    setAccountEnabled: ({ cfg, enabled }) => ({
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        "dcgchat": {
+          ...(cfg.channels?.["dcgchat"] as Record<string, unknown> | undefined),
+          enabled,
+        },
+      },
+    }),
+    isConfigured: (account) => account.configured,
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      enabled: account.enabled,
+      configured: account.configured,
+      wsUrl: account.wsUrl,
+      botToken: account.botToken ? "***" : "",
+      userId: account.userId,
+    }),
+  },
+  messaging: {
+    normalizeTarget: (raw) => raw?.trim() || undefined,
+    targetResolver: {
+      looksLikeId: (raw) => Boolean(raw?.trim()),
+      hint: "userId",
+    },
+  },
+  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)}`);
+      return {
+        channel: "dcgchat",
+        messageId: `dcg-${Date.now()}`,
+        chatId: target,
+      };
+    },
+  },
+  gateway: {
+    startAccount: async (ctx) => {
+      const { monitorDcgchatProvider } = await import("./monitor.js");
+      const account = resolveAccount(ctx.cfg, ctx.accountId);
+      if (!account.wsUrl) {
+        ctx.log?.warn(`dcgchat[${account.accountId}]: wsUrl not configured, skipping`);
+        return;
+      }
+      // ctx.log?.info(`dcgchat[${account.accountId}]: connecting to ${account.wsUrl}`);
+      return monitorDcgchatProvider({
+        config: ctx.cfg,
+        runtime: ctx.runtime,
+        abortSignal: ctx.abortSignal,
+        accountId: ctx.accountId,
+      });
+    },
+  },
+};

package/src/monitor.ts

@@ -0,0 +1,159 @@
+import WebSocket from "ws";
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+import { resolveAccount } from "./channel.js";
+import { handleDcgchatMessage } from "./bot.js";
+import type { InboundMessage, OutboundReply } from "./types.js";
+
+export type MonitorDcgchatOpts = {
+  config?: ClawdbotConfig;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  accountId?: string;
+};
+
+const RECONNECT_DELAY_MS = 3000;
+const HEARTBEAT_INTERVAL_MS = 30_000;
+
+function buildConnectUrl(wsUrl: string, botToken: string, userId: string): string {
+  const url = new URL(wsUrl);
+  if (botToken) url.searchParams.set("bot_token", botToken);
+  if (userId) url.searchParams.set("_userId", userId);
+  url.searchParams.set("_domainId", "1000");
+  url.searchParams.set("_appId", "100");
+  return url.toString();
+}
+
+export async function monitorDcgchatProvider(opts: MonitorDcgchatOpts): Promise<void> {
+  const { config, runtime, abortSignal, accountId } = opts;
+  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.wsUrl, account.botToken, account.userId);
+    log(`dcgchat[${account.accountId}]: connecting to ${connectUrl}`);
+    ws = new WebSocket(connectUrl);
+
+    ws.on("open", () => {
+      log(`dcgchat[${account.accountId}]: connected`);
+      startHeartbeat();
+    });
+
+    ws.on("message", async (data) => {
+      log(`dcgchat[${account.accountId}]: on message, ${data.toString()}`);
+      let parsed: { messageType?: string, content: string };
+      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;
+      }
+
+      if (parsed.messageType !== "openclaw_bot_chat") {
+        log(`dcgchat[${account.accountId}]: ignoring unknown messageType: ${parsed.messageType}`);
+        return;
+      }
+
+      parsed.content = JSON.parse(parsed.content)
+
+      const msg = parsed as unknown as InboundMessage;
+      const reply = await handleDcgchatMessage({
+        cfg,
+        msg,
+        accountId: account.accountId,
+        runtime,
+      });
+
+      if (ws?.readyState === WebSocket.OPEN) {
+        const res = {
+          ...reply,
+          content: JSON.stringify(reply.content)
+        }
+        ws.send(JSON.stringify(res));
+      }
+    });
+
+    ws.on("close", () => {
+      stopHeartbeat();
+      log(`dcgchat[${account.accountId}]: disconnected`);
+      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/runtime.ts

@@ -0,0 +1,14 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+let runtime: PluginRuntime | null = null;
+
+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/types.ts

@@ -0,0 +1,66 @@
+/**
+ * 插件配置（channels.dcgchat 下的字段）
+ */
+export type DcgchatConfig = {
+  enabled?: boolean;
+  /** 后端 WebSocket 地址，例如 ws://localhost:8080/openclaw/ws */
+  wsUrl?: string;
+  /** 连接认证 token */
+  botToken?: string;
+  /** 用户标识 */
+  userId?: string;
+};
+
+export type ResolvedDcgchatAccount = {
+  accountId: string;
+  enabled: boolean;
+  configured: boolean;
+  wsUrl: string;
+  botToken: string;
+  userId: string;
+};
+
+/**
+ * 下行消息：后端 → OpenClaw（用户发的消息）
+ */
+// export type InboundMessage = {
+//   type: "message";
+//   userId: string;
+//   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;
+    }
+}
+
+//  {"_userId":40,"content":"{\"bot_token\":\"sk_b7f8a3e1c5d24e6f8a1b3c4d5e6f7a8b\",\"session_id\":\"1\",\"message_id\":\"1\",\"text\":\"你好\"}","messageType":"openclaw_bot_chat","msgId":398599,"source":"server","title":"OPENCLAW机器人对话"}
+
+/**
+ * 上行消息：OpenClaw → 后端（Agent 回复）
+ */
+// export type OutboundReply = {
+//   type: "reply";
+//   userId: string;
+//   text: string;
+// };
+
+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; // ""
+    }
+}