1275 lines
42 KiB
Go

package api
import (
"context"
"encoding/json"
"errors"
"net/http"
"net/mail"
"strings"
"time"
"droboticflow/internal/ai"
"droboticflow/internal/domain"
"droboticflow/internal/store"
"github.com/go-chi/chi/v5"
)
type validationIssue struct {
Field string `json:"field"`
Message string `json:"message"`
}
type server struct {
store store.Store
ai ai.Service
}
func maskedSecretPreview(value string) string {
compact := strings.Join(strings.Fields(strings.TrimSpace(value)), "")
if compact == "" {
compact = strings.TrimSpace(value)
}
if compact == "" {
return ""
}
runes := []rune(compact)
switch length := len(runes); {
case length <= 2:
return strings.Repeat("*", length)
case length <= 6:
return string(runes[:1]) + "****" + string(runes[length-1:])
case length <= 10:
return string(runes[:2]) + "****" + string(runes[length-2:])
default:
return string(runes[:4]) + "****" + string(runes[length-4:])
}
}
func NewHandler(dataStore store.Store, aiService ai.Service) http.Handler {
if aiService == nil {
aiService = ai.NewDisabledService("", "", "AI 服务未配置")
}
instance := &server{store: dataStore, ai: aiService}
router := chi.NewRouter()
router.Get("/api/health", instance.handleHealth)
router.Get("/api/ai/status", instance.handleAIStatus)
router.Post("/api/ai/operators/generate", instance.handleAIOperatorGenerate)
router.Post("/api/ai/workflows/generate", instance.handleAIWorkflowGenerate)
router.Get("/api/dashboard", instance.handleDashboard)
router.Get("/api/projects", instance.handleProjectsList)
router.Post("/api/projects", instance.handleProjectsCreate)
router.Get("/api/projects/{id}", instance.handleProjectsGet)
router.Put("/api/projects/{id}", instance.handleProjectsUpdate)
router.Delete("/api/projects/{id}", instance.handleProjectsDelete)
router.Get("/api/projects/{id}/workflows", instance.handleProjectWorkflowsList)
router.Post("/api/projects/{id}/workflows", instance.handleProjectWorkflowsCreate)
router.Get("/api/workflows/{id}", instance.handleWorkflowsGet)
router.Put("/api/workflows/{id}", instance.handleWorkflowsUpdate)
router.Delete("/api/workflows/{id}", instance.handleWorkflowsDelete)
router.Post("/api/workflows/{id}/run", instance.handleWorkflowRun)
router.Get("/api/templates", instance.handleTemplatesList)
router.Post("/api/templates", instance.handleTemplatesCreate)
router.Get("/api/templates/{id}", instance.handleTemplatesGet)
router.Put("/api/templates/{id}", instance.handleTemplatesUpdate)
router.Delete("/api/templates/{id}", instance.handleTemplatesDelete)
router.Get("/api/operators", instance.handleOperatorsList)
router.Post("/api/operators", instance.handleOperatorsCreate)
router.Get("/api/operators/{id}", instance.handleOperatorsGet)
router.Put("/api/operators/{id}", instance.handleOperatorsUpdate)
router.Delete("/api/operators/{id}", instance.handleOperatorsDelete)
router.Get("/api/runs", instance.handleRunsList)
router.Get("/api/runs/{id}", instance.handleRunsGet)
router.Get("/api/runs/{id}/logs", instance.handleRunsLogs)
router.Get("/api/runs/{id}/resources", instance.handleRunsResources)
router.Get("/api/runs/{id}/artifacts", instance.handleRunsArtifacts)
router.Get("/api/audit-tasks", instance.handleAuditTasksList)
router.Post("/api/audit-tasks/{id}/approve", instance.handleAuditTaskApprove)
router.Post("/api/audit-tasks/{id}/reject", instance.handleAuditTaskReject)
router.Get("/api/users", instance.handleUsersList)
router.Post("/api/users", instance.handleUsersCreate)
router.Put("/api/users/{id}", instance.handleUsersUpdate)
router.Delete("/api/users/{id}", instance.handleUsersDelete)
router.Get("/api/settings", instance.handleSettingsGet)
router.Put("/api/settings", instance.handleSettingsUpdate)
router.Get("/api/storage/buckets", instance.handleStorageBuckets)
router.Get("/api/storage/objects", instance.handleStorageObjects)
return router
}
func (server *server) handleHealth(writer http.ResponseWriter, _ *http.Request) {
renderJSON(writer, http.StatusOK, map[string]string{"status": "ok", "service": "droboticflow-api"})
}
func (server *server) handleAIStatus(writer http.ResponseWriter, _ *http.Request) {
renderJSON(writer, http.StatusOK, server.resolveAIService(context.Background()).Status())
}
type aiGenerateRequest struct {
Description string `json:"description"`
}
func (server *server) handleAIOperatorGenerate(writer http.ResponseWriter, request *http.Request) {
var payload aiGenerateRequest
if !decodeJSON(writer, request, &payload) {
return
}
if strings.TrimSpace(payload.Description) == "" {
renderValidationError(writer, validationIssue{Field: "description", Message: "description is required"})
return
}
item, err := server.resolveAIService(request.Context()).GenerateOperator(request.Context(), payload.Description)
if err != nil {
renderAIError(writer, err)
return
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleAIWorkflowGenerate(writer http.ResponseWriter, request *http.Request) {
var payload aiGenerateRequest
if !decodeJSON(writer, request, &payload) {
return
}
if strings.TrimSpace(payload.Description) == "" {
renderValidationError(writer, validationIssue{Field: "description", Message: "description is required"})
return
}
operators, err := server.store.ListOperators(request.Context())
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if len(operators) == 0 {
renderValidationError(writer, validationIssue{Field: "operators", Message: "at least one operator is required to generate a workflow"})
return
}
item, err := server.resolveAIService(request.Context()).GenerateWorkflow(request.Context(), payload.Description, operators)
if err != nil {
renderAIError(writer, err)
return
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleDashboard(writer http.ResponseWriter, request *http.Request) {
summary, err := server.store.GetDashboardSummary(request.Context())
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, summary)
}
func (server *server) populateProjectWorkflowCounts(ctx context.Context, items []domain.ProjectRecord) ([]domain.ProjectRecord, error) {
if len(items) == 0 {
return items, nil
}
workflows, err := server.store.ListAllWorkflows(ctx)
if err != nil {
return nil, err
}
counts := make(map[string]int, len(items))
for _, workflow := range workflows {
if workflow.ProjectID == "" {
continue
}
counts[workflow.ProjectID]++
}
enriched := make([]domain.ProjectRecord, len(items))
for index, item := range items {
item.WorkflowCount = counts[item.ID]
enriched[index] = item
}
return enriched, nil
}
func (server *server) populateSingleProjectWorkflowCount(ctx context.Context, item *domain.ProjectRecord) (*domain.ProjectRecord, error) {
if item == nil {
return nil, nil
}
workflows, err := server.store.ListWorkflowsByProject(ctx, item.ID)
if err != nil {
return nil, err
}
enriched := *item
enriched.WorkflowCount = len(workflows)
return &enriched, nil
}
func (server *server) handleProjectsList(writer http.ResponseWriter, request *http.Request) {
items, err := server.store.ListProjects(request.Context())
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
items, err = server.populateProjectWorkflowCounts(request.Context(), items)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) handleProjectsCreate(writer http.ResponseWriter, request *http.Request) {
var payload domain.CreateProjectInput
if !decodeJSON(writer, request, &payload) {
return
}
if strings.TrimSpace(payload.Name) == "" {
renderValidationError(writer, validationIssue{Field: "name", Message: "name is required"})
return
}
project, err := server.store.CreateProject(request.Context(), payload)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusCreated, project)
}
func (server *server) handleProjectsGet(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetProject(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Project not found"})
return
}
item, err = server.populateSingleProjectWorkflowCount(request.Context(), item)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, item)
}
type projectPatch struct {
Name *string `json:"name"`
Description *string `json:"description"`
Status *string `json:"status"`
}
func (server *server) handleProjectsUpdate(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetProject(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Project not found"})
return
}
var payload projectPatch
if !decodeJSON(writer, request, &payload) {
return
}
if payload.Name != nil {
item.Name = strings.TrimSpace(*payload.Name)
}
if payload.Description != nil {
item.Description = *payload.Description
}
if payload.Status != nil {
item.Status = *payload.Status
}
item.UpdatedAt = nowISO()
if err := server.store.UpsertProject(request.Context(), *item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
item, err = server.populateSingleProjectWorkflowCount(request.Context(), item)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleProjectsDelete(writer http.ResponseWriter, request *http.Request) {
deleted, err := server.store.DeleteProject(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if !deleted {
writer.WriteHeader(http.StatusNotFound)
return
}
writer.WriteHeader(http.StatusNoContent)
}
func (server *server) handleProjectWorkflowsList(writer http.ResponseWriter, request *http.Request) {
items, err := server.store.ListWorkflowsByProject(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func validWorkflowType(value domain.WorkflowType) bool {
return value == domain.WorkflowTypeBatch || value == domain.WorkflowTypeStreaming
}
func validateWorkflowExecutionConfig(maxConcurrentRuns int, nodeTimeoutSeconds int, runTimeoutSeconds int, maxRetryAttempts int, retryBackoffSeconds int) []validationIssue {
issues := make([]validationIssue, 0, 5)
if maxConcurrentRuns < 0 {
issues = append(issues, validationIssue{Field: "maxConcurrentRuns", Message: "maxConcurrentRuns must be zero or greater"})
}
if nodeTimeoutSeconds < 0 {
issues = append(issues, validationIssue{Field: "nodeTimeoutSeconds", Message: "nodeTimeoutSeconds must be zero or greater"})
}
if runTimeoutSeconds < 0 {
issues = append(issues, validationIssue{Field: "runTimeoutSeconds", Message: "runTimeoutSeconds must be zero or greater"})
}
if maxRetryAttempts < 0 {
issues = append(issues, validationIssue{Field: "maxRetryAttempts", Message: "maxRetryAttempts must be zero or greater"})
}
if retryBackoffSeconds < 0 {
issues = append(issues, validationIssue{Field: "retryBackoffSeconds", Message: "retryBackoffSeconds must be zero or greater"})
}
return issues
}
func (server *server) handleProjectWorkflowsCreate(writer http.ResponseWriter, request *http.Request) {
var payload domain.CreateWorkflowInput
if !decodeJSON(writer, request, &payload) {
return
}
payload.ProjectID = chi.URLParam(request, "id")
if strings.TrimSpace(payload.Name) == "" || !validWorkflowType(payload.Type) {
renderValidationError(writer,
validationIssue{Field: "name", Message: "name is required"},
validationIssue{Field: "type", Message: "type must be batch or streaming"},
)
return
}
if issues := validateWorkflowExecutionConfig(payload.MaxConcurrentRuns, payload.NodeTimeoutSeconds, payload.RunTimeoutSeconds, payload.MaxRetryAttempts, payload.RetryBackoffSeconds); len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
item, err := server.store.CreateWorkflow(request.Context(), payload)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusCreated, item)
}
func (server *server) handleWorkflowsGet(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetWorkflow(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Workflow not found"})
return
}
renderJSON(writer, http.StatusOK, item)
}
type workflowPatch struct {
Name *string `json:"name"`
Description *string `json:"description"`
Type *domain.WorkflowType `json:"type"`
MaxConcurrentRuns *int `json:"maxConcurrentRuns"`
NodeTimeoutSeconds *int `json:"nodeTimeoutSeconds"`
RunTimeoutSeconds *int `json:"runTimeoutSeconds"`
MaxRetryAttempts *int `json:"maxRetryAttempts"`
RetryBackoffSeconds *int `json:"retryBackoffSeconds"`
Schedule *domain.WorkflowSchedule `json:"schedule"`
Nodes *[]domain.WorkflowNode `json:"nodes"`
Edges *[]domain.WorkflowEdge `json:"edges"`
Status *domain.WorkflowStatus `json:"status"`
}
func (server *server) handleWorkflowsUpdate(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetWorkflow(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Workflow not found"})
return
}
var payload workflowPatch
if !decodeJSON(writer, request, &payload) {
return
}
if payload.Name != nil {
item.Name = *payload.Name
}
if payload.Description != nil {
item.Description = *payload.Description
}
if payload.Type != nil {
item.Type = *payload.Type
}
if payload.MaxConcurrentRuns != nil {
if issues := validateWorkflowExecutionConfig(*payload.MaxConcurrentRuns, 0, 0, 0, 0); len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
item.MaxConcurrentRuns = *payload.MaxConcurrentRuns
}
if payload.NodeTimeoutSeconds != nil {
if issues := validateWorkflowExecutionConfig(0, *payload.NodeTimeoutSeconds, 0, 0, 0); len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
item.NodeTimeoutSeconds = *payload.NodeTimeoutSeconds
}
if payload.RunTimeoutSeconds != nil {
if issues := validateWorkflowExecutionConfig(0, 0, *payload.RunTimeoutSeconds, 0, 0); len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
item.RunTimeoutSeconds = *payload.RunTimeoutSeconds
}
if payload.MaxRetryAttempts != nil {
if issues := validateWorkflowExecutionConfig(0, 0, 0, *payload.MaxRetryAttempts, 0); len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
item.MaxRetryAttempts = *payload.MaxRetryAttempts
}
if payload.RetryBackoffSeconds != nil {
if issues := validateWorkflowExecutionConfig(0, 0, 0, 0, *payload.RetryBackoffSeconds); len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
item.RetryBackoffSeconds = *payload.RetryBackoffSeconds
}
if payload.Schedule != nil {
item.Schedule = payload.Schedule
}
if payload.Nodes != nil {
item.Nodes = *payload.Nodes
}
if payload.Edges != nil {
item.Edges = *payload.Edges
}
if payload.Status != nil {
item.Status = *payload.Status
}
item.UpdatedAt = nowISO()
if err := server.store.UpsertWorkflow(request.Context(), *item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleWorkflowsDelete(writer http.ResponseWriter, request *http.Request) {
deleted, err := server.store.DeleteWorkflow(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if !deleted {
writer.WriteHeader(http.StatusNotFound)
return
}
writer.WriteHeader(http.StatusNoContent)
}
type runRequest struct {
Trigger domain.RunTrigger `json:"trigger"`
}
func validRunTrigger(value domain.RunTrigger) bool {
return value == domain.RunTriggerManual || value == domain.RunTriggerScheduled || value == domain.RunTriggerRetry
}
func (server *server) handleWorkflowRun(writer http.ResponseWriter, request *http.Request) {
payload := runRequest{Trigger: domain.RunTriggerManual}
if request.ContentLength != 0 {
if !decodeJSON(writer, request, &payload) {
return
}
}
if !validRunTrigger(payload.Trigger) {
renderValidationError(writer, validationIssue{Field: "trigger", Message: "trigger must be manual, scheduled, or retry"})
return
}
run, err := server.store.CreateRun(request.Context(), chi.URLParam(request, "id"), payload.Trigger)
if err != nil {
if strings.Contains(err.Error(), "not found") {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": err.Error()})
return
}
if errors.Is(err, store.ErrWorkflowAlreadyCompleted) {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "工作流已成功执行,不支持再次手动运行"})
return
}
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusAccepted, run)
}
func (server *server) handleTemplatesList(writer http.ResponseWriter, request *http.Request) {
items, err := server.store.ListTemplates(request.Context())
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) handleTemplatesCreate(writer http.ResponseWriter, request *http.Request) {
var payload domain.CreateTemplateInput
if !decodeJSON(writer, request, &payload) {
return
}
if payload.Type == "" {
payload.Type = domain.WorkflowTypeBatch
}
issues := make([]validationIssue, 0)
if strings.TrimSpace(payload.Name) == "" {
issues = append(issues, validationIssue{Field: "name", Message: "name is required"})
}
if !validWorkflowType(payload.Type) {
issues = append(issues, validationIssue{Field: "type", Message: "type must be batch or streaming"})
}
if configIssues := validateWorkflowExecutionConfig(payload.MaxConcurrentRuns, payload.NodeTimeoutSeconds, payload.RunTimeoutSeconds, payload.MaxRetryAttempts, payload.RetryBackoffSeconds); len(configIssues) > 0 {
issues = append(issues, configIssues...)
}
if len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
item, err := server.store.CreateTemplate(request.Context(), payload)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusCreated, item)
}
func (server *server) handleTemplatesGet(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetTemplate(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Template not found"})
return
}
renderJSON(writer, http.StatusOK, item)
}
type templatePatch struct {
Name *string `json:"name"`
Description *string `json:"description"`
Type *domain.WorkflowType `json:"type"`
MaxConcurrentRuns *int `json:"maxConcurrentRuns"`
NodeTimeoutSeconds *int `json:"nodeTimeoutSeconds"`
RunTimeoutSeconds *int `json:"runTimeoutSeconds"`
MaxRetryAttempts *int `json:"maxRetryAttempts"`
RetryBackoffSeconds *int `json:"retryBackoffSeconds"`
Schedule *domain.WorkflowSchedule `json:"schedule"`
Nodes *[]domain.WorkflowNode `json:"nodes"`
Edges *[]domain.WorkflowEdge `json:"edges"`
}
func (server *server) handleTemplatesUpdate(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetTemplate(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Template not found"})
return
}
var payload templatePatch
if !decodeJSON(writer, request, &payload) {
return
}
if payload.Name != nil {
item.Name = *payload.Name
}
if payload.Description != nil {
item.Description = *payload.Description
}
if payload.Type != nil {
if !validWorkflowType(*payload.Type) {
renderValidationError(writer, validationIssue{Field: "type", Message: "type must be batch or streaming"})
return
}
item.Type = *payload.Type
}
if payload.MaxConcurrentRuns != nil {
if issues := validateWorkflowExecutionConfig(*payload.MaxConcurrentRuns, 0, 0, 0, 0); len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
item.MaxConcurrentRuns = *payload.MaxConcurrentRuns
}
if payload.NodeTimeoutSeconds != nil {
if issues := validateWorkflowExecutionConfig(0, *payload.NodeTimeoutSeconds, 0, 0, 0); len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
item.NodeTimeoutSeconds = *payload.NodeTimeoutSeconds
}
if payload.RunTimeoutSeconds != nil {
if issues := validateWorkflowExecutionConfig(0, 0, *payload.RunTimeoutSeconds, 0, 0); len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
item.RunTimeoutSeconds = *payload.RunTimeoutSeconds
}
if payload.MaxRetryAttempts != nil {
if issues := validateWorkflowExecutionConfig(0, 0, 0, *payload.MaxRetryAttempts, 0); len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
item.MaxRetryAttempts = *payload.MaxRetryAttempts
}
if payload.RetryBackoffSeconds != nil {
if issues := validateWorkflowExecutionConfig(0, 0, 0, 0, *payload.RetryBackoffSeconds); len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
item.RetryBackoffSeconds = *payload.RetryBackoffSeconds
}
if payload.Schedule != nil {
item.Schedule = payload.Schedule
}
if payload.Nodes != nil {
item.Nodes = *payload.Nodes
}
if payload.Edges != nil {
item.Edges = *payload.Edges
}
item.UpdatedAt = nowISO()
if err := server.store.UpsertTemplate(request.Context(), *item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleTemplatesDelete(writer http.ResponseWriter, request *http.Request) {
deleted, err := server.store.DeleteTemplate(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if !deleted {
writer.WriteHeader(http.StatusNotFound)
return
}
writer.WriteHeader(http.StatusNoContent)
}
func (server *server) handleOperatorsList(writer http.ResponseWriter, request *http.Request) {
items, err := server.store.ListOperators(request.Context())
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) handleOperatorsCreate(writer http.ResponseWriter, request *http.Request) {
var payload domain.CreateOperatorInput
if !decodeJSON(writer, request, &payload) {
return
}
if strings.TrimSpace(payload.Name) == "" || strings.TrimSpace(payload.Category) == "" || strings.TrimSpace(payload.Description) == "" {
renderValidationError(writer,
validationIssue{Field: "name", Message: "name is required"},
validationIssue{Field: "category", Message: "category is required"},
validationIssue{Field: "description", Message: "description is required"},
)
return
}
item, err := server.store.CreateOperator(request.Context(), payload)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusCreated, item)
}
func (server *server) handleOperatorsGet(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetOperator(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Operator not found"})
return
}
renderJSON(writer, http.StatusOK, item)
}
type operatorPatch struct {
Name *string `json:"name"`
Type *string `json:"type"`
Category *string `json:"category"`
Description *string `json:"description"`
Inputs *[]domain.PortDefinition `json:"inputs"`
Outputs *[]domain.PortDefinition `json:"outputs"`
ConfigSchema *map[string]any `json:"configSchema"`
Image *string `json:"image"`
SkillDefinition *string `json:"skillDefinition"`
Hyperparams *[]domain.HyperParam `json:"hyperparams"`
Resources *domain.OperatorResources `json:"resources"`
}
func (server *server) handleOperatorsUpdate(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetOperator(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Operator not found"})
return
}
var payload operatorPatch
if !decodeJSON(writer, request, &payload) {
return
}
if payload.Name != nil {
item.Name = *payload.Name
}
if payload.Type != nil {
item.Type = *payload.Type
}
if payload.Category != nil {
item.Category = *payload.Category
}
if payload.Description != nil {
item.Description = *payload.Description
}
if payload.Inputs != nil {
item.Inputs = *payload.Inputs
}
if payload.Outputs != nil {
item.Outputs = *payload.Outputs
}
if payload.ConfigSchema != nil {
item.ConfigSchema = *payload.ConfigSchema
}
if payload.Image != nil {
item.Image = *payload.Image
}
if payload.SkillDefinition != nil {
item.SkillDefinition = *payload.SkillDefinition
}
if payload.Hyperparams != nil {
item.Hyperparams = *payload.Hyperparams
}
if payload.Resources != nil {
item.Resources = payload.Resources
}
item.UpdatedAt = nowISO()
if err := server.store.UpsertOperator(request.Context(), *item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleOperatorsDelete(writer http.ResponseWriter, request *http.Request) {
deleted, err := server.store.DeleteOperator(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if !deleted {
writer.WriteHeader(http.StatusNotFound)
return
}
writer.WriteHeader(http.StatusNoContent)
}
func (server *server) handleRunsList(writer http.ResponseWriter, request *http.Request) {
items, err := server.store.ListRuns(request.Context(), request.URL.Query().Get("status"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) loadRun(ctx context.Context, id string) (*domain.RunRecord, error) {
item, err := server.store.GetRun(ctx, id)
if err != nil || item == nil {
return item, err
}
return item, nil
}
func (server *server) handleRunsGet(writer http.ResponseWriter, request *http.Request) {
item, err := server.loadRun(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Run not found"})
return
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleRunsLogs(writer http.ResponseWriter, request *http.Request) {
item, err := server.loadRun(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Run not found"})
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": item.Logs})
}
func (server *server) handleRunsResources(writer http.ResponseWriter, request *http.Request) {
item, err := server.loadRun(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Run not found"})
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": item.ResourceSeries})
}
func (server *server) handleRunsArtifacts(writer http.ResponseWriter, request *http.Request) {
item, err := server.loadRun(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Run not found"})
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": item.Artifacts})
}
func (server *server) handleAuditTasksList(writer http.ResponseWriter, request *http.Request) {
items, err := server.store.ListAuditTasks(request.Context(), request.URL.Query().Get("status"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) resolveAuditTask(ctx context.Context, id string, decision domain.AuditStatus) (*domain.AuditTaskRecord, error) {
task, err := server.store.GetAuditTask(ctx, id)
if err != nil || task == nil {
return task, err
}
task.Status = decision
task.UpdatedAt = nowISO()
if err := server.store.UpsertAuditTask(ctx, *task); err != nil {
return nil, err
}
run, err := server.store.GetRun(ctx, task.RunID)
if err != nil {
return nil, err
}
if run != nil {
run.Status = domain.RunStatusQueued
run.UpdatedAt = nowISO()
if err := server.store.UpsertRun(ctx, *run); err != nil {
return nil, err
}
}
return task, nil
}
func (server *server) handleAuditTaskApprove(writer http.ResponseWriter, request *http.Request) {
task, err := server.resolveAuditTask(request.Context(), chi.URLParam(request, "id"), domain.AuditStatusApproved)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if task == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Audit task not found"})
return
}
renderJSON(writer, http.StatusOK, task)
}
func (server *server) handleAuditTaskReject(writer http.ResponseWriter, request *http.Request) {
task, err := server.resolveAuditTask(request.Context(), chi.URLParam(request, "id"), domain.AuditStatusRejected)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if task == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Audit task not found"})
return
}
renderJSON(writer, http.StatusOK, task)
}
func (server *server) handleUsersList(writer http.ResponseWriter, request *http.Request) {
items, err := server.store.ListUsers(request.Context())
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func normalizeUserInput(name string, email string) (string, string) {
return strings.TrimSpace(name), strings.TrimSpace(strings.ToLower(email))
}
func (server *server) handleUsersCreate(writer http.ResponseWriter, request *http.Request) {
var payload domain.CreateUserInput
if !decodeJSON(writer, request, &payload) {
return
}
payload.Name, payload.Email = normalizeUserInput(payload.Name, payload.Email)
if payload.Name == "" {
renderValidationError(writer, validationIssue{Field: "name", Message: "name is required"})
return
}
if _, err := mail.ParseAddress(payload.Email); err != nil {
renderValidationError(writer, validationIssue{Field: "email", Message: "email must be valid"})
return
}
if !validUserRole(payload.Role) {
renderValidationError(writer, validationIssue{Field: "role", Message: "role must be admin, auditor, or operator"})
return
}
item, err := server.store.CreateUser(request.Context(), payload)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusCreated, item)
}
type userPatch struct {
Name *string `json:"name"`
Email *string `json:"email"`
Role *domain.UserRole `json:"role"`
}
func validUserRole(value domain.UserRole) bool {
return value == domain.UserRoleAdmin || value == domain.UserRoleAuditor || value == domain.UserRoleOperator
}
func (server *server) handleUsersUpdate(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetUser(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "User not found"})
return
}
var payload userPatch
if !decodeJSON(writer, request, &payload) {
return
}
if payload.Name != nil {
item.Name = strings.TrimSpace(*payload.Name)
}
if payload.Email != nil {
normalizedEmail := strings.TrimSpace(strings.ToLower(*payload.Email))
if _, err := mail.ParseAddress(normalizedEmail); err != nil {
renderValidationError(writer, validationIssue{Field: "email", Message: "email must be valid"})
return
}
item.Email = normalizedEmail
}
if payload.Role != nil {
if !validUserRole(*payload.Role) {
renderValidationError(writer, validationIssue{Field: "role", Message: "role must be admin, auditor, or operator"})
return
}
item.Role = *payload.Role
}
item.UpdatedAt = nowISO()
if err := server.store.UpsertUser(request.Context(), *item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleUsersDelete(writer http.ResponseWriter, request *http.Request) {
deleted, err := server.store.DeleteUser(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if !deleted {
writer.WriteHeader(http.StatusNotFound)
return
}
writer.WriteHeader(http.StatusNoContent)
}
func (server *server) handleSettingsGet(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetSettings(request.Context())
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, sanitizeSettings(item))
}
type settingsPatch struct {
K8s *struct {
Enabled *bool `json:"enabled"`
Endpoint *string `json:"endpoint"`
Namespace *string `json:"namespace"`
Kubeconfig *string `json:"kubeconfig"`
} `json:"k8s"`
Worker *struct {
PollIntervalMS *int `json:"pollIntervalMs"`
MaxConcurrentRuns *int `json:"maxConcurrentRuns"`
} `json:"worker"`
AI *struct {
Provider *string `json:"provider"`
BaseURL *string `json:"baseURL"`
Model *string `json:"model"`
APIKey *string `json:"apiKey"`
} `json:"ai"`
Defaults *struct {
CPURequest *string `json:"cpuRequest"`
CPULimit *string `json:"cpuLimit"`
MemoryRequest *string `json:"memoryRequest"`
MemoryLimit *string `json:"memoryLimit"`
} `json:"defaults"`
Timezone *string `json:"timezone"`
}
func (server *server) handleSettingsUpdate(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetSettings(request.Context())
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
var payload settingsPatch
if !decodeJSON(writer, request, &payload) {
return
}
if payload.Timezone != nil {
timezone := strings.TrimSpace(*payload.Timezone)
if timezone == "" {
renderValidationError(writer, validationIssue{Field: "timezone", Message: "timezone is required"})
return
}
if _, err := time.LoadLocation(timezone); err != nil {
renderValidationError(writer, validationIssue{Field: "timezone", Message: "timezone must be a valid IANA timezone"})
return
}
item.Timezone = timezone
}
if payload.K8s != nil {
if payload.K8s.Enabled != nil {
item.K8s.Enabled = *payload.K8s.Enabled
}
if payload.K8s.Endpoint != nil {
item.K8s.Endpoint = *payload.K8s.Endpoint
}
if payload.K8s.Namespace != nil {
item.K8s.Namespace = *payload.K8s.Namespace
}
if payload.K8s.Kubeconfig != nil {
item.K8s.Kubeconfig = strings.TrimSpace(*payload.K8s.Kubeconfig)
}
}
if payload.Worker != nil {
if payload.Worker.PollIntervalMS != nil && *payload.Worker.PollIntervalMS > 0 {
item.Worker.PollIntervalMS = *payload.Worker.PollIntervalMS
}
if payload.Worker.MaxConcurrentRuns != nil && *payload.Worker.MaxConcurrentRuns > 0 {
item.Worker.MaxConcurrentRuns = *payload.Worker.MaxConcurrentRuns
}
}
if payload.AI != nil {
if payload.AI.Provider != nil {
item.AI.Provider = strings.TrimSpace(*payload.AI.Provider)
}
if payload.AI.BaseURL != nil {
item.AI.BaseURL = strings.TrimSpace(*payload.AI.BaseURL)
}
if payload.AI.Model != nil {
item.AI.Model = strings.TrimSpace(*payload.AI.Model)
}
if payload.AI.APIKey != nil {
item.AI.APIKey = strings.TrimSpace(*payload.AI.APIKey)
}
}
if payload.Defaults != nil {
if payload.Defaults.CPURequest != nil {
item.Defaults.CPURequest = *payload.Defaults.CPURequest
}
if payload.Defaults.CPULimit != nil {
item.Defaults.CPULimit = *payload.Defaults.CPULimit
}
if payload.Defaults.MemoryRequest != nil {
item.Defaults.MemoryRequest = *payload.Defaults.MemoryRequest
}
if payload.Defaults.MemoryLimit != nil {
item.Defaults.MemoryLimit = *payload.Defaults.MemoryLimit
}
}
item.UpdatedAt = nowISO()
if err := server.store.UpsertSettings(request.Context(), *item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, sanitizeSettings(item))
}
func (server *server) resolveAIService(ctx context.Context) ai.Service {
settings, err := server.store.GetSettings(ctx)
if err != nil || settings == nil {
return server.ai
}
if strings.TrimSpace(settings.AI.APIKey) != "" {
return ai.NewService(settings.AI.BaseURL, settings.AI.APIKey, settings.AI.Model)
}
if server.ai != nil && server.ai.Status().Enabled {
return server.ai
}
return ai.NewDisabledService(settings.AI.BaseURL, settings.AI.Model, "服务端未配置 AI_API_KEY")
}
func sanitizeSettings(item *domain.SettingsRecord) *domain.SettingsView {
if item == nil {
return nil
}
view := &domain.SettingsView{
ID: item.ID,
K8s: item.K8s,
Worker: item.Worker,
AI: item.AI,
Defaults: item.Defaults,
Timezone: item.Timezone,
UpdatedAt: item.UpdatedAt,
}
view.K8s.HasKubeconfig = strings.TrimSpace(view.K8s.Kubeconfig) != ""
view.K8s.KubeconfigPreview = maskedSecretPreview(view.K8s.Kubeconfig)
view.K8s.Kubeconfig = ""
view.AI.HasAPIKey = strings.TrimSpace(view.AI.APIKey) != ""
view.AI.APIKeyPreview = maskedSecretPreview(view.AI.APIKey)
view.AI.APIKey = ""
return view
}
func (server *server) handleStorageBuckets(writer http.ResponseWriter, request *http.Request) {
sourcePath := strings.TrimSpace(request.URL.Query().Get("sourcePath"))
if sourcePath == "" {
renderValidationError(writer, validationIssue{Field: "sourcePath", Message: "sourcePath is required"})
return
}
items, err := server.store.ListStorageBuckets(request.Context(), sourcePath)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) handleStorageObjects(writer http.ResponseWriter, request *http.Request) {
sourcePath := strings.TrimSpace(request.URL.Query().Get("sourcePath"))
if sourcePath == "" {
renderValidationError(writer, validationIssue{Field: "sourcePath", Message: "sourcePath is required"})
return
}
items, err := server.store.ListStorageObjects(
request.Context(),
sourcePath,
request.URL.Query().Get("bucket"),
request.URL.Query().Get("prefix"),
)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func decodeJSON(writer http.ResponseWriter, request *http.Request, target any) bool {
defer request.Body.Close()
decoder := json.NewDecoder(request.Body)
if err := decoder.Decode(target); err != nil {
renderJSON(writer, http.StatusBadRequest, map[string]any{"error": "Validation failed", "issues": []validationIssue{{Field: "body", Message: "invalid JSON payload"}}})
return false
}
return true
}
func renderValidationError(writer http.ResponseWriter, issues ...validationIssue) {
renderJSON(writer, http.StatusBadRequest, map[string]any{"error": "Validation failed", "issues": issues})
}
func renderError(writer http.ResponseWriter, status int, err error) {
renderJSON(writer, status, map[string]string{"error": err.Error()})
}
func renderAIError(writer http.ResponseWriter, err error) {
switch {
case errors.Is(err, ai.ErrUnavailable):
renderJSON(writer, http.StatusServiceUnavailable, map[string]string{"error": "AI 服务未配置,请在服务端配置 AI_API_KEY 后再试"})
case strings.Contains(err.Error(), "AI 生成超时") || strings.Contains(err.Error(), "AI 服务响应超时"):
renderJSON(writer, http.StatusGatewayTimeout, map[string]string{"error": err.Error()})
case strings.Contains(strings.ToLower(err.Error()), "description is required"):
renderValidationError(writer, validationIssue{Field: "description", Message: "description is required"})
default:
renderJSON(writer, http.StatusBadGateway, map[string]string{"error": err.Error()})
}
}
func renderJSON(writer http.ResponseWriter, status int, payload any) {
writer.Header().Set("Content-Type", "application/json")
writer.WriteHeader(status)
_ = json.NewEncoder(writer).Encode(payload)
}
func nowISO() string {
return time.Now().UTC().Format(time.RFC3339Nano)
}