openclaw-plugin-wecom 0.3.1 → 0.3.3

package/README.md

@@ -1,135 +1,190 @@
-# OpenClaw WeCom AI Bot Plugin
+# OpenClaw WeCom (Enterprise WeChat) AI Bot Plugin
 
 [简体中文](https://github.com/sunnoy/openclaw-plugin-wecom/blob/main/README_ZH.md) | [English](https://github.com/sunnoy/openclaw-plugin-wecom/blob/main/README.md)
 
-`openclaw-plugin-wecom` is an enterprise WeChat (WeCom) integration plugin specifically developed for the [OpenClaw](https://github.com/sunnoy/openclaw-plugin-wecom) framework. It allows you to seamlessly integrate powerful AI capabilities into WeCom with support for multiple advanced features.
+`openclaw-plugin-wecom` is a WeCom (Enterprise WeChat) integration plugin developed for the [OpenClaw](https://github.com/openclaw/openclaw) framework. It enables seamless integration of powerful AI capabilities into WeCom with advanced features.
 
 ## ✨ Key Features
 
-- 🌊 **Streaming Output**: Based on the latest WeCom AI Bot streaming mechanism for a smooth typing-like response experience.
-- 🤖 **Dynamic Agent Management**: Automatically creates an independent Agent per DM user and per group chat. Each Agent has its own workspace and conversation history, keeping data isolated by default.
-- 👥 **Deep Group Chat Integration**: Supports group message parsing and precise triggering via @mentions.
-- 🛠️ **Enhanced Commands**: Built-in support for common commands (e.g., `/new` for a new session, `/status` to check status) with command allowlist configuration.
-- 🔒 **Security & Authentication**: Full support for WeCom message encryption/decryption, URL verification, and sender identity validation.
-- ⚡ **High-Performance Async Processing**: Uses an asynchronous message processing architecture to ensure high responsiveness of the WeCom gateway even during long-running AI inference.
+- 🌊 **Streaming Output**: Smooth typewriter-style responses using WeCom's latest AI bot streaming mechanism.
+- 🤖 **Dynamic Agent Management**: Automatically creates independent Agents per user/group chat with isolated workspaces and conversation contexts.
+- 👥 **Group Chat Integration**: Full support for group messages with @mention triggering.
+- 🛠️ **Command Support**: Built-in commands (`/new`, `/status`, `/help`, `/compact`) with configurable whitelist.
+- 🔒 **Security**: Complete support for WeCom message encryption/decryption and sender verification.
+- ⚡ **Async Processing**: High-performance async architecture ensures gateway responsiveness during AI inference.
 
-## 🤖 Dynamic Agent Routing (How it works)
+## 🚀 Quick Start
 
-OpenClaw decides which Agent to run by parsing `SessionKey`. This plugin uses that mechanism to provide per-user / per-group isolation:
+### Option 1: Docker Deployment (Recommended)
 
-1. When a WeCom message arrives, the plugin generates a deterministic `agentId`:
-   - DM: `wxwork-dm-<userId>`
-   - Group: `wxwork-group-<chatId>`
-2. The plugin routes the message by setting `SessionKey` to:
-   - `agent:<agentId>:<peerKind>:<peerId>`
-3. OpenClaw extracts `<agentId>` from `SessionKey` and will automatically create / reuse the Agent workspace (typically under `~/.openclaw/workspace-<agentId>` for non-default agents).
+This repository provides a complete Docker deployment solution that **deploys OpenClaw + WeCom plugin in one step**, with automated installation and configuration.
 
-### Multi-tenant by design
+```bash
+# 1. Clone the repository
+git clone https://github.com/sunnoy/openclaw-plugin-wecom.git
+cd openclaw-plugin-wecom/deploy
 
-Dynamic agents act like lightweight “tenants”:
+# 2. Copy environment configuration
+cp .env.example .env
 
-- **Per-user / per-group isolation**: each DM user or group chat maps to a dedicated Agent with its own workspace and session store keys.
-- **No extra infra**: no database or tenant registry needed — routing is derived deterministically from the inbound identity.
+# 3. Edit .env file with your settings
+vim .env
 
-### Dynamic agent config (local config keys)
+# 4. Run deployment script
+./deploy.sh
+```
 
-All keys live under `channels.wxwork`:
+The deployment script automatically:
+- Creates data directories and sets permissions
+- Generates configuration files
+- Starts Docker containers
+- Installs the WeCom plugin
+- Configures and restarts services
 
-- `dynamicAgents.enabled` (boolean, default: `true`): enable/disable per-user/per-group agents.
-- `dm.createAgentOnFirstMessage` (boolean, default: `true`): whether DMs should use dynamic agents.
-- `groupChat.enabled` (boolean, default: `true`): enable group chat handling.
-- `groupChat.createAgentOnFirstMessage` (boolean, default: `true`): whether group chats should use dynamic agents.
-- `groupChat.requireMention` (boolean, default: `true`): require an @mention to respond in groups.
-- `groupChat.mentionPatterns` (string[], default: `["@"]`): patterns treated as “mention”.
+#### 🌟 Deployment Highlights
 
-If you prefer all WeCom messages to use OpenClaw’s **default Agent**, disable dynamic agents:
+**Custom Data Directory & Agent Workspace Paths**
 
-```json
-{
-  "channels": {
-    "wxwork": {
-      "dynamicAgents": { "enabled": false }
-    }
-  }
-}
+The core advantage of this deployment is unified data storage in a custom path, effectively utilizing data disks:
+
+```bash
+# .env configuration example
+OPENCLAW_DATA_DIR=/data/openclaw    # Custom data directory
 ```
 
-## 🚀 Quick Start
+- **OpenClaw State Directory**: `/data/openclaw/`
+- **Dynamic Agent Workspace**: `/data/openclaw/.openclaw/` 
+- **Plugin Directory**: `/data/openclaw/extensions/`
+- **Canvas Data**: `/data/openclaw/canvas/`
+
+Benefits:
+- ✅ All Agent workspace data stored on data disk, avoiding system disk usage
+- ✅ Independent Agent files for each user/group managed under unified path
+- ✅ Easy backup, migration, and expansion
+- ✅ Enterprise-ready deployment with independently mountable data disks
 
-### 1. Install Plugin
+### Option 2: Manual Plugin Installation
 
-Run the following in your OpenClaw project directory:
+Install in an existing OpenClaw environment:
 
 ```bash
 openclaw plugins install openclaw-plugin-wecom
 ```
 
-Alternatively (if you're managing plugins via `package.json` yourself):
+Or via npm:
 
 ```bash
 npm install openclaw-plugin-wecom
 ```
 
-### 2. Configure Plugin
-
-Add the plugin configuration to your OpenClaw configuration file (e.g., `config.json`):
+Then add to your OpenClaw configuration:
 
 ```json
 {
   "plugins": {
     "entries": {
-      "openclaw-plugin-wecom": { "enabled": true }
+      "wecom": { "enabled": true }
     }
   },
   "channels": {
-    "wxwork": {
+    "wecom": {
       "enabled": true,
-      "token": "YOUR_TOKEN",
-      "encodingAesKey": "YOUR_ENCODING_AES_KEY",
-      "webhookPath": "/webhooks/wxwork",
-      "accounts": {
-        "default": {
-          "allowFrom": ["*"]
-        }
-      },
-      "commands": {
-        "enabled": true,
-        "allowlist": ["/new", "/status", "/help", "/compact"]
-      },
-      "dynamicAgents": {
-        "enabled": true
-      }
+      "token": "Your Token",
+      "encodingAesKey": "Your EncodingAESKey"
     }
   }
 }
 ```
 
-### 3. WeCom Admin Portal Setup
+### WeCom Backend Setup
 
-1. Create an "AI Bot" in the WeCom management backend.
-2. Set the "Message Receiving Configuration" URL to your service address (e.g., `https://your-domain.com/webhooks/wxwork`).
-3. Fill in the corresponding Token and EncodingAESKey.
+1. Create an "Intelligent Bot" in WeCom Admin Console.
+2. Set the "Receive Message" URL to your service address (e.g., `https://your-domain.com/webhooks/wecom`).
+3. Enter the corresponding Token and EncodingAESKey.
 
-## 🛠️ Command Support
+## 📂 Project Structure
 
-The plugin has built-in handling for the following commands:
+```
+openclaw-plugin-wecom/
+├── deploy/                      # Deployment files
+│   ├── deploy.sh               # One-click deployment script
+│   ├── docker-compose.yml      # Docker Compose configuration
+│   ├── .env.example            # Environment variables template
+│   ├── openclaw.json.base      # Base configuration template
+│   └── openclaw.json.template  # Full configuration template
+├── Dockerfile                   # OpenClaw image build file
+├── local.sh                     # Local image build script
+├── index.js                     # Plugin entry point
+├── webhook.js                   # WeCom HTTP communication
+├── dynamic-agent.js             # Dynamic Agent routing
+├── stream-manager.js            # Streaming response management
+├── crypto.js                    # WeCom encryption
+└── client.js                    # Client logic
+```
 
-- `/new`: Reset current conversation and start a new session.
-- `/compact`: Compact session context, keeping key summaries to save tokens.
-- `/help`: View help information.
-- `/status`: View current Agent and plugin status.
+## 🤖 Dynamic Agent Routing
 
-## 📂 Project Structure
+The plugin implements per-user/per-group isolation:
+
+1. On message arrival, generates a deterministic `agentId`:
+   - DM: `wecom-dm-<userId>`
+   - Group: `wecom-group-<chatId>`
+2. OpenClaw automatically creates/reuses the corresponding Agent workspace.
+
+### Configuration Options
+
+Under `channels.wecom`:
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `dynamicAgents.enabled` | boolean | `true` | Enable dynamic Agents |
+| `dm.createAgentOnFirstMessage` | boolean | `true` | Use dynamic Agent for DMs |
+| `groupChat.enabled` | boolean | `true` | Enable group chat handling |
+| `groupChat.requireMention` | boolean | `true` | Require @mention in groups |
+
+To route all messages to the default Agent:
+
+```json
+{
+  "channels": {
+    "wecom": {
+      "dynamicAgents": { "enabled": false }
+    }
+  }
+}
+```
+
+## 🛠️ Command Whitelist
+
+To prevent regular users from executing sensitive Gateway management commands via WeCom messages, this plugin supports a **command whitelist** mechanism. Only commands in the whitelist will be executed; others are ignored.
+
+> 💡 **Note**: This configuration is already included in `deploy/openclaw.json.template` and takes effect automatically upon deployment.
+
+```json
+{
+  "channels": {
+    "wecom": {
+      "commands": {
+        "enabled": true,
+        "allowlist": ["/new", "/status", "/help", "/compact"]
+      }
+    }
+  }
+}
+```
+
+| Command | Description | Security Level |
+|---------|-------------|----------------|
+| `/new` | Reset conversation, start fresh | ✅ User-level |
+| `/compact` | Compress conversation context | ✅ User-level |
+| `/help` | Show help information | ✅ User-level |
+| `/status` | Show Agent status | ✅ User-level |
 
-- `index.js`: Plugin entry point, handling all core routing and lifecycle management.
-- `webhook.js`: Handles WeCom HTTP communication, encryption/decryption, and message parsing.
-- `dynamic-agent.js`: Dynamic Agent allocation logic.
-- `stream-manager.js`: Manages the state and data partitioning of streaming responses.
-- `crypto.js`: Implementation of WeCom encryption algorithms.
+> ⚠️ **Security Note**: Do not add `/gateway`, `/plugins`, or other management commands to the whitelist to prevent regular users from gaining Gateway instance admin privileges.
 
 ## 🤝 Contributing
 
-We welcome contributions! If you find a bug or have suggestions for new features, please submit an Issue or Pull Request.
+We welcome contributions! Please submit Issues or Pull Requests for bugs or feature suggestions.
 
 ## 📄 License
 

package/README_ZH.md

@@ -2,130 +2,185 @@
 
 [简体中文](https://github.com/sunnoy/openclaw-plugin-wecom/blob/main/README_ZH.md) | [English](https://github.com/sunnoy/openclaw-plugin-wecom/blob/main/README.md)
 
-`openclaw-plugin-wecom` 是一个专为 [OpenClaw](https://github.com/sunnoy/openclaw-plugin-wecom) 框架开发的企业微信（WeCom）集成插件。它允许你将强大的 AI 能力无缝接入企业微信，并支持多项高级功能。
+`openclaw-plugin-wecom` 是一个专为 [OpenClaw](https://github.com/openclaw/openclaw) 框架开发的企业微信（WeCom）集成插件。它允许你将强大的 AI 能力无缝接入企业微信，并支持多项高级功能。
 
 ## ✨ 核心特性
 
 - 🌊 **流式输出 (Streaming)**: 基于企业微信最新的 AI 机器人流式分片机制，实现流畅的打字机式回复体验。
-- 🤖 **动态 Agent 管理**: 默认按“每个私聊用户 / 每个群聊”自动创建独立 Agent。每个 Agent 拥有独立的工作区与对话上下文，实现更强的数据隔离。
+- 🤖 **动态 Agent 管理**: 默认按"每个私聊用户 / 每个群聊"自动创建独立 Agent。每个 Agent 拥有独立的工作区与对话上下文，实现更强的数据隔离。
 - 👥 **群聊深度集成**: 支持群聊消息解析，可通过 @提及（At-mention）精准触发机器人响应。
 - 🛠️ **指令增强**: 内置常用指令支持（如 `/new` 开启新会话、`/status` 查看状态等），并提供指令白名单配置功能。
 - 🔒 **安全与认证**: 完整支持企业微信消息加解密、URL 验证及发送者身份校验。
 - ⚡ **高性能异步处理**: 采用异步消息处理架构，确保即使在长耗时 AI 推理过程中，企业微信网关也能保持高响应性。
 
-## 🤖 动态 Agent 路由（工作原理）
+## 🚀 快速开始
 
-OpenClaw 会通过解析 `SessionKey` 来决定本次消息由哪个 Agent 处理。本插件利用这一机制实现“按人/按群隔离”：
+### 方式一：Docker 一键部署（推荐）
 
-1. 企业微信消息到达后，插件会生成一个确定性的 `agentId`：
-   - 私聊：`wxwork-dm-<userId>`
-   - 群聊：`wxwork-group-<chatId>`
-2. 插件将消息路由到该 Agent：把 `SessionKey` 设为
-   - `agent:<agentId>:<peerKind>:<peerId>`
-3. OpenClaw 从 `SessionKey` 中提取 `<agentId>`，并自动创建/复用对应的 Agent 工作区（非默认 Agent 通常落在 `~/.openclaw/workspace-<agentId>`）。
+本仓库提供了完整的 Docker 部署方案，**一键部署 OpenClaw + 企业微信插件**，包含自动化安装和配置。
 
-### 多租户（按人/按群隔离）亮点
+```bash
+# 1. 克隆仓库
+git clone https://github.com/sunnoy/openclaw-plugin-wecom.git
+cd openclaw-plugin-wecom/deploy
 
-动态 Agent 可以理解为“轻量多租户”实现：
+# 2. 复制环境变量配置
+cp .env.example .env
 
-- **按用户/按群聊隔离**：每个私聊用户、每个群聊都映射到独立 Agent，拥有独立 workspace 与会话存储 key。
-- **无需额外基础设施**：不需要租户表/数据库；路由完全由消息身份确定性推导得到。
+# 3. 编辑 .env 文件，填写实际配置
+vim .env
 
-### 动态 Agent 配置（本地配置项）
+# 4. 运行部署脚本
+./deploy.sh
+```
 
-配置都在 `channels.wxwork` 下：
+部署脚本会自动执行：
+- 创建数据目录和设置权限
+- 生成配置文件
+- 启动 Docker 容器
+- 安装企业微信插件
+- 配置并重启服务
 
-- `dynamicAgents.enabled`（boolean，默认：`true`）：是否启用按人/按群动态 Agent。
-- `dm.createAgentOnFirstMessage`（boolean，默认：`true`）：私聊是否使用动态 Agent。
-- `groupChat.enabled`（boolean，默认：`true`）：是否启用群聊处理。
-- `groupChat.createAgentOnFirstMessage`（boolean，默认：`true`）：群聊是否使用动态 Agent。
-- `groupChat.requireMention`（boolean，默认：`true`）：群聊是否必须 @ 提及才响应。
-- `groupChat.mentionPatterns`（string[]，默认：`["@"]`）：哪些字符串算作“提及”。
+#### 🌟 部署亮点
 
-如果你希望企业微信消息全部进入 OpenClaw 的**默认 Agent**，可以关闭动态 Agent：
+**自定义数据目录 & Agent Workspace 路径**
 
-```json
-{
-  "channels": {
-    "wxwork": {
-      "dynamicAgents": { "enabled": false }
-    }
-  }
-}
+本部署方案的核心优势是将所有数据统一存储到自定义路径，有效利用数据盘：
+
+```bash
+# .env 配置示例
+OPENCLAW_DATA_DIR=/data/openclaw    # 自定义数据目录
 ```
 
-## 🚀 快速开始
+- **OpenClaw 状态目录**：`/data/openclaw/`
+- **动态 Agent Workspace**：`/data/openclaw/.openclaw/` 
+- **插件目录**：`/data/openclaw/extensions/`
+- **Canvas 数据**：`/data/openclaw/canvas/`
+
+这意味着：
+- ✅ 所有 Agent 工作区数据存储在数据盘，避免占用系统盘空间
+- ✅ 每个用户/群聊的独立 Agent 文件都在统一路径下管理
+- ✅ 方便备份、迁移和扩容
+- ✅ 适合企业级部署，数据盘可独立挂载和扩展
 
-### 1. 安装插件
+### 方式二：手动安装插件
 
-在你的 OpenClaw 项目目录中运行：
+在已有的 OpenClaw 环境中安装：
 
 ```bash
 openclaw plugins install openclaw-plugin-wecom
 ```
 
-或者（如果你习惯自己在 `package.json` 中管理依赖）：
+或通过 npm：
 
 ```bash
 npm install openclaw-plugin-wecom
 ```
 
-### 2. 配置插件
-
-在 OpenClaw 的配置文件（如 `config.json`）中添加插件配置：
+然后在 OpenClaw 配置文件中添加：
 
 ```json
 {
   "plugins": {
     "entries": {
-      "openclaw-plugin-wecom": { "enabled": true }
+      "wecom": { "enabled": true }
     }
   },
   "channels": {
-    "wxwork": {
+    "wecom": {
       "enabled": true,
       "token": "你的 Token",
-      "encodingAesKey": "你的 EncodingAESKey",
-      "webhookPath": "/webhooks/wxwork",
-      "accounts": {
-        "default": {
-          "allowFrom": ["*"]
-        }
-      },
-      "commands": {
-        "enabled": true,
-        "allowlist": ["/new", "/status", "/help", "/compact"]
-      },
-      "dynamicAgents": {
-        "enabled": true
-      }
+      "encodingAesKey": "你的 EncodingAESKey"
     }
   }
 }
 ```
 
-### 3. 企业微信后台设置
+### 企业微信后台设置
 
-1. 在企业微信管理后台创建一个“智能机器人”。
-2. 将机器人的“接收消息配置”中的 URL 设置为你的服务地址（例如：`https://your-domain.com/webhooks/wxwork`）。
+1. 在企业微信管理后台创建一个"智能机器人"。
+2. 将机器人的"接收消息配置"中的 URL 设置为你的服务地址（例如：`https://your-domain.com/webhooks/wecom`）。
 3. 填入对应的 Token 和 EncodingAESKey。
 
-## 🛠️ 指令支持
+## 📂 项目结构
 
-插件内置了对以下指令的处理：
+```
+openclaw-plugin-wecom/
+├── deploy/                      # 部署相关文件
+│   ├── deploy.sh               # 一键部署脚本
+│   ├── docker-compose.yml      # Docker Compose 配置
+│   ├── .env.example            # 环境变量示例
+│   ├── openclaw.json.base      # 基础配置模板
+│   └── openclaw.json.template  # 完整配置模板
+├── Dockerfile                   # OpenClaw 镜像构建文件
+├── local.sh                     # 本地镜像构建脚本
+├── index.js                     # 插件入口
+├── webhook.js                   # 企业微信 HTTP 通信处理
+├── dynamic-agent.js             # 动态 Agent 分配逻辑
+├── stream-manager.js            # 流式回复管理
+├── crypto.js                    # 企业微信加密算法
+└── client.js                    # 客户端逻辑
+```
 
-- `/new`: 重置当前对话，开启全新会话。
-- `/compact`: 压缩当前会话上下文，保留关键摘要以节省 Token。
-- `/help`: 查看帮助信息。
-- `/status`: 查看当前 Agent 及插件状态。
+## 🤖 动态 Agent 路由
 
-## 📂 项目结构
+OpenClaw 会通过解析 `SessionKey` 来决定本次消息由哪个 Agent 处理。本插件实现"按人/按群隔离"：
+
+1. 企业微信消息到达后，插件生成确定性的 `agentId`：
+   - 私聊：`wecom-dm-<userId>`
+   - 群聊：`wecom-group-<chatId>`
+2. OpenClaw 自动创建/复用对应的 Agent 工作区。
+
+### 配置选项
+
+配置在 `channels.wecom` 下：
+
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `dynamicAgents.enabled` | boolean | `true` | 是否启用动态 Agent |
+| `dm.createAgentOnFirstMessage` | boolean | `true` | 私聊使用动态 Agent |
+| `groupChat.enabled` | boolean | `true` | 启用群聊处理 |
+| `groupChat.requireMention` | boolean | `true` | 群聊必须 @ 提及才响应 |
+
+如果需要所有消息进入默认 Agent：
+
+```json
+{
+  "channels": {
+    "wecom": {
+      "dynamicAgents": { "enabled": false }
+    }
+  }
+}
+```
+
+## 🛠️ 指令白名单
+
+为防止普通用户通过企业微信消息执行敏感的 Gateway 管理指令，本插件支持**指令白名单**机制。只有配置在白名单中的指令才会被执行，其他指令将被忽略。
+
+> 💡 **提示**：此配置已包含在 `deploy/openclaw.json.template` 中，部署时会自动生效。
+
+```json
+{
+  "channels": {
+    "wecom": {
+      "commands": {
+        "enabled": true,
+        "allowlist": ["/new", "/status", "/help", "/compact"]
+      }
+    }
+  }
+}
+```
+
+| 指令 | 说明 | 安全级别 |
+|------|------|----------|
+| `/new` | 重置当前对话，开启全新会话 | ✅ 用户级 |
+| `/compact` | 压缩当前会话上下文 | ✅ 用户级 |
+| `/help` | 查看帮助信息 | ✅ 用户级 |
+| `/status` | 查看当前 Agent 状态 | ✅ 用户级 |
 
-- `index.js`: 插件入口，处理所有核心路由与生命周期管理。
-- `webhook.js`: 处理企业微信 HTTP 通信、加解密及消息解析。
-- `dynamic-agent.js`: 动态 Agent 分配逻辑。
-- `stream-manager.js`: 管理流式回复的状态与数据分片。
-- `crypto.js`: 企业微信加密算法实现。
+> ⚠️ **安全提示**：不要将 `/gateway`、`/plugins` 等管理指令添加到白名单，避免普通用户获得 Gateway 实例的管理权限。
 
 ## 🤝 贡献规范
 

package/client.js

@@ -1,11 +1,11 @@
 /**
- * WxWork AI Bot Client
+ * WeCom AI Bot Client
  * 智能机器人专用 - 只使用 response_url 回复，不需要 access_token
  * https://developer.work.weixin.qq.com/document/path/101039
  */
 
 import { logger } from "./logger.js";
-import { withRetry, parseWxWorkError, CONSTANTS } from "./utils.js";
+import { withRetry, parseWecomError, CONSTANTS } from "./utils.js";
 
 /**
  * 通过 response_url 主动回复消息
@@ -32,7 +32,7 @@ export async function sendReplyMessage(responseUrl, message) {
 
         const data = await res.json();
         if (data.errcode !== 0) {
-            const errorInfo = parseWxWorkError(data.errcode, data.errmsg);
+            const errorInfo = parseWecomError(data.errcode, data.errmsg);
             throw new Error(`Response failed: [${data.errcode}] ${errorInfo.message}`);
         }
 
@@ -108,7 +108,7 @@ export async function sendStreamChunk(responseUrl, streamId, content, isFinished
 
     const data = await res.json();
     if (data.errcode !== 0) {
-        const errorInfo = parseWxWorkError(data.errcode, data.errmsg);
+        const errorInfo = parseWecomError(data.errcode, data.errmsg);
         throw new Error(`Stream response failed: [${data.errcode}] ${errorInfo.message}`);
     }
 

package/crypto.js

@@ -7,7 +7,7 @@ import { logger } from "./logger.js";
  * Enterprise WeChat Intelligent Robot Crypto Implementation
  * Simplified for AI Bot mode (no corpId validation)
  */
-export class WxWorkCrypto {
+export class WecomCrypto {
     token;
     encodingAesKey;
     aesKey;
@@ -24,7 +24,7 @@ export class WxWorkCrypto {
         this.encodingAesKey = encodingAesKey;
         this.aesKey = Buffer.from(encodingAesKey + "=", "base64");
         this.iv = this.aesKey.subarray(0, 16);
-        logger.debug("WxWorkCrypto initialized (AI Bot mode)");
+        logger.debug("WecomCrypto initialized (AI Bot mode)");
     }
 
     getSignature(timestamp, nonce, encrypt) {

package/dynamic-agent.js

@@ -16,7 +16,7 @@ import { logger } from "./logger.js";
 
 /**
  * 生成 AgentId
- * 规范：wxwork-dm-{userId} 或 wxwork-group-{groupId}
+ * 规范：wecom-dm-{userId} 或 wecom-group-{groupId}
  * 
  * @param {string} chatType - "dm" 或 "group"
  * @param {string} peerId - userId 或 groupId
@@ -25,28 +25,28 @@ import { logger } from "./logger.js";
 export function generateAgentId(chatType, peerId) {
     const sanitizedId = String(peerId).toLowerCase().replace(/[^a-z0-9_-]/g, "_");
     if (chatType === "group") {
-        return `wxwork-group-${sanitizedId}`;
+        return `wecom-group-${sanitizedId}`;
     }
-    return `wxwork-dm-${sanitizedId}`;
+    return `wecom-dm-${sanitizedId}`;
 }
 
 /**
  * 获取动态 Agent 配置
  */
 export function getDynamicAgentConfig(config) {
-    const wxwork = config?.channels?.wxwork || {};
+    const wecom = config?.channels?.wecom || {};
     return {
-        enabled: wxwork.dynamicAgents?.enabled !== false,
+        enabled: wecom.dynamicAgents?.enabled !== false,
 
         // 私聊配置
-        dmCreateAgent: wxwork.dm?.createAgentOnFirstMessage !== false,
+        dmCreateAgent: wecom.dm?.createAgentOnFirstMessage !== false,
 
         // 群聊配置
-        groupEnabled: wxwork.groupChat?.enabled !== false,
-        groupRequireMention: wxwork.groupChat?.requireMention !== false,
-        groupMentionPatterns: wxwork.groupChat?.mentionPatterns || ["@"],
-        groupCreateAgent: wxwork.groupChat?.createAgentOnFirstMessage !== false,
-        groupHistoryLimit: wxwork.groupChat?.historyLimit || 10,
+        groupEnabled: wecom.groupChat?.enabled !== false,
+        groupRequireMention: wecom.groupChat?.requireMention !== false,
+        groupMentionPatterns: wecom.groupChat?.mentionPatterns || ["@"],
+        groupCreateAgent: wecom.groupChat?.createAgentOnFirstMessage !== false,
+        groupHistoryLimit: wecom.groupChat?.historyLimit || 10,
     };
 }
 

package/index.js

@@ -1,4 +1,4 @@
-import { WxWorkWebhook } from "./webhook.js";
+import { WecomWebhook } from "./webhook.js";
 import { logger } from "./logger.js";
 import { streamManager } from "./stream-manager.js";
 import {
@@ -36,8 +36,8 @@ const DEFAULT_COMMAND_BLOCK_MESSAGE = `⚠️ 该命令不可用。
  * 获取命令白名单配置
  */
 function getCommandConfig(config) {
-  const wxwork = config?.channels?.wxwork || {};
-  const commands = wxwork.commands || {};
+  const wecom = config?.channels?.wecom || {};
+  const commands = wecom.commands || {};
   return {
     allowlist: commands.allowlist || DEFAULT_COMMAND_ALLOWLIST,
     blockMessage: commands.blockMessage || DEFAULT_COMMAND_BLOCK_MESSAGE,
@@ -90,7 +90,7 @@ function setRuntime(runtime) {
 
 function getRuntime() {
   if (!_runtime) {
-    throw new Error("[wxwork] Runtime not initialized");
+    throw new Error("[wecom] Runtime not initialized");
   }
   return _runtime;
 }
@@ -102,19 +102,19 @@ const webhookTargets = new Map();
 // can be added to the correct stream instead of using response_url
 const activeStreams = new Map();
 
-function normalizeWxWorkAllowFromEntry(raw) {
+function normalizeWecomAllowFromEntry(raw) {
   const trimmed = String(raw ?? "").trim();
   if (!trimmed) return null;
   if (trimmed === "*") return "*";
-  return trimmed.replace(/^(wxwork|wecom|wework):/i, "").replace(/^user:/i, "").toLowerCase();
+  return trimmed.replace(/^(wecom|wework):/i, "").replace(/^user:/i, "").toLowerCase();
 }
 
-function resolveWxWorkAllowFrom(cfg, accountId) {
-  const wxwork = cfg?.channels?.wxwork;
-  if (!wxwork) return [];
+function resolveWecomAllowFrom(cfg, accountId) {
+  const wecom = cfg?.channels?.wecom;
+  if (!wecom) return [];
 
   const normalizedAccountId = String(accountId || DEFAULT_ACCOUNT_ID).trim().toLowerCase();
-  const accounts = wxwork.accounts;
+  const accounts = wecom.accounts;
   const account =
     accounts && typeof accounts === "object"
       ? accounts[accountId] ??
@@ -124,20 +124,20 @@ function resolveWxWorkAllowFrom(cfg, accountId) {
       : undefined;
 
   const allowFromRaw =
-    account?.dm?.allowFrom ?? account?.allowFrom ?? wxwork.dm?.allowFrom ?? wxwork.allowFrom ?? [];
+    account?.dm?.allowFrom ?? account?.allowFrom ?? wecom.dm?.allowFrom ?? wecom.allowFrom ?? [];
 
   if (!Array.isArray(allowFromRaw)) return [];
 
   return allowFromRaw
-    .map(normalizeWxWorkAllowFromEntry)
+    .map(normalizeWecomAllowFromEntry)
     .filter((entry) => Boolean(entry));
 }
 
-function resolveWxWorkCommandAuthorized({ cfg, accountId, senderId }) {
+function resolveWecomCommandAuthorized({ cfg, accountId, senderId }) {
   const sender = String(senderId ?? "").trim().toLowerCase();
   if (!sender) return false;
 
-  const allowFrom = resolveWxWorkAllowFrom(cfg, accountId);
+  const allowFrom = resolveWecomAllowFrom(cfg, accountId);
   if (allowFrom.includes("*") || allowFrom.length === 0) return true;
   return allowFrom.includes(sender);
 }
@@ -170,13 +170,13 @@ function registerWebhookTarget(target) {
 // Channel Plugin Definition
 // =============================================================================
 
-const wxworkChannelPlugin = {
-  id: "wxwork",
+const wecomChannelPlugin = {
+  id: "wecom",
   meta: {
-    id: "wxwork",
+    id: "wecom",
     label: "Enterprise WeChat",
     selectionLabel: "Enterprise WeChat (AI Bot)",
-    docsPath: "/channels/wxwork",
+    docsPath: "/channels/wecom",
     blurb: "Enterprise WeChat AI Bot channel plugin.",
     aliases: ["wecom", "wework"],
   },
@@ -186,41 +186,41 @@ const wxworkChannelPlugin = {
     threads: false,
     media: false,
     nativeCommands: false,
-    blockStreaming: true, // WxWork AI Bot uses stream response format
+    blockStreaming: true, // WeCom AI Bot uses stream response format
   },
-  reload: { configPrefixes: ["channels.wxwork"] },
+  reload: { configPrefixes: ["channels.wecom"] },
   config: {
     listAccountIds: (cfg) => {
-      const wxwork = cfg?.channels?.wxwork;
-      if (!wxwork || !wxwork.enabled) return [];
+      const wecom = cfg?.channels?.wecom;
+      if (!wecom || !wecom.enabled) return [];
       return [DEFAULT_ACCOUNT_ID];
     },
     resolveAccount: (cfg, accountId) => {
-      const wxwork = cfg?.channels?.wxwork;
-      if (!wxwork) return null;
+      const wecom = cfg?.channels?.wecom;
+      if (!wecom) return null;
       return {
         id: accountId || DEFAULT_ACCOUNT_ID,
         accountId: accountId || DEFAULT_ACCOUNT_ID,
-        enabled: wxwork.enabled !== false,
-        token: wxwork.token || "",
-        encodingAesKey: wxwork.encodingAesKey || "",
-        webhookPath: wxwork.webhookPath || "/webhooks/wxwork",
-        config: wxwork,
+        enabled: wecom.enabled !== false,
+        token: wecom.token || "",
+        encodingAesKey: wecom.encodingAesKey || "",
+        webhookPath: wecom.webhookPath || "/webhooks/wecom",
+        config: wecom,
       };
     },
     defaultAccountId: (cfg) => {
-      const wxwork = cfg?.channels?.wxwork;
-      if (!wxwork || !wxwork.enabled) return null;
+      const wecom = cfg?.channels?.wecom;
+      if (!wecom || !wecom.enabled) return null;
       return DEFAULT_ACCOUNT_ID;
     },
     setAccountEnabled: ({ cfg, accountId, enabled }) => {
       if (!cfg.channels) cfg.channels = {};
-      if (!cfg.channels.wxwork) cfg.channels.wxwork = {};
-      cfg.channels.wxwork.enabled = enabled;
+      if (!cfg.channels.wecom) cfg.channels.wecom = {};
+      cfg.channels.wecom.enabled = enabled;
       return cfg;
     },
     deleteAccount: ({ cfg, accountId }) => {
-      if (cfg.channels?.wxwork) delete cfg.channels.wxwork;
+      if (cfg.channels?.wecom) delete cfg.channels.wecom;
       return cfg;
     },
   },
@@ -232,8 +232,8 @@ const wxworkChannelPlugin = {
   // Outbound adapter: Send messages via stream (all messages go through stream now)
   outbound: {
     sendText: async ({ cfg, to, text, accountId }) => {
-      // to格式: "wxwork:userid" 或 "userid"
-      const userId = to.replace(/^wxwork:/, "");
+      // to格式: \"wecom:userid\" 或 \"userid\"
+      const userId = to.replace(/^wecom:/, "");
 
       // 获取该用户当前活跃的 streamId
       const streamId = activeStreams.get(userId);
@@ -246,21 +246,21 @@ const wxworkChannelPlugin = {
         streamManager.appendStream(streamId, separator + text);
 
         return {
-          channel: "wxwork",
+          channel: "wecom",
           messageId: `msg_stream_${Date.now()}`,
         };
       }
 
       // 如果没有活跃的流，记录警告
-      logger.warn("WxWork outbound: no active stream for user", { userId });
+      logger.warn("WeCom outbound: no active stream for user", { userId });
 
       return {
-        channel: "wxwork",
+        channel: "wecom",
         messageId: `fake_${Date.now()}`,
       };
     },
     sendMedia: async ({ cfg, to, text, mediaUrl, accountId }) => {
-      const userId = to.replace(/^wxwork:/, "");
+      const userId = to.replace(/^wecom:/, "");
       const streamId = activeStreams.get(userId);
 
       if (streamId && streamManager.hasStream(streamId)) {
@@ -272,15 +272,15 @@ const wxworkChannelPlugin = {
         streamManager.appendStream(streamId, separator + content);
 
         return {
-          channel: "wxwork",
+          channel: "wecom",
           messageId: `msg_stream_${Date.now()}`,
         };
       }
 
-      logger.warn("WxWork outbound sendMedia: no active stream", { userId });
+      logger.warn("WeCom outbound sendMedia: no active stream", { userId });
 
       return {
-        channel: "wxwork",
+        channel: "wecom",
         messageId: `fake_${Date.now()}`,
       };
     },
@@ -288,17 +288,17 @@ const wxworkChannelPlugin = {
   gateway: {
     startAccount: async (ctx) => {
       const account = ctx.account;
-      logger.info("WxWork gateway starting", { accountId: account.accountId, webhookPath: account.webhookPath });
+      logger.info("WeCom gateway starting", { accountId: account.accountId, webhookPath: account.webhookPath });
 
       const unregister = registerWebhookTarget({
-        path: account.webhookPath || "/webhooks/wxwork",
+        path: account.webhookPath || "/webhooks/wecom",
         account,
         config: ctx.cfg,
       });
 
       return {
         shutdown: async () => {
-          logger.info("WxWork gateway shutting down");
+          logger.info("WeCom gateway shutting down");
           unregister();
         },
       };
@@ -310,7 +310,7 @@ const wxworkChannelPlugin = {
 // HTTP Webhook Handler
 // =============================================================================
 
-async function wxworkHttpHandler(req, res) {
+async function wecomHttpHandler(req, res) {
   const url = new URL(req.url || "", "http://localhost");
   const path = normalizeWebhookPath(url.pathname);
   const targets = webhookTargets.get(path);
@@ -320,7 +320,7 @@ async function wxworkHttpHandler(req, res) {
   }
 
   const query = Object.fromEntries(url.searchParams);
-  logger.debug("WxWork HTTP request", { method: req.method, path });
+  logger.debug("WeCom HTTP request", { method: req.method, path });
 
   // GET: URL Verification
   if (req.method === "GET") {
@@ -331,7 +331,7 @@ async function wxworkHttpHandler(req, res) {
       return true;
     }
 
-    const webhook = new WxWorkWebhook({
+    const webhook = new WecomWebhook({
       token: target.account.token,
       encodingAesKey: target.account.encodingAesKey,
     });
@@ -340,13 +340,13 @@ async function wxworkHttpHandler(req, res) {
     if (echo) {
       res.writeHead(200, { "Content-Type": "text/plain" });
       res.end(echo);
-      logger.info("WxWork URL verification successful");
+      logger.info("WeCom URL verification successful");
       return true;
     }
 
     res.writeHead(403, { "Content-Type": "text/plain" });
     res.end("Verification failed");
-    logger.warn("WxWork URL verification failed");
+    logger.warn("WeCom URL verification failed");
     return true;
   }
 
@@ -365,9 +365,9 @@ async function wxworkHttpHandler(req, res) {
       chunks.push(chunk);
     }
     const body = Buffer.concat(chunks).toString("utf-8");
-    logger.debug("WxWork message received", { bodyLength: body.length });
+    logger.debug("WeCom message received", { bodyLength: body.length });
 
-    const webhook = new WxWorkWebhook({
+    const webhook = new WecomWebhook({
       token: target.account.token,
       encodingAesKey: target.account.encodingAesKey,
     });
@@ -413,7 +413,7 @@ async function wxworkHttpHandler(req, res) {
         account: target.account,
         config: target.config,
       }).catch((err) => {
-        logger.error("WxWork message processing failed", { error: err.message });
+        logger.error("WeCom message processing failed", { error: err.message });
         // 即使失败也要标记流为完成
         streamManager.finishStream(streamId);
       });
@@ -474,7 +474,7 @@ async function wxworkHttpHandler(req, res) {
 
     // Handle event
     if (result.event) {
-      logger.info("WxWork event received", { event: result.event });
+      logger.info("WeCom event received", { event: result.event });
 
       // 处理进入会话事件 - 发送欢迎语
       if (result.event?.event_type === "enter_chat") {
@@ -544,7 +544,7 @@ async function processInboundMessage({ message, streamId, timestamp, nonce, acco
   // 确定 peerId：群聊用 chatId，私聊用 senderId
   const peerId = isGroupChat ? chatId : senderId;
   const peerKind = isGroupChat ? "group" : "dm";
-  const conversationId = isGroupChat ? `wxwork:group:${chatId}` : `wxwork:${senderId}`;
+  const conversationId = isGroupChat ? `wecom:group:${chatId}` : `wecom:${senderId}`;
 
   // 设置用户当前活跃的 streamId，供 outbound.sendText 使用
   // 群聊时用 chatId 作为 key
@@ -557,21 +557,21 @@ async function processInboundMessage({ message, streamId, timestamp, nonce, acco
   let rawBody = rawContent;
   if (isGroupChat) {
     if (!shouldTriggerGroupResponse(rawContent, config)) {
-      logger.debug("WxWork: group message ignored (no mention)", { chatId, senderId });
+      logger.debug("WeCom: group message ignored (no mention)", { chatId, senderId });
       return;
     }
     // 提取实际内容（移除 @提及）
     rawBody = extractGroupMessageContent(rawContent, config);
   }
 
-  const commandAuthorized = resolveWxWorkCommandAuthorized({
+  const commandAuthorized = resolveWecomCommandAuthorized({
     cfg: config,
     accountId: account.accountId,
     senderId,
   });
 
   if (!rawBody.trim()) {
-    logger.debug("WxWork: empty message, skipping");
+    logger.debug("WeCom: empty message, skipping");
     return;
   }
 
@@ -583,7 +583,7 @@ async function processInboundMessage({ message, streamId, timestamp, nonce, acco
   if (commandCheck.isCommand && !commandCheck.allowed) {
     // 命令不在白名单中，返回拒绝消息
     const cmdConfig = getCommandConfig(config);
-    logger.warn("WxWork: blocked command", {
+    logger.warn("WeCom: blocked command", {
       command: commandCheck.command,
       from: senderId,
       chatType: peerKind
@@ -598,7 +598,7 @@ async function processInboundMessage({ message, streamId, timestamp, nonce, acco
     return;
   }
 
-  logger.info("WxWork processing message", {
+  logger.info("WeCom processing message", {
     from: senderId,
     chatType: peerKind,
     peerId,
@@ -626,7 +626,7 @@ async function processInboundMessage({ message, streamId, timestamp, nonce, acco
   // ========================================================================
   const route = core.routing.resolveAgentRoute({
     cfg: config,
-    channel: "wxwork",
+    channel: "wecom",
     accountId: account.accountId,
     peer: {
       kind: peerKind,
@@ -666,7 +666,7 @@ async function processInboundMessage({ message, streamId, timestamp, nonce, acco
     Body: body,
     RawBody: rawBody,
     CommandBody: rawBody,
-    From: `wxwork:${senderId}`,
+    From: `wecom:${senderId}`,
     To: conversationId,
     SessionKey: route.sessionKey,
     AccountId: route.accountId,
@@ -675,9 +675,9 @@ async function processInboundMessage({ message, streamId, timestamp, nonce, acco
     SenderName: senderId,
     SenderId: senderId,
     GroupId: isGroupChat ? chatId : undefined,
-    Provider: "wxwork",
-    Surface: "wxwork",
-    OriginatingChannel: "wxwork",
+    Provider: "wecom",
+    Surface: "wecom",
+    OriginatingChannel: "wecom",
     OriginatingTo: conversationId,
     CommandAuthorized: commandAuthorized,
   });
@@ -688,7 +688,7 @@ async function processInboundMessage({ message, streamId, timestamp, nonce, acco
     sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
     ctx: ctxPayload,
   }).catch((err) => {
-    logger.error("WxWork: failed updating session meta", { error: err.message });
+    logger.error("WeCom: failed updating session meta", { error: err.message });
   });
 
   // Dispatch reply with AI processing
@@ -703,7 +703,7 @@ async function processInboundMessage({ message, streamId, timestamp, nonce, acco
           textPreview: (payload.text || "").substring(0, 50),
         });
 
-        await deliverWxWorkReply({
+        await deliverWecomReply({
           payload,
           account,
           responseUrl,
@@ -714,11 +714,11 @@ async function processInboundMessage({ message, streamId, timestamp, nonce, acco
         // 如果是最终回复,标记流为完成
         if (streamId && info.kind === "final") {
           streamManager.finishStream(streamId);
-          logger.info("WxWork stream finished", { streamId });
+          logger.info("WeCom stream finished", { streamId });
         }
       },
       onError: (err, info) => {
-        logger.error("WxWork reply failed", { error: err.message, kind: info.kind });
+        logger.error("WeCom reply failed", { error: err.message, kind: info.kind });
         // 发生错误时也标记流为完成
         if (streamId) {
           streamManager.finishStream(streamId);
@@ -731,7 +731,7 @@ async function processInboundMessage({ message, streamId, timestamp, nonce, acco
   if (streamId) {
     streamManager.finishStream(streamId);
     activeStreams.delete(streamKey);  // 清理活跃流映射
-    logger.info("WxWork stream finished (dispatch complete)", { streamId });
+    logger.info("WeCom stream finished (dispatch complete)", { streamId });
   }
 }
 
@@ -739,10 +739,10 @@ async function processInboundMessage({ message, streamId, timestamp, nonce, acco
 // Outbound Reply Delivery (Stream-only mode)
 // =============================================================================
 
-async function deliverWxWorkReply({ payload, account, responseUrl, senderId, streamId }) {
+async function deliverWecomReply({ payload, account, responseUrl, senderId, streamId }) {
   const text = payload.text || "";
 
-  logger.debug("deliverWxWorkReply called", {
+  logger.debug("deliverWecomReply called", {
     hasText: !!text.trim(),
     textPreview: text.substring(0, 50),
     streamId,
@@ -751,7 +751,7 @@ async function deliverWxWorkReply({ payload, account, responseUrl, senderId, str
 
   // 所有消息都通过流式发送
   if (!text.trim()) {
-    logger.debug("WxWork: empty block, skipping stream update");
+    logger.debug("WeCom: empty block, skipping stream update");
     return;
   }
 
@@ -762,7 +762,7 @@ async function deliverWxWorkReply({ payload, account, responseUrl, senderId, str
 
     // 去重：检查流内容是否已包含此消息（避免 block + final 重复）
     if (stream.content.includes(content.trim())) {
-      logger.debug("WxWork: duplicate content, skipping", {
+      logger.debug("WeCom: duplicate content, skipping", {
         streamId: targetStreamId,
         contentPreview: content.substring(0, 30)
       });
@@ -779,23 +779,23 @@ async function deliverWxWorkReply({ payload, account, responseUrl, senderId, str
     const activeStreamId = activeStreams.get(senderId);
     if (activeStreamId && streamManager.hasStream(activeStreamId)) {
       appendToStream(activeStreamId, text);
-      logger.debug("WxWork stream appended (via activeStreams)", {
+      logger.debug("WeCom stream appended (via activeStreams)", {
         streamId: activeStreamId,
         contentLength: text.length,
       });
       return;
     }
-    logger.warn("WxWork: no active stream for this message", { senderId });
+    logger.warn("WeCom: no active stream for this message", { senderId });
     return;
   }
 
   if (!streamManager.hasStream(streamId)) {
-    logger.warn("WxWork: stream not found, cannot update", { streamId });
+    logger.warn("WeCom: stream not found, cannot update", { streamId });
     return;
   }
 
   appendToStream(streamId, text);
-  logger.debug("WxWork stream appended", {
+  logger.debug("WeCom stream appended", {
     streamId,
     contentLength: text.length,
     to: senderId
@@ -807,24 +807,24 @@ async function deliverWxWorkReply({ payload, account, responseUrl, senderId, str
 // =============================================================================
 
 const plugin = {
-  id: "openclaw-plugin-wecom",
+  id: "wecom",
   name: "Enterprise WeChat",
   description: "Enterprise WeChat AI Bot channel plugin for OpenClaw",
   configSchema: { type: "object", additionalProperties: false, properties: {} },
   register(api) {
-    logger.info("WxWork plugin registering...");
+    logger.info("WeCom plugin registering...");
 
     // Save runtime for message processing
     setRuntime(api.runtime);
     _openclawConfig = api.config;
 
     // Register channel
-    api.registerChannel({ plugin: wxworkChannelPlugin });
-    logger.info("WxWork channel registered");
+    api.registerChannel({ plugin: wecomChannelPlugin });
+    logger.info("WeCom channel registered");
 
     // Register HTTP handler for webhooks
-    api.registerHttpHandler(wxworkHttpHandler);
-    logger.info("WxWork HTTP handler registered");
+    api.registerHttpHandler(wecomHttpHandler);
+    logger.info("WeCom HTTP handler registered");
   },
 };
 

package/logger.js

@@ -1,9 +1,9 @@
 /**
- * Structured logging for WxWork plugin
+ * Structured logging for WeCom plugin
  */
 export class Logger {
     prefix;
-    constructor(prefix = "[wxwork]") {
+    constructor(prefix = "[wecom]") {
         this.prefix = prefix;
     }
     log(level, message, context) {

package/openclaw.plugin.json

@@ -1,11 +1,13 @@
 {
   "id": "openclaw-plugin-wecom",
-  "name": "OpenClaw WeCom (WxWork)",
-  "description": "Enterprise WeChat (WeCom/WxWork) messaging channel plugin for OpenClaw",
-  "channels": ["wxwork"],
+  "name": "OpenClaw WeCom",
+  "description": "Enterprise WeChat (WeCom) messaging channel plugin for OpenClaw",
+  "channels": [
+    "wecom"
+  ],
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
     "properties": {}
   }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "openclaw-plugin-wecom",
-    "version": "0.3.1",
+    "version": "0.3.3",
     "description": "Enterprise WeChat AI Bot channel plugin for OpenClaw",
     "type": "module",
     "main": "index.js",
@@ -27,11 +27,11 @@
             "./index.js"
         ],
         "channel": {
-            "id": "wxwork",
+            "id": "wecom",
             "label": "Enterprise WeChat",
             "selectionLabel": "Enterprise WeChat (AI Bot)",
-            "docsPath": "/channels/wxwork",
-            "docsLabel": "wxwork",
+            "docsPath": "/channels/wecom",
+            "docsLabel": "wecom",
             "blurb": "Support for Enterprise WeChat (WeCom) AI Bot integration",
             "order": 90,
             "aliases": [
@@ -46,7 +46,7 @@
     },
     "keywords": [
         "openclaw",
-        "wxwork",
+        "wecom",
         "wecom",
         "chat",
         "plugin"

package/utils.js

@@ -1,5 +1,5 @@
 /**
- * Utility functions and helpers for WxWork plugin
+ * Utility functions and helpers for WeCom plugin
  */
 export class TTLCache {
     options;
@@ -137,7 +137,7 @@ export class MessageDeduplicator {
         this.seen.set(msgId, true);
     }
 }
-export function parseWxWorkError(errcode, errmsg) {
+export function parseWecomError(errcode, errmsg) {
     // Reference: https://developer.work.weixin.qq.com/document/path/96213
     switch (errcode) {
         case -1:
@@ -198,7 +198,7 @@ export function parseWxWorkError(errcode, errmsg) {
     }
 }
 export function shouldRetryError(errcode) {
-    const info = parseWxWorkError(errcode, "");
+    const info = parseWecomError(errcode, "");
     return info.retryable;
 }
 // ============================================================================

package/webhook.js

@@ -1,9 +1,9 @@
-import { WxWorkCrypto } from "./crypto.js";
+import { WecomCrypto } from "./crypto.js";
 import { logger } from "./logger.js";
 import { MessageDeduplicator, randomString } from "./utils.js";
 
 /**
- * WxWork AI Bot Webhook Handler
+ * WeCom AI Bot Webhook Handler
  * Based on official demo: https://developer.work.weixin.qq.com/document/path/101039
  *
  * Key differences from legacy mode:
@@ -11,15 +11,15 @@ import { MessageDeduplicator, randomString } from "./utils.js";
  * - receiveid is empty string for AI Bot
  * - Response uses stream message format
  */
-export class WxWorkWebhook {
+export class WecomWebhook {
     config;
     crypto;
     deduplicator = new MessageDeduplicator();
 
     constructor(config) {
         this.config = config;
-        this.crypto = new WxWorkCrypto(config.token, config.encodingAesKey);
-        logger.debug("WxWorkWebhook initialized (AI Bot mode)");
+        this.crypto = new WecomCrypto(config.token, config.encodingAesKey);
+        logger.debug("WecomWebhook initialized (AI Bot mode)");
     }
 
     // =========================================================================
@@ -180,7 +180,7 @@ export class WxWorkWebhook {
             };
         }
         else if (msgtype === "stream") {
-            // Stream continuation request from WxWork
+            // Stream continuation request from WeCom
             const streamId = data.stream?.id;
             logger.debug("Received stream refresh request", { streamId });
             return {