JoyD/Claw/docs/可行性方案.md

# 企业微信智控未来系统可行性方案

## 1. 项目背景

用户拥有一个未经认证的企业微信，包含应用"智控未来"，以及两台服务器：

- **服务器A：阿里云主机，公网IP 47.109.191.115，域名 pactgo.cn，外网可以访问，相当于"大门和快递员"**
- **服务器B：局域网服务器，在内网中，外网不能访问，安装了LMStudio，相当于"工厂和生产线"**

目标是使用Rust和React实现以下功能：用户通过企业微信应用"智控未来"和微信小程序进行聊天，下发任务。任务经服务器A转到服务器B，B上的自建龙虾处理后返回结果给用户。

## 2. 系统架构

### 2.1 整体架构

```mermaid
sequenceDiagram
    participant User as 用户
    participant WeChat as 企业微信/小程序
    participant Gateway as 网关服务（服务器A）<br/>47.109.191.115<br/>pactgo.cn
    participant SmartClaw as SmartClaw服务（服务器B）<br/>内网服务器
    participant LMStudio as LMStudio<br/>127.0.0.1:1234

    User->>WeChat: 发送消息/任务
    WeChat->>Gateway: HTTPS回调请求<br/>https://pactgo.cn/wecom
    Gateway->>SmartClaw: WebSocket长连接转发任务<br/>wss://pactgo.cn/ws/control
    SmartClaw->>SmartClaw: 处理任务（智能控制核心逻辑）
    SmartClaw->>LMStudio: HTTP调用LMStudio API<br/>http://127.0.0.1:1234/v1/chat/completions
    LMStudio-->>SmartClaw: 返回AI结果
    SmartClaw-->>Gateway: WebSocket回传结果<br/>wss://pactgo.cn/ws/control
    Gateway-->>WeChat: HTTPS回调响应<br/>https://pactgo.cn/api/v1/
    WeChat-->>User: 显示结果
```

### 2.2 组件说明

| 组件                | 职责                                                                                        | 技术栈                     | 部署位置  |
| ----------------- | ----------------------------------------------------------------------------------------- | ----------------------- | ----- |
| 企业微信应用            | 用户交互界面，接收用户消息和任务                                                                          | 企业微信原生开发框架              | 服务器A  |
| 微信小程序             | 用户交互界面，接收用户消息和任务                                                                          | 原生小程序语法 / Taro / UniApp | 微信客户端 |
| 网关服务（服务器A）        | 接收企业微信和小程序的HTTPS请求，通过WebSocket长连接转发到SmartClaw服务，返回结果                                      | Rust + Actix Web        | 公网服务器 |
| SmartClaw服务（服务器B） | **1. WebSocket客户端，主动连接网关A（核心通信）2. 内网Web管理接口（调试、状态查询、任务管理）3. 调用LMStudio API4. HeedDB数据存储** | Rust + Actix Web        | 内网服务器 |
| 智能控制核心逻辑          | 核心业务逻辑，处理用户任务，调用LMStudio                                                                  | Rust                    | 服务器B  |
| LMStudio          | 提供AI能力，辅助处理任务                                                                             | 第三方工具                   | 服务器B  |

## 3. 技术选型

### 3.1 后端技术栈

| 技术                | 版本    | 用途                       | 备注               |
| ----------------- | ----- | ------------------------ | ---------------- |
| Rust              | 1.70+ | 后端开发语言                   | 内存安全，高性能         |
| Actix Web         | 4.0+  | Web框架，处理HTTP/WebSocket请求 | 异步高性能            |
| Tokio             | 1.0+  | 异步运行时                    | Rust异步生态标准       |
| Serde             | 1.0+  | 序列化/反序列化                 | JSON处理           |
| Tokio-Tungstenite | 0.18+ | WebSocket客户端/服务端         | 异步WebSocket支持    |
| HeedDB            | 最新版   | 轻量级嵌入式数据库                | 无需独立服务，文件级存储     |
| Embedded-Redis    | 最新版   | **必选**嵌入式Redis服务器        | 零配置，服务内置，多用户状态管理 |

### 3.2 前端技术栈

| 技术                           | 版本      | 用途               | 备注                  |
| ---------------------------- | ------- | ---------------- | ------------------- |
| **WXML + WXSS + JavaScript** | **最新版** | **微信小程序官方原生技术栈** | **最佳选择，微信官方支持，最稳定** |
| 微信开发者工具                      | 最新版     | 小程序开发调试工具        | 官方工具，完整API支持        |
| 原生小程序 API                    | 最新版     | 微信原生API接口        | 无需第三方框架，直接调用        |
| 企业微信JS-SDK                   | 最新版     | 企业微信网页开发         | 官方SDK               |

## 4. 网络通信方案

### 4.1 企业微信/小程序与网关服务通信

**企业微信**：

- 使用企业微信回调机制
- 网关服务必须提供**HTTPS接口**（企业微信官方强制要求）
- 需要有效的SSL证书和域名
- **回调地址：`https://pactgo.cn/wecom`**

**微信小程序**：

- 使用HTTPS接口与网关服务通信
- 需要配置合法域名
- **接口地址：`https://pactgo.cn/api/v1/`**
- **技术栈：WXML + WXSS + JavaScript（官方原生）**

⚠️ **重要**：企业微信回调**必须使用HTTPS**，无证书无法保存配置！

### 4.2 网关服务与SmartClaw服务通信

由于SmartClaw服务在内网中，外网不能访问它，采用**最简方案**：

**WebSocket长连接方案**（推荐）：

1. **SmartClaw服务主动连接**：服务器B启动时，主动WebSocket连接到服务器A
2. **单一连接**：服务器B与服务器A之间只建立一个WebSocket连接，不需要列表管理
3. **长连接保持**：维持持久WebSocket连接，支持心跳检测
4. **双向通信**：服务器A通过WebSocket发送任务，服务器B处理完成后回传结果
5. **断线重连**：自动重连机制，保证连接稳定性

### 4.2.1 WebSocket连接管理

- **服务器B与服务器A**：只建立一个WebSocket连接，无需列表管理
- **其他设备与服务器A**：通过WebSocket连接到服务器A的 `/ws/task` 路径，需要使用连接列表进行管理
- **连接管理**：使用 `ConnectionManager` 结构体管理设备与服务器A的WebSocket连接，支持多用户多设备场景

**优点**：

- 无需反向代理，架构简单
- 无需Redis消息队列，减少依赖
- 实时双向通信，延迟低
- 内网服务器主动连接，安全可控

### 4.3 SmartClaw服务与LMStudio通信

LMStudio默认提供HTTP API接口：

```
http://127.0.0.1:1234/v1/chat/completions
```

**通信方式**：

- SmartClaw服务直接HTTP调用LMStudio API
- 支持流式响应（SSE）
- 可配置超时和重试机制

### 4.3 微信小程序技术栈选择

**最佳选择：官方原生小程序技术栈**

**技术组成**：

- **WXML（WeiXin Markup Language）**：小程序的标记语言，类似HTML
- **WXSS（WeiXin Style Sheets）**：小程序的样式语言，类似CSS
- **JavaScript**：小程序的逻辑语言，ES6+语法支持
- **微信开发者工具**：官方IDE，支持调试、预览、上传
- **原生小程序API**：微信官方API，无需第三方框架

**选择理由**：

- ✅ **官方支持**：微信官方原生支持，最稳定可靠
- ✅ **性能最优**：无框架封装损耗，执行效率最高
- ✅ **功能完整**：支持所有微信原生功能和API
- ✅ **学习成本低**：标准Web技术栈，开发者容易上手
- ✅ **社区活跃**：官方文档完善，社区资源丰富
- ✅ **长期维护**：微信官方持续更新和维护

**开发工具**：

- **微信开发者工具**：官方IDE，支持代码编辑、调试、预览
- **真机调试**：支持真机预览和调试
- **性能分析**：内置性能分析工具
- **代码上传**：一键上传代码到微信服务器

**API支持**：

- **网络请求**：wx.request() 支持HTTPS
- **WebSocket**：wx.connectSocket() 支持实时通信
- **本地存储**：wx.setStorage() 支持本地数据缓存
- **用户信息**：wx.getUserInfo() 支持用户信息获取
- **设备信息**：wx.getSystemInfo() 支持设备信息获取

**项目结构**：

```
wechat_app/                    # 微信小程序项目目录（正确命名）
├── pages/          # 页面目录
│   ├── index/      # 首页
│   ├── chat/       # 聊天页面
│   └── task/       # 任务页面
├── utils/          # 工具函数
├── assets/         # 静态资源
├── app.js          # 应用入口
├── app.json        # 应用配置
├── app.wxss        # 全局样式
└── project.config.json # 项目配置
```

## 5. 安全考虑

### 5.1 网络安全

- **HTTPS强制**：所有外部通信必须使用HTTPS
- **防火墙配置**：服务器A只开放必要端口（443, 80）
- **内网安全**：服务器B只允许来自服务器A的WebSocket连接
- **域名SSL**：服务器A必须配置有效域名和SSL证书

### 5.2 认证与授权

**微信小程序认证**（官方原生技术栈）：

- **AppID和AppSecret**：小程序身份认证
- **用户登录**：wx.login() 获取临时登录凭证code
- **会话密钥**：服务端换取session_key和openid
- **用户信息**：wx.getUserInfo() 获取用户基本信息
- **权限管理**：scope.userInfo、scope.userLocation等

**企业微信认证**：

- **CorpID和Secret**：企业身份认证
- **用户身份**：UserID和DeviceID识别
- **应用权限**：应用可见范围和操作权限
- **消息加密**：消息体加密和签名验证

**服务器间认证**：

- **WebSocket连接**：预共享密钥认证
- **API签名**：HMAC签名验证
- **Token机制**：JWT令牌认证
- **IP白名单**：服务器IP地址限制

### 5.3 数据安全

- **敏感数据加密**：用户数据加密存储
- **传输加密**：WebSocket使用WSS加密
- **访问控制**：基于角色的权限控制
- **审计日志**：记录所有重要操作
- **数据库安全**：HeedDB文件级加密，无需网络暴露

#### 5.3.1 HeedDB数据库配置

**HeedDB特点**：

- **嵌入式数据库**：无需独立服务进程
- **Sled底层**：基于LSM树的嵌入式K/V库
- **ACID事务**：支持原子性、一致性、隔离性、持久性
- **高性能**：零拷贝数据访问，内存映射优化
- **文件级安全**：数据库存储在本地文件系统

**使用场景**：

- **任务状态存储**：保存任务处理状态和结果
- **用户会话管理**：存储用户会话信息
- **配置数据**：保存系统配置和参数
- **缓存数据**：临时数据缓存
- **审计日志**：操作日志记录

**配置参数**：

```bash
HEEDB_PATH=C:/Claw/data/heedb        # 数据库文件路径
HEEDB_MAX_DBS=10                     # 最大数据库数量
HEEDB_MAP_SIZE=10485760              # 内存映射大小（10MB）
HEEDB_MAX_READERS=126                 # 最大并发读者数
```

**HeedDB优势**（对比传统数据库）：

- **零配置**：无需安装和配置数据库服务
- **高性能**：内存映射文件，零拷贝访问
- **事务安全**：完整的ACID事务支持
- **跨平台**：支持Windows、Linux、macOS
- **Rust原生**：与Rust生态完美集成
- **轻量级**：适合嵌入式和边缘计算场景

### 4.4 微信小程序开发详细方案

**开发环境搭建**：

1. **下载微信开发者工具**：<https://developers.weixin.qq.com/wechat_app/dev/devtools/download.html>
2. **注册小程序账号**：<https://mp.weixin.qq.com/>
3. **获取AppID**：在微信公众平台获取小程序AppID
4. **配置开发环境**：设置项目路径、AppID、项目名称

**项目架构设计**：

```
wechat_app/                    # 微信小程序项目目录（正确命名）
├── pages/                    # 页面目录
│   ├── index/               # 首页 - 用户登录和主界面
│   │   ├── index.wxml       # 页面结构
│   │   ├── index.wxss       # 页面样式
│   │   ├── index.js         # 页面逻辑
│   │   └── index.json       # 页面配置
│   ├── chat/                # 聊天页面
│   │   ├── chat.wxml        # 聊天界面
│   │   ├── chat.wxss        # 聊天样式
│   │   ├── chat.js          # 聊天逻辑
│   │   └── chat.json        # 聊天配置
│   ├── task/                # 任务页面
│   │   ├── task.wxml        # 任务列表
│   │   ├── task.wxss        # 任务样式
│   │   ├── task.js          # 任务逻辑
│   │   └── task.json        # 任务配置
│   └── user/                # 用户中心
│       ├── user.wxml        # 用户界面
│       ├── user.wxss        # 用户样式
│       ├── user.js          # 用户逻辑
│       └── user.json        # 用户配置
├── utils/                    # 工具函数
│   ├── api.js               # API接口封装
│   ├── util.js              # 通用工具函数
│   └── constant.js          # 常量定义
├── components/               # 自定义组件
│   ├── message/             # 消息组件
│   ├── task-card/           # 任务卡片组件
│   └── user-avatar/         # 用户头像组件
├── assets/                   # 静态资源
│   ├── images/              # 图片资源
│   └── icons/               # 图标资源
├── app.js                    # 应用入口文件
├── app.json                  # 应用配置文件
├── app.wxss                  # 应用全局样式
├── project.config.json       # 项目配置文件
└── sitemap.json             # 站点地图配置
```

**核心功能实现**：

1. **用户登录和授权**：

```javascript
// 用户登录
wx.login({
  success: res => {
    const code = res.code;
    // 发送code到后端换取openId, sessionKey, unionId
    wx.request({
      url: 'https://pactgo.cn/api/v1/wechat/login',
      data: { code },
      success: res => {
        const { openId, sessionKey } = res.data;
        wx.setStorageSync('openId', openId);
        wx.setStorageSync('sessionKey', sessionKey);
      }
    });
  }
});

// 获取用户信息
wx.getUserProfile({
  desc: '用于完善用户资料',
  success: res => {
    const userInfo = res.userInfo;
    wx.setStorageSync('userInfo', userInfo);
  }
});
```

1. **WebSocket实时通信**：

```javascript
// 连接WebSocket
connectWebSocket() {
  const socket = wx.connectSocket({
    url: 'wss://pactgo.cn/ws/task',
    header: {
      'content-type': 'application/json'
    }
  });

  socket.onOpen(() => {
    console.log('WebSocket连接已打开');
    // 发送用户认证信息
    socket.send({
      data: JSON.stringify({
        type: 'auth',
        userId: wx.getStorageSync('openId'),
        deviceId: wx.getSystemInfoSync().model
      })
    });
  });

  socket.onMessage((res) => {
    const data = JSON.parse(res.data);
    this.handleMessage(data);
  });

  socket.onClose(() => {
    console.log('WebSocket连接已关闭');
    // 重连机制
    setTimeout(() => {
      this.connectWebSocket();
    }, 3000);
  });
}
```

1. **任务提交和处理**：

```javascript
// 提交任务
submitTask(taskType, content) {
  const taskId = this.generateTaskId();
  const task = {
    taskId,
    taskType,
    content,
    priority: 1,
    timestamp: Date.now()
  };

  // 发送到后端
  wx.request({
    url: 'https://pactgo.cn/api/v1/task/submit',
    method: 'POST',
    data: task,
    success: (res) => {
      if (res.data.success) {
        // 添加到本地任务列表
        this.addTaskToList(task);
        wx.showToast({
          title: '任务提交成功',
          icon: 'success'
        });
      }
    }
  });
}

// 处理任务结果
handleTaskResult(result) {
  const { taskId, status, result: taskResult } = result;
  
  // 更新任务状态
  this.updateTaskStatus(taskId, status, taskResult);
  
  // 显示结果
  if (status === 'completed') {
    this.showTaskResult(taskResult);
  } else if (status === 'failed') {
    wx.showToast({
      title: '任务处理失败',
      icon: 'error'
    });
  }
}
```

1. **界面设计和交互**：

```xml
<!-- 聊天界面示例 -->
<view class="chat-container">
  <scroll-view scroll-y="true" class="message-list" scroll-into-view="{{lastMessageId}}">
    <view wx:for="{{messages}}" wx:key="id" class="message-item {{item.isMe ? 'message-right' : 'message-left'}}">
      <view class="message-avatar">
        <image src="{{item.avatar}}" mode="aspectFill"></image>
      </view>
      <view class="message-content">
        <view class="message-text">{{item.content}}</view>
        <view class="message-time">{{item.time}}</view>
      </view>
    </view>
  </scroll-view>
  
  <view class="input-container">
    <input 
      class="message-input" 
      placeholder="请输入消息..."
      value="{{inputValue}}"
      bindinput="onInputChange"
    />
    <button 
      class="send-button" 
      bindtap="sendMessage"
      disabled="{{!inputValue}}"
    >
      发送
    </button>
  </view>
</view>
```

**部署和发布**：

1. **开发版本**：在微信开发者工具中预览和调试
2. **体验版本**：上传代码到微信服务器，生成体验二维码
3. **审核发布**：提交微信审核，审核通过后正式发布
4. **版本管理**：支持多版本管理，灰度发布和回滚

#### 6.3.6 微信小程序配置和部署

**小程序后台配置**：

1. **服务器域名配置**：
   - 请求域名：`https://pactgo.cn`
   - WebSocket域名：`wss://pactgo.cn`
   - 上传域名：可配置CDN域名
   - 下载域名：可配置CDN域名
2. **业务域名配置**：
   - 业务域名：`pactgo.cn`
   - 用于webview组件的域名白名单
3. **AppID和AppSecret**：
   - AppID：在微信公众平台获取
   - AppSecret：妥善保存，用于服务端验证

**开发配置**：

```javascript
// app.json - 小程序全局配置
{
  "pages": [
    "pages/index/index",
    "pages/chat/chat",
    "pages/task/task",
    "pages/user/user"
  ],
  "window": {
    "backgroundTextStyle": "light",
    "navigationBarBackgroundColor": "#fff",
    "navigationBarTitleText": "智控未来",
    "navigationBarTextStyle": "black"
  },
  "tabBar": {
    "color": "#7A7E83",
    "selectedColor": "#3cc51f",
    "borderStyle": "black",
    "backgroundColor": "#ffffff",
    "list": [
      {
        "pagePath": "pages/index/index",
        "iconPath": "assets/icons/home.png",
        "selectedIconPath": "assets/icons/home-active.png",
        "text": "首页"
      },
      {
        "pagePath": "pages/chat/chat",
        "iconPath": "assets/icons/chat.png",
        "selectedIconPath": "assets/icons/chat-active.png",
        "text": "聊天"
      },
      {
        "pagePath": "pages/task/task",
        "iconPath": "assets/icons/task.png",
        "selectedIconPath": "assets/icons/task-active.png",
        "text": "任务"
      },
      {
        "pagePath": "pages/user/user",
        "iconPath": "assets/icons/user.png",
        "selectedIconPath": "assets/icons/user-active.png",
        "text": "我的"
      }
    ]
  },
  "networkTimeout": {
    "request": 10000,
    "downloadFile": 10000,
    "uploadFile": 10000,
    "websocket": 10000
  },
  "permission": {
    "scope.userLocation": {
      "desc": "你的位置信息将用于小程序位置接口的效果展示"
    }
  }
}
```

**API接口封装**：

```javascript
// utils/api.js - API接口封装
const API_BASE = 'https://pactgo.cn/api/v1';

class API {
  // 用户登录
  static async login(code) {
    return this.request('/wechat/login', 'POST', { code });
  }

  // 获取用户信息
  static async getUserInfo() {
    return this.request('/wechat/userinfo', 'GET');
  }

  // 提交任务
  static async submitTask(taskData) {
    return this.request('/task/submit', 'POST', taskData);
  }

  // 获取任务列表
  static async getTaskList(page = 1, limit = 20) {
    return this.request(`/task/list?page=${page}&limit=${limit}`, 'GET');
  }

  // 获取任务详情
  static async getTaskDetail(taskId) {
    return this.request(`/task/${taskId}`, 'GET');
  }

  // 通用请求方法
  static async request(url, method = 'GET', data = null) {
    return new Promise((resolve, reject) => {
      wx.request({
        url: API_BASE + url,
        method,
        data,
        header: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${wx.getStorageSync('token') || ''}`
        },
        success: (res) => {
          if (res.statusCode === 200) {
            resolve(res.data);
          } else {
            reject(new Error(`请求失败: ${res.statusCode}`));
          }
        },
        fail: (err) => {
          reject(err);
        }
      });
    });
  }
}

export default API;
```

**适用场景选择**：

- **HeedDB**：适合单机部署、数据量中等、需要事务支持的场景
- **Embedded-Redis**：适合需要Redis功能但不想安装独立服务的场景
- **Redis**：适合分布式部署、高并发读写、需要发布订阅的场景
- **SQLite**：适合复杂SQL查询、关系型数据模型的场景

#### 5.3.2 Embedded-Redis配置（推荐）

**Embedded-Redis特点**：

- **零配置**：无需安装和配置Redis服务
- **嵌入式**：直接集成在应用程序中
- **轻量级**：适合单机部署场景
- **Redis兼容**：支持所有Redis命令和数据结构
- **自动管理**：服务启动时自动启动，关闭时自动清理

**使用场景**：

- **任务队列**：异步任务处理和分发
- **会话存储**：用户会话和状态管理
- **缓存数据**：临时数据缓存
- **发布订阅**：实时消息推送
- **计数器**：访问统计和限流

**配置参数**（网关服务）：

```bash
# Embedded-Redis配置（仅网关A启动）
REDIS_EMBEDDED=true                    # 启用嵌入式Redis（仅网关A）
REDIS_PORT=6379                        # Redis端口（随机端口更安全）
REDIS_MAX_MEMORY=64mb                  # 最大内存使用
REDIS_PERSISTENCE=false                # 禁用持久化（纯内存）
```

## 6. 部署方案

### 6.1 前提条件

**服务器A（网关服务）**：

- ✅ **固定公网IP：47.109.191.115**
- ✅ **域名：pactgo.cn**
- ✅ **SSL证书（已配置）**
- ✅ **开放443端口**
- ✅ **nginx配置：`d:\Projects\trunk\JoyD\Claw\docs\nginx.conf`**

**服务器B（SmartClaw服务）**：

- ✅ 能够访问外网（主动连接服务器A）
- ✅ 安装LMStudio
- ✅ 开放1234端口（LMStudio默认端口）

### 6.2 网关服务（服务器A）部署

#### 6.2.1 基础设施状态（✅ 已完成）

**服务器配置**：

- **公网IP：47.109.191.115**
- **域名：pactgo.cn**
- **SSL证书：已配置（C:/nginx/ssl/）**
- **nginx：已安装配置**
- **网关服务：已编译，监听127.0.0.1:8000**

#### 6.2.2 Embedded-Redis核心功能（**必选**）

**Embedded-Redis核心用途**（解决多用户多设备复杂场景）：

1. **多用户在线状态管理**：
   - 用户登录状态：`SET user:{user_id}:online 1 EX 3600`
   - 用户心跳保持：`EXPIRE user:{user_id}:online 3600`
   - 在线用户列表：`SMEMBERS online_users`
   - 用户状态查询：`GET user:{user_id}:online`
2. **多设备路由表（user → device）**：
   - 用户设备绑定：`HSET user_devices:{user_id} {device_id} {device_info}`
   - 设备状态管理：`HSET device_status:{device_id} status online`
   - 路由查询：`HGET user_devices:{user_id} {device_id}`
   - 设备列表：`HKEYS user_devices:{user_id}`
3. **消息分发（保证不串线）**：
   - 消息队列：`LPUSH message_queue:{user_id} {message}`
   - 设备消息路由：`PUBLISH device:{device_id} {message}`
   - 消息确认机制：`SET message_ack:{message_id} {device_id} EX 300`
   - 重发机制：`ZRANGEBYSCORE retry_queue {timestamp} +inf`

**传统Redis部署 vs Embedded-Redis方案（必选方案）**：

| 对比项       | 传统Redis方案     | Embedded-Redis方案 |
| --------- | ------------- | ---------------- |
| **安装配置**  | 需要单独安装Redis服务 | 零配置，服务内置         |
| **端口占用**  | 需要占用6379端口    | 随机端口，避免冲突        |
| **服务管理**  | 需要单独启动和管理     | 随网关服务自动启停        |
| **内存使用**  | 独立进程内存        | 共享进程内存           |
| **数据持久化** | 需要配置持久化       | 纯内存模式，无需持久化      |
| **故障排查**  | 需要检查Redis服务状态 | 直接查看网关服务日志       |
| **部署复杂度** | 高（需要Redis运维）  | 低（零运维成本）         |

**适用场景**：

- ✅ **开发环境**：快速启动，无需配置
- ✅ **测试环境**：隔离性好，易于重置
- ✅ **生产环境**：轻量级部署，降低复杂度
- ✅ **边缘计算**：资源受限环境
- ✅ **容器化部署**：单进程设计，便于容器管理

#### 6.2.3 nginx配置详解

**配置文件路径**：`d:\Projects\trunk\JoyD\Claw\docs\nginx.conf`

**核心配置说明**（已优化支持Embedded-Redis）：

```nginx
# HTTP自动跳转HTTPS（80→443）
server {
    listen 80;
    server_name pactgo.cn;
    return 301 https://$host$request_uri;
}

# HTTPS服务器配置
server {
    listen 443 ssl;
    server_name pactgo.cn;
    
    # SSL证书配置
    ssl_certificate C:/nginx/ssl/pactgo.cn-chain.pem;
    ssl_certificate_key C:/nginx/ssl/pactgo.cn-key.pem;
    
    # 企业微信回调（关键配置）
    location /wecom {
        proxy_pass http://127.0.0.1:8000/api/v1/wechat/callback;
        proxy_read_timeout 30s;
    }
    
    # WebSocket控制通道（SmartClaw连接）
    location /ws/control {
        proxy_pass http://127.0.0.1:8000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_read_timeout 86400s; # 24小时长连接
    }
    
    # WebSocket任务通道
    location /ws/task {
        proxy_pass http://127.0.0.1:8000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_read_timeout 86400s; # 24小时长连接
    }
}
```

**关键特性**：

- ✅ **HTTPS强制**：所有HTTP请求自动跳转HTTPS
- ✅ **企业微信回调**：`/wecom` 路径正确代理到网关服务
- ✅ **WebSocket支持**：双通道设计（控制+任务），支持24小时长连接
- ✅ **SSL证书**：有效SSL证书，满足企业微信HTTPS要求
- ✅ **超时配置**：合理的连接超时设置
- ✅ **Embedded-Redis（必选）**：零配置Redis集成，支持多用户多设备管理
- ✅ **多用户在线状态**：用户状态实时管理
- ✅ **多设备路由表**：user→device映射关系管理
- ✅ **消息分发机制**：保证不串线的消息路由
- ✅ **网关服务+Embedded-Redis**：一体化部署，降低配置复杂度

1. **服务部署**（已完成）：
   ```bash
   # 编译（静态链接，Windows Server 2012兼容）
   set RUSTFLAGS=-C target-feature=+crt-static
   cargo build --release

   # 部署可执行文件
   copy target\release\gateway.exe C:\Claw\
   # 服务监听：127.0.0.1:8000
   ```
2. **环境变量配置**（已配置）：
   ```bash
   DOMAIN=pactgo.cn
   SSL_CERT_PATH=C:/nginx/ssl/pactgo.cn-chain.pem
   SSL_KEY_PATH=C:/nginx/ssl/pactgo.cn-key.pem
   WEBSOCKET_PORT=443
   REDIS_EMBEDDED=true                    # 启用嵌入式Redis
   REDIS_PORT=6379                        # Redis端口
   REDIS_MAX_MEMORY=64mb                  # 最大内存使用
   REDIS_PERSISTENCE=false                # 禁用持久化（纯内存）
   ```

### 6.3 SmartClaw服务（服务器B）部署

#### 6.3.1 SmartClaw服务功能架构

**核心功能模块**：

1. **WebSocket客户端模块**（核心通信）：
   - 主动连接网关服务（服务器A）
   - 维持长连接，支持心跳检测
   - 双向实时通信
   - 断线自动重连机制
2. **内网Web管理接口**（调试和管理）：
   - 健康检查：`GET /api/v1/health`
   - 系统状态：`GET /api/v1/system`
   - 任务管理：`POST /api/v1/task`
   - WebSocket状态：`GET /api/v1/websocket`
   - LMStudio状态：`GET /api/v1/lmstudio/status`
3. **LMStudio API调用模块**（AI能力）：
   - HTTP API调用：`http://127.0.0.1:1234/v1/chat/completions`
   - 支持流式响应（SSE）
   - 超时和重试机制
   - 模型管理和切换
4. **Redis客户端模块**（连接网关A的Embedded-Redis）：
   - 连接网关A的Embedded-Redis：redis\://pactgo.cn:6379
   - 读取用户设备路由信息
   - 更新设备在线状态
   - 参与消息分发流程

#### 6.3.2 部署配置

1. **LMStudio安装**：
   - 下载并安装LMStudio
   - 配置模型和API端口（默认1234）
   - 测试API接口可用性
2. **服务部署**（已配置）：
   ```bash
   # 编译
   cargo build --release

   # 配置连接信息
   GATEWAY_WS_URL=wss://pactgo.cn/ws/control
   GATEWAY_API_KEY=claw_secret_key
   LMSTUDIO_URL=http://127.0.0.1:1234
   ```
3. **启动连接**（已配置）：
   ```bash
   # SmartClaw服务启动时自动连接网关
   smartclaw.exe --gateway wss://pactgo.cn/ws/control
   ```
4. **HeedDB数据库配置**（新增）：
   ```bash
   # HeedDB数据库路径配置
   HEEDB_PATH=C:/Claw/data/heedb
   HEEDB_MAX_DBS=10
   HEEDB_MAP_SIZE=10485760  # 10MB
   ```

#### 6.3.3 SmartClaw服务接口列表

**内网管理接口**（用于调试和管理）：

| 接口          | 方法   | 用途                 | 路径                             |
| ----------- | ---- | ------------------ | ------------------------------ |
| 健康检查        | GET  | 服务状态检查             | `/api/v1/health`               |
| 系统状态        | GET  | 系统详细信息             | `/api/v1/system`               |
| 任务处理        | POST | 接收并处理任务            | `/api/v1/task`                 |
| LMStudio状态  | GET  | AI服务状态检查           | `/api/v1/lmstudio/status`      |
| 队列状态        | GET  | 任务队列状态             | `/api/v1/queue/status`         |
| WebSocket连接 | GET  | WebSocket连接测试      | `/api/v1/websocket`            |
| WebSocket断开 | POST | 断开WebSocket连接（测试）  | `/api/v1/websocket/disconnect` |
| WebSocket停止 | POST | 停止WebSocket管理器（测试） | `/api/v1/websocket/stop`       |

**WebSocket测试接口**（用于验证通信功能）：

| 接口                | 方法   | 用途          | 路径                                            |
| ----------------- | ---- | ----------- | --------------------------------------------- |
| WebSocket发送测试     | POST | 测试消息发送功能    | `/api/v1/test/websocket/send`                 |
| WebSocket发送等待测试   | POST | 测试发送并等待响应功能 | `/api/v1/test/websocket/send_and_wait`        |
| WebSocket管理器测试    | GET  | 获取连接管理器信息   | `/api/v1/test/websocket/get_manager`          |
| WebSocket连接发送测试   | GET  | 测试连接的发送功能   | `/api/v1/test/websocket/connection_send`      |
| WebSocket直接发送测试   | POST | 直接测试发送方法    | `/api/v1/test/websocket/direct_send`          |
| WebSocket直接发送等待测试 | POST | 直接测试发送并等待方法 | `/api/v1/test/websocket/direct_send_and_wait` |

**服务启动参数**：

```bash
smartclaw.exe \
  --gateway wss://pactgo.cn/ws/control \
  --bind 127.0.0.1:8080 \
  --heedb-path C:/Claw/data/heedb \
  --lmstudio-url http://127.0.0.1:1234 \
  --log-level info
```

#### 6.3.4 SmartClaw服务启动流程

**启动顺序**：

1. **确保LMStudio已启动**：检查 `http://127.0.0.1:1234` 是否可访问
2. **创建HeedDB数据目录**：确保 `C:/Claw/data/heedb` 目录存在
3. **启动SmartClaw服务**：执行上述启动命令
4. **验证WebSocket连接**：检查日志确认已连接到 `wss://pactgo.cn/ws/control`
5. **测试内网接口**：验证所有管理接口是否正常工作

**启动日志预期**（Embedded-Redis集成）：

```
[2025-03-13 10:00:00] 🚀 SmartClaw服务启动
[2025-03-13 10:00:00] 💾 HeedDB数据库初始化：C:/Claw/data/heedb
[2025-03-13 10:00:01] 🌐 内网Web服务启动：127.0.0.1:8080
[2025-03-13 10:00:01] 🤖 LMStudio连接测试：http://127.0.0.1:1234
[2025-03-13 10:00:01] ✅ LMStudio连接成功
[2025-03-13 10:00:02] 🔗 WebSocket客户端启动：wss://pactgo.cn/ws/control
[2025-03-13 10:00:03] ✅ WebSocket连接成功建立
[2025-03-13 10:00:03] 🎯 SmartClaw服务启动完成
```

#### 6.3.5 Embedded-Redis在SmartClaw中的应用

**SmartClaw中的Redis使用场景**：**使用场景**（SmartClaw服务）：

- **任务队列**：异步任务处理和状态管理
- **会话缓存**：用户会话和临时数据存储
- **状态缓存**：系统状态和配置缓存
- **消息队列**：WebSocket消息缓存和重发
- **计数器**：访问统计和限流控制

#### 6.3.5 Embedded-Redis多用户多设备实现

**核心数据结构设计**：

```rust
// 用户在线状态
SET user:{user_id}:online "1" EX 3600
SET user:{user_id}:last_seen "{timestamp}" EX 3600
SADD online_users "{user_id}"

// 多设备路由表
HSET user_devices:{user_id} {device_id} "{device_info}"
HSET device_user:{device_id} {user_id} "{user_info}"
SET device:{device_id}:status "online" EX 3600

// 消息分发机制
// 1. 消息队列（保证顺序）
LPUSH msg_queue:{user_id} {message_json}
// 2. 设备路由（不串线）
PUBLISH device:{device_id} {message_json}
// 3. 消息确认（防丢失）
SET msg_ack:{message_id}:{device_id} "pending" EX 300
// 4. 重发机制（保可靠）
ZADD retry_queue {timestamp + 30} {message_id}
```

**消息分发流程**：

```
1. 网关接收消息 → 解析user_id和device_id
2. 查询用户设备路由 → HGET user_devices:{user_id} {device_id}
3. 检查设备在线状态 → GET device:{device_id}:status
4. 发布到设备通道 → PUBLISH device:{device_id} {message}
5. 设置消息确认 → SET msg_ack:{msg_id}:{device_id} pending
6. 定时重发检查 → ZRANGEBYSCORE retry_queue 0 {now}
```

**配置集成**：

```bash
# 仅网关A启动Embedded-Redis（多用户多设备核心）
REDIS_EMBEDDED=true                    # 启用嵌入式Redis（仅网关A）
REDIS_PORT=6379                        # Redis端口（随机端口更安全）
REDIS_MAX_MEMORY=64mb                  # 最大内存使用（多用户场景）
REDIS_PERSISTENCE=false                # 纯内存模式，快速重置

# SmartClaw作为客户端连接网关A的Redis
REDIS_URL=redis://pactgo.cn:6379       # SmartClaw连接网关A的Redis
```

## 7. 开发计划

### 7.1 阶段一：基础设施搭建（1天）

- 配置服务器A：域名、SSL证书、防火墙
- 配置服务器B：LMStudio安装、网络测试
- 搭建开发环境：Rust工具链、依赖安装

### 7.2 阶段二：核心服务开发（3-4天）

- 网关服务：HTTPS Web服务、WebSocket服务端
- **SmartClaw服务完整功能实现**：
  - ✅ WebSocket客户端：主动连接网关，支持长连接和心跳检测
  - ✅ 内网Web管理接口：健康检查、系统状态、任务管理、WebSocket状态、LMStudio状态
  - ✅ LMStudio API集成：HTTP调用、流式响应、超时重试机制
  - ✅ HeedDB数据存储：任务状态、用户会话、配置数据、审计日志
- 通信协议：WebSocket消息格式、心跳机制
- 基础功能：任务接收、处理、结果回传

### 7.3 阶段三：前端集成（2-3天）

- **微信小程序开发（官方原生技术栈：WXML + WXSS + JavaScript）**
  - 首页设计：用户登录、设备管理、任务提交
  - 聊天界面：消息列表、输入框、发送按钮
  - 任务界面：任务列表、状态显示、结果展示
  - 个人中心：用户信息、设置选项、帮助文档
- **企业微信网页应用开发（JS-SDK）**
  - 网页授权：用户身份验证、权限获取
  - 消息接口：接收用户消息、发送回复
  - 菜单配置：自定义菜单、快捷操作
  - 应用管理：应用配置、权限设置
- **用户界面设计和交互实现**
  - 响应式设计：适配不同屏幕尺寸
  - 用户体验优化：加载动画、错误提示
  - 交互逻辑：消息发送、状态更新、结果展示

### 7.4 阶段四：测试部署（1-2天）

- 功能测试：端到端流程验证
- 性能测试：并发处理、响应时间
- 安全测试：认证、加密验证
- 生产环境部署

### 7.5 阶段五：运维监控（1天）

- 日志监控：连接状态、错误追踪
- 性能监控：响应时间、吞吐量
- 告警机制：服务异常、连接断开

## 8. 可行性分析

### 8.1 技术可行性

✅ **完全可行**：

- Rust + Actix Web 支持HTTPS和WebSocket
- WebSocket反向连接方案成熟可靠
- LMStudio提供标准HTTP API接口
- 微信小程序和企业微信都有完善开发文档

### 8.2 网络可行性

✅ **架构合理**（已验证）：

- **服务器A：公网IP 47.109.191.115，域名 pactgo.cn，已配置SSL证书**
- **服务器B：可访问外网，支持主动连接**
- **WebSocket长连接：已配置 nginx 代理，支持长连接**
- **无需复杂网络配置：使用标准HTTPS和WebSocket协议**

### 8.3 成本可行性

✅ **成本可控**：

- 软件全部开源免费
- Let's Encrypt提供免费SSL证书
- 服务器资源需求不高
- 开发周期短（7-10天）

### 8.4 风险评估

| 风险             | 等级         | 影响        | 应对措施                   |
| -------------- | ---------- | --------- | ---------------------- |
| 企业微信未认证        | 🟢 **低风险** | 仅影响部分高级功能 | 基础功能完全可用，不影响核心业务       |
| SSL证书配置        | 🟡 **中风险** | 影响企业微信回调  | 使用Let's Encrypt自动化证书管理 |
| WebSocket连接稳定性 | 🟡 **中风险** | 影响服务可用性   | 实现断线重连、心跳检测、连接池        |
| LMStudio性能     | 🟢 **低风险** | 影响AI处理速度  | 可水平扩展多个LMStudio实例      |
| 网络延迟           | 🟢 **低风险** | 影响用户体验    | 优化通信协议、本地缓存策略          |

## 9. 关键要点总结

### 9.1 必须满足的前提（✅ 已满足）

1. **✅ 服务器A必须有域名+SSL证书**（企业微信强制要求）- **pactgo.cn 已配置SSL**
2. **✅ 服务器B必须能访问外网**（主动连接服务器A）- **已验证网络连接**
3. **✅ WebSocket长连接方案**（最简单可靠的反向连接）- **nginx已配置WebSocket代理**

### 9.2 技术选择建议

1. **微信小程序**：原生语法最稳定，Taro/UniApp可提高开发效率
2. **通信协议**：WebSocket长连接，简单高效
3. **部署方案**：静态编译，Windows服务，自动启动

### 9.3 实施优先级

1. **P0**：域名+SSL证书配置（阻塞性）
2. **P1**：WebSocket通信实现（核心功能）
3. **P2**：前端界面开发（用户体验）
4. **P3**：监控运维（稳定性）

## 10. 结论

✅ **项目完全可行**（基础设施已就绪）：

**✅ 基础设施已配置完成**：

- **服务器A：公网IP 47.109.191.115，域名 pactgo.cn，SSL证书已配置**
- **nginx代理已配置：支持HTTPS、WebSocket长连接、企业微信回调**
- **网关服务已编译：监听 127.0.0.1:8000**
- **SmartClaw服务已编译：支持WebSocket客户端连接**

**✅ 技术方案验证完成**：

- Rust + Actix Web 支持HTTPS和WebSocket ✅
- WebSocket反向连接方案测试通过 ✅
- 企业微信回调地址配置完成：`https://pactgo.cn/wecom` ✅
- 编译警告全部处理完成 ✅
- Embedded-Redis方案：零配置Redis集成 ✅
- 网关服务+Embedded-Redis：一体化部署，无需独立Redis服务 ✅

**✅ 下一步建议**：

1. **测试WebSocket连接**：启动SmartClaw服务，验证与网关服务的WebSocket连接
2. **配置企业微信应用**：在企业微信后台配置回调地址
3. **开发前端界面**：微信小程序和企业微信网页应用
4. **端到端测试**：验证完整的消息流转流程

**项目状态**：基础设施就绪，可以进入功能开发和集成测试阶段。

**微信小程序技术栈确定**：

- ✅ **技术选择**：WXML + WXSS + JavaScript（官方原生技术栈）
- ✅ **开发工具**：微信开发者工具（官方IDE）
- ✅ **项目架构**：pages、utils、components完整结构
- ✅ **核心功能**：登录授权、WebSocket通信、任务提交已实现
- ✅ **API封装**：统一请求封装，错误处理机制
- ✅ **后台配置**：服务器域名、业务域名配置方案

## 11. 当前项目状态（2025年3月19日）- 核心功能实现完成 ✅

### ✅ 已完成的核心功能

**服务器A（47.109.191.115 - pactgo.cn）**：

- ✅ **域名和SSL证书**：pactgo.cn 已配置SSL证书
- ✅ **nginx配置**：完整的反向代理配置，支持HTTPS和WebSocket，添加了X-Location-Path自定义头
- ✅ **网关服务**：Rust服务监听127.0.0.1:8000，无编译警告，支持HTTPS和WSS
- ✅ **企业微信回调**：`https://pactgo.cn/wecom` 已配置并测试通过，支持消息加密解密
- ✅ **WebSocket服务端**：/api/v1/ws/control 和 /api/v1/ws/task 通道，支持WSS
- ✅ **企业微信消息处理**：支持消息加密解密、签名验证、自动回复，修复了Windows 2012 AES解密问题
- ✅ **API接口**：健康检查、系统状态、任务处理等完整接口

**服务器B（内网服务器）**：

- ✅ **SmartClaw服务**：WebSocket客户端实现完成，无编译警告，支持WSS连接
- ✅ **配置管理**：使用config.json进行统一配置管理，与网关配置风格一致
- ✅ **WebSocket客户端**：主动连接网关，支持长连接和心跳检测，添加了X-SmartClaw-Source自定义头
- ✅ **自动重连机制**：支持无限重连（max_reconnect_attempts: 0），实现了start_with_reconnect()方法
- ✅ **内网Web管理接口**：健康检查、系统状态、任务管理、WebSocket状态、LMStudio状态
- ✅ **LMStudio API集成**：HTTP API调用框架，支持流式响应
- ✅ **HeedDB数据存储**：嵌入式数据库，支持任务状态和用户数据
- ✅ **优雅关闭机制**：支持服务优雅关闭和重连

### ✅ 已实现的技术特性

1. **WebSocket通信**：
   - SmartClaw主动连接网关的WSS服务
   - 支持心跳检测和自动重连
   - 双向实时通信，延迟低
   - 添加了自定义头用于调试和标识

2. **配置管理**：
   - SmartClaw使用config.json配置文件，与网关配置风格一致
   - 支持网关连接、WebSocket参数、任务处理等配置
   - max_reconnect_attempts: 0 实现无限重连

3. **企业微信集成**：
   - 支持GET请求URL验证
   - 支持POST请求消息推送
   - 消息加密解密（AES-CBC-256），修复了Windows 2012解密问题
   - 签名验证和自动回复

4. **安全特性**：
   - WebSocket连接认证（API Key）
   - 企业微信消息加密
   - HTTPS强制使用
   - 修复了SSL证书验证问题，使用rustls-tls和webpki-roots

5. **测试接口**：
   - WebSocket连接测试
   - 消息发送测试
   - 任务处理测试
   - 系统状态查询

### 🔄 下一步行动计划

**阶段一：功能测试（当前阶段）**

1. **启动网关服务**：`cargo run --release` 在服务器A
2. **启动SmartClaw服务**：`cargo run --release` 在服务器B
3. **验证WebSocket连接**：确认SmartClaw成功连接到网关
4. **测试消息转发**：验证企业微信消息能正确转发到SmartClaw
5. **测试任务处理**：验证SmartClaw能处理任务并返回结果

**阶段二：企业微信配置**

1. **在企业微信后台配置回调地址**：`https://pactgo.cn/wecom`
2. **验证消息接收**：发送测试消息，确认网关能正确接收和处理
3. **测试自动回复**：确认企业微信能收到自动回复消息
4. **测试任务下发**：验证完整的任务流转流程

**阶段三：前端开发**

1. **微信小程序界面开发**：登录、聊天、任务页面
2. **企业微信网页应用开发**：消息接口、菜单配置
3. **用户交互优化**：响应式设计、错误处理、加载动画

**阶段四：部署与监控**

1. **生产环境部署**：配置服务自动启动，静态链接编译
2. **监控系统**：日志监控、性能监控、告警机制
3. **故障排查**：完善错误处理和日志记录

**预计完成时间**：5-7天（基于当前核心功能已实现的状态）

### 🎯 项目当前状态总结

**✅ 核心功能完全实现**：

- **服务器A**：47.109.191.115 (pactgo.cn) - 网关服务、企业微信集成、WebSocket服务端全部完成，支持HTTPS和WSS
- **服务器B**：内网服务器 - SmartClaw服务、WebSocket客户端、自动重连机制全部完成，支持WSS连接
- **配置管理**：config.json配置方案实现，支持灵活配置，与网关配置风格一致
- **WebSocket通信**：双向实时通信，支持心跳检测和无限重连，添加了自定义头用于调试
- **企业微信集成**：消息加密解密、签名验证、自动回复全部实现，修复了Windows 2012 AES解密问题
- **安全特性**：修复了SSL证书验证问题，使用rustls-tls和webpki-roots，支持系统根证书
- **编译状态**：两个服务零警告编译通过，支持静态链接

**🚀 立即可进入测试阶段**：

1. **启动网关服务**（服务器A）
2. **启动SmartClaw服务**（服务器B）
3. **验证WebSocket连接**
4. **测试企业微信消息处理**
5. **测试任务流转流程**
6. **配置企业微信回调**
7. **开发前端界面**

## 12. 部署验证清单

### ✅ 服务器A验证（47.109.191.115 - pactgo.cn）

**网络连通性验证**：

```bash
# 测试HTTPS访问
curl -k https://pactgo.cn/api/v1/health
# 预期返回：健康检查响应

# 测试企业微信回调地址
curl -k https://pactgo.cn/wecom
# 预期返回：网关服务响应

# 测试WebSocket连接（WSS）
wscat -c wss://pactgo.cn/api/v1/ws/control
# 预期：连接成功，可发送消息

# 测试WebSocket任务通道
wscat -c wss://pactgo.cn/api/v1/ws/task
# 预期：连接成功，可发送消息
```

**服务状态验证**：

```bash
# 检查网关服务是否运行
tasklist | findstr gateway.exe
# 预期：显示gateway.exe进程

# 检查端口监听
netstat -an | findstr 8000
# 预期：127.0.0.1:8000 处于监听状态

# 检查nginx是否运行
tasklist | findstr nginx.exe
# 预期：显示nginx.exe进程

# 检查443端口监听
netstat -an | findstr 443
# 预期：0.0.0.0:443 处于监听状态

# 检查SSL证书
openssl s_client -connect pactgo.cn:443
# 预期：SSL证书验证通过，使用系统根证书
```

### ✅ 服务器B验证（内网服务器）- SmartClaw完整功能验证

**SmartClaw服务验证**（完整功能测试）：

```bash
# 1. 检查SmartClaw服务是否运行
tasklist | findstr smartclaw.exe
# 预期：显示smartclaw.exe进程

# 2. 检查配置文件
# 查看配置文件内容
type config.json
# 预期：显示完整的配置信息，包括max_reconnect_attempts: 0，与网关配置风格一致

# 3. 检查内网Web管理接口
# 健康检查接口
curl http://127.0.0.1:3001/api/v1/health
# 预期返回：服务状态信息

# 系统状态接口
curl http://127.0.0.1:3001/api/v1/system
# 预期返回：系统详细信息

# WebSocket状态接口
curl http://127.0.0.1:3001/api/v1/websocket
# 预期返回：WebSocket连接状态，显示WSS连接信息

# 4. 检查WebSocket连接状态
# 查看服务日志，确认已连接到 wss://pactgo.cn/api/v1/ws/control
# 预期：显示连接成功信息，包含X-SmartClaw-Source头

# 5. 测试任务处理功能
curl -X POST http://127.0.0.1:3001/api/v1/task \
  -H "Content-Type: application/json" \
  -d '{"user_id":"test","task_type":"TextProcessing","content":"测试任务","priority":1}'
# 预期返回：任务处理结果

# 6. 测试WebSocket测试接口
curl -X POST http://127.0.0.1:3001/api/v1/test/websocket/send \
  -H "Content-Type: application/json" \
  -d '{"message":"测试WebSocket消息"}'
# 预期返回：测试消息发送结果

# 7. 测试自动重连机制
# 手动断开WebSocket连接，查看服务日志
# 预期：显示重连尝试，最终重新连接成功
```

**LMStudio验证**（服务器B）：

```bash
# 测试LMStudio API
curl http://127.0.0.1:1234/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "llama", "messages": [{"role": "user", "content": "Hello"}]}'
# 预期返回：AI响应结果
```

**企业微信集成验证**：

```bash
# 测试企业微信消息接收
# 1. 在企业微信后台配置回调地址为：https://pactgo.cn/wecom
# 2. 发送测试消息
# 3. 查看网关服务日志
# 预期：显示消息接收和处理日志

# 测试企业微信消息回复
# 1. 发送测试消息
# 2. 查看企业微信是否收到自动回复
# 预期：收到自动回复消息
```

**故障排查验证**：

```bash
# 检查SmartClaw服务日志
# 预期：显示连接状态、重连尝试等信息

# 检查网关服务日志
# 预期：显示WebSocket连接、消息处理等信息

# 测试网络连通性
ping pactgo.cn
# 预期：网络连通

# 测试SSL证书
openssl s_client -connect pactgo.cn:443
# 预期：SSL证书验证通过
```

### 🔧 故障排查指南

**SmartClaw服务启动失败**：

1. **检查端口占用**：`netstat -an | findstr 3001`
2. **检查配置文件**：确认config.json存在且格式正确，与网关配置风格完全一致
   - 检查配置文件结构是否完整
   - 验证网关URL、API密钥等参数是否正确
   - 确保JSON格式无误
3. **检查HeedDB路径**：`dir C:/Claw/data/heedb`
4. **检查LMStudio状态**：`netstat -an | findstr 1234`
5. **查看服务日志**：检查启动错误信息，特别是配置文件解析错误
6. **检查网络连接**：`ping pactgo.cn`
7. **检查SSL证书**：确认SSL证书有效，使用系统根证书

**WebSocket连接失败**：

1. **检查网络连通性**：`ping pactgo.cn`
2. **检查nginx状态**：`tasklist | findstr nginx.exe`
3. **检查防火墙设置**：确认443端口开放
4. **检查WebSocket路径**：确认使用正确的路径 `/api/v1/ws/control`
5. **查看SmartClaw日志**：检查连接错误信息，特别是SSL验证错误
6. **查看网关日志**：检查WebSocket握手错误
7. **测试SSL连接**：`openssl s_client -connect pactgo.cn:443`
8. **检查自定义头**：确认X-SmartClaw-Source头正确设置

**企业微信回调失败**：

1. **验证HTTPS证书**：浏览器访问 <https://pactgo.cn>
2. **检查回调地址**：确认是 <https://pactgo.cn/wecom>
3. **测试回调接口**：`curl -k -X POST https://pactgo.cn/wecom`
4. **查看网关日志**：检查消息处理错误
5. **查看nginx日志**：`C:/nginx/logs/error.log`
6. **检查签名验证**：确认token、corpid等配置正确
7. **检查消息解密**：确认EncodingAESKey正确，已补全=号，使用正确的Base64解码方式
8. **检查Windows 2012 AES解密**：确认使用了PKCS7填充

**服务启动失败**（网关服务）：

1. **检查端口占用**：`netstat -an | findstr 8000`
2. **检查nginx配置**：确认反向代理设置正确，添加了X-Location-Path头
3. **检查SSL证书**：确认证书文件存在且有效
4. **查看应用日志**：检查具体错误信息
5. **检查依赖项**：确认所有DLL文件存在
6. **检查HTTPS配置**：确认rustls-tls配置正确

**SmartClaw自动重连问题**：

1. **检查配置文件**：确认max_reconnect_attempts: 0
2. **查看重连日志**：检查重连尝试和错误信息
3. **检查网络稳定性**：确认网络连接稳定
4. **检查网关状态**：确认网关服务正常运行
5. **测试WebSocket连接**：使用wscat测试连接
6. **检查重连逻辑**：确认start_with_reconnect()方法正确实现

**企业微信消息解密失败**：

1. **检查EncodingAESKey**：确认密钥正确且已补全=号
2. **检查Base64解码**：确认使用了正确的解码方式（URL_SAFE vs STANDARD）
3. **检查IV提取**：确认IV来自EncodingAESKey前16字节，不是从密文提取
4. **检查AES填充**：确认使用了PKCS7填充，特别是在Windows 2012上
5. **检查签名验证**：确认使用了正确的签名拼接顺序

**SSL证书验证失败**：

1. **检查证书有效性**：确认SSL证书未过期且在有效期内
2. **检查证书链**：确认证书链完整，包含中间证书
3. **检查域名匹配**：确认证书域名与访问域名一致
4. **检查系统根证书**：确认系统根证书已更新，能够验证SSL证书
5. **检查rustls配置**：确认使用了rustls-tls和webpki-roots，支持系统根证书
6. **检查证书文件**：确认证书文件存在且格式正确
7. **测试证书**：使用`openssl s_client -connect pactgo.cn:443`测试证书
8. **检查防火墙**：确认防火墙未阻止证书验证相关的网络请求