Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

15.2 KB
Raw Blame
package httpapi

import (
	"fmt"
	"net/http"
	"strconv"
	"strings"
	"time"

	"agentflow/internal/domain"

	"github.com/gin-gonic/gin"
)

type roomsHandlers struct {
	*deps
	runCache roomRunCache
}

// roomMaxSOPs bounds one multi-SOP dispatch.
const roomMaxSOPs = 5

type roomIssueRequest struct {
	Title       string   `json:"title"`
	Description string   `json:"description"`
	WorkflowID  string   `json:"workflowId"`
	WorkflowIDs []string `json:"workflowIds"`
	AgentID     string   `json:"agentId"`
	// IssueID dispatches onto an existing requirement instead of opening a
	// new one; the issue must belong to the room's project.
	IssueID string `json:"issueId"`
}

type roomIssueResult struct {
	Message       domain.ChatMessage   `json:"message"`
	Messages      []domain.ChatMessage `json:"messages,omitempty"`
	Issue         domain.Issue         `json:"issue"`
	Task          *domain.Task         `json:"task,omitempty"`
	Tasks         []domain.Task        `json:"tasks,omitempty"`
	DispatchError string               `json:"dispatchError,omitempty"`
}

func roomWorkflowIDs(req roomIssueRequest) []string {
	seen := map[string]bool{}
	var out []string
	for _, id := range append([]string{req.WorkflowID}, req.WorkflowIDs...) {
		id = strings.TrimSpace(id)
		if id == "" || seen[id] {
			continue
		}
		seen[id] = true
		out = append(out, id)
	}
	return out
}

func (h *roomsHandlers) rooms(c *gin.Context) {
	switch c.Request.Method {
	case http.MethodGet:
		projectID := strings.TrimSpace(c.Query("projectId"))
		if projectID == "" {
			c.JSON(http.StatusBadRequest, gin.H{"error": "projectId is required"})
			return
		}
		if _, ok := h.repo.Project(projectID); !ok {
			c.JSON(http.StatusNotFound, gin.H{"error": "project not found"})
			return
		}
		if !h.roomAccess(c, projectID, false) {
			return
		}
		c.JSON(http.StatusOK, h.roomViews(h.repo.Rooms(projectID)))
	case http.MethodPost:
		var req struct {
			ProjectID string `json:"projectId"`
			Name      string `json:"name"`
		}
		if !decode(c, &req) {
			return
		}
		req.ProjectID = strings.TrimSpace(req.ProjectID)
		req.Name = strings.TrimSpace(req.Name)
		if req.ProjectID == "" || req.Name == "" {
			c.JSON(http.StatusBadRequest, gin.H{"error": "projectId and name are required"})
			return
		}
		if _, ok := h.repo.Project(req.ProjectID); !ok {
			c.JSON(http.StatusBadRequest, gin.H{"error": "project not found"})
			return
		}
		if len([]rune(req.Name)) > 80 {
			c.JSON(http.StatusBadRequest, gin.H{"error": "群名称不能超过 80 个字"})
			return
		}
		if !h.roomAccess(c, req.ProjectID, true) {
			return
		}
		userID, _ := h.roomActor(c)
		room := domain.ChatRoom{ID: newChatID("room"), ProjectID: req.ProjectID, Name: req.Name, CreatedBy: userID}
		if err := h.repo.PutRoom(room); err != nil {
			respond(c, err)
			return
		}
		stored, _ := h.repo.Room(room.ID)
		c.JSON(http.StatusCreated, h.roomView(stored))
	default:
		c.JSON(http.StatusMethodNotAllowed, gin.H{"error": "method not allowed"})
	}
}

func (h *roomsHandlers) room(c *gin.Context) {
	room, ok := h.repo.Room(c.Param("id"))
	if !ok {
		c.JSON(http.StatusNotFound, gin.H{"error": "room not found"})
		return
	}
	switch c.Request.Method {
	case http.MethodGet:
		if !h.roomAccess(c, room.ProjectID, false) {
			return
		}
		c.JSON(http.StatusOK, h.roomView(room))
	case http.MethodPatch:
		if !h.roomAccess(c, room.ProjectID, true) {
			return
		}
		var req struct {
			Name string `json:"name"`
		}
		if !decode(c, &req) {
			return
		}
		req.Name = strings.TrimSpace(req.Name)
		if req.Name == "" {
			c.JSON(http.StatusBadRequest, gin.H{"error": "群名称不能为空"})
			return
		}
		if len([]rune(req.Name)) > 80 {
			c.JSON(http.StatusBadRequest, gin.H{"error": "群名称不能超过 80 个字"})
			return
		}
		room.Name = req.Name
		if err := h.repo.PutRoom(room); err != nil {
			respond(c, err)
			return
		}
		stored, _ := h.repo.Room(room.ID)
		c.JSON(http.StatusOK, h.roomView(stored))
	default:
		c.JSON(http.StatusMethodNotAllowed, gin.H{"error": "method not allowed"})
	}
}

func (h *roomsHandlers) messages(c *gin.Context) {
	room, ok := h.repo.Room(c.Param("id"))
	if !ok {
		c.JSON(http.StatusNotFound, gin.H{"error": "room not found"})
		return
	}
	if !h.roomAccess(c, room.ProjectID, c.Request.Method != http.MethodGet) {
		return
	}
	switch c.Request.Method {
	case http.MethodGet:
		c.JSON(http.StatusOK, h.syncRoomRuns(room, h.repo.Messages(room.ID, 200)))
	case http.MethodPost:
		var req struct {
			Body string `json:"body"`
		}
		if !decode(c, &req) {
			return
		}
		body := strings.TrimSpace(req.Body)
		if body == "" {
			c.JSON(http.StatusBadRequest, gin.H{"error": "消息不能为空"})
			return
		}
		if len([]rune(body)) > 4000 {
			c.JSON(http.StatusBadRequest, gin.H{"error": "消息不能超过 4000 个字"})
			return
		}
		userID, author := h.roomActor(c)
		msg := domain.ChatMessage{ID: newChatID("msg"), RoomID: room.ID, UserID: userID, Author: author, Kind: "text", Body: body, CreatedAt: time.Now().UTC()}
		if err := h.repo.PutMessage(msg); err != nil {
			respond(c, err)
			return
		}
		h.touchRoom(room)
		c.JSON(http.StatusCreated, msg)
	default:
		c.JSON(http.StatusMethodNotAllowed, gin.H{"error": "method not allowed"})
	}
}

func (h *roomsHandlers) createIssue(c *gin.Context) {
	if c.Request.Method != http.MethodPost {
		c.JSON(http.StatusMethodNotAllowed, gin.H{"error": "method not allowed"})
		return
	}
	room, ok := h.repo.Room(c.Param("id"))
	if !ok {
		c.JSON(http.StatusNotFound, gin.H{"error": "room not found"})
		return
	}
	if !h.roomAccess(c, room.ProjectID, true) {
		return
	}
	var req roomIssueRequest
	if !decode(c, &req) {
		return
	}
	result, ok := h.dispatchRoomIssue(c, room, req)
	if !ok {
		return
	}
	c.JSON(http.StatusCreated, result)
}

// dispatchRoomIssue creates the issue behind a room dispatch and starts every
// requested SOP, posting one dispatch card per lane. Errors are written to c.
func (h *roomsHandlers) dispatchRoomIssue(c *gin.Context, room domain.ChatRoom, req roomIssueRequest) (roomIssueResult, bool) {
	if len([]rune(req.Title)) > 200 || len([]rune(req.Description)) > 8000 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "标题或描述过长"})
		return roomIssueResult{}, false
	}
	req.Title = strings.TrimSpace(req.Title)
	req.Description = strings.TrimSpace(req.Description)
	workflowIDs := roomWorkflowIDs(req)
	if req.Title == "" && strings.TrimSpace(req.IssueID) == "" {
		c.JSON(http.StatusBadRequest, gin.H{"error": "title is required"})
		return roomIssueResult{}, false
	}
	// Roles stay inside the SOP. A room can only start work by dispatching
	// one or more workflows; a bare agentId does not assign or run anything.
	if len(workflowIDs) == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "请选择要派发的 SOP"})
		return roomIssueResult{}, false
	}
	if len(workflowIDs) > roomMaxSOPs {
		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("一次最多派给 %d 条 SOP", roomMaxSOPs)})
		return roomIssueResult{}, false
	}
	workflowNames := make([]string, len(workflowIDs))
	for i, id := range workflowIDs {
		wf, found := h.repo.Workflow(id)
		if !found || (!wf.Generic && !catalogVisible(wf.ProjectID, wf.Shared, room.ProjectID)) {
			c.JSON(http.StatusBadRequest, gin.H{"error": "SOP 不存在或不属于当前项目"})
			return roomIssueResult{}, false
		}
		workflowNames[i] = wf.Name
	}
	userID, author := h.roomActor(c)
	if id := strings.TrimSpace(req.IssueID); id != "" {
		existing, found := h.repo.Issue(id)
		if !found || existing.ProjectID != room.ProjectID {
			c.JSON(http.StatusBadRequest, gin.H{"error": "需求不存在或不属于当前项目"})
			return roomIssueResult{}, false
		}
		return h.dispatchToIssue(c, room, existing, req.Description, workflowIDs, workflowNames, userID, author)
	}
	issue := domain.Issue{
		ID:          newChatID("iss"),
		ProjectID:   room.ProjectID,
		Title:       req.Title,
		Description: req.Description,
		Status:      "todo",
		Priority:    "medium",
		Kind:        "issue",
		Source:      "local",
		WorkflowID:  workflowIDs[0],
	}
	if userID > 0 {
		issue.AssigneeUserID = userID
	}
	_, _, targetName := roomDispatchTarget(workflowIDs, workflowNames)
	issue.AppendOperation(domain.IssueOperation{
		Actor: author, ActorUserID: userID, Action: "create",
		Detail: "从协作群「" + room.Name + "」建单,派给" + targetName,
	})
	if err := h.repo.PutIssue(issue); err != nil {
		respond(c, err)
		return roomIssueResult{}, false
	}
	stored, _ := h.repo.Issue(issue.ID)
	return h.dispatchToIssue(c, room, stored, req.Description, workflowIDs, workflowNames, userID, author)
}

// dispatchToIssue starts each workflow on stored and records one dispatch
// message per lane on the room timeline.
func (h *roomsHandlers) dispatchToIssue(c *gin.Context, room domain.ChatRoom, stored domain.Issue, description string, workflowIDs, workflowNames []string, userID int64, author string) (roomIssueResult, bool) {
	targetType, targetID, targetName := roomDispatchTarget(workflowIDs, workflowNames)
	result := roomIssueResult{Issue: stored}
	base := domain.ChatMessage{
		RoomID: room.ID, UserID: userID, Author: author, Kind: domain.ChatKindDispatch,
		IssueID: stored.ID, IssueNumber: stored.Number, IssueTitle: stored.Title,
		TargetType: targetType, TargetID: targetID, TargetName: targetName,
	}
	var messages []domain.ChatMessage
	var errs []string
	for i, wfID := range workflowIDs {
		msg := base
		msg.ID = newChatID("msg")
		msg.CreatedAt = time.Now().UTC()
		msg.Lane = i
		msg.WorkflowID = wfID
		msg.WorkflowName = workflowNames[i]
		if i == 0 {
			msg.Body = description
		}
		task, err := dispatchIssue(h.deps, dispatchRequest{IssueID: stored.ID, WorkflowID: wfID, TriggerUserID: userID})
		if err != nil {
			msg.DispatchError = err.Error()
			errs = append(errs, "「"+fallbackName(workflowNames[i], wfID)+"」"+err.Error())
		} else {
			msg.TaskID = task.ID
			msg.RunID = task.RunID
			result.Tasks = append(result.Tasks, publicTask(task))
			name := workflowNames[i]
			_, _ = h.repo.PatchIssue(stored.ID, func(iss *domain.Issue) error {
				iss.AppendOperation(domain.IssueOperation{Actor: author, ActorUserID: userID, Action: "dispatch", Detail: "协作群派发 SOP「" + name + "」"})
				return nil
			})
		}
		messages = append(messages, msg)
	}
	if len(result.Tasks) > 0 {
		result.Task = &result.Tasks[0]
		if again, ok := h.repo.Issue(stored.ID); ok {
			result.Issue = again
		}
	}
	result.DispatchError = strings.Join(errs, ";")
	for _, msg := range messages {
		if err := h.repo.PutMessage(msg); err != nil {
			respond(c, err)
			return roomIssueResult{}, false
		}
	}
	h.touchRoom(room)
	result.Message = messages[0]
	result.Messages = messages
	return result, true
}

// roomDispatchTarget describes the SOPs a room dispatches to. A single SOP
// reuses roomTarget; several SOPs become a "multi" target keyed by the first
// SOP and named after every SOP in dispatch order.
func roomDispatchTarget(workflowIDs, workflowNames []string) (typ, id, name string) {
	typ, id, name = roomTarget(workflowIDs[0], workflowNames[0], "", "")
	if len(workflowIDs) > 1 {
		quoted := make([]string, len(workflowNames))
		for i, workflowName := range workflowNames {
			quoted[i] = "「" + fallbackName(workflowName, workflowIDs[i]) + "」"
		}
		typ, name = "multi", "SOP"+strings.Join(quoted, "、")
	}
	return typ, id, name
}

func roomTarget(workflowID, workflowName, agentID, agentName string) (typ, id, name string) {
	switch {
	case workflowID != "" && agentID != "":
		return "both", workflowID, "SOP「" + fallbackName(workflowName, workflowID) + "」和角色「" + fallbackName(agentName, agentID) + "」"
	case workflowID != "":
		return "sop", workflowID, "SOP「" + fallbackName(workflowName, workflowID) + "」"
	default:
		return "role", agentID, "角色「" + fallbackName(agentName, agentID) + "」"
	}
}

func fallbackName(name, id string) string {
	if strings.TrimSpace(name) != "" {
		return name
	}
	return id
}

func catalogVisible(ownerProject string, shared bool, projectID string) bool {
	return domain.CatalogVisible(ownerProject, shared, projectID)
}

// roomAccess checks the signed-in user against the project roster. Anonymous
// requests only reach here when platform auth is disabled (local dev), which
// matches every other project-scoped API. Viewers may read but not post.
func (h *roomsHandlers) roomAccess(c *gin.Context, projectID string, write bool) bool {
	current, ok := h.requestUser(c.Request, true)
	if !ok || current == nil {
		if authRequired() {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "authentication required"})
			return false
		}
		return true
	}
	if h.isPlatformAdmin(c.Request) {
		return true
	}
	project, found := h.repo.Project(projectID)
	if !found {
		c.JSON(http.StatusNotFound, gin.H{"error": "project not found"})
		return false
	}
	if project.OwnerID <= 0 && len(project.Members) == 0 {
		return true
	}
	_, userID := actorLabel(current)
	if userID > 0 && project.OwnerID == userID {
		return true
	}
	for _, member := range project.Members {
		if userID > 0 && member.UserID == userID {
			if write && strings.EqualFold(strings.TrimSpace(member.Role), "viewer") {
				c.JSON(http.StatusForbidden, gin.H{"error": "只读成员不能在群里发言或派单"})
				return false
			}
			return true
		}
	}
	c.JSON(http.StatusForbidden, gin.H{"error": "你不是该项目成员,不能访问协作群"})
	return false
}

func (h *roomsHandlers) roomActor(c *gin.Context) (int64, string) {
	current, ok := h.requestUser(c.Request, true)
	if !ok || current == nil {
		return 0, "群成员"
	}
	name, id := actorLabel(current)
	if name == "" {
		name = "群成员"
	}
	return id, name
}

func (h *roomsHandlers) touchRoom(room domain.ChatRoom) {
	room.UpdatedAt = time.Now().UTC()
	_ = h.repo.PutRoom(room)
}

func (h *roomsHandlers) roomViews(rooms []domain.ChatRoom) []domain.ChatRoomView {
	out := make([]domain.ChatRoomView, 0, len(rooms))
	rosters := map[string][]domain.ChatMember{}
	for _, room := range rooms {
		members, ok := rosters[room.ProjectID]
		if !ok {
			members = h.projectRoster(room.ProjectID)
			rosters[room.ProjectID] = members
		}
		out = append(out, domain.ChatRoomView{ChatRoom: room, Members: members})
	}
	return out
}

func (h *roomsHandlers) roomView(room domain.ChatRoom) domain.ChatRoomView {
	return domain.ChatRoomView{ChatRoom: room, Members: h.projectRoster(room.ProjectID)}
}

// projectRoster lists the project owner and members; rooms share it because
// room membership follows the project.
func (h *roomsHandlers) projectRoster(projectID string) []domain.ChatMember {
	members := []domain.ChatMember{}
	project, ok := h.repo.Project(projectID)
	if !ok {
		return members
	}
	seen := map[int64]bool{}
	add := func(id int64, role string) {
		if id <= 0 || seen[id] {
			return
		}
		user, found := h.repo.User(id)
		if !found {
			return
		}
		seen[id] = true
		name := strings.TrimSpace(user.LoginName)
		if cn := strings.TrimSpace(user.ChineseName); cn != "" && name != "" {
			name = name + "(" + cn + ")"
		} else if cn != "" {
			name = cn
		}
		members = append(members, domain.ChatMember{UserID: id, Name: name, Role: role})
	}
	add(project.OwnerID, "owner")
	for _, member := range project.Members {
		add(member.UserID, member.Role)
	}
	return members
}

func newChatID(prefix string) string {
	return prefix + "-" + strconv.FormatInt(time.Now().UnixNano(), 36) + "-" + strings.NewReplacer("-", "", "_", "").Replace(randomID())
}