From 7b9dee726874a03af79ed23ba6275960559eacfc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=85=AC=E6=98=8E?= <83812544+Ed1s0nZ@users.noreply.github.com> Date: Fri, 2 Jan 2026 00:18:39 +0800 Subject: [PATCH] Add files via upload --- README.md | 4 + README_CN.md | 4 + internal/app/app.go | 12 + internal/database/batch_task.go | 314 +++++ internal/database/database.go | 36 + internal/handler/agent.go | 307 ++++- internal/handler/batch_task_manager.go | 589 ++++++++++ internal/handler/task_manager.go | 93 +- web/static/css/style.css | 722 ++++++++++++ web/static/js/chat.js | 34 +- web/static/js/router.js | 86 +- web/static/js/tasks.js | 1466 ++++++++++++++++++++++++ web/templates/index.html | 122 ++ 13 files changed, 3761 insertions(+), 28 deletions(-) create mode 100644 internal/database/batch_task.go create mode 100644 internal/handler/batch_task_manager.go create mode 100644 web/static/js/tasks.js diff --git a/README.md b/README.md index db723a2f..be6dc053 100644 --- a/README.md +++ b/README.md @@ -34,6 +34,7 @@ CyberStrikeAI is an **AI-native security testing platform** built in Go. It inte - 📚 Knowledge base with vector search and hybrid retrieval for security expertise - 📁 Conversation grouping with pinning, rename, and batch management - 🛡️ Vulnerability management with CRUD operations, severity tracking, status workflow, and statistics +- 📋 Batch task management: create task queues, add multiple tasks, and execute them sequentially ## Tool Overview @@ -109,6 +110,7 @@ CyberStrikeAI ships with 100+ curated tools covering the whole kill chain: - **History & audit** – Every conversation and tool invocation is stored in SQLite with replay. - **Conversation groups** – Organize conversations into groups, pin important groups, rename or delete groups via context menu. - **Vulnerability management** – Create, update, and track vulnerabilities discovered during testing. Filter by severity (critical/high/medium/low/info), status (open/confirmed/fixed/false_positive), and conversation. View statistics and export findings. +- **Batch task management** – Create task queues with multiple tasks, add or edit tasks before execution, and run them sequentially. Each task executes as a separate conversation, with status tracking (pending/running/completed/failed/cancelled) and full execution history. - **Settings** – Tweak provider keys, MCP enablement, tool toggles, and agent iteration limits. ### Built-in Safeguards @@ -221,6 +223,7 @@ CyberStrikeAI ships with 100+ curated tools covering the whole kill chain: ### Automation Hooks - **REST APIs** – everything the UI uses (auth, conversations, tool runs, monitor, vulnerabilities) is available over JSON. - **Vulnerability APIs** – manage vulnerabilities via `/api/vulnerabilities` endpoints: `GET /api/vulnerabilities` (list with filters), `POST /api/vulnerabilities` (create), `GET /api/vulnerabilities/:id` (get), `PUT /api/vulnerabilities/:id` (update), `DELETE /api/vulnerabilities/:id` (delete), `GET /api/vulnerabilities/stats` (statistics). +- **Batch Task APIs** – manage batch task queues via `/api/batch-tasks` endpoints: `POST /api/batch-tasks` (create queue), `GET /api/batch-tasks` (list queues), `GET /api/batch-tasks/:queueId` (get queue), `POST /api/batch-tasks/:queueId/start` (start execution), `POST /api/batch-tasks/:queueId/cancel` (cancel), `DELETE /api/batch-tasks/:queueId` (delete), `POST /api/batch-tasks/:queueId/tasks` (add task), `PUT /api/batch-tasks/:queueId/tasks/:taskId` (update task), `DELETE /api/batch-tasks/:queueId/tasks/:taskId` (delete task). Tasks execute sequentially, each creating a separate conversation with full status tracking. - **Task control** – pause/resume/stop long scans, re-run steps with new params, or stream transcripts. - **Audit & security** – rotate passwords via `/api/auth/change-password`, enforce short-lived sessions, and restrict MCP ports at the network layer when exposing the service. @@ -318,6 +321,7 @@ Build an attack chain for the latest engagement and export the node list with se ## Changelog (Recent) +- 2025-12-26 – Added batch task management feature: create task queues with multiple tasks, add/edit/delete tasks before execution, and execute them sequentially. Each task runs as a separate conversation with status tracking (pending/running/completed/failed/cancelled). All queues and tasks are persisted in the database. - 2025-12-25 – Added vulnerability management feature: full CRUD operations for tracking vulnerabilities discovered during testing. Supports severity levels (critical/high/medium/low/info), status workflow (open/confirmed/fixed/false_positive), filtering by conversation/severity/status, and comprehensive statistics dashboard. - 2025-12-25 – Added conversation grouping feature: organize conversations into groups, pin groups to top, rename/delete groups via context menu. All group data is persisted in the database. - 2025-12-24 – Refactored attack chain generation logic, achieving 2x faster generation speed. Redesigned attack chain frontend visualization for improved user experience. diff --git a/README_CN.md b/README_CN.md index 8743c987..0fab287d 100644 --- a/README_CN.md +++ b/README_CN.md @@ -32,6 +32,7 @@ CyberStrikeAI 是一款 **AI 原生安全测试平台**，基于 Go 构建，集 - 📚 知识库功能：向量检索与混合搜索，为 AI 提供安全专业知识 - 📁 对话分组管理：支持分组创建、置顶、重命名、删除等操作 - 🛡️ 漏洞管理功能：完整的漏洞 CRUD 操作，支持严重程度分级、状态流转、按对话/严重程度/状态过滤，以及统计看板 +- 📋 批量任务管理：创建任务队列，批量添加任务，依次顺序执行，支持任务编辑与状态跟踪 ## 工具概览 @@ -107,6 +108,7 @@ CyberStrikeAI 是一款 **AI 原生安全测试平台**，基于 Go 构建，集 - **会话历史**：所有对话与工具调用保存在 SQLite，可随时重放。 - **对话分组**：将对话按项目或主题组织到不同分组，支持置顶、重命名、删除等操作，所有数据持久化存储。 - **漏洞管理**：在测试过程中创建、更新和跟踪发现的漏洞。支持按严重程度（严重/高/中/低/信息）、状态（待确认/已确认/已修复/误报）和对话进行过滤，查看统计信息并导出发现。 +- **批量任务管理**：创建任务队列，批量添加多个任务，执行前可编辑或删除任务，然后依次顺序执行。每个任务会作为独立对话执行，支持完整的状态跟踪（待执行/执行中/已完成/失败/已取消）和执行历史。 - **可视化配置**：在界面中切换模型、启停工具、设置迭代次数等。 ### 默认安全措施 @@ -219,6 +221,7 @@ CyberStrikeAI 是一款 **AI 原生安全测试平台**，基于 Go 构建，集 ### 自动化与安全 - **REST API**：认证、会话、任务、监控、漏洞管理等接口全部开放，可与 CI/CD 集成。 - **漏洞管理 API**：通过 `/api/vulnerabilities` 端点管理漏洞：`GET /api/vulnerabilities`（列表，支持过滤）、`POST /api/vulnerabilities`（创建）、`GET /api/vulnerabilities/:id`（获取）、`PUT /api/vulnerabilities/:id`（更新）、`DELETE /api/vulnerabilities/:id`（删除）、`GET /api/vulnerabilities/stats`（统计）。 +- **批量任务 API**：通过 `/api/batch-tasks` 端点管理批量任务队列：`POST /api/batch-tasks`（创建队列）、`GET /api/batch-tasks`（列表）、`GET /api/batch-tasks/:queueId`（获取队列）、`POST /api/batch-tasks/:queueId/start`（开始执行）、`POST /api/batch-tasks/:queueId/cancel`（取消）、`DELETE /api/batch-tasks/:queueId`（删除队列）、`POST /api/batch-tasks/:queueId/tasks`（添加任务）、`PUT /api/batch-tasks/:queueId/tasks/:taskId`（更新任务）、`DELETE /api/batch-tasks/:queueId/tasks/:taskId`（删除任务）。任务依次顺序执行，每个任务创建独立对话，支持完整状态跟踪。 - **任务控制**：支持暂停/终止长任务、修改参数后重跑、流式获取日志。 - **安全管理**：`/api/auth/change-password` 可即时轮换口令；建议在暴露 MCP 端口时配合网络层 ACL。 @@ -315,6 +318,7 @@ CyberStrikeAI/ ``` ## Changelog（近期） +- 2025-12-26 —— 新增批量任务管理功能：支持创建任务队列，批量添加多个任务，执行前可编辑或删除任务，然后依次顺序执行。每个任务作为独立对话运行，支持状态跟踪（待执行/执行中/已完成/失败/已取消），所有队列和任务数据持久化存储到数据库。 - 2025-12-25 —— 新增漏洞管理功能：完整的漏洞 CRUD 操作，支持跟踪测试过程中发现的漏洞。支持严重程度分级（严重/高/中/低/信息）、状态流转（待确认/已确认/已修复/误报）、按对话/严重程度/状态过滤，以及统计看板。 - 2025-12-25 —— 新增对话分组功能：支持创建分组、将对话移动到分组、分组置顶、重命名和删除等操作，所有分组数据持久化存储到数据库。 - 2025-12-24 —— 重构攻击链生成逻辑，生成速度提升一倍。重构攻击链前端页面展示，优化用户体验。 diff --git a/internal/app/app.go b/internal/app/app.go index 8d8f1d7e..5cc0c1e8 100644 --- a/internal/app/app.go +++ b/internal/app/app.go @@ -423,6 +423,18 @@ func setupRoutes( // Agent Loop 取消与任务列表 protected.POST("/agent-loop/cancel", agentHandler.CancelAgentLoop) protected.GET("/agent-loop/tasks", agentHandler.ListAgentTasks) + protected.GET("/agent-loop/tasks/completed", agentHandler.ListCompletedTasks) + + // 批量任务管理 + protected.POST("/batch-tasks", agentHandler.CreateBatchQueue) + protected.GET("/batch-tasks", agentHandler.ListBatchQueues) + protected.GET("/batch-tasks/:queueId", agentHandler.GetBatchQueue) + protected.POST("/batch-tasks/:queueId/start", agentHandler.StartBatchQueue) + protected.POST("/batch-tasks/:queueId/cancel", agentHandler.CancelBatchQueue) + protected.DELETE("/batch-tasks/:queueId", agentHandler.DeleteBatchQueue) + protected.PUT("/batch-tasks/:queueId/tasks/:taskId", agentHandler.UpdateBatchTask) + protected.POST("/batch-tasks/:queueId/tasks", agentHandler.AddBatchTask) + protected.DELETE("/batch-tasks/:queueId/tasks/:taskId", agentHandler.DeleteBatchTask) // 对话历史 protected.POST("/conversations", conversationHandler.CreateConversation) diff --git a/internal/database/batch_task.go b/internal/database/batch_task.go new file mode 100644 index 00000000..483890cd --- /dev/null +++ b/internal/database/batch_task.go @@ -0,0 +1,314 @@ +package database + +import ( + "database/sql" + "fmt" + "time" + + "go.uber.org/zap" +) + +// BatchTaskQueueRow 批量任务队列数据库行 +type BatchTaskQueueRow struct { + ID string + Status string + CreatedAt time.Time + StartedAt sql.NullTime + CompletedAt sql.NullTime + CurrentIndex int +} + +// BatchTaskRow 批量任务数据库行 +type BatchTaskRow struct { + ID string + QueueID string + Message string + ConversationID sql.NullString + Status string + StartedAt sql.NullTime + CompletedAt sql.NullTime + Error sql.NullString + Result sql.NullString +} + +// CreateBatchQueue 创建批量任务队列 +func (db *DB) CreateBatchQueue(queueID string, tasks []map[string]interface{}) error { + tx, err := db.Begin() + if err != nil { + return fmt.Errorf("开始事务失败: %w", err) + } + defer tx.Rollback() + + now := time.Now() + _, err = tx.Exec( + "INSERT INTO batch_task_queues (id, status, created_at, current_index) VALUES (?, ?, ?, ?)", + queueID, "pending", now, 0, + ) + if err != nil { + return fmt.Errorf("创建批量任务队列失败: %w", err) + } + + // 插入任务 + for _, task := range tasks { + taskID, ok := task["id"].(string) + if !ok { + continue + } + message, ok := task["message"].(string) + if !ok { + continue + } + + _, err = tx.Exec( + "INSERT INTO batch_tasks (id, queue_id, message, status) VALUES (?, ?, ?, ?)", + taskID, queueID, message, "pending", + ) + if err != nil { + return fmt.Errorf("创建批量任务失败: %w", err) + } + } + + return tx.Commit() +} + +// GetBatchQueue 获取批量任务队列 +func (db *DB) GetBatchQueue(queueID string) (*BatchTaskQueueRow, error) { + var row BatchTaskQueueRow + var createdAt string + err := db.QueryRow( + "SELECT id, status, created_at, started_at, completed_at, current_index FROM batch_task_queues WHERE id = ?", + queueID, + ).Scan(&row.ID, &row.Status, &createdAt, &row.StartedAt, &row.CompletedAt, &row.CurrentIndex) + if err == sql.ErrNoRows { + return nil, nil + } + if err != nil { + return nil, fmt.Errorf("查询批量任务队列失败: %w", err) + } + + parsedTime, parseErr := time.Parse("2006-01-02 15:04:05", createdAt) + if parseErr != nil { + // 尝试其他时间格式 + parsedTime, parseErr = time.Parse(time.RFC3339, createdAt) + if parseErr != nil { + db.logger.Warn("解析创建时间失败", zap.String("createdAt", createdAt), zap.Error(parseErr)) + parsedTime = time.Now() + } + } + row.CreatedAt = parsedTime + return &row, nil +} + +// GetAllBatchQueues 获取所有批量任务队列 +func (db *DB) GetAllBatchQueues() ([]*BatchTaskQueueRow, error) { + rows, err := db.Query( + "SELECT id, status, created_at, started_at, completed_at, current_index FROM batch_task_queues ORDER BY created_at DESC", + ) + if err != nil { + return nil, fmt.Errorf("查询批量任务队列列表失败: %w", err) + } + defer rows.Close() + + var queues []*BatchTaskQueueRow + for rows.Next() { + var row BatchTaskQueueRow + var createdAt string + if err := rows.Scan(&row.ID, &row.Status, &createdAt, &row.StartedAt, &row.CompletedAt, &row.CurrentIndex); err != nil { + return nil, fmt.Errorf("扫描批量任务队列失败: %w", err) + } + parsedTime, parseErr := time.Parse("2006-01-02 15:04:05", createdAt) + if parseErr != nil { + parsedTime, parseErr = time.Parse(time.RFC3339, createdAt) + if parseErr != nil { + db.logger.Warn("解析创建时间失败", zap.String("createdAt", createdAt), zap.Error(parseErr)) + parsedTime = time.Now() + } + } + row.CreatedAt = parsedTime + queues = append(queues, &row) + } + + return queues, nil +} + +// GetBatchTasks 获取批量任务队列的所有任务 +func (db *DB) GetBatchTasks(queueID string) ([]*BatchTaskRow, error) { + rows, err := db.Query( + "SELECT id, queue_id, message, conversation_id, status, started_at, completed_at, error, result FROM batch_tasks WHERE queue_id = ? ORDER BY id", + queueID, + ) + if err != nil { + return nil, fmt.Errorf("查询批量任务失败: %w", err) + } + defer rows.Close() + + var tasks []*BatchTaskRow + for rows.Next() { + var task BatchTaskRow + if err := rows.Scan( + &task.ID, &task.QueueID, &task.Message, &task.ConversationID, + &task.Status, &task.StartedAt, &task.CompletedAt, &task.Error, &task.Result, + ); err != nil { + return nil, fmt.Errorf("扫描批量任务失败: %w", err) + } + tasks = append(tasks, &task) + } + + return tasks, nil +} + +// UpdateBatchQueueStatus 更新批量任务队列状态 +func (db *DB) UpdateBatchQueueStatus(queueID, status string) error { + var err error + now := time.Now() + + if status == "running" { + _, err = db.Exec( + "UPDATE batch_task_queues SET status = ?, started_at = COALESCE(started_at, ?) WHERE id = ?", + status, now, queueID, + ) + } else if status == "completed" || status == "cancelled" { + _, err = db.Exec( + "UPDATE batch_task_queues SET status = ?, completed_at = COALESCE(completed_at, ?) WHERE id = ?", + status, now, queueID, + ) + } else { + _, err = db.Exec( + "UPDATE batch_task_queues SET status = ? WHERE id = ?", + status, queueID, + ) + } + + if err != nil { + return fmt.Errorf("更新批量任务队列状态失败: %w", err) + } + return nil +} + +// UpdateBatchTaskStatus 更新批量任务状态 +func (db *DB) UpdateBatchTaskStatus(queueID, taskID, status string, conversationID, result, errorMsg string) error { + var err error + now := time.Now() + + // 构建更新语句 + var updates []string + var args []interface{} + + updates = append(updates, "status = ?") + args = append(args, status) + + if conversationID != "" { + updates = append(updates, "conversation_id = ?") + args = append(args, conversationID) + } + + if result != "" { + updates = append(updates, "result = ?") + args = append(args, result) + } + + if errorMsg != "" { + updates = append(updates, "error = ?") + args = append(args, errorMsg) + } + + if status == "running" { + updates = append(updates, "started_at = COALESCE(started_at, ?)") + args = append(args, now) + } + + if status == "completed" || status == "failed" || status == "cancelled" { + updates = append(updates, "completed_at = COALESCE(completed_at, ?)") + args = append(args, now) + } + + args = append(args, queueID, taskID) + + // 构建SQL语句 + sql := "UPDATE batch_tasks SET " + for i, update := range updates { + if i > 0 { + sql += ", " + } + sql += update + } + sql += " WHERE queue_id = ? AND id = ?" + + _, err = db.Exec(sql, args...) + if err != nil { + return fmt.Errorf("更新批量任务状态失败: %w", err) + } + return nil +} + +// UpdateBatchQueueCurrentIndex 更新批量任务队列的当前索引 +func (db *DB) UpdateBatchQueueCurrentIndex(queueID string, currentIndex int) error { + _, err := db.Exec( + "UPDATE batch_task_queues SET current_index = ? WHERE id = ?", + currentIndex, queueID, + ) + if err != nil { + return fmt.Errorf("更新批量任务队列当前索引失败: %w", err) + } + return nil +} + +// UpdateBatchTaskMessage 更新批量任务消息 +func (db *DB) UpdateBatchTaskMessage(queueID, taskID, message string) error { + _, err := db.Exec( + "UPDATE batch_tasks SET message = ? WHERE queue_id = ? AND id = ?", + message, queueID, taskID, + ) + if err != nil { + return fmt.Errorf("更新批量任务消息失败: %w", err) + } + return nil +} + +// AddBatchTask 添加任务到批量任务队列 +func (db *DB) AddBatchTask(queueID, taskID, message string) error { + _, err := db.Exec( + "INSERT INTO batch_tasks (id, queue_id, message, status) VALUES (?, ?, ?, ?)", + taskID, queueID, message, "pending", + ) + if err != nil { + return fmt.Errorf("添加批量任务失败: %w", err) + } + return nil +} + +// DeleteBatchTask 删除批量任务 +func (db *DB) DeleteBatchTask(queueID, taskID string) error { + _, err := db.Exec( + "DELETE FROM batch_tasks WHERE queue_id = ? AND id = ?", + queueID, taskID, + ) + if err != nil { + return fmt.Errorf("删除批量任务失败: %w", err) + } + return nil +} + +// DeleteBatchQueue 删除批量任务队列 +func (db *DB) DeleteBatchQueue(queueID string) error { + tx, err := db.Begin() + if err != nil { + return fmt.Errorf("开始事务失败: %w", err) + } + defer tx.Rollback() + + // 删除任务（外键会自动级联删除） + _, err = tx.Exec("DELETE FROM batch_tasks WHERE queue_id = ?", queueID) + if err != nil { + return fmt.Errorf("删除批量任务失败: %w", err) + } + + // 删除队列 + _, err = tx.Exec("DELETE FROM batch_task_queues WHERE id = ?", queueID) + if err != nil { + return fmt.Errorf("删除批量任务队列失败: %w", err) + } + + return tx.Commit() +} + diff --git a/internal/database/database.go b/internal/database/database.go index f5e5c00f..4b962e3b 100644 --- a/internal/database/database.go +++ b/internal/database/database.go @@ -189,6 +189,32 @@ func (db *DB) initTables() error { FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE CASCADE );` + // 创建批量任务队列表 + createBatchTaskQueuesTable := ` + CREATE TABLE IF NOT EXISTS batch_task_queues ( + id TEXT PRIMARY KEY, + status TEXT NOT NULL, + created_at DATETIME NOT NULL, + started_at DATETIME, + completed_at DATETIME, + current_index INTEGER NOT NULL DEFAULT 0 + );` + + // 创建批量任务表 + createBatchTasksTable := ` + CREATE TABLE IF NOT EXISTS batch_tasks ( + id TEXT PRIMARY KEY, + queue_id TEXT NOT NULL, + message TEXT NOT NULL, + conversation_id TEXT, + status TEXT NOT NULL, + started_at DATETIME, + completed_at DATETIME, + error TEXT, + result TEXT, + FOREIGN KEY (queue_id) REFERENCES batch_task_queues(id) ON DELETE CASCADE + );` + // 创建索引 createIndexes := ` CREATE INDEX IF NOT EXISTS idx_messages_conversation_id ON messages(conversation_id); @@ -212,6 +238,8 @@ func (db *DB) initTables() error { CREATE INDEX IF NOT EXISTS idx_vulnerabilities_severity ON vulnerabilities(severity); CREATE INDEX IF NOT EXISTS idx_vulnerabilities_status ON vulnerabilities(status); CREATE INDEX IF NOT EXISTS idx_vulnerabilities_created_at ON vulnerabilities(created_at); + CREATE INDEX IF NOT EXISTS idx_batch_tasks_queue_id ON batch_tasks(queue_id); + CREATE INDEX IF NOT EXISTS idx_batch_task_queues_created_at ON batch_task_queues(created_at); ` if _, err := db.Exec(createConversationsTable); err != nil { @@ -258,6 +286,14 @@ func (db *DB) initTables() error { return fmt.Errorf("创建vulnerabilities表失败: %w", err) } + if _, err := db.Exec(createBatchTaskQueuesTable); err != nil { + return fmt.Errorf("创建batch_task_queues表失败: %w", err) + } + + if _, err := db.Exec(createBatchTasksTable); err != nil { + return fmt.Errorf("创建batch_tasks表失败: %w", err) + } + // 为已有表添加新字段（如果不存在）- 必须在创建索引之前 if err := db.migrateConversationsTable(); err != nil { db.logger.Warn("迁移conversations表失败", zap.Error(err)) diff --git a/internal/handler/agent.go b/internal/handler/agent.go index eed96615..cb726a18 100644 --- a/internal/handler/agent.go +++ b/internal/handler/agent.go @@ -7,8 +7,8 @@ import ( "fmt" "net/http" "strings" - "unicode/utf8" "time" + "unicode/utf8" "cyberstrike-ai/internal/agent" "cyberstrike-ai/internal/database" @@ -25,16 +25,16 @@ func safeTruncateString(s string, maxLen int) string { if utf8.RuneCountInString(s) <= maxLen { return s } - + // 将字符串转换为 rune 切片以正确计算字符数 runes := []rune(s) if len(runes) <= maxLen { return s } - + // 截断到最大长度 truncated := string(runes[:maxLen]) - + // 尝试在标点符号或空格处截断，使截断更自然 // 在截断点往前查找合适的断点（不超过20%的长度） searchRange := maxLen / 5 @@ -43,7 +43,7 @@ func safeTruncateString(s string, maxLen int) string { } breakChars := []rune("，。、 ,.;:!?！？/\\-_") bestBreakPos := len(runes[:maxLen]) - + for i := bestBreakPos - 1; i >= bestBreakPos-searchRange && i >= 0; i-- { for _, breakChar := range breakChars { if runes[i] == breakChar { @@ -52,7 +52,7 @@ func safeTruncateString(s string, maxLen int) string { } } } - + found: truncated = string(runes[:bestBreakPos]) return truncated + "..." @@ -64,6 +64,7 @@ type AgentHandler struct { db *database.DB logger *zap.Logger tasks *AgentTaskManager + batchTaskManager *BatchTaskManager knowledgeManager interface { // 知识库管理器接口 LogRetrieval(conversationID, messageID, query, riskType string, retrievedItems []string) error } @@ -71,11 +72,20 @@ type AgentHandler struct { // NewAgentHandler 创建新的Agent处理器 func NewAgentHandler(agent *agent.Agent, db *database.DB, logger *zap.Logger) *AgentHandler { + batchTaskManager := NewBatchTaskManager() + batchTaskManager.SetDB(db) + + // 从数据库加载所有批量任务队列 + if err := batchTaskManager.LoadFromDB(); err != nil { + logger.Warn("从数据库加载批量任务队列失败", zap.Error(err)) + } + return &AgentHandler{ - agent: agent, - db: db, - logger: logger, - tasks: NewAgentTaskManager(), + agent: agent, + db: db, + logger: logger, + tasks: NewAgentTaskManager(), + batchTaskManager: batchTaskManager, } } @@ -724,6 +734,283 @@ func (h *AgentHandler) ListAgentTasks(c *gin.Context) { }) } +// ListCompletedTasks 列出最近完成的任务历史 +func (h *AgentHandler) ListCompletedTasks(c *gin.Context) { + c.JSON(http.StatusOK, gin.H{ + "tasks": h.tasks.GetCompletedTasks(), + }) +} + +// BatchTaskRequest 批量任务请求 +type BatchTaskRequest struct { + Tasks []string `json:"tasks" binding:"required"` // 任务列表，每行一个任务 +} + +// CreateBatchQueue 创建批量任务队列 +func (h *AgentHandler) CreateBatchQueue(c *gin.Context) { + var req BatchTaskRequest + if err := c.ShouldBindJSON(&req); err != nil { + c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) + return + } + + if len(req.Tasks) == 0 { + c.JSON(http.StatusBadRequest, gin.H{"error": "任务列表不能为空"}) + return + } + + // 过滤空任务 + validTasks := make([]string, 0, len(req.Tasks)) + for _, task := range req.Tasks { + if task != "" { + validTasks = append(validTasks, task) + } + } + + if len(validTasks) == 0 { + c.JSON(http.StatusBadRequest, gin.H{"error": "没有有效的任务"}) + return + } + + queue := h.batchTaskManager.CreateBatchQueue(validTasks) + c.JSON(http.StatusOK, gin.H{ + "queueId": queue.ID, + "queue": queue, + }) +} + +// GetBatchQueue 获取批量任务队列 +func (h *AgentHandler) GetBatchQueue(c *gin.Context) { + queueID := c.Param("queueId") + queue, exists := h.batchTaskManager.GetBatchQueue(queueID) + if !exists { + c.JSON(http.StatusNotFound, gin.H{"error": "队列不存在"}) + return + } + c.JSON(http.StatusOK, gin.H{"queue": queue}) +} + +// ListBatchQueues 列出所有批量任务队列 +func (h *AgentHandler) ListBatchQueues(c *gin.Context) { + queues := h.batchTaskManager.GetAllQueues() + c.JSON(http.StatusOK, gin.H{"queues": queues}) +} + +// StartBatchQueue 开始执行批量任务队列 +func (h *AgentHandler) StartBatchQueue(c *gin.Context) { + queueID := c.Param("queueId") + queue, exists := h.batchTaskManager.GetBatchQueue(queueID) + if !exists { + c.JSON(http.StatusNotFound, gin.H{"error": "队列不存在"}) + return + } + + if queue.Status != "pending" && queue.Status != "paused" { + c.JSON(http.StatusBadRequest, gin.H{"error": "队列状态不允许启动"}) + return + } + + // 在后台执行批量任务 + go h.executeBatchQueue(queueID) + + h.batchTaskManager.UpdateQueueStatus(queueID, "running") + c.JSON(http.StatusOK, gin.H{"message": "批量任务已开始执行", "queueId": queueID}) +} + +// CancelBatchQueue 取消批量任务队列 +func (h *AgentHandler) CancelBatchQueue(c *gin.Context) { + queueID := c.Param("queueId") + success := h.batchTaskManager.CancelQueue(queueID) + if !success { + c.JSON(http.StatusNotFound, gin.H{"error": "队列不存在或无法取消"}) + return + } + c.JSON(http.StatusOK, gin.H{"message": "批量任务已取消"}) +} + +// DeleteBatchQueue 删除批量任务队列 +func (h *AgentHandler) DeleteBatchQueue(c *gin.Context) { + queueID := c.Param("queueId") + success := h.batchTaskManager.DeleteQueue(queueID) + if !success { + c.JSON(http.StatusNotFound, gin.H{"error": "队列不存在"}) + return + } + c.JSON(http.StatusOK, gin.H{"message": "批量任务队列已删除"}) +} + +// UpdateBatchTask 更新批量任务消息 +func (h *AgentHandler) UpdateBatchTask(c *gin.Context) { + queueID := c.Param("queueId") + taskID := c.Param("taskId") + + var req struct { + Message string `json:"message" binding:"required"` + } + if err := c.ShouldBindJSON(&req); err != nil { + c.JSON(http.StatusBadRequest, gin.H{"error": "无效的请求参数: " + err.Error()}) + return + } + + if req.Message == "" { + c.JSON(http.StatusBadRequest, gin.H{"error": "任务消息不能为空"}) + return + } + + err := h.batchTaskManager.UpdateTaskMessage(queueID, taskID, req.Message) + if err != nil { + c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) + return + } + + // 返回更新后的队列信息 + queue, exists := h.batchTaskManager.GetBatchQueue(queueID) + if !exists { + c.JSON(http.StatusNotFound, gin.H{"error": "队列不存在"}) + return + } + c.JSON(http.StatusOK, gin.H{"message": "任务已更新", "queue": queue}) +} + +// AddBatchTask 添加任务到批量任务队列 +func (h *AgentHandler) AddBatchTask(c *gin.Context) { + queueID := c.Param("queueId") + + var req struct { + Message string `json:"message" binding:"required"` + } + if err := c.ShouldBindJSON(&req); err != nil { + c.JSON(http.StatusBadRequest, gin.H{"error": "无效的请求参数: " + err.Error()}) + return + } + + if req.Message == "" { + c.JSON(http.StatusBadRequest, gin.H{"error": "任务消息不能为空"}) + return + } + + task, err := h.batchTaskManager.AddTaskToQueue(queueID, req.Message) + if err != nil { + c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) + return + } + + // 返回更新后的队列信息 + queue, exists := h.batchTaskManager.GetBatchQueue(queueID) + if !exists { + c.JSON(http.StatusNotFound, gin.H{"error": "队列不存在"}) + return + } + c.JSON(http.StatusOK, gin.H{"message": "任务已添加", "task": task, "queue": queue}) +} + +// DeleteBatchTask 删除批量任务 +func (h *AgentHandler) DeleteBatchTask(c *gin.Context) { + queueID := c.Param("queueId") + taskID := c.Param("taskId") + + err := h.batchTaskManager.DeleteTask(queueID, taskID) + if err != nil { + c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) + return + } + + // 返回更新后的队列信息 + queue, exists := h.batchTaskManager.GetBatchQueue(queueID) + if !exists { + c.JSON(http.StatusNotFound, gin.H{"error": "队列不存在"}) + return + } + c.JSON(http.StatusOK, gin.H{"message": "任务已删除", "queue": queue}) +} + +// executeBatchQueue 执行批量任务队列 +func (h *AgentHandler) executeBatchQueue(queueID string) { + h.logger.Info("开始执行批量任务队列", zap.String("queueId", queueID)) + + for { + // 检查队列状态 + queue, exists := h.batchTaskManager.GetBatchQueue(queueID) + if !exists || queue.Status == "cancelled" || queue.Status == "completed" { + break + } + + // 获取下一个任务 + task, hasNext := h.batchTaskManager.GetNextTask(queueID) + if !hasNext { + // 所有任务完成 + h.batchTaskManager.UpdateQueueStatus(queueID, "completed") + h.logger.Info("批量任务队列执行完成", zap.String("queueId", queueID)) + break + } + + // 更新任务状态为运行中 + h.batchTaskManager.UpdateTaskStatus(queueID, task.ID, "running", "", "") + + // 创建新对话 + title := safeTruncateString(task.Message, 50) + conv, err := h.db.CreateConversation(title) + var conversationID string + if err != nil { + h.logger.Error("创建对话失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.Error(err)) + h.batchTaskManager.UpdateTaskStatus(queueID, task.ID, "failed", "", "创建对话失败: "+err.Error()) + h.batchTaskManager.MoveToNextTask(queueID) + continue + } + conversationID = conv.ID + + // 保存conversationId到任务中（即使是运行中状态也要保存，以便查看对话） + h.batchTaskManager.UpdateTaskStatusWithConversationID(queueID, task.ID, "running", "", "", conversationID) + + // 保存用户消息 + _, err = h.db.AddMessage(conversationID, "user", task.Message, nil) + if err != nil { + h.logger.Error("保存用户消息失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID), zap.Error(err)) + } + + // 执行任务 + h.logger.Info("执行批量任务", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("message", task.Message), zap.String("conversationId", conversationID)) + + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Minute) + result, err := h.agent.AgentLoopWithConversationID(ctx, task.Message, []agent.ChatMessage{}, conversationID) + cancel() + + if err != nil { + h.logger.Error("批量任务执行失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID), zap.Error(err)) + h.batchTaskManager.UpdateTaskStatus(queueID, task.ID, "failed", "", err.Error()) + } else { + h.logger.Info("批量任务执行成功", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID)) + + // 保存助手回复 + _, err = h.db.AddMessage(conversationID, "assistant", result.Response, result.MCPExecutionIDs) + if err != nil { + h.logger.Error("保存助手消息失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID), zap.Error(err)) + } + + // 保存ReAct数据 + if result.LastReActInput != "" || result.LastReActOutput != "" { + if err := h.db.SaveReActData(conversationID, result.LastReActInput, result.LastReActOutput); err != nil { + h.logger.Warn("保存ReAct数据失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.Error(err)) + } else { + h.logger.Info("已保存ReAct数据", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID)) + } + } + + // 保存结果 + h.batchTaskManager.UpdateTaskStatusWithConversationID(queueID, task.ID, "completed", result.Response, "", conversationID) + } + + // 移动到下一个任务 + h.batchTaskManager.MoveToNextTask(queueID) + + // 检查是否被取消 + queue, _ = h.batchTaskManager.GetBatchQueue(queueID) + if queue.Status == "cancelled" { + break + } + } +} + // loadHistoryFromReActData 从保存的ReAct数据恢复历史消息上下文 // 采用与攻击链生成类似的拼接逻辑：优先使用保存的last_react_input和last_react_output，若不存在则回退到消息表 func (h *AgentHandler) loadHistoryFromReActData(conversationID string) ([]agent.ChatMessage, error) { diff --git a/internal/handler/batch_task_manager.go b/internal/handler/batch_task_manager.go new file mode 100644 index 00000000..02141bd5 --- /dev/null +++ b/internal/handler/batch_task_manager.go @@ -0,0 +1,589 @@ +package handler + +import ( + "crypto/rand" + "encoding/hex" + "fmt" + "sync" + "time" + + "cyberstrike-ai/internal/database" +) + +// BatchTask 批量任务项 +type BatchTask struct { + ID string `json:"id"` + Message string `json:"message"` + ConversationID string `json:"conversationId,omitempty"` + Status string `json:"status"` // pending, running, completed, failed, cancelled + StartedAt *time.Time `json:"startedAt,omitempty"` + CompletedAt *time.Time `json:"completedAt,omitempty"` + Error string `json:"error,omitempty"` + Result string `json:"result,omitempty"` +} + +// BatchTaskQueue 批量任务队列 +type BatchTaskQueue struct { + ID string `json:"id"` + Tasks []*BatchTask `json:"tasks"` + Status string `json:"status"` // pending, running, paused, completed, cancelled + CreatedAt time.Time `json:"createdAt"` + StartedAt *time.Time `json:"startedAt,omitempty"` + CompletedAt *time.Time `json:"completedAt,omitempty"` + CurrentIndex int `json:"currentIndex"` + mu sync.RWMutex +} + +// BatchTaskManager 批量任务管理器 +type BatchTaskManager struct { + db *database.DB + queues map[string]*BatchTaskQueue + mu sync.RWMutex +} + +// NewBatchTaskManager 创建批量任务管理器 +func NewBatchTaskManager() *BatchTaskManager { + return &BatchTaskManager{ + queues: make(map[string]*BatchTaskQueue), + } +} + +// SetDB 设置数据库连接 +func (m *BatchTaskManager) SetDB(db *database.DB) { + m.mu.Lock() + defer m.mu.Unlock() + m.db = db +} + +// CreateBatchQueue 创建批量任务队列 +func (m *BatchTaskManager) CreateBatchQueue(tasks []string) *BatchTaskQueue { + m.mu.Lock() + defer m.mu.Unlock() + + queueID := time.Now().Format("20060102150405") + "-" + generateShortID() + queue := &BatchTaskQueue{ + ID: queueID, + Tasks: make([]*BatchTask, 0, len(tasks)), + Status: "pending", + CreatedAt: time.Now(), + CurrentIndex: 0, + } + + // 准备数据库保存的任务数据 + dbTasks := make([]map[string]interface{}, 0, len(tasks)) + + for _, message := range tasks { + if message == "" { + continue // 跳过空行 + } + taskID := generateShortID() + task := &BatchTask{ + ID: taskID, + Message: message, + Status: "pending", + } + queue.Tasks = append(queue.Tasks, task) + dbTasks = append(dbTasks, map[string]interface{}{ + "id": taskID, + "message": message, + }) + } + + // 保存到数据库 + if m.db != nil { + if err := m.db.CreateBatchQueue(queueID, dbTasks); err != nil { + // 如果数据库保存失败，记录错误但继续（使用内存缓存） + // 这里可以添加日志记录 + } + } + + m.queues[queueID] = queue + return queue +} + +// GetBatchQueue 获取批量任务队列 +func (m *BatchTaskManager) GetBatchQueue(queueID string) (*BatchTaskQueue, bool) { + m.mu.RLock() + queue, exists := m.queues[queueID] + m.mu.RUnlock() + + if exists { + return queue, true + } + + // 如果内存中不存在，尝试从数据库加载 + if m.db != nil { + if queue := m.loadQueueFromDB(queueID); queue != nil { + m.mu.Lock() + m.queues[queueID] = queue + m.mu.Unlock() + return queue, true + } + } + + return nil, false +} + +// loadQueueFromDB 从数据库加载单个队列 +func (m *BatchTaskManager) loadQueueFromDB(queueID string) *BatchTaskQueue { + if m.db == nil { + return nil + } + + queueRow, err := m.db.GetBatchQueue(queueID) + if err != nil || queueRow == nil { + return nil + } + + taskRows, err := m.db.GetBatchTasks(queueID) + if err != nil { + return nil + } + + queue := &BatchTaskQueue{ + ID: queueRow.ID, + Status: queueRow.Status, + CreatedAt: queueRow.CreatedAt, + CurrentIndex: queueRow.CurrentIndex, + Tasks: make([]*BatchTask, 0, len(taskRows)), + } + + if queueRow.StartedAt.Valid { + queue.StartedAt = &queueRow.StartedAt.Time + } + if queueRow.CompletedAt.Valid { + queue.CompletedAt = &queueRow.CompletedAt.Time + } + + for _, taskRow := range taskRows { + task := &BatchTask{ + ID: taskRow.ID, + Message: taskRow.Message, + Status: taskRow.Status, + } + if taskRow.ConversationID.Valid { + task.ConversationID = taskRow.ConversationID.String + } + if taskRow.StartedAt.Valid { + task.StartedAt = &taskRow.StartedAt.Time + } + if taskRow.CompletedAt.Valid { + task.CompletedAt = &taskRow.CompletedAt.Time + } + if taskRow.Error.Valid { + task.Error = taskRow.Error.String + } + if taskRow.Result.Valid { + task.Result = taskRow.Result.String + } + queue.Tasks = append(queue.Tasks, task) + } + + return queue +} + +// GetAllQueues 获取所有队列 +func (m *BatchTaskManager) GetAllQueues() []*BatchTaskQueue { + m.mu.RLock() + result := make([]*BatchTaskQueue, 0, len(m.queues)) + for _, queue := range m.queues { + result = append(result, queue) + } + m.mu.RUnlock() + + // 如果数据库可用，确保所有数据库中的队列都已加载到内存 + if m.db != nil { + dbQueues, err := m.db.GetAllBatchQueues() + if err == nil { + m.mu.Lock() + for _, queueRow := range dbQueues { + if _, exists := m.queues[queueRow.ID]; !exists { + if queue := m.loadQueueFromDB(queueRow.ID); queue != nil { + m.queues[queueRow.ID] = queue + result = append(result, queue) + } + } + } + m.mu.Unlock() + } + } + + return result +} + +// LoadFromDB 从数据库加载所有队列 +func (m *BatchTaskManager) LoadFromDB() error { + if m.db == nil { + return nil + } + + queueRows, err := m.db.GetAllBatchQueues() + if err != nil { + return err + } + + m.mu.Lock() + defer m.mu.Unlock() + + for _, queueRow := range queueRows { + if _, exists := m.queues[queueRow.ID]; exists { + continue // 已存在，跳过 + } + + taskRows, err := m.db.GetBatchTasks(queueRow.ID) + if err != nil { + continue // 跳过加载失败的任务 + } + + queue := &BatchTaskQueue{ + ID: queueRow.ID, + Status: queueRow.Status, + CreatedAt: queueRow.CreatedAt, + CurrentIndex: queueRow.CurrentIndex, + Tasks: make([]*BatchTask, 0, len(taskRows)), + } + + if queueRow.StartedAt.Valid { + queue.StartedAt = &queueRow.StartedAt.Time + } + if queueRow.CompletedAt.Valid { + queue.CompletedAt = &queueRow.CompletedAt.Time + } + + for _, taskRow := range taskRows { + task := &BatchTask{ + ID: taskRow.ID, + Message: taskRow.Message, + Status: taskRow.Status, + } + if taskRow.ConversationID.Valid { + task.ConversationID = taskRow.ConversationID.String + } + if taskRow.StartedAt.Valid { + task.StartedAt = &taskRow.StartedAt.Time + } + if taskRow.CompletedAt.Valid { + task.CompletedAt = &taskRow.CompletedAt.Time + } + if taskRow.Error.Valid { + task.Error = taskRow.Error.String + } + if taskRow.Result.Valid { + task.Result = taskRow.Result.String + } + queue.Tasks = append(queue.Tasks, task) + } + + m.queues[queueRow.ID] = queue + } + + return nil +} + +// UpdateTaskStatus 更新任务状态 +func (m *BatchTaskManager) UpdateTaskStatus(queueID, taskID, status string, result, errorMsg string) { + m.UpdateTaskStatusWithConversationID(queueID, taskID, status, result, errorMsg, "") +} + +// UpdateTaskStatusWithConversationID 更新任务状态（包含conversationId） +func (m *BatchTaskManager) UpdateTaskStatusWithConversationID(queueID, taskID, status string, result, errorMsg, conversationID string) { + m.mu.Lock() + defer m.mu.Unlock() + + queue, exists := m.queues[queueID] + if !exists { + return + } + + for _, task := range queue.Tasks { + if task.ID == taskID { + task.Status = status + if result != "" { + task.Result = result + } + if errorMsg != "" { + task.Error = errorMsg + } + if conversationID != "" { + task.ConversationID = conversationID + } + now := time.Now() + if status == "running" && task.StartedAt == nil { + task.StartedAt = &now + } + if status == "completed" || status == "failed" || status == "cancelled" { + task.CompletedAt = &now + } + break + } + } + + // 同步到数据库 + if m.db != nil { + if err := m.db.UpdateBatchTaskStatus(queueID, taskID, status, conversationID, result, errorMsg); err != nil { + // 记录错误但继续（使用内存缓存） + } + } +} + +// UpdateQueueStatus 更新队列状态 +func (m *BatchTaskManager) UpdateQueueStatus(queueID, status string) { + m.mu.Lock() + defer m.mu.Unlock() + + queue, exists := m.queues[queueID] + if !exists { + return + } + + queue.Status = status + now := time.Now() + if status == "running" && queue.StartedAt == nil { + queue.StartedAt = &now + } + if status == "completed" || status == "cancelled" { + queue.CompletedAt = &now + } + + // 同步到数据库 + if m.db != nil { + if err := m.db.UpdateBatchQueueStatus(queueID, status); err != nil { + // 记录错误但继续（使用内存缓存） + } + } +} + +// UpdateTaskMessage 更新任务消息（仅限待执行状态） +func (m *BatchTaskManager) UpdateTaskMessage(queueID, taskID, message string) error { + m.mu.Lock() + defer m.mu.Unlock() + + queue, exists := m.queues[queueID] + if !exists { + return fmt.Errorf("队列不存在") + } + + // 检查队列状态，只有待执行状态的队列才能编辑任务 + if queue.Status != "pending" { + return fmt.Errorf("只有待执行状态的队列才能编辑任务") + } + + // 查找并更新任务 + for _, task := range queue.Tasks { + if task.ID == taskID { + // 只有待执行状态的任务才能编辑 + if task.Status != "pending" { + return fmt.Errorf("只有待执行状态的任务才能编辑") + } + task.Message = message + + // 同步到数据库 + if m.db != nil { + if err := m.db.UpdateBatchTaskMessage(queueID, taskID, message); err != nil { + return fmt.Errorf("更新任务消息失败: %w", err) + } + } + return nil + } + } + + return fmt.Errorf("任务不存在") +} + +// AddTaskToQueue 添加任务到队列（仅限待执行状态） +func (m *BatchTaskManager) AddTaskToQueue(queueID, message string) (*BatchTask, error) { + m.mu.Lock() + defer m.mu.Unlock() + + queue, exists := m.queues[queueID] + if !exists { + return nil, fmt.Errorf("队列不存在") + } + + // 检查队列状态，只有待执行状态的队列才能添加任务 + if queue.Status != "pending" { + return nil, fmt.Errorf("只有待执行状态的队列才能添加任务") + } + + if message == "" { + return nil, fmt.Errorf("任务消息不能为空") + } + + // 生成任务ID + taskID := generateShortID() + task := &BatchTask{ + ID: taskID, + Message: message, + Status: "pending", + } + + // 添加到内存队列 + queue.Tasks = append(queue.Tasks, task) + + // 同步到数据库 + if m.db != nil { + if err := m.db.AddBatchTask(queueID, taskID, message); err != nil { + // 如果数据库保存失败，从内存中移除 + queue.Tasks = queue.Tasks[:len(queue.Tasks)-1] + return nil, fmt.Errorf("添加任务失败: %w", err) + } + } + + return task, nil +} + +// DeleteTask 删除任务（仅限待执行状态） +func (m *BatchTaskManager) DeleteTask(queueID, taskID string) error { + m.mu.Lock() + defer m.mu.Unlock() + + queue, exists := m.queues[queueID] + if !exists { + return fmt.Errorf("队列不存在") + } + + // 检查队列状态，只有待执行状态的队列才能删除任务 + if queue.Status != "pending" { + return fmt.Errorf("只有待执行状态的队列才能删除任务") + } + + // 查找并删除任务 + taskIndex := -1 + for i, task := range queue.Tasks { + if task.ID == taskID { + // 只有待执行状态的任务才能删除 + if task.Status != "pending" { + return fmt.Errorf("只有待执行状态的任务才能删除") + } + taskIndex = i + break + } + } + + if taskIndex == -1 { + return fmt.Errorf("任务不存在") + } + + // 从内存队列中删除 + queue.Tasks = append(queue.Tasks[:taskIndex], queue.Tasks[taskIndex+1:]...) + + // 同步到数据库 + if m.db != nil { + if err := m.db.DeleteBatchTask(queueID, taskID); err != nil { + // 如果数据库删除失败，恢复内存中的任务 + // 这里需要重新插入，但为了简化，我们只记录错误 + return fmt.Errorf("删除任务失败: %w", err) + } + } + + return nil +} + +// GetNextTask 获取下一个待执行的任务 +func (m *BatchTaskManager) GetNextTask(queueID string) (*BatchTask, bool) { + m.mu.RLock() + defer m.mu.RUnlock() + + queue, exists := m.queues[queueID] + if !exists { + return nil, false + } + + for i := queue.CurrentIndex; i < len(queue.Tasks); i++ { + task := queue.Tasks[i] + if task.Status == "pending" { + queue.CurrentIndex = i + return task, true + } + } + + return nil, false +} + +// MoveToNextTask 移动到下一个任务 +func (m *BatchTaskManager) MoveToNextTask(queueID string) { + m.mu.Lock() + defer m.mu.Unlock() + + queue, exists := m.queues[queueID] + if !exists { + return + } + + queue.CurrentIndex++ + + // 同步到数据库 + if m.db != nil { + if err := m.db.UpdateBatchQueueCurrentIndex(queueID, queue.CurrentIndex); err != nil { + // 记录错误但继续（使用内存缓存） + } + } +} + +// CancelQueue 取消队列 +func (m *BatchTaskManager) CancelQueue(queueID string) bool { + m.mu.Lock() + defer m.mu.Unlock() + + queue, exists := m.queues[queueID] + if !exists { + return false + } + + if queue.Status == "completed" || queue.Status == "cancelled" { + return false + } + + queue.Status = "cancelled" + now := time.Now() + queue.CompletedAt = &now + + // 取消所有待执行的任务 + for _, task := range queue.Tasks { + if task.Status == "pending" { + task.Status = "cancelled" + task.CompletedAt = &now + // 同步到数据库 + if m.db != nil { + m.db.UpdateBatchTaskStatus(queueID, task.ID, "cancelled", "", "", "") + } + } + } + + // 同步队列状态到数据库 + if m.db != nil { + if err := m.db.UpdateBatchQueueStatus(queueID, "cancelled"); err != nil { + // 记录错误但继续（使用内存缓存） + } + } + + return true +} + +// DeleteQueue 删除队列 +func (m *BatchTaskManager) DeleteQueue(queueID string) bool { + m.mu.Lock() + defer m.mu.Unlock() + + _, exists := m.queues[queueID] + if !exists { + return false + } + + // 从数据库删除 + if m.db != nil { + if err := m.db.DeleteBatchQueue(queueID); err != nil { + // 记录错误但继续（使用内存缓存） + } + } + + delete(m.queues, queueID) + return true +} + +// generateShortID 生成短ID +func generateShortID() string { + b := make([]byte, 4) + rand.Read(b) + return time.Now().Format("150405") + "-" + hex.EncodeToString(b) +} diff --git a/internal/handler/task_manager.go b/internal/handler/task_manager.go index 7c44a338..ff059322 100644 --- a/internal/handler/task_manager.go +++ b/internal/handler/task_manager.go @@ -23,16 +23,31 @@ type AgentTask struct { cancel func(error) } +// CompletedTask 已完成的任务（用于历史记录） +type CompletedTask struct { + ConversationID string `json:"conversationId"` + Message string `json:"message,omitempty"` + StartedAt time.Time `json:"startedAt"` + CompletedAt time.Time `json:"completedAt"` + Status string `json:"status"` +} + // AgentTaskManager 管理正在运行的Agent任务 type AgentTaskManager struct { - mu sync.RWMutex - tasks map[string]*AgentTask + mu sync.RWMutex + tasks map[string]*AgentTask + completedTasks []*CompletedTask // 最近完成的任务历史 + maxHistorySize int // 最大历史记录数 + historyRetention time.Duration // 历史记录保留时间 } // NewAgentTaskManager 创建任务管理器 func NewAgentTaskManager() *AgentTaskManager { return &AgentTaskManager{ - tasks: make(map[string]*AgentTask), + tasks: make(map[string]*AgentTask), + completedTasks: make([]*CompletedTask, 0), + maxHistorySize: 50, // 最多保留50条历史记录 + historyRetention: 24 * time.Hour, // 保留24小时 } } @@ -118,9 +133,49 @@ func (m *AgentTaskManager) FinishTask(conversationID string, finalStatus string) task.Status = finalStatus } + // 保存到历史记录 + completedTask := &CompletedTask{ + ConversationID: task.ConversationID, + Message: task.Message, + StartedAt: task.StartedAt, + CompletedAt: time.Now(), + Status: finalStatus, + } + + // 添加到历史记录 + m.completedTasks = append(m.completedTasks, completedTask) + + // 清理过期和过多的历史记录 + m.cleanupHistory() + + // 从运行任务中移除 delete(m.tasks, conversationID) } +// cleanupHistory 清理过期的历史记录 +func (m *AgentTaskManager) cleanupHistory() { + now := time.Now() + cutoffTime := now.Add(-m.historyRetention) + + // 过滤掉过期的记录 + validTasks := make([]*CompletedTask, 0, len(m.completedTasks)) + for _, task := range m.completedTasks { + if task.CompletedAt.After(cutoffTime) { + validTasks = append(validTasks, task) + } + } + + // 如果仍然超过最大数量，只保留最新的 + if len(validTasks) > m.maxHistorySize { + // 按完成时间排序，保留最新的 + // 由于是追加的，最新的在最后，所以直接取最后N个 + start := len(validTasks) - m.maxHistorySize + validTasks = validTasks[start:] + } + + m.completedTasks = validTasks +} + // GetActiveTasks 返回所有正在运行的任务 func (m *AgentTaskManager) GetActiveTasks() []*AgentTask { m.mu.RLock() @@ -137,3 +192,35 @@ func (m *AgentTaskManager) GetActiveTasks() []*AgentTask { } return result } + +// GetCompletedTasks 返回最近完成的任务历史 +func (m *AgentTaskManager) GetCompletedTasks() []*CompletedTask { + m.mu.RLock() + defer m.mu.RUnlock() + + // 清理过期记录（只读锁，不影响其他操作） + // 注意：这里不能直接调用cleanupHistory，因为需要写锁 + // 所以返回时过滤过期记录 + now := time.Now() + cutoffTime := now.Add(-m.historyRetention) + + result := make([]*CompletedTask, 0, len(m.completedTasks)) + for _, task := range m.completedTasks { + if task.CompletedAt.After(cutoffTime) { + result = append(result, task) + } + } + + // 按完成时间倒序排序（最新的在前） + // 由于是追加的，最新的在最后，需要反转 + for i, j := 0, len(result)-1; i < j; i, j = i+1, j-1 { + result[i], result[j] = result[j], result[i] + } + + // 限制返回数量 + if len(result) > m.maxHistorySize { + result = result[:m.maxHistorySize] + } + + return result +} diff --git a/web/static/css/style.css b/web/static/css/style.css index da794489..08c9d05b 100644 --- a/web/static/css/style.css +++ b/web/static/css/style.css @@ -6187,6 +6187,728 @@ header { background: rgba(0, 102, 255, 0.1); } +/* 任务管理页面样式 */ +.tasks-stats-bar { + display: flex; + gap: 24px; + padding: 16px 20px; + background: linear-gradient(135deg, rgba(0, 102, 255, 0.05) 0%, rgba(0, 102, 255, 0.02) 100%); + border: 1px solid rgba(0, 102, 255, 0.15); + border-radius: 12px; + box-shadow: var(--shadow-sm); + margin-bottom: 24px; + flex-wrap: wrap; +} + +.tasks-controls { + margin-bottom: 24px; +} + +.tasks-filters { + display: flex; + gap: 16px; + align-items: flex-end; + flex-wrap: wrap; + padding: 16px; + background: var(--bg-secondary); + border: 1px solid var(--border-color); + border-radius: 12px; +} + +.tasks-filters label { + display: flex; + flex-direction: column; + gap: 6px; + font-size: 0.875rem; + color: var(--text-secondary); + font-weight: 500; +} + +.tasks-filters select { + padding: 8px 12px; + border: 1px solid var(--border-color); + border-radius: 6px; + font-size: 0.875rem; + background: var(--bg-primary); + color: var(--text-primary); + min-width: 150px; + cursor: pointer; + transition: all 0.2s; +} + +.tasks-filters select:focus { + outline: none; + border-color: var(--accent-color); + box-shadow: 0 0 0 2px rgba(0, 102, 255, 0.1); +} + +.tasks-filters select:hover { + border-color: var(--accent-color); +} + +.tasks-batch-actions { + display: flex; + align-items: center; + gap: 12px; + padding: 12px 16px; + background: rgba(0, 102, 255, 0.05); + border: 1px solid rgba(0, 102, 255, 0.2); + border-radius: 8px; + margin-top: 12px; +} + +.tasks-batch-actions span { + font-size: 0.875rem; + color: var(--text-primary); + font-weight: 500; +} + +.auto-refresh-toggle { + display: flex; + align-items: center; + gap: 8px; + font-size: 0.875rem; + color: var(--text-primary); + cursor: pointer; + user-select: none; +} + +.auto-refresh-toggle input[type="checkbox"] { + width: 18px; + height: 18px; + cursor: pointer; + accent-color: var(--accent-color); +} + +.page-header-actions { + display: flex; + align-items: center; + gap: 12px; +} + +.show-history-toggle { + display: flex; + align-items: center; + gap: 8px; + font-size: 0.875rem; + color: var(--text-primary); + cursor: pointer; + user-select: none; + margin-left: auto; +} + +.show-history-toggle input[type="checkbox"] { + width: 18px; + height: 18px; + cursor: pointer; + accent-color: var(--accent-color); +} + +.tasks-history-section { + margin-top: 32px; + padding-top: 24px; + border-top: 2px solid var(--border-color); +} + +.tasks-history-header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 16px; + padding-bottom: 12px; + border-bottom: 1px solid var(--border-color); +} + +.tasks-history-title { + font-size: 0.9375rem; + font-weight: 600; + color: var(--text-secondary); +} + +.task-item-history { + opacity: 0.85; +} + +.task-item-history:hover { + opacity: 1; +} + +.task-history-badge { + font-size: 0.875rem; + margin-left: 4px; + opacity: 0.7; +} + +.task-stat-item { + display: flex; + flex-direction: column; + gap: 4px; +} + +.task-stat-label { + font-size: 0.8125rem; + color: var(--text-secondary); + font-weight: 500; +} + +.task-stat-value { + font-size: 1.5rem; + font-weight: 600; + color: var(--accent-color); +} + +.tasks-list { + display: flex; + flex-direction: column; + gap: 16px; +} + +.tasks-empty { + display: flex; + flex-direction: column; + align-items: center; + justify-content: center; + padding: 60px 20px; + text-align: center; + color: var(--text-secondary); +} + +.tasks-empty p { + font-size: 1rem; + margin-bottom: 16px; +} + +.task-item { + background: var(--bg-primary); + border: 1px solid var(--border-color); + border-radius: 12px; + padding: 20px; + box-shadow: var(--shadow-sm); + transition: all 0.2s ease; +} + +.task-item:hover { + box-shadow: var(--shadow-md); + transform: translateY(-2px); +} + +.task-header { + display: flex; + justify-content: space-between; + align-items: center; + gap: 16px; + flex-wrap: wrap; +} + +.task-info { + display: flex; + align-items: center; + gap: 12px; + flex: 1; + min-width: 200px; +} + +.task-checkbox { + display: flex; + align-items: center; + cursor: pointer; +} + +.task-checkbox input[type="checkbox"] { + width: 18px; + height: 18px; + cursor: pointer; + accent-color: var(--accent-color); +} + +.task-checkbox-placeholder { + width: 18px; + height: 18px; +} + +.task-status { + display: inline-flex; + align-items: center; + padding: 4px 12px; + border-radius: 12px; + font-size: 0.8125rem; + font-weight: 500; + white-space: nowrap; +} + +.task-status-running { + background: rgba(0, 123, 255, 0.1); + color: var(--accent-color); + border: 1px solid rgba(0, 123, 255, 0.3); +} + +.task-status-cancelling { + background: rgba(255, 193, 7, 0.1); + color: #b8860b; + border: 1px solid rgba(255, 193, 7, 0.3); +} + +.task-status-completed { + background: rgba(40, 167, 69, 0.1); + color: var(--success-color); + border: 1px solid rgba(40, 167, 69, 0.3); +} + +.task-status-failed, +.task-status-timeout { + background: rgba(220, 53, 69, 0.1); + color: var(--error-color); + border: 1px solid rgba(220, 53, 69, 0.3); +} + +.task-status-cancelled { + background: rgba(108, 117, 125, 0.1); + color: var(--text-secondary); + border: 1px solid rgba(108, 117, 125, 0.3); +} + +.task-status-unknown { + background: var(--bg-secondary); + color: var(--text-secondary); + border: 1px solid var(--border-color); +} + +.task-message { + font-size: 0.9375rem; + color: var(--text-primary); + font-weight: 500; + word-break: break-word; +} + +.task-actions { + display: flex; + align-items: center; + gap: 12px; + flex-wrap: wrap; +} + +.task-time { + font-size: 0.8125rem; + color: var(--text-secondary); + white-space: nowrap; +} + +.task-duration { + font-size: 0.8125rem; + color: var(--accent-color); + font-weight: 500; + white-space: nowrap; + padding: 4px 8px; + background: rgba(0, 102, 255, 0.1); + border-radius: 4px; +} + +.task-details { + margin-top: 12px; + padding-top: 12px; + border-top: 1px solid var(--border-color); + display: flex; + align-items: center; + gap: 8px; + font-size: 0.8125rem; +} + +.task-id-label { + color: var(--text-secondary); + font-weight: 500; +} + +.task-id-value { + color: var(--text-primary); + font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; + background: var(--bg-secondary); + padding: 2px 8px; + border-radius: 4px; + word-break: break-all; + cursor: pointer; + transition: all 0.2s; +} + +.task-id-value:hover { + background: var(--bg-tertiary); + color: var(--accent-color); +} + +@media (max-width: 768px) { + .tasks-stats-bar { + flex-direction: column; + gap: 12px; + } + + .task-stat-item { + flex-direction: row; + justify-content: space-between; + align-items: center; + } + + .tasks-filters { + flex-direction: column; + align-items: stretch; + } + + .tasks-filters select { + min-width: 100%; + } + + .tasks-batch-actions { + flex-direction: column; + align-items: stretch; + } + + .page-header-actions { + flex-direction: column; + align-items: stretch; + } + + .task-header { + flex-direction: column; + align-items: flex-start; + } + + .task-actions { + width: 100%; + justify-content: flex-end; + flex-wrap: wrap; + } + + .task-duration { + font-size: 0.75rem; + padding: 2px 6px; + } +} + +/* 批量任务相关样式 */ +.batch-queues-section { + margin-top: 32px; + padding-top: 24px; + border-top: 2px solid var(--border-color); +} + +.batch-queues-header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 16px; + padding-bottom: 12px; + border-bottom: 1px solid var(--border-color); +} + +.batch-queues-header h3 { + margin: 0; + font-size: 1.125rem; + font-weight: 600; + color: var(--text-primary); +} + +.batch-queues-list { + display: flex; + flex-direction: column; + gap: 16px; +} + +.batch-queue-item { + background: var(--bg-primary); + border: 1px solid var(--border-color); + border-radius: 12px; + padding: 20px; + box-shadow: var(--shadow-sm); + transition: all 0.2s ease; + cursor: pointer; +} + +.batch-queue-item:hover { + box-shadow: var(--shadow-md); + transform: translateY(-2px); + border-color: var(--accent-color); +} + +.batch-queue-header { + display: flex; + justify-content: space-between; + align-items: center; + gap: 16px; + margin-bottom: 12px; + flex-wrap: wrap; +} + +.batch-queue-info { + display: flex; + align-items: center; + gap: 12px; + flex: 1; + flex-wrap: wrap; +} + +.batch-queue-status { + display: inline-flex; + align-items: center; + padding: 4px 12px; + border-radius: 12px; + font-size: 0.8125rem; + font-weight: 500; + white-space: nowrap; +} + +.batch-queue-status-pending { + background: rgba(108, 117, 125, 0.1); + color: var(--text-secondary); + border: 1px solid rgba(108, 117, 125, 0.3); +} + +.batch-queue-status-running { + background: rgba(0, 123, 255, 0.1); + color: var(--accent-color); + border: 1px solid rgba(0, 123, 255, 0.3); +} + +.batch-queue-status-completed { + background: rgba(40, 167, 69, 0.1); + color: var(--success-color); + border: 1px solid rgba(40, 167, 69, 0.3); +} + +.batch-queue-status-cancelled { + background: rgba(108, 117, 125, 0.1); + color: var(--text-secondary); + border: 1px solid rgba(108, 117, 125, 0.3); +} + +.batch-queue-id { + font-size: 0.8125rem; + color: var(--text-secondary); + font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; +} + +.batch-queue-time { + font-size: 0.8125rem; + color: var(--text-secondary); +} + +.batch-queue-progress { + display: flex; + align-items: center; + gap: 12px; + min-width: 200px; +} + +.batch-queue-progress-bar { + flex: 1; + height: 8px; + background: var(--bg-secondary); + border-radius: 4px; + overflow: hidden; +} + +.batch-queue-progress-fill { + height: 100%; + background: linear-gradient(90deg, var(--accent-color) 0%, var(--accent-hover) 100%); + transition: width 0.3s ease; +} + +.batch-queue-progress-text { + font-size: 0.8125rem; + color: var(--text-secondary); + white-space: nowrap; + min-width: 60px; + text-align: right; +} + +.batch-queue-stats { + display: flex; + gap: 16px; + flex-wrap: wrap; + font-size: 0.8125rem; + color: var(--text-secondary); +} + +.batch-queue-stats span { + white-space: nowrap; +} + +.batch-queue-detail-info { + margin-bottom: 24px; + padding: 16px; + background: var(--bg-secondary); + border-radius: 8px; +} + +.batch-queue-detail-info .detail-item { + margin-bottom: 8px; + font-size: 0.875rem; +} + +.batch-queue-detail-info .detail-item strong { + color: var(--text-primary); + margin-right: 8px; +} + +.batch-queue-tasks-list { + max-height: 500px; + overflow-y: auto; +} + +.batch-queue-tasks-list h4 { + margin: 0 0 16px 0; + font-size: 1rem; + font-weight: 600; + color: var(--text-primary); +} + +.batch-task-item { + background: var(--bg-primary); + border: 1px solid var(--border-color); + border-radius: 8px; + padding: 16px; + margin-bottom: 12px; + transition: all 0.2s ease; +} + +.batch-task-item:hover { + box-shadow: var(--shadow-sm); +} + +.batch-task-item-active { + border-color: var(--accent-color); + background: rgba(0, 102, 255, 0.02); +} + +.batch-task-header { + display: flex; + align-items: center; + gap: 12px; + margin-bottom: 8px; + flex-wrap: wrap; +} + +.batch-task-header .btn-small { + margin-left: auto; + flex-shrink: 0; +} + +.batch-task-header .batch-task-edit-btn { + margin-left: 8px; +} + +.batch-task-header .batch-task-delete-btn { + margin-left: 8px; +} + +.batch-task-index { + font-weight: 600; + color: var(--text-secondary); + min-width: 30px; +} + +.batch-task-status { + display: inline-flex; + align-items: center; + padding: 2px 8px; + border-radius: 8px; + font-size: 0.75rem; + font-weight: 500; + white-space: nowrap; +} + +.batch-task-status-pending { + background: rgba(108, 117, 125, 0.1); + color: var(--text-secondary); +} + +.batch-task-status-running { + background: rgba(0, 123, 255, 0.1); + color: var(--accent-color); +} + +.batch-task-status-completed { + background: rgba(40, 167, 69, 0.1); + color: var(--success-color); +} + +.batch-task-status-failed { + background: rgba(220, 53, 69, 0.1); + color: var(--error-color); +} + +.batch-task-status-cancelled { + background: rgba(108, 117, 125, 0.1); + color: var(--text-secondary); +} + +.batch-task-message { + flex: 1; + font-size: 0.875rem; + color: var(--text-primary); + word-break: break-word; +} + +.batch-task-time { + font-size: 0.75rem; + color: var(--text-secondary); + margin-top: 4px; +} + +.batch-task-error { + font-size: 0.8125rem; + color: var(--error-color); + margin-top: 8px; + padding: 8px; + background: rgba(220, 53, 69, 0.05); + border-radius: 4px; + border-left: 3px solid var(--error-color); +} + +.batch-task-result { + font-size: 0.8125rem; + color: var(--text-primary); + margin-top: 8px; + padding: 8px; + background: var(--bg-secondary); + border-radius: 4px; + max-height: 150px; + overflow-y: auto; + word-break: break-word; +} + +.batch-import-stats { + display: none; + padding: 8px 12px; + background: rgba(0, 102, 255, 0.05); + border: 1px solid rgba(0, 102, 255, 0.2); + border-radius: 6px; + font-size: 0.875rem; + color: var(--accent-color); +} + +.batch-import-stat { + font-weight: 500; +} + +@media (max-width: 768px) { + .batch-queue-header { + flex-direction: column; + align-items: flex-start; + } + + .batch-queue-progress { + width: 100%; + } + + .batch-queue-stats { + flex-direction: column; + gap: 8px; + } + + .batch-task-header { + flex-direction: column; + align-items: flex-start; + } +} + /* 漏洞管理页面样式 */ .vulnerability-dashboard { margin-bottom: 24px; diff --git a/web/static/js/chat.js b/web/static/js/chat.js index 548d9bf7..0ca68ce5 100644 --- a/web/static/js/chat.js +++ b/web/static/js/chat.js @@ -3778,7 +3778,18 @@ let pendingGroupMappings = {}; // 待保留的分组映射（用于处理后端A async function loadGroups() { try { const response = await apiFetch('/api/groups'); - groupsCache = await response.json(); + if (!response.ok) { + groupsCache = []; + return; + } + const data = await response.json(); + // 确保groupsCache是有效数组 + if (Array.isArray(data)) { + groupsCache = data; + } else { + // 如果返回的不是数组，使用空数组（不打印警告，因为可能后端返回了错误格式但我们要优雅处理） + groupsCache = []; + } const groupsList = document.getElementById('conversation-groups-list'); if (!groupsList) return; @@ -4723,13 +4734,20 @@ async function loadConversationGroupMapping() { groups = groupsCache; } else { const response = await apiFetch('/api/groups'); - groups = await response.json(); - } - - // 确保groups是有效数组 - if (!Array.isArray(groups)) { - console.warn('loadConversationGroupMapping: groups不是有效数组，使用空数组'); - groups = []; + if (!response.ok) { + // 如果API请求失败，使用空数组，不打印警告（这是正常错误处理） + groups = []; + } else { + groups = await response.json(); + // 确保groups是有效数组，只在真正异常时才打印警告 + if (!Array.isArray(groups)) { + // 只在返回的不是数组且不是null/undefined时才打印警告（可能是后端返回了错误格式） + if (groups !== null && groups !== undefined) { + console.warn('loadConversationGroupMapping: groups不是有效数组，使用空数组', groups); + } + groups = []; + } + } } // 保存待保留的映射 diff --git a/web/static/js/router.js b/web/static/js/router.js index 93c3d58b..fc810203 100644 --- a/web/static/js/router.js +++ b/web/static/js/router.js @@ -3,14 +3,37 @@ let currentPage = 'chat'; // 初始化路由 function initRouter() { - // 默认显示对话页面 - switchPage('chat'); - // 从URL hash读取页面（如果有） const hash = window.location.hash.slice(1); - if (hash && ['chat', 'vulnerabilities', 'mcp-monitor', 'mcp-management', 'knowledge-management', 'knowledge-retrieval-logs', 'settings'].includes(hash)) { - switchPage(hash); + if (hash) { + const hashParts = hash.split('?'); + const pageId = hashParts[0]; + if (pageId && ['chat', 'vulnerabilities', 'mcp-monitor', 'mcp-management', 'knowledge-management', 'knowledge-retrieval-logs', 'settings', 'tasks'].includes(pageId)) { + switchPage(pageId); + + // 如果是chat页面且带有conversation参数，加载对应对话 + if (pageId === 'chat' && hashParts.length > 1) { + const params = new URLSearchParams(hashParts[1]); + const conversationId = params.get('conversation'); + if (conversationId) { + setTimeout(() => { + // 尝试多种方式调用loadConversation + if (typeof loadConversation === 'function') { + loadConversation(conversationId); + } else if (typeof window.loadConversation === 'function') { + window.loadConversation(conversationId); + } else { + console.warn('loadConversation function not found'); + } + }, 500); + } + } + return; + } } + + // 默认显示对话页面 + switchPage('chat'); } // 切换页面 @@ -178,6 +201,12 @@ function initPage(pageId) { case 'chat': // 对话页面已由chat.js初始化 break; + case 'tasks': + // 初始化任务管理页面 + if (typeof initTasksPage === 'function') { + initTasksPage(); + } + break; case 'mcp-monitor': // 初始化监控面板 if (typeof refreshMonitorPanel === 'function') { @@ -211,6 +240,11 @@ function initPage(pageId) { } break; } + + // 清理其他页面的定时器 + if (pageId !== 'tasks' && typeof cleanupTasksPage === 'function') { + cleanupTasksPage(); + } } // 页面加载完成后初始化路由 @@ -221,10 +255,48 @@ document.addEventListener('DOMContentLoaded', function() { // 监听hash变化 window.addEventListener('hashchange', function() { const hash = window.location.hash.slice(1); - if (hash && ['chat', 'vulnerabilities', 'mcp-monitor', 'mcp-management', 'knowledge-management', 'knowledge-retrieval-logs', 'settings'].includes(hash)) { - switchPage(hash); + // 处理带参数的hash（如 chat?conversation=xxx） + const hashParts = hash.split('?'); + const pageId = hashParts[0]; + + if (pageId && ['chat', 'tasks', 'vulnerabilities', 'mcp-monitor', 'mcp-management', 'knowledge-management', 'knowledge-retrieval-logs', 'settings'].includes(pageId)) { + switchPage(pageId); + + // 如果是chat页面且带有conversation参数，加载对应对话 + if (pageId === 'chat' && hashParts.length > 1) { + const params = new URLSearchParams(hashParts[1]); + const conversationId = params.get('conversation'); + if (conversationId) { + setTimeout(() => { + // 尝试多种方式调用loadConversation + if (typeof loadConversation === 'function') { + loadConversation(conversationId); + } else if (typeof window.loadConversation === 'function') { + window.loadConversation(conversationId); + } else { + console.warn('loadConversation function not found'); + } + }, 200); + } + } } }); + + // 页面加载时也检查hash参数 + const hash = window.location.hash.slice(1); + if (hash) { + const hashParts = hash.split('?'); + const pageId = hashParts[0]; + if (pageId === 'chat' && hashParts.length > 1) { + const params = new URLSearchParams(hashParts[1]); + const conversationId = params.get('conversation'); + if (conversationId && typeof loadConversation === 'function') { + setTimeout(() => { + loadConversation(conversationId); + }, 500); + } + } + } }); // 切换侧边栏折叠/展开 diff --git a/web/static/js/tasks.js b/web/static/js/tasks.js new file mode 100644 index 00000000..a96adeb9 --- /dev/null +++ b/web/static/js/tasks.js @@ -0,0 +1,1466 @@ +// 任务管理页面功能 + +// HTML转义函数（如果未定义） +if (typeof escapeHtml === 'undefined') { + function escapeHtml(text) { + if (text == null) return ''; + const div = document.createElement('div'); + div.textContent = text; + return div.innerHTML; + } +} + +// 任务管理状态 +const tasksState = { + allTasks: [], + filteredTasks: [], + selectedTasks: new Set(), + autoRefresh: true, + refreshInterval: null, + durationUpdateInterval: null, + completedTasksHistory: [], // 保存最近完成的任务历史 + showHistory: true // 是否显示历史记录 +}; + +// 从localStorage加载已完成任务历史 +function loadCompletedTasksHistory() { + try { + const saved = localStorage.getItem('tasks-completed-history'); + if (saved) { + const history = JSON.parse(saved); + // 只保留最近24小时内完成的任务 + const now = Date.now(); + const oneDayAgo = now - 24 * 60 * 60 * 1000; + tasksState.completedTasksHistory = history.filter(task => { + const completedTime = task.completedAt || task.startedAt; + return completedTime && new Date(completedTime).getTime() > oneDayAgo; + }); + // 保存清理后的历史 + saveCompletedTasksHistory(); + } + } catch (error) { + console.error('加载已完成任务历史失败:', error); + tasksState.completedTasksHistory = []; + } +} + +// 保存已完成任务历史到localStorage +function saveCompletedTasksHistory() { + try { + localStorage.setItem('tasks-completed-history', JSON.stringify(tasksState.completedTasksHistory)); + } catch (error) { + console.error('保存已完成任务历史失败:', error); + } +} + +// 更新已完成任务历史 +function updateCompletedTasksHistory(currentTasks) { + // 保存当前所有任务作为快照（用于下次比较） + const currentTaskIds = new Set(currentTasks.map(t => t.conversationId)); + + // 如果是首次加载，只需要保存当前任务快照 + if (tasksState.allTasks.length === 0) { + return; + } + + const previousTaskIds = new Set(tasksState.allTasks.map(t => t.conversationId)); + + // 找出刚完成的任务（之前存在但现在不存在的） + // 只要任务从列表中消失了，就认为它已完成 + const justCompleted = tasksState.allTasks.filter(task => { + return previousTaskIds.has(task.conversationId) && !currentTaskIds.has(task.conversationId); + }); + + // 将刚完成的任务添加到历史中 + justCompleted.forEach(task => { + // 检查是否已存在（避免重复添加） + const exists = tasksState.completedTasksHistory.some(t => t.conversationId === task.conversationId); + if (!exists) { + // 如果任务状态不是最终状态，标记为completed + const finalStatus = ['completed', 'failed', 'timeout', 'cancelled'].includes(task.status) + ? task.status + : 'completed'; + + tasksState.completedTasksHistory.push({ + conversationId: task.conversationId, + message: task.message || '未命名任务', + startedAt: task.startedAt, + status: finalStatus, + completedAt: new Date().toISOString() + }); + } + }); + + // 限制历史记录数量（最多保留50条） + if (tasksState.completedTasksHistory.length > 50) { + tasksState.completedTasksHistory = tasksState.completedTasksHistory + .sort((a, b) => new Date(b.completedAt || b.startedAt) - new Date(a.completedAt || a.startedAt)) + .slice(0, 50); + } + + saveCompletedTasksHistory(); +} + +// 加载任务列表 +async function loadTasks() { + const listContainer = document.getElementById('tasks-list'); + if (!listContainer) return; + + listContainer.innerHTML = ''; + + try { + // 并行加载运行中的任务和已完成的任务历史 + const [activeResponse, completedResponse] = await Promise.allSettled([ + apiFetch('/api/agent-loop/tasks'), + apiFetch('/api/agent-loop/tasks/completed').catch(() => null) // 如果API不存在，返回null + ]); + + // 处理运行中的任务 + if (activeResponse.status === 'rejected' || !activeResponse.value || !activeResponse.value.ok) { + throw new Error('获取任务列表失败'); + } + + const activeResult = await activeResponse.value.json(); + const activeTasks = activeResult.tasks || []; + + // 加载已完成任务历史（如果API可用） + let completedTasks = []; + if (completedResponse.status === 'fulfilled' && completedResponse.value && completedResponse.value.ok) { + try { + const completedResult = await completedResponse.value.json(); + completedTasks = completedResult.tasks || []; + } catch (e) { + console.warn('解析已完成任务历史失败:', e); + } + } + + // 保存所有任务 + tasksState.allTasks = activeTasks; + + // 更新已完成任务历史（从后端API获取） + if (completedTasks.length > 0) { + // 合并后端历史记录和本地历史记录（去重） + const backendTaskIds = new Set(completedTasks.map(t => t.conversationId)); + const localHistory = tasksState.completedTasksHistory.filter(t => + !backendTaskIds.has(t.conversationId) + ); + + // 后端的历史记录优先，然后添加本地独有的 + tasksState.completedTasksHistory = [ + ...completedTasks.map(t => ({ + conversationId: t.conversationId, + message: t.message || '未命名任务', + startedAt: t.startedAt, + status: t.status || 'completed', + completedAt: t.completedAt || new Date().toISOString() + })), + ...localHistory + ]; + + // 限制历史记录数量 + if (tasksState.completedTasksHistory.length > 50) { + tasksState.completedTasksHistory = tasksState.completedTasksHistory + .sort((a, b) => new Date(b.completedAt || b.startedAt) - new Date(a.completedAt || a.startedAt)) + .slice(0, 50); + } + + saveCompletedTasksHistory(); + } else { + // 如果后端API不可用，仍然使用前端逻辑更新历史 + updateCompletedTasksHistory(activeTasks); + } + + updateTaskStats(activeTasks); + filterAndSortTasks(); + startDurationUpdates(); + } catch (error) { + console.error('加载任务失败:', error); + listContainer.innerHTML = ` +
+

加载失败: ${escapeHtml(error.message)}

+ +
+ `; + } +} + +// 更新任务统计 +function updateTaskStats(tasks) { + const stats = { + running: 0, + cancelling: 0, + completed: 0, + failed: 0, + timeout: 0, + cancelled: 0, + total: tasks.length + }; + + tasks.forEach(task => { + if (task.status === 'running') { + stats.running++; + } else if (task.status === 'cancelling') { + stats.cancelling++; + } else if (task.status === 'completed') { + stats.completed++; + } else if (task.status === 'failed') { + stats.failed++; + } else if (task.status === 'timeout') { + stats.timeout++; + } else if (task.status === 'cancelled') { + stats.cancelled++; + } + }); + + const statRunning = document.getElementById('stat-running'); + const statCancelling = document.getElementById('stat-cancelling'); + const statCompleted = document.getElementById('stat-completed'); + const statTotal = document.getElementById('stat-total'); + + if (statRunning) statRunning.textContent = stats.running; + if (statCancelling) statCancelling.textContent = stats.cancelling; + if (statCompleted) statCompleted.textContent = stats.completed; + if (statTotal) statTotal.textContent = stats.total; +} + +// 筛选任务 +function filterTasks() { + filterAndSortTasks(); +} + +// 排序任务 +function sortTasks() { + filterAndSortTasks(); +} + +// 筛选和排序任务 +function filterAndSortTasks() { + const statusFilter = document.getElementById('tasks-status-filter')?.value || 'all'; + const sortBy = document.getElementById('tasks-sort-by')?.value || 'time-desc'; + + // 合并当前任务和历史任务 + let allTasks = [...tasksState.allTasks]; + + // 如果显示历史记录，添加历史任务 + if (tasksState.showHistory) { + const historyTasks = tasksState.completedTasksHistory + .filter(ht => !tasksState.allTasks.some(t => t.conversationId === ht.conversationId)) + .map(ht => ({ ...ht, isHistory: true })); + allTasks = [...allTasks, ...historyTasks]; + } + + // 筛选 + let filtered = allTasks; + if (statusFilter === 'active') { + // 仅运行中的任务（不包括历史） + filtered = tasksState.allTasks.filter(task => + task.status === 'running' || task.status === 'cancelling' + ); + } else if (statusFilter === 'history') { + // 仅历史记录 + filtered = allTasks.filter(task => task.isHistory); + } else if (statusFilter !== 'all') { + filtered = allTasks.filter(task => task.status === statusFilter); + } + + // 排序 + filtered.sort((a, b) => { + const aTime = new Date(a.completedAt || a.startedAt); + const bTime = new Date(b.completedAt || b.startedAt); + + switch (sortBy) { + case 'time-asc': + return aTime - bTime; + case 'time-desc': + return bTime - aTime; + case 'status': + return (a.status || '').localeCompare(b.status || ''); + case 'message': + return (a.message || '').localeCompare(b.message || ''); + default: + return 0; + } + }); + + tasksState.filteredTasks = filtered; + renderTasks(filtered); + updateBatchActions(); +} + +// 切换显示历史记录 +function toggleShowHistory(show) { + tasksState.showHistory = show; + localStorage.setItem('tasks-show-history', show ? 'true' : 'false'); + filterAndSortTasks(); +} + +// 计算执行时长 +function calculateDuration(startedAt) { + if (!startedAt) return '未知'; + const start = new Date(startedAt); + const now = new Date(); + const diff = Math.floor((now - start) / 1000); // 秒 + + if (diff < 60) { + return `${diff}秒`; + } else if (diff < 3600) { + const minutes = Math.floor(diff / 60); + const seconds = diff % 60; + return `${minutes}分${seconds}秒`; + } else { + const hours = Math.floor(diff / 3600); + const minutes = Math.floor((diff % 3600) / 60); + return `${hours}小时${minutes}分`; + } +} + +// 开始时长更新 +function startDurationUpdates() { + // 清除旧的定时器 + if (tasksState.durationUpdateInterval) { + clearInterval(tasksState.durationUpdateInterval); + } + + // 每秒更新一次执行时长 + tasksState.durationUpdateInterval = setInterval(() => { + updateTaskDurations(); + }, 1000); +} + +// 更新任务执行时长显示 +function updateTaskDurations() { + const taskItems = document.querySelectorAll('.task-item[data-task-id]'); + taskItems.forEach(item => { + const startedAt = item.dataset.startedAt; + const status = item.dataset.status; + const durationEl = item.querySelector('.task-duration'); + + if (durationEl && startedAt && (status === 'running' || status === 'cancelling')) { + durationEl.textContent = calculateDuration(startedAt); + } + }); +} + +// 渲染任务列表 +function renderTasks(tasks) { + const listContainer = document.getElementById('tasks-list'); + if (!listContainer) return; + + if (tasks.length === 0) { + listContainer.innerHTML = ` +
+

当前没有符合条件的任务

+ ${tasksState.allTasks.length === 0 && tasksState.completedTasksHistory.length > 0 ? + '

提示：有已完成的任务历史，请勾选"显示历史记录"查看

' : ''} +
+ `; + return; + } + + // 状态映射 + const statusMap = { + 'running': { text: '执行中', class: 'task-status-running' }, + 'cancelling': { text: '取消中', class: 'task-status-cancelling' }, + 'failed': { text: '执行失败', class: 'task-status-failed' }, + 'timeout': { text: '执行超时', class: 'task-status-timeout' }, + 'cancelled': { text: '已取消', class: 'task-status-cancelled' }, + 'completed': { text: '已完成', class: 'task-status-completed' } + }; + + // 分离当前任务和历史任务 + const activeTasks = tasks.filter(t => !t.isHistory); + const historyTasks = tasks.filter(t => t.isHistory); + + let html = ''; + + // 渲染当前任务 + if (activeTasks.length > 0) { + html += activeTasks.map(task => renderTaskItem(task, statusMap)).join(''); + } + + // 渲染历史任务 + if (historyTasks.length > 0) { + html += `
+
+ 📜 最近完成的任务（最近24小时） + +
+ ${historyTasks.map(task => renderTaskItem(task, statusMap, true)).join('')} +
`; + } + + listContainer.innerHTML = html; +} + +// 渲染单个任务项 +function renderTaskItem(task, statusMap, isHistory = false) { + const startedTime = task.startedAt ? new Date(task.startedAt) : null; + const completedTime = task.completedAt ? new Date(task.completedAt) : null; + + const timeText = startedTime && !isNaN(startedTime.getTime()) + ? startedTime.toLocaleString('zh-CN', { + year: 'numeric', + month: '2-digit', + day: '2-digit', + hour: '2-digit', + minute: '2-digit', + second: '2-digit' + }) + : '未知时间'; + + const completedText = completedTime && !isNaN(completedTime.getTime()) + ? completedTime.toLocaleString('zh-CN', { + year: 'numeric', + month: '2-digit', + day: '2-digit', + hour: '2-digit', + minute: '2-digit', + second: '2-digit' + }) + : ''; + + const status = statusMap[task.status] || { text: task.status, class: 'task-status-unknown' }; + const isFinalStatus = ['failed', 'timeout', 'cancelled', 'completed'].includes(task.status); + const canCancel = !isFinalStatus && task.status !== 'cancelling' && !isHistory; + const isSelected = tasksState.selectedTasks.has(task.conversationId); + const duration = (task.status === 'running' || task.status === 'cancelling') + ? calculateDuration(task.startedAt) + : ''; + + return ` +
+
+
+ ${canCancel ? ` + + ` : '
'} + ${status.text} + ${isHistory ? '📜' : ''} + ${escapeHtml(task.message || '未命名任务')} +
+
+ ${duration ? `⏱ ${duration}` : ''} + + ${isHistory && completedText ? completedText : timeText} + + ${canCancel ? `` : ''} + ${task.conversationId ? `` : ''} +
+
+ ${task.conversationId ? ` +
+ 对话ID: + ${escapeHtml(task.conversationId)} +
+ ` : ''} +
+ `; +} + +// 清空任务历史 +function clearTasksHistory() { + if (!confirm('确定要清空所有任务历史记录吗？')) { + return; + } + tasksState.completedTasksHistory = []; + saveCompletedTasksHistory(); + filterAndSortTasks(); +} + +// 切换任务选择 +function toggleTaskSelection(conversationId, selected) { + if (selected) { + tasksState.selectedTasks.add(conversationId); + } else { + tasksState.selectedTasks.delete(conversationId); + } + updateBatchActions(); +} + +// 更新批量操作UI +function updateBatchActions() { + const batchActions = document.getElementById('tasks-batch-actions'); + const selectedCount = document.getElementById('tasks-selected-count'); + + if (!batchActions || !selectedCount) return; + + const count = tasksState.selectedTasks.size; + if (count > 0) { + batchActions.style.display = 'flex'; + selectedCount.textContent = `已选择 ${count} 项`; + } else { + batchActions.style.display = 'none'; + } +} + +// 清除任务选择 +function clearTaskSelection() { + tasksState.selectedTasks.clear(); + updateBatchActions(); + // 重新渲染以更新复选框状态 + filterAndSortTasks(); +} + +// 批量取消任务 +async function batchCancelTasks() { + const selected = Array.from(tasksState.selectedTasks); + if (selected.length === 0) return; + + if (!confirm(`确定要取消 ${selected.length} 个任务吗？`)) { + return; + } + + let successCount = 0; + let failCount = 0; + + for (const conversationId of selected) { + try { + const response = await apiFetch('/api/agent-loop/cancel', { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + }, + body: JSON.stringify({ conversationId }), + }); + + if (response.ok) { + successCount++; + } else { + failCount++; + } + } catch (error) { + console.error('取消任务失败:', conversationId, error); + failCount++; + } + } + + // 清除选择 + clearTaskSelection(); + + // 刷新任务列表 + await loadTasks(); + + // 显示结果 + if (failCount > 0) { + alert(`批量取消完成：成功 ${successCount} 个，失败 ${failCount} 个`); + } else { + alert(`成功取消 ${successCount} 个任务`); + } +} + +// 复制任务ID +function copyTaskId(conversationId) { + navigator.clipboard.writeText(conversationId).then(() => { + // 显示复制成功提示 + const tooltip = document.createElement('div'); + tooltip.textContent = '已复制!'; + tooltip.style.cssText = 'position: fixed; top: 50%; left: 50%; transform: translate(-50%, -50%); background: rgba(0,0,0,0.8); color: white; padding: 8px 16px; border-radius: 4px; z-index: 10000;'; + document.body.appendChild(tooltip); + setTimeout(() => tooltip.remove(), 1000); + }).catch(err => { + console.error('复制失败:', err); + }); +} + +// 取消任务 +async function cancelTask(conversationId, button) { + if (!conversationId) return; + + const originalText = button.textContent; + button.disabled = true; + button.textContent = '取消中...'; + + try { + const response = await apiFetch('/api/agent-loop/cancel', { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + }, + body: JSON.stringify({ conversationId }), + }); + + if (!response.ok) { + const result = await response.json().catch(() => ({})); + throw new Error(result.error || '取消任务失败'); + } + + // 从选择中移除 + tasksState.selectedTasks.delete(conversationId); + updateBatchActions(); + + // 重新加载任务列表 + await loadTasks(); + } catch (error) { + console.error('取消任务失败:', error); + alert('取消任务失败: ' + error.message); + button.disabled = false; + button.textContent = originalText; + } +} + +// 查看对话 +function viewConversation(conversationId) { + if (!conversationId) return; + + // 切换到对话页面 + if (typeof switchPage === 'function') { + switchPage('chat'); + // 加载并选中该对话 - 使用全局函数 + setTimeout(() => { + // 尝试多种方式加载对话 + if (typeof loadConversation === 'function') { + loadConversation(conversationId); + } else if (typeof window.loadConversation === 'function') { + window.loadConversation(conversationId); + } else { + // 如果函数不存在，尝试通过URL跳转 + window.location.hash = `chat?conversation=${conversationId}`; + console.log('切换到对话页面，对话ID:', conversationId); + } + }, 500); + } +} + +// 刷新任务列表 +async function refreshTasks() { + await loadTasks(); +} + +// 切换自动刷新 +function toggleTasksAutoRefresh(enabled) { + tasksState.autoRefresh = enabled; + + // 保存到localStorage + localStorage.setItem('tasks-auto-refresh', enabled ? 'true' : 'false'); + + if (enabled) { + // 启动自动刷新 + if (!tasksState.refreshInterval) { + tasksState.refreshInterval = setInterval(() => { + loadBatchQueues(); + }, 5000); + } + } else { + // 停止自动刷新 + if (tasksState.refreshInterval) { + clearInterval(tasksState.refreshInterval); + tasksState.refreshInterval = null; + } + } +} + +// 初始化任务管理页面 +function initTasksPage() { + // 恢复自动刷新设置 + const autoRefreshCheckbox = document.getElementById('tasks-auto-refresh'); + if (autoRefreshCheckbox) { + const saved = localStorage.getItem('tasks-auto-refresh'); + const enabled = saved !== null ? saved === 'true' : true; + autoRefreshCheckbox.checked = enabled; + toggleTasksAutoRefresh(enabled); + } else { + toggleTasksAutoRefresh(true); + } + + // 只加载批量任务队列 + loadBatchQueues(); +} + +// 清理定时器（页面切换时调用） +function cleanupTasksPage() { + if (tasksState.refreshInterval) { + clearInterval(tasksState.refreshInterval); + tasksState.refreshInterval = null; + } + if (tasksState.durationUpdateInterval) { + clearInterval(tasksState.durationUpdateInterval); + tasksState.durationUpdateInterval = null; + } + tasksState.selectedTasks.clear(); + stopBatchQueueRefresh(); +} + +// 导出函数供全局使用 +window.loadTasks = loadTasks; +window.cancelTask = cancelTask; +window.viewConversation = viewConversation; +window.refreshTasks = refreshTasks; +window.initTasksPage = initTasksPage; +window.cleanupTasksPage = cleanupTasksPage; +window.filterTasks = filterTasks; +window.sortTasks = sortTasks; +window.toggleTaskSelection = toggleTaskSelection; +window.clearTaskSelection = clearTaskSelection; +window.batchCancelTasks = batchCancelTasks; +window.copyTaskId = copyTaskId; +window.toggleTasksAutoRefresh = toggleTasksAutoRefresh; +window.toggleShowHistory = toggleShowHistory; +window.clearTasksHistory = clearTasksHistory; + +// ==================== 批量任务功能 ==================== + +// 批量任务状态 +const batchQueuesState = { + queues: [], + currentQueueId: null, + refreshInterval: null +}; + +// 显示批量导入模态框 +function showBatchImportModal() { + const modal = document.getElementById('batch-import-modal'); + const input = document.getElementById('batch-tasks-input'); + if (modal && input) { + input.value = ''; + updateBatchImportStats(''); + modal.style.display = 'block'; + input.focus(); + } +} + +// 关闭批量导入模态框 +function closeBatchImportModal() { + const modal = document.getElementById('batch-import-modal'); + if (modal) { + modal.style.display = 'none'; + } +} + +// 更新批量导入统计 +function updateBatchImportStats(text) { + const statsEl = document.getElementById('batch-import-stats'); + if (!statsEl) return; + + const lines = text.split('\n').filter(line => line.trim() !== ''); + const count = lines.length; + + if (count > 0) { + statsEl.innerHTML = `
共 ${count} 个任务
`; + statsEl.style.display = 'block'; + } else { + statsEl.style.display = 'none'; + } +} + +// 监听批量任务输入 +document.addEventListener('DOMContentLoaded', function() { + const input = document.getElementById('batch-tasks-input'); + if (input) { + input.addEventListener('input', function() { + updateBatchImportStats(this.value); + }); + } +}); + +// 创建批量任务队列 +async function createBatchQueue() { + const input = document.getElementById('batch-tasks-input'); + if (!input) return; + + const text = input.value.trim(); + if (!text) { + alert('请输入至少一个任务'); + return; + } + + // 按行分割任务 + const tasks = text.split('\n').map(line => line.trim()).filter(line => line !== ''); + if (tasks.length === 0) { + alert('没有有效的任务'); + return; + } + + try { + const response = await apiFetch('/api/batch-tasks', { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + }, + body: JSON.stringify({ tasks }), + }); + + if (!response.ok) { + const result = await response.json().catch(() => ({})); + throw new Error(result.error || '创建批量任务队列失败'); + } + + const result = await response.json(); + closeBatchImportModal(); + + // 显示队列详情 + showBatchQueueDetail(result.queueId); + + // 刷新批量队列列表 + refreshBatchQueues(); + } catch (error) { + console.error('创建批量任务队列失败:', error); + alert('创建批量任务队列失败: ' + error.message); + } +} + +// 加载批量任务队列列表 +async function loadBatchQueues() { + const section = document.getElementById('batch-queues-section'); + if (!section) return; + + try { + const response = await apiFetch('/api/batch-tasks'); + if (!response.ok) { + throw new Error('获取批量任务队列失败'); + } + + const result = await response.json(); + batchQueuesState.queues = result.queues || []; + renderBatchQueues(batchQueuesState.queues); + } catch (error) { + console.error('加载批量任务队列失败:', error); + section.style.display = 'block'; + const list = document.getElementById('batch-queues-list'); + if (list) { + list.innerHTML = '

加载失败: ' + escapeHtml(error.message) + '

'; + } + } +} + +// 渲染批量任务队列列表 +function renderBatchQueues(queues) { + const section = document.getElementById('batch-queues-section'); + const list = document.getElementById('batch-queues-list'); + + if (!section || !list) return; + + section.style.display = 'block'; + + if (queues.length === 0) { + list.innerHTML = '

当前没有批量任务队列

'; + return; + } + + // 按创建时间倒序排序 + const sortedQueues = [...queues].sort((a, b) => + new Date(b.createdAt) - new Date(a.createdAt) + ); + + list.innerHTML = sortedQueues.map(queue => { + const statusMap = { + 'pending': { text: '待执行', class: 'batch-queue-status-pending' }, + 'running': { text: '执行中', class: 'batch-queue-status-running' }, + 'paused': { text: '已暂停', class: 'batch-queue-status-paused' }, + 'completed': { text: '已完成', class: 'batch-queue-status-completed' }, + 'cancelled': { text: '已取消', class: 'batch-queue-status-cancelled' } + }; + + const status = statusMap[queue.status] || { text: queue.status, class: 'batch-queue-status-unknown' }; + + // 统计任务状态 + const stats = { + total: queue.tasks.length, + pending: 0, + running: 0, + completed: 0, + failed: 0, + cancelled: 0 + }; + + queue.tasks.forEach(task => { + if (task.status === 'pending') stats.pending++; + else if (task.status === 'running') stats.running++; + else if (task.status === 'completed') stats.completed++; + else if (task.status === 'failed') stats.failed++; + else if (task.status === 'cancelled') stats.cancelled++; + }); + + const progress = stats.total > 0 ? Math.round((stats.completed + stats.failed + stats.cancelled) / stats.total * 100) : 0; + + return ` +
+
+
+ ${status.text} + 队列ID: ${escapeHtml(queue.id)} + 创建时间: ${new Date(queue.createdAt).toLocaleString('zh-CN')} +
+
+
+
+
+ ${progress}% (${stats.completed + stats.failed + stats.cancelled}/${stats.total}) +
+
+
+ 总计: ${stats.total} + 待执行: ${stats.pending} + 执行中: ${stats.running} + 已完成: ${stats.completed} + 失败: ${stats.failed} + ${stats.cancelled > 0 ? `已取消: ${stats.cancelled}` : ''} +
+
+ `; + }).join(''); +} + +// 显示批量任务队列详情 +async function showBatchQueueDetail(queueId) { + const modal = document.getElementById('batch-queue-detail-modal'); + const title = document.getElementById('batch-queue-detail-title'); + const content = document.getElementById('batch-queue-detail-content'); + const startBtn = document.getElementById('batch-queue-start-btn'); + const cancelBtn = document.getElementById('batch-queue-cancel-btn'); + const deleteBtn = document.getElementById('batch-queue-delete-btn'); + const addTaskBtn = document.getElementById('batch-queue-add-task-btn'); + + if (!modal || !content) return; + + try { + const response = await apiFetch(`/api/batch-tasks/${queueId}`); + if (!response.ok) { + throw new Error('获取队列详情失败'); + } + + const result = await response.json(); + const queue = result.queue; + batchQueuesState.currentQueueId = queueId; + + if (title) { + title.textContent = `批量任务队列 - ${queue.id}`; + } + + // 更新按钮显示 + if (addTaskBtn) { + addTaskBtn.style.display = queue.status === 'pending' ? 'inline-block' : 'none'; + } + if (startBtn) { + startBtn.style.display = (queue.status === 'pending' || queue.status === 'paused') ? 'inline-block' : 'none'; + } + if (cancelBtn) { + cancelBtn.style.display = (queue.status === 'running' || queue.status === 'paused') ? 'inline-block' : 'none'; + } + if (deleteBtn) { + deleteBtn.style.display = (queue.status === 'completed' || queue.status === 'cancelled') ? 'inline-block' : 'none'; + } + + // 渲染任务列表 + const statusMap = { + 'pending': { text: '待执行', class: 'batch-task-status-pending' }, + 'running': { text: '执行中', class: 'batch-task-status-running' }, + 'completed': { text: '已完成', class: 'batch-task-status-completed' }, + 'failed': { text: '失败', class: 'batch-task-status-failed' }, + 'cancelled': { text: '已取消', class: 'batch-task-status-cancelled' } + }; + + content.innerHTML = ` +
+
+ 队列ID: ${escapeHtml(queue.id)} +
+
+ 状态: ${statusMap[queue.status]?.text || queue.status} +
+
+ 创建时间: ${new Date(queue.createdAt).toLocaleString('zh-CN')} +
+ ${queue.startedAt ? `
开始时间: ${new Date(queue.startedAt).toLocaleString('zh-CN')}
` : ''} + ${queue.completedAt ? `
完成时间: ${new Date(queue.completedAt).toLocaleString('zh-CN')}
` : ''} +
+ 任务总数: ${queue.tasks.length} +
+
+
+

任务列表

+ ${queue.tasks.map((task, index) => { + const taskStatus = statusMap[task.status] || { text: task.status, class: 'batch-task-status-unknown' }; + const canEdit = queue.status === 'pending' && task.status === 'pending'; + const taskMessageEscaped = escapeHtml(task.message).replace(/'/g, "'").replace(/"/g, """).replace(/\n/g, "\\n"); + return ` +
+
+ #${index + 1} + ${taskStatus.text} + ${escapeHtml(task.message)} + ${canEdit ? `` : ''} + ${canEdit ? `` : ''} + ${task.conversationId ? `` : ''} +
+ ${task.startedAt ? `
开始: ${new Date(task.startedAt).toLocaleString('zh-CN')}
` : ''} + ${task.completedAt ? `
完成: ${new Date(task.completedAt).toLocaleString('zh-CN')}
` : ''} + ${task.error ? `
错误: ${escapeHtml(task.error)}
` : ''} + ${task.result ? `
结果: ${escapeHtml(task.result.substring(0, 200))}${task.result.length > 200 ? '...' : ''}
` : ''} +
+ `; + }).join('')} +
+ `; + + modal.style.display = 'block'; + + // 如果队列正在运行，自动刷新 + if (queue.status === 'running') { + startBatchQueueRefresh(queueId); + } + } catch (error) { + console.error('获取队列详情失败:', error); + alert('获取队列详情失败: ' + error.message); + } +} + +// 开始批量任务队列 +async function startBatchQueue() { + const queueId = batchQueuesState.currentQueueId; + if (!queueId) return; + + try { + const response = await apiFetch(`/api/batch-tasks/${queueId}/start`, { + method: 'POST', + }); + + if (!response.ok) { + const result = await response.json().catch(() => ({})); + throw new Error(result.error || '启动批量任务失败'); + } + + // 刷新详情 + showBatchQueueDetail(queueId); + refreshBatchQueues(); + } catch (error) { + console.error('启动批量任务失败:', error); + alert('启动批量任务失败: ' + error.message); + } +} + +// 取消批量任务队列 +async function cancelBatchQueue() { + const queueId = batchQueuesState.currentQueueId; + if (!queueId) return; + + if (!confirm('确定要取消这个批量任务队列吗？正在执行的任务会完成，但后续任务将不会执行。')) { + return; + } + + try { + const response = await apiFetch(`/api/batch-tasks/${queueId}/cancel`, { + method: 'POST', + }); + + if (!response.ok) { + const result = await response.json().catch(() => ({})); + throw new Error(result.error || '取消批量任务失败'); + } + + // 刷新详情 + showBatchQueueDetail(queueId); + refreshBatchQueues(); + } catch (error) { + console.error('取消批量任务失败:', error); + alert('取消批量任务失败: ' + error.message); + } +} + +// 删除批量任务队列 +async function deleteBatchQueue() { + const queueId = batchQueuesState.currentQueueId; + if (!queueId) return; + + if (!confirm('确定要删除这个批量任务队列吗？此操作不可恢复。')) { + return; + } + + try { + const response = await apiFetch(`/api/batch-tasks/${queueId}`, { + method: 'DELETE', + }); + + if (!response.ok) { + const result = await response.json().catch(() => ({})); + throw new Error(result.error || '删除批量任务队列失败'); + } + + closeBatchQueueDetailModal(); + refreshBatchQueues(); + } catch (error) { + console.error('删除批量任务队列失败:', error); + alert('删除批量任务队列失败: ' + error.message); + } +} + +// 关闭批量任务队列详情模态框 +function closeBatchQueueDetailModal() { + const modal = document.getElementById('batch-queue-detail-modal'); + if (modal) { + modal.style.display = 'none'; + } + batchQueuesState.currentQueueId = null; + stopBatchQueueRefresh(); +} + +// 开始批量队列刷新 +function startBatchQueueRefresh(queueId) { + if (batchQueuesState.refreshInterval) { + clearInterval(batchQueuesState.refreshInterval); + } + + batchQueuesState.refreshInterval = setInterval(() => { + if (batchQueuesState.currentQueueId === queueId) { + showBatchQueueDetail(queueId); + refreshBatchQueues(); + } else { + stopBatchQueueRefresh(); + } + }, 3000); // 每3秒刷新一次 +} + +// 停止批量队列刷新 +function stopBatchQueueRefresh() { + if (batchQueuesState.refreshInterval) { + clearInterval(batchQueuesState.refreshInterval); + batchQueuesState.refreshInterval = null; + } +} + +// 刷新批量任务队列列表 +async function refreshBatchQueues() { + await loadBatchQueues(); +} + +// 查看批量任务的对话 +function viewBatchTaskConversation(conversationId) { + if (!conversationId) return; + + // 关闭批量任务详情模态框 + closeBatchQueueDetailModal(); + + // 直接使用URL hash跳转，让router处理页面切换和对话加载 + // 这样更可靠，因为router会确保页面切换完成后再加载对话 + window.location.hash = `chat?conversation=${conversationId}`; +} + +// 编辑批量任务的状态 +const editBatchTaskState = { + queueId: null, + taskId: null +}; + +// 从元素获取任务信息并打开编辑模态框 +function editBatchTaskFromElement(button) { + const taskItem = button.closest('.batch-task-item'); + if (!taskItem) { + console.error('无法找到任务项元素'); + return; + } + + const queueId = taskItem.getAttribute('data-queue-id'); + const taskId = taskItem.getAttribute('data-task-id'); + const taskMessage = taskItem.getAttribute('data-task-message'); + + if (!queueId || !taskId) { + console.error('任务信息不完整'); + return; + } + + // 解码HTML实体 + const decodedMessage = taskMessage + .replace(/'/g, "'") + .replace(/"/g, '"') + .replace(/\\n/g, '\n'); + + editBatchTask(queueId, taskId, decodedMessage); +} + +// 打开编辑批量任务模态框 +function editBatchTask(queueId, taskId, currentMessage) { + editBatchTaskState.queueId = queueId; + editBatchTaskState.taskId = taskId; + + const modal = document.getElementById('edit-batch-task-modal'); + const messageInput = document.getElementById('edit-task-message'); + + if (!modal || !messageInput) { + console.error('编辑任务模态框元素不存在'); + return; + } + + messageInput.value = currentMessage; + modal.style.display = 'block'; + + // 聚焦到输入框 + setTimeout(() => { + messageInput.focus(); + messageInput.select(); + }, 100); + + // 添加ESC键监听 + const handleKeyDown = (e) => { + if (e.key === 'Escape') { + closeEditBatchTaskModal(); + document.removeEventListener('keydown', handleKeyDown); + } + }; + document.addEventListener('keydown', handleKeyDown); + + // 添加Enter+Ctrl/Cmd保存功能 + const handleKeyPress = (e) => { + if ((e.ctrlKey || e.metaKey) && e.key === 'Enter') { + e.preventDefault(); + saveBatchTask(); + document.removeEventListener('keydown', handleKeyPress); + } + }; + messageInput.addEventListener('keydown', handleKeyPress); +} + +// 关闭编辑批量任务模态框 +function closeEditBatchTaskModal() { + const modal = document.getElementById('edit-batch-task-modal'); + if (modal) { + modal.style.display = 'none'; + } + editBatchTaskState.queueId = null; + editBatchTaskState.taskId = null; +} + +// 保存批量任务 +async function saveBatchTask() { + const queueId = editBatchTaskState.queueId; + const taskId = editBatchTaskState.taskId; + const messageInput = document.getElementById('edit-task-message'); + + if (!queueId || !taskId) { + alert('任务信息不完整'); + return; + } + + if (!messageInput) { + alert('无法获取任务消息输入框'); + return; + } + + const message = messageInput.value.trim(); + if (!message) { + alert('任务消息不能为空'); + return; + } + + try { + const response = await apiFetch(`/api/batch-tasks/${queueId}/tasks/${taskId}`, { + method: 'PUT', + headers: { + 'Content-Type': 'application/json', + }, + body: JSON.stringify({ message: message }), + }); + + if (!response.ok) { + const result = await response.json().catch(() => ({})); + throw new Error(result.error || '更新任务失败'); + } + + // 关闭编辑模态框 + closeEditBatchTaskModal(); + + // 刷新队列详情 + if (batchQueuesState.currentQueueId === queueId) { + showBatchQueueDetail(queueId); + } + + // 刷新队列列表 + refreshBatchQueues(); + } catch (error) { + console.error('保存任务失败:', error); + alert('保存任务失败: ' + error.message); + } +} + +// 显示添加批量任务模态框 +function showAddBatchTaskModal() { + const queueId = batchQueuesState.currentQueueId; + if (!queueId) { + alert('队列信息不存在'); + return; + } + + const modal = document.getElementById('add-batch-task-modal'); + const messageInput = document.getElementById('add-task-message'); + + if (!modal || !messageInput) { + console.error('添加任务模态框元素不存在'); + return; + } + + messageInput.value = ''; + modal.style.display = 'block'; + + // 聚焦到输入框 + setTimeout(() => { + messageInput.focus(); + }, 100); + + // 添加ESC键监听 + const handleKeyDown = (e) => { + if (e.key === 'Escape') { + closeAddBatchTaskModal(); + document.removeEventListener('keydown', handleKeyDown); + } + }; + document.addEventListener('keydown', handleKeyDown); + + // 添加Enter+Ctrl/Cmd保存功能 + const handleKeyPress = (e) => { + if ((e.ctrlKey || e.metaKey) && e.key === 'Enter') { + e.preventDefault(); + saveAddBatchTask(); + messageInput.removeEventListener('keydown', handleKeyPress); + } + }; + messageInput.addEventListener('keydown', handleKeyPress); +} + +// 关闭添加批量任务模态框 +function closeAddBatchTaskModal() { + const modal = document.getElementById('add-batch-task-modal'); + const messageInput = document.getElementById('add-task-message'); + if (modal) { + modal.style.display = 'none'; + } + if (messageInput) { + messageInput.value = ''; + } +} + +// 保存添加的批量任务 +async function saveAddBatchTask() { + const queueId = batchQueuesState.currentQueueId; + const messageInput = document.getElementById('add-task-message'); + + if (!queueId) { + alert('队列信息不存在'); + return; + } + + if (!messageInput) { + alert('无法获取任务消息输入框'); + return; + } + + const message = messageInput.value.trim(); + if (!message) { + alert('任务消息不能为空'); + return; + } + + try { + const response = await apiFetch(`/api/batch-tasks/${queueId}/tasks`, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + }, + body: JSON.stringify({ message: message }), + }); + + if (!response.ok) { + const result = await response.json().catch(() => ({})); + throw new Error(result.error || '添加任务失败'); + } + + // 关闭添加任务模态框 + closeAddBatchTaskModal(); + + // 刷新队列详情 + if (batchQueuesState.currentQueueId === queueId) { + showBatchQueueDetail(queueId); + } + + // 刷新队列列表 + refreshBatchQueues(); + } catch (error) { + console.error('添加任务失败:', error); + alert('添加任务失败: ' + error.message); + } +} + +// 从元素获取任务信息并删除任务 +function deleteBatchTaskFromElement(button) { + const taskItem = button.closest('.batch-task-item'); + if (!taskItem) { + console.error('无法找到任务项元素'); + return; + } + + const queueId = taskItem.getAttribute('data-queue-id'); + const taskId = taskItem.getAttribute('data-task-id'); + const taskMessage = taskItem.getAttribute('data-task-message'); + + if (!queueId || !taskId) { + console.error('任务信息不完整'); + return; + } + + // 解码HTML实体以显示消息 + const decodedMessage = taskMessage + .replace(/'/g, "'") + .replace(/"/g, '"') + .replace(/\\n/g, '\n'); + + // 截断长消息用于确认对话框 + const displayMessage = decodedMessage.length > 50 + ? decodedMessage.substring(0, 50) + '...' + : decodedMessage; + + if (!confirm(`确定要删除这个任务吗？\n\n任务内容: ${displayMessage}\n\n此操作不可恢复。`)) { + return; + } + + deleteBatchTask(queueId, taskId); +} + +// 删除批量任务 +async function deleteBatchTask(queueId, taskId) { + if (!queueId || !taskId) { + alert('任务信息不完整'); + return; + } + + try { + const response = await apiFetch(`/api/batch-tasks/${queueId}/tasks/${taskId}`, { + method: 'DELETE', + }); + + if (!response.ok) { + const result = await response.json().catch(() => ({})); + throw new Error(result.error || '删除任务失败'); + } + + // 刷新队列详情 + if (batchQueuesState.currentQueueId === queueId) { + showBatchQueueDetail(queueId); + } + + // 刷新队列列表 + refreshBatchQueues(); + } catch (error) { + console.error('删除任务失败:', error); + alert('删除任务失败: ' + error.message); + } +} + +// 导出函数 +window.showBatchImportModal = showBatchImportModal; +window.closeBatchImportModal = closeBatchImportModal; +window.createBatchQueue = createBatchQueue; +window.showBatchQueueDetail = showBatchQueueDetail; +window.startBatchQueue = startBatchQueue; +window.cancelBatchQueue = cancelBatchQueue; +window.deleteBatchQueue = deleteBatchQueue; +window.closeBatchQueueDetailModal = closeBatchQueueDetailModal; +window.refreshBatchQueues = refreshBatchQueues; +window.viewBatchTaskConversation = viewBatchTaskConversation; +window.editBatchTask = editBatchTask; +window.editBatchTaskFromElement = editBatchTaskFromElement; +window.closeEditBatchTaskModal = closeEditBatchTaskModal; +window.saveBatchTask = saveBatchTask; +window.showAddBatchTaskModal = showAddBatchTaskModal; +window.closeAddBatchTaskModal = closeAddBatchTaskModal; +window.saveAddBatchTask = saveAddBatchTask; +window.deleteBatchTaskFromElement = deleteBatchTaskFromElement; diff --git a/web/templates/index.html b/web/templates/index.html index fd147ee1..82d52eab 100644 --- a/web/templates/index.html +++ b/web/templates/index.html @@ -76,6 +76,17 @@ 对话 +
+
+ + + + + + + 任务管理 +
+
@@ -541,6 +552,31 @@
+ +
+
+

任务管理

+
+ + + +
+
+
+ + +
+
+
@@ -1096,6 +1132,91 @@
+ + + + + + + + + + + +