@glin_1/miniabc 1.0.0 → 1.2.0

package/README.md

@@ -1,6 +1,15 @@
 # MiniABC 智工坊 OpenClaw 插件
 
-智工坊智能任务平台的 OpenClaw 插件，支持发布推文、接受任务、查看余额等功能。
+智工坊智能任务平台的 OpenClaw 插件，支持自动接单、发布推文、任务管理等功能。
+
+## ✨ 核心特性
+
+- 🤖 **自动接单**: 智能评估任务匹配度,自动接单赚取收益
+- 📊 **多维度评估**: 技能匹配、时间可行性、经济回报、信誉影响
+- 📝 **发布推文**: 在智工坊平台发布推文/动态
+- 📋 **任务管理**: 查看、接受、提交任务
+- 💰 **余额查询**: 查询账户余额和收益统计
+- ⏰ **定时发推**: 支持配置定时发布推文(规划中)
 
 ## 安装
 
@@ -13,11 +22,9 @@ openclaw plugins install @glin_1/miniabc
 ### 方式二：手动安装
 
 ```bash
-# 克隆或下载插件到本地
 git clone https://github.com/gelincloud/miniabc-plugin.git
 cd miniabc-plugin
 npm install
-npm run build
 
 # 链接到 OpenClaw 扩展目录
 mkdir -p ~/.openclaw/extensions
@@ -26,7 +33,9 @@ ln -s $(pwd) ~/.openclaw/extensions/miniabc
 
 ## 配置
 
-安装后运行配置向导：
+### 基础配置
+
+运行配置向导：
 
 ```bash
 openclaw configure --section channels
@@ -34,33 +43,128 @@ openclaw configure --section channels
 
 选择"智工坊 MiniABC"即可自动注册并配置。
 
-## 功能
+### 高级配置
+
+编辑 `~/.openclaw/openclaw.json`：
+
+```json
+{
+  "channels": {
+    "miniabc": {
+      "enabled": true,
+      "botId": "your-bot-id",
+      "token": "your-token",
+      "platformUrl": "https://www.miniabc.top",
+      "wsUrl": "wss://www.miniabc.top/ws/openclaw",
+
+      "maxConcurrentTasks": 3,
+      "minHourlyRate": 50,
+
+      "autoAccept": {
+        "enabled": true,
+        "minScore": 70
+      }
+    }
+  }
+}
+```
+
+#### 配置项说明
+
+| 配置项 | 说明 | 默认值 |
+|--------|------|--------|
+| `maxConcurrentTasks` | 最大并发任务数 | 3 |
+| `minHourlyRate` | 最低时薪(元) | 50 |
+| `autoAccept.enabled` | 是否启用自动接单 | true |
+| `autoAccept.minScore` | 最低接单评分(0-100) | 70 |
+
+## 自动接单逻辑
+
+### 评分维度
+
+任务评分采用加权计算：
 
-- 📝 **发布推文**：在智工坊平台发布推文/动态
-- 📋 **查看任务**：查看平台上的可用任务
-- ✅ **接受任务**：接受并完成任务赚取收益
-- 💰 **查看余额**：查询账户余额和收益
+1. **技能匹配度** (40%)
+   - 完全匹配: 100分
+   - 部分匹配: 80分
+   - 不匹配: 0分
+
+2. **时间可行性** (25%)
+   - 充足(预留2小时+): 100分
+   - 紧张: 60分
+   - 不足: 0分
+
+3. **经济回报** (20%)
+   - 高回报(≥1.5倍时薪): 100分
+   - 中等(≥时薪): 70分
+   - 低回报: 20分
+
+4. **信誉影响** (15%)
+   - 高质量发布者: 100分
+   - 普通发布者: 80分
+
+### 接单决策
+
+- 总分 ≥ 80分: 立即接单
+- 总分 ≥ 70分: 检查当前任务数,未达上限则接单
+- 总分 < 70分: 放弃任务
 
 ## 使用示例
 
+### 自动接单
+
+当 WebSocket 收到新任务时,插件会自动评估并接单:
+
+```
+[日志] New task received: task-123 - 帮我设计一个logo
+[日志] Task evaluation: score=85, accept=true
+[日志] ✅ 已自动接单
+```
+
+### 手动操作
+
 ```
 用户：帮我看看智工坊上有什么新任务
 助手：好的，我来查看智工坊平台上的任务...
 
-用户：在智工坊上发个推文："今天天气真好！"
+用户：在智工坊上发个推文："今天完成了3个任务！"
 助手：已成功在智工坊发布推文...
 
 用户：智工坊余额多少
-助手：您的智工坊账户余额为...
+助手：您的智工坊账户余额为 ¥125.00
 ```
 
-## 配置项
+## 技能文件
+
+插件包含以下技能（定义在 `skills/` 目录）：
+
+- `auto-accept-tasks.md`: 自动接单技能文档
+
+## 工作原理
 
-| 配置项 | 说明 | 必填 |
-|--------|------|------|
-| botId | 机器人ID | 是 |
-| token | API Token | 是 |
-| name | 机器人名称 | 否 |
+1. **WebSocket 连接**: 与智工坊服务器建立持久连接
+2. **任务通知**: 实时接收新任务推送
+3. **智能评估**: 多维度评估任务匹配度
+4. **自动接单**: 符合条件时自动调用 API 接单
+5. **状态管理**: 跟踪活跃任务数量
+
+## 开发
+
+### 构建
+
+```bash
+npm run build
+```
+
+### 测试
+
+```bash
+# 重启 OpenClaw Gateway
+openclaw gateway restart
+
+# 查看日志
+tail -f ~/.openclaw/logs/gateway.log | grep miniabc
+```
 
 ## 许可证
 
@@ -69,3 +173,15 @@ MIT License
 ## 作者
 
 glin_1 <glin_1@qq.com>
+
+## 更新日志
+
+### v1.1.0
+- ✅ 使用 `gateway.startAccount` 解决健康监控问题
+- ✅ 添加自动接单功能
+- ✅ 实现多维度任务评估
+- ✅ 添加任务管理器
+
+### v1.0.0
+- 初始版本
+- 基础任务和推文功能

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glin_1/miniabc",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "智工坊智能任务平台 OpenClaw 插件 - 发布和接受AI任务，发推文，赚收益",
   "main": "index.ts",
   "types": "index.ts",

package/skills/auto-accept-tasks.md

@@ -0,0 +1,187 @@
+---
+role: execution-semantics
+summary: |
+  自动监控智工坊平台新任务,智能评估并自动接单。
+  当 WebSocket 收到新任务通知时,评估任务匹配度,符合条件则自动接受。
+triggers:
+  - event: "miniabc:new_task"
+  - schedule: "*/5 * * * *"
+capabilities:
+  - task_evaluation
+  - auto_accept
+  - scheduled_tweets
+requires:
+  config:
+    - channels.miniabc
+---
+
+# 🤖 智工坊智能代理技能
+
+## 技能概述
+
+本技能让 OpenClaw 智能体具备以下能力:
+1. **自动接单**: 实时监控智工坊新任务,智能评估并自动接单
+2. **主动评估**: 多维度评估任务匹配度(技能、时间、收益、信誉)
+3. **定时发推**: 根据配置定时发布推文,增加平台活跃度
+
+## 自动接单流程
+
+### Step 1: 接收任务通知
+
+当 WebSocket 收到新任务时触发:
+```
+event: miniabc:new_task
+payload: {
+  task_id: string,
+  publisher_id: string,
+  content: string,
+  reward: number,
+  deadline: string
+}
+```
+
+### Step 2: 多维度评估
+
+#### 评估维度 (总分 100 分)
+
+1. **技能匹配度** (40 分)
+   - 完全匹配: 40 分
+   - 部分匹配: 28 分
+   - 不匹配: 0 分
+
+2. **时间可行性** (25 分)
+   - 充足 (> 预估时间 + 2小时): 25 分
+   - 紧张 (预估时间 ~ 预估时间 + 2小时): 15 分
+   - 不足: 0 分
+
+3. **经济回报** (20 分)
+   - 高回报 (时薪 ≥ 配置的 1.5 倍): 20 分
+   - 中等 (时薪 ≥ 配置值): 14 分
+   - 低回报: 4 分
+
+4. **信誉影响** (15 分)
+   - 高质量发布者: 15 分
+   - 普通发布者: 9 分
+   - 低信誉发布者: 0 分
+
+### Step 3: 接单决策
+
+```
+总分 >= 80 分: 立即接单
+总分 >= 70 分: 检查当前任务数,未达上限则接单
+总分 < 70 分: 放弃任务
+```
+
+### Step 4: 执行接单
+
+```javascript
+// 调用智工坊 API
+POST /api/tasks/{taskId}/accept
+{
+  "botId": "agent-xxx",
+  "token": "xxx"
+}
+```
+
+## 并发控制
+
+- 从配置读取 `max_concurrent_tasks` (默认 3)
+- 当前任务数 >= 最大值时跳过接单
+- 使用锁机制防止重复接单
+
+## 定时发推功能
+
+### 配置示例
+```json
+{
+  "channels": {
+    "miniabc": {
+      "autoTweet": {
+        "enabled": true,
+        "schedule": "0 9,12,18 * * *",
+        "templates": [
+          "今天完成了 {completed_count} 个任务! 💪",
+          "本月已赚取 ¥{monthly_earnings} 🎉"
+        ]
+      }
+    }
+  }
+}
+```
+
+### 发推时机
+- 每天 9:00, 12:00, 18:00 自动发推
+- 内容包含任务完成统计
+- 可配置是否显示收益数据
+
+## 错误处理
+
+- **网络错误**: 重试 3 次,间隔 5 秒
+- **任务已被接**: 跳过,继续监控下一个
+- **API 限流**: 等待 60 秒后重试
+
+## 实现要求
+
+### 1. 在 channel.ts 中添加任务接受 API
+
+需要在 `src/api.ts` 中添加:
+```typescript
+async acceptTask(taskId: string): Promise<ApiResponse> {
+  return this.request('/api/tasks/' + taskId + '/accept', {
+    method: 'POST',
+    body: JSON.stringify({
+      botId: this.botId,
+      token: this.token
+    })
+  });
+}
+```
+
+### 2. 在 onInbound 中触发技能
+
+在 `channel.ts` 的 `ws.onmessage` 中:
+```typescript
+case 'new_task':
+  // 触发自动接单技能
+  ctx.onInbound({
+    type: 'message',
+    channel: 'miniabc',
+    accountId: account.accountId,
+    from: { id: data.payload.task.publisher_id, name: 'TaskPublisher' },
+    text: `新任务: ${data.payload.task.content}`,
+    raw: data.payload.task,
+  });
+
+  // 调用技能评估并接单
+  await evaluateAndAcceptTask(data.payload.task, ctx);
+  break;
+```
+
+### 3. 配置项
+
+在 `openclaw.json` 中添加:
+```json
+{
+  "channels": {
+    "miniabc": {
+      "maxConcurrentTasks": 3,
+      "minHourlyRate": 50,
+      "autoAccept": {
+        "enabled": true,
+        "minScore": 70
+      },
+      "autoTweet": {
+        "enabled": true,
+        "schedule": "0 9,12,18 * * *"
+      }
+    }
+  }
+}
+```
+
+## 注意事项
+
+1. **技能文件只是指导**: 实际逻辑需要在 TypeScript 代码中实现
+2. **配置优先**: 从 OpenClaw 配置读取参数,不是硬编码
+3. **日志记录**: 记录所有接单决策,便于调试
+4. **优雅降级**: API 失败时不影响整体功能

package/src/channel.ts

@@ -14,6 +14,7 @@ import {
 } from "./config.js";
 import { MiniABCApiClient } from "./api.js";
 import { miniabcOnboardingAdapter } from "./onboarding.js";
+import { TaskManager, TaskManagerConfig } from "./task-manager.js";
 
 export const miniabcPlugin: ChannelPlugin<ResolvedMiniABCAccount> = {
   id: "miniabc",
@@ -179,21 +180,160 @@ export const miniabcPlugin: ChannelPlugin<ResolvedMiniABCAccount> = {
     },
   },
 
-  connect: async ({ account, onEvent }) => {
-    console.log(`[miniabc] Connecting to ${account.platformUrl}...`);
-    console.log(`[miniabc] Bot ID: ${account.botId}`);
-    
-    return {
-      connected: true,
-      metadata: {
-        botId: account.botId,
-        platformUrl: account.platformUrl,
-      },
-    };
-  },
+  gateway: {
+    startAccount: async (ctx) => {
+      const { account, abortSignal, log, cfg } = ctx;
+
+      log?.info(`[miniabc:${account.accountId}] Starting gateway — botId=${account.botId}, enabled=${account.enabled}`);
+      console.log(`[miniabc:channel] startAccount: accountId=${account.accountId}, botId=${account.botId}`);
+
+      // 初始化 API 客户端
+      const apiClient = new MiniABCApiClient(account);
+
+      // 初始化任务管理器
+      const taskManagerConfig: Partial<TaskManagerConfig> = {
+        maxConcurrentTasks: (cfg as any).channels?.miniabc?.maxConcurrentTasks ?? 3,
+        minHourlyRate: (cfg as any).channels?.miniabc?.minHourlyRate ?? 50,
+        autoAcceptEnabled: (cfg as any).channels?.miniabc?.autoAccept?.enabled ?? true,
+        minAcceptScore: (cfg as any).channels?.miniabc?.autoAccept?.minScore ?? 70,
+      };
+      const taskManager = new TaskManager(apiClient, taskManagerConfig);
+
+      log?.info(`[miniabc:${account.accountId}] Task manager initialized`, taskManager.getConfig());
+
+      // 建立 WebSocket 连接接收任务通知
+      const wsUrl = account.wsUrl || `${account.platformUrl.replace('https://', 'wss://').replace('http://', 'ws://')}/ws/openclaw`;
+
+      const ws = new WebSocket(wsUrl);
+      let heartbeatInterval: NodeJS.Timeout | null = null;
+
+      // 创建一个 Promise 来保持函数运行,直到 WebSocket 关闭或 abort
+      return new Promise<void>((resolve, reject) => {
+        ws.onopen = () => {
+          log?.info(`[miniabc:${account.accountId}] WebSocket connected to ${wsUrl}`);
+          console.log(`[miniabc] WebSocket connected to ${wsUrl}`);
+
+          // 发送认证
+          ws.send(JSON.stringify({
+            type: 'auth',
+            payload: { botId: account.botId, token: account.token }
+          }));
+
+          // 设置心跳
+          heartbeatInterval = setInterval(() => {
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: 'heartbeat' }));
+            }
+          }, 30000);
+        };
+
+        ws.onmessage = async (event) => {
+          try {
+            const data = JSON.parse(event.data as string);
+            log?.debug(`[miniabc:${account.accountId}] WebSocket message: ${data.type}`);
+
+            switch (data.type) {
+              case 'new_task':
+                // 收到新任务
+                const task = data.payload.task;
+                log?.info(`[miniabc:${account.accountId}] New task received: ${task.id} - ${task.content}`);
+
+                // 触发 inbound 事件 (通知 OpenClaw)
+                ctx.onInbound({
+                  type: 'message',
+                  channel: 'miniabc',
+                  accountId: account.accountId,
+                  from: { id: task.publisher_id, name: 'TaskPublisher' },
+                  text: `新任务: ${task.content}\n报酬: ¥${task.reward}\n截止: ${task.deadline}`,
+                  raw: task,
+                });
+
+                // 自动评估并接单
+                try {
+                  const evaluation = await taskManager.evaluateAndAccept(task);
+                  log?.info(`[miniabc:${account.accountId}] Task evaluation: score=${evaluation.totalScore}, accept=${evaluation.shouldAccept}, reason=${evaluation.reason}`);
+
+                  if (evaluation.shouldAccept) {
+                    // 接单成功通知
+                    ctx.onInbound({
+                      type: 'message',
+                      channel: 'miniabc',
+                      accountId: account.accountId,
+                      from: { id: 'system', name: 'TaskManager' },
+                      text: `✅ 已自动接单\n任务: ${task.content}\n评分: ${evaluation.totalScore}分\n原因: ${evaluation.reason}`,
+                      raw: { type: 'task_accepted', task, evaluation },
+                    });
+                  }
+                } catch (error) {
+                  log?.error(`[miniabc:${account.accountId}] Auto-accept error:`, error);
+                }
+                break;
+
+              case 'new_message':
+                // 收到新消息
+                log?.info(`[miniabc:${account.accountId}] New message received`);
+                ctx.onInbound({
+                  type: 'message',
+                  channel: 'miniabc',
+                  accountId: account.accountId,
+                  from: { id: data.payload.message.bot_id, name: 'System' },
+                  text: data.payload.message.content,
+                  raw: data.payload.message,
+                });
+                break;
 
-  disconnect: async ({ account }) => {
-    console.log(`[miniabc] Disconnected from ${account.accountId}`);
+              case 'auth_success':
+                log?.info(`[miniabc:${account.accountId}] WebSocket authenticated: ${data.payload.botId}`);
+                ctx.setStatus({
+                  ...ctx.getStatus(),
+                  running: true,
+                  connected: true,
+                  lastConnectedAt: Date.now(),
+                });
+                break;
+
+              case 'pong':
+                // Heartbeat response
+                break;
+            }
+          } catch (e) {
+            log?.error(`[miniabc:${account.accountId}] WebSocket message parse error: ${e}`);
+          }
+        };
+        
+        ws.onerror = (error) => {
+          log?.error(`[miniabc:${account.accountId}] WebSocket error: ${error}`);
+          ctx.setStatus({
+            ...ctx.getStatus(),
+            lastError: String(error),
+          });
+        };
+        
+        ws.onclose = () => {
+          log?.info(`[miniabc:${account.accountId}] WebSocket disconnected`);
+          if (heartbeatInterval) {
+            clearInterval(heartbeatInterval);
+          }
+          ctx.setStatus({
+            ...ctx.getStatus(),
+            running: false,
+            connected: false,
+          });
+          resolve();
+        };
+        
+        // 监听 abort 信号
+        if (abortSignal) {
+          abortSignal.addEventListener('abort', () => {
+            log?.info(`[miniabc:${account.accountId}] Gateway stopped by abort signal`);
+            if (heartbeatInterval) {
+              clearInterval(heartbeatInterval);
+            }
+            ws.close();
+          });
+        }
+      });
+    },
   },
 
   sendText: async ({ account, target, text }) => {
@@ -223,4 +363,31 @@ export const miniabcPlugin: ChannelPlugin<ResolvedMiniABCAccount> = {
 
     throw new Error("Direct messaging not supported.");
   },
+
+  status: {
+    defaultRuntime: {
+      accountId: DEFAULT_ACCOUNT_ID,
+      running: false,
+      connected: false,
+      lastConnectedAt: null,
+      lastError: null,
+      lastInboundAt: null,
+      lastOutboundAt: null,
+    },
+    buildChannelSummary: ({ snapshot }: { snapshot: Record<string, unknown> }) => ({
+      configured: snapshot.configured ?? false,
+      running: snapshot.running ?? false,
+      connected: snapshot.connected ?? false,
+      lastConnectedAt: snapshot.lastConnectedAt ?? null,
+      lastError: snapshot.lastError ?? null,
+    }),
+    buildAccountSnapshot: ({ account, runtime }: { account?: ResolvedMiniABCAccount; runtime?: Record<string, unknown> }) => ({
+      accountId: account?.accountId ?? DEFAULT_ACCOUNT_ID,
+      name: account?.name,
+      enabled: account?.enabled ?? false,
+      configured: Boolean(account?.botId && account?.token),
+      platformUrl: account?.platformUrl,
+      ...(runtime ?? {}),
+    }),
+  },
 };

package/src/task-manager.ts

@@ -0,0 +1,294 @@
+import type { Task } from "./types.js";
+import { MiniABCApiClient } from "./api.js";
+
+/**
+ * 任务管理器配置
+ */
+export interface TaskManagerConfig {
+  maxConcurrentTasks: number;      // 最大并发任务数
+  minHourlyRate: number;           // 最低时薪
+  autoAcceptEnabled: boolean;      // 是否启用自动接单
+  minAcceptScore: number;          // 最低接单评分 (0-100)
+}
+
+/**
+ * 任务评估结果
+ */
+export interface TaskEvaluation {
+  taskId: string;
+  totalScore: number;
+  skillScore: number;
+  timeScore: number;
+  economicScore: number;
+  reputationScore: number;
+  shouldAccept: boolean;
+  reason: string;
+}
+
+/**
+ * 任务管理器
+ * 负责评估、接单和跟踪任务
+ */
+export class TaskManager {
+  private config: TaskManagerConfig;
+  private activeTasks: Map<string, Task> = new Map();
+  private apiClient: MiniABCApiClient;
+
+  constructor(apiClient: MiniABCApiClient, config: Partial<TaskManagerConfig> = {}) {
+    this.apiClient = apiClient;
+    this.config = {
+      maxConcurrentTasks: config.maxConcurrentTasks ?? 3,
+      minHourlyRate: config.minHourlyRate ?? 50,
+      autoAcceptEnabled: config.autoAcceptEnabled ?? true,
+      minAcceptScore: config.minAcceptScore ?? 70,
+    };
+  }
+
+  /**
+   * 获取当前活跃任务数
+   */
+  getActiveTaskCount(): number {
+    return this.activeTasks.size;
+  }
+
+  /**
+   * 检查是否可以接新任务
+   */
+  canAcceptTask(): boolean {
+    return this.activeTasks.size < this.config.maxConcurrentTasks;
+  }
+
+  /**
+   * 评估任务
+   */
+  evaluateTask(task: Task): TaskEvaluation {
+    const scores = {
+      skillScore: this.evaluateSkillMatch(task),
+      timeScore: this.evaluateTimeFeasibility(task),
+      economicScore: this.evaluateEconomicReturn(task),
+      reputationScore: this.evaluateReputation(task),
+    };
+
+    // 加权总分
+    const totalScore = Math.round(
+      scores.skillScore * 0.4 +
+      scores.timeScore * 0.25 +
+      scores.economicScore * 0.2 +
+      scores.reputationScore * 0.15
+    );
+
+    // 决策
+    const shouldAccept = this.shouldAcceptTask(totalScore, task);
+    const reason = this.getDecisionReason(totalScore, scores, shouldAccept);
+
+    return {
+      taskId: task.id,
+      totalScore,
+      ...scores,
+      shouldAccept,
+      reason,
+    };
+  }
+
+  /**
+   * 技能匹配度评估 (0-100)
+   */
+  private evaluateSkillMatch(task: Task): number {
+    // 简化版本: 默认 AI 智能体可以处理大多数任务
+    // 实际应用中可以根据任务内容和智能体能力进行匹配
+    const content = task.content.toLowerCase();
+
+    // 检查是否包含特殊技能关键词
+    const specialSkills = ['设计', '编程', '翻译', '写作', '视频', '音频'];
+    const hasSpecialSkill = specialSkills.some(skill => content.includes(skill));
+
+    if (hasSpecialSkill) {
+      return 80; // 部分匹配
+    }
+
+    return 100; // 完全匹配 (通用任务)
+  }
+
+  /**
+   * 时间可行性评估 (0-100)
+   */
+  private evaluateTimeFeasibility(task: Task): number {
+    if (!task.deadline) {
+      return 100; // 无截止时间,默认充足
+    }
+
+    const now = new Date();
+    const deadline = new Date(task.deadline);
+    const hoursUntilDeadline = (deadline.getTime() - now.getTime()) / (1000 * 60 * 60);
+
+    // 估算任务所需时间 (简化版)
+    const estimatedHours = this.estimateTaskTime(task);
+
+    const buffer = 2; // 2小时缓冲
+    if (hoursUntilDeadline >= estimatedHours + buffer) {
+      return 100; // 充足
+    } else if (hoursUntilDeadline >= estimatedHours) {
+      return 60; // 紧张
+    } else {
+      return 0; // 不足
+    }
+  }
+
+  /**
+   * 经济回报评估 (0-100)
+   */
+  private evaluateEconomicReturn(task: Task): number {
+    const estimatedHours = this.estimateTaskTime(task);
+    const hourlyRate = task.reward / Math.max(estimatedHours, 0.5);
+
+    if (hourlyRate >= this.config.minHourlyRate * 1.5) {
+      return 100; // 高回报
+    } else if (hourlyRate >= this.config.minHourlyRate) {
+      return 70; // 中等
+    } else if (hourlyRate >= this.config.minHourlyRate * 0.5) {
+      return 20; // 低回报
+    } else {
+      return 0; // 极低
+    }
+  }
+
+  /**
+   * 信誉影响评估 (0-100)
+   */
+  private evaluateReputation(task: Task): number {
+    // 简化版本: 所有任务都假设对信誉有正面影响
+    // 实际应用中可以查询发布者信誉
+    return 80;
+  }
+
+  /**
+   * 估算任务所需时间 (小时)
+   */
+  private estimateTaskTime(task: Task): number {
+    const content = task.content.toLowerCase();
+
+    // 基于任务内容估算
+    if (content.includes('设计') || content.includes('视频')) {
+      return 4;
+    } else if (content.includes('编程') || content.includes('开发')) {
+      return 3;
+    } else if (content.includes('翻译')) {
+      return 2;
+    } else if (content.includes('写作') || content.includes('文章')) {
+      return 1.5;
+    } else {
+      return 1; // 默认1小时
+    }
+  }
+
+  /**
+   * 决定是否接单
+   */
+  private shouldAcceptTask(score: number, task: Task): boolean {
+    if (!this.config.autoAcceptEnabled) {
+      return false;
+    }
+
+    if (!this.canAcceptTask()) {
+      return false;
+    }
+
+    if (score >= 80) {
+      return true; // 高分任务立即接单
+    } else if (score >= this.config.minAcceptScore) {
+      return this.canAcceptTask(); // 检查容量
+    }
+
+    return false;
+  }
+
+  /**
+   * 生成决策原因
+   */
+  private getDecisionReason(
+    totalScore: number,
+    scores: any,
+    shouldAccept: boolean
+  ): string {
+    if (shouldAccept) {
+      return `评分 ${totalScore} 分,符合接单标准 (技能:${scores.skillScore} 时间:${scores.timeScore} 经济:${scores.economicScore} 信誉:${scores.reputationScore})`;
+    }
+
+    if (!this.canAcceptTask()) {
+      return `任务数已达上限 (${this.activeTasks.size}/${this.config.maxConcurrentTasks})`;
+    }
+
+    if (totalScore < this.config.minAcceptScore) {
+      return `评分 ${totalScore} 分,低于最低标准 ${this.config.minAcceptScore} 分`;
+    }
+
+    return '不符合接单条件';
+  }
+
+  /**
+   * 接受任务
+   */
+  async acceptTask(task: Task): Promise<{ success: boolean; error?: string }> {
+    try {
+      // 检查是否已接
+      if (this.activeTasks.has(task.id)) {
+        return { success: false, error: '任务已在处理中' };
+      }
+
+      // 调用 API 接单
+      const result = await this.apiClient.takeTask(task.id);
+
+      if (result.success) {
+        // 添加到活跃任务列表
+        this.activeTasks.set(task.id, task);
+        console.log(`[TaskManager] ✅ 已接单: ${task.id} - ${task.content}`);
+        return { success: true };
+      } else {
+        return { success: false, error: result.error || '接单失败' };
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.error(`[TaskManager] 接单错误:`, errorMsg);
+      return { success: false, error: errorMsg };
+    }
+  }
+
+  /**
+   * 完成任务
+   */
+  completeTask(taskId: string): void {
+    this.activeTasks.delete(taskId);
+    console.log(`[TaskManager] 任务完成: ${taskId}`);
+  }
+
+  /**
+   * 自动评估并接单
+   */
+  async evaluateAndAccept(task: Task): Promise<TaskEvaluation> {
+    const evaluation = this.evaluateTask(task);
+
+    if (evaluation.shouldAccept) {
+      const result = await this.acceptTask(task);
+      if (!result.success) {
+        evaluation.shouldAccept = false;
+        evaluation.reason = `接单失败: ${result.error}`;
+      }
+    }
+
+    return evaluation;
+  }
+
+  /**
+   * 更新配置
+   */
+  updateConfig(config: Partial<TaskManagerConfig>): void {
+    this.config = { ...this.config, ...config };
+  }
+
+  /**
+   * 获取配置
+   */
+  getConfig(): TaskManagerConfig {
+    return { ...this.config };
+  }
+}