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.
JavaScript agent-orchestrationagentic-workflowai-agentsai-codingclaude-codecode-reviewcodebuddycodexcoding-agentscursordeveloper-toolshuman-on-the-loopllmmcpmulti-agentsdlcself-hostedsopworkflow-automationworkflow-engine
package httpapi
import (
"context"
"encoding/json"
"fmt"
"log"
"net/http"
"strings"
"sync"
"time"
"agentflow/internal/domain"
"agentflow/internal/runeval"
"github.com/gin-gonic/gin"
)
const (
runEvalTimeout = 10 * time.Minute
runEvalMaxInflight = 2
)
type runEvalExecFunc func(ctx context.Context, rec domain.RunEvalRecord, run domain.Run, user domain.User, emit func(string, any)) (domain.RunEvalResult, error)
type runEvalJobEvent struct {
Seq int
Type string
Payload any
}
type runEvalJob struct {
runID string
evalID string
mu sync.Mutex
seq int
events []runEvalJobEvent
subs map[chan runEvalJobEvent]struct{}
cancel context.CancelFunc
done chan struct{}
}
type runEvalHub struct {
mu sync.Mutex
jobs map[string]*runEvalJob
tokens chan struct{}
}
var (
runEvalExecMu sync.Mutex
runEvalExecOverride runEvalExecFunc
)
func setRunEvalExecForTest(fn runEvalExecFunc) {
runEvalExecMu.Lock()
runEvalExecOverride = fn
runEvalExecMu.Unlock()
}
func currentRunEvalExec() runEvalExecFunc {
runEvalExecMu.Lock()
defer runEvalExecMu.Unlock()
if runEvalExecOverride != nil {
return runEvalExecOverride
}
return nil
}
func newRunEvalHub() *runEvalHub {
return &runEvalHub{jobs: map[string]*runEvalJob{}, tokens: make(chan struct{}, runEvalMaxInflight)}
}
func (h *runsHandlers) evalHub() *runEvalHub {
if h.evalJobs == nil {
h.evalJobs = newRunEvalHub()
}
return h.evalJobs
}
func (h *runsHandlers) startRunEval(c *gin.Context) {
id := c.Param("id")
run, ok := h.repo.Run(id)
if !ok {
c.JSON(http.StatusNotFound, map[string]string{"error": "run not found"})
return
}
if !domain.TerminalRunStatus(run.Status) {
c.JSON(http.StatusConflict, map[string]string{"error": "请等 SOP 跑完后再评测"})
return
}
current, loggedIn := h.requestUser(c.Request, true)
if !loggedIn {
c.JSON(http.StatusUnauthorized, map[string]string{"error": "请先登录后评测"})
return
}
user, ok := h.repo.User(current.ID)
if !ok || strings.TrimSpace(user.CodeBuddyAPIKey) == "" {
c.JSON(http.StatusBadRequest, map[string]string{"error": "请先在个人配置中配置自己的 CodeBuddy API Key"})
return
}
if rec, busy := h.repo.ActiveRunEval(id); busy {
hub := h.evalHub()
hub.mu.Lock()
job := hub.jobs[id]
hub.mu.Unlock()
if job != nil {
c.JSON(http.StatusConflict, map[string]string{"error": "这次运行已有评测在进行"})
return
}
// The row was saved as running, then startup failed before a job existed.
h.failRunEval(rec, "上次评测没有真正启动")
}
var req struct {
Model string `json:"model"`
}
if c.Request.ContentLength > 0 && !decode(c, &req) {
return
}
// Run evals run on CodeBuddy only: refuse a "codex:…" id instead of
// silently evaluating with the CodeBuddy default.
if engine, _ := assistantModelEngine(req.Model); engine != assistantEngineCodeBuddy {
c.JSON(http.StatusBadRequest, map[string]string{"error": "运行评测目前只支持 CodeBuddy 模型,请改选 CodeBuddy 模型"})
return
}
catalog := loadAssistantModels(c.Request.Context(), user.CodeBuddyInternetEnvironment)
model := assistantAllowedModel(req.Model, catalog)
project, _ := h.repo.Project(run.ExecutionContext.ProjectID)
rec := domain.RunEvalRecord{
ID: "eval-" + randomID(),
RunID: id,
Status: domain.RunEvalRunning,
Model: model,
Policy: domain.EffectiveRunEvalPolicy(project.RunEval),
CreatedBy: user.ID,
CreatedAt: time.Now().UTC(),
}
if err := h.repo.PutRunEval(rec); err != nil {
respond(c, err)
return
}
h.launchRunEval(rec, run, user)
c.JSON(http.StatusAccepted, rec)
}
func (h *runsHandlers) getRunEval(c *gin.Context) {
id := c.Param("id")
if !h.repo.RunExists(id) {
c.JSON(http.StatusNotFound, map[string]string{"error": "run not found"})
return
}
if rec, ok := h.repo.LatestRunEval(id); ok {
c.JSON(http.StatusOK, rec)
return
}
c.JSON(http.StatusOK, map[string]any{"runId": id, "status": ""})
}
func (h *runsHandlers) listRunEvals(c *gin.Context) {
id := c.Param("id")
if !h.repo.RunExists(id) {
c.JSON(http.StatusNotFound, map[string]string{"error": "run not found"})
return
}
c.JSON(http.StatusOK, h.repo.ListRunEvals(id))
}
func (h *runsHandlers) streamRunEval(c *gin.Context) {
id := c.Param("id")
if !h.repo.RunExists(id) {
c.JSON(http.StatusNotFound, map[string]string{"error": "run not found"})
return
}
hub := h.evalHub()
hub.mu.Lock()
job := hub.jobs[id]
hub.mu.Unlock()
if job == nil {
if rec, ok := h.repo.LatestRunEval(id); ok {
c.Header("Content-Type", "text/event-stream; charset=utf-8")
c.Status(http.StatusOK)
writeSSE(c, "done", rec)
return
}
c.JSON(http.StatusNotFound, map[string]string{"error": "eval not found"})
return
}
ch, replay := job.subscribe()
defer job.unsubscribe(ch)
c.Header("Content-Type", "text/event-stream; charset=utf-8")
c.Header("Cache-Control", "no-cache")
c.Header("Connection", "keep-alive")
c.Header("X-Accel-Buffering", "no")
c.Status(http.StatusOK)
for _, ev := range replay {
writeSSE(c, ev.Type, ev.Payload)
}
notify := c.Request.Context().Done()
for {
select {
case <-notify:
return
case ev, ok := <-ch:
if !ok {
return
}
writeSSE(c, ev.Type, ev.Payload)
if ev.Type == "done" || ev.Type == "error" {
return
}
}
}
}
func writeSSE(c *gin.Context, event string, payload any) {
raw, err := json.Marshal(payload)
if err != nil {
return
}
fmt.Fprintf(c.Writer, "event: %s\ndata: %s\n\n", event, raw)
if f, ok := c.Writer.(http.Flusher); ok {
f.Flush()
}
}
func (h *runsHandlers) applyRunEval(c *gin.Context) {
id := c.Param("id")
run, ok := h.repo.Run(id)
if !ok {
c.JSON(http.StatusNotFound, map[string]string{"error": "run not found"})
return
}
if _, loggedIn := h.requestUser(c.Request, true); !loggedIn {
c.JSON(http.StatusUnauthorized, map[string]string{"error": "请先登录后再应用评测建议"})
return
}
var req struct {
EvalID string `json:"evalId"`
RecommendationIDs []string `json:"recommendationIds"`
}
if !decode(c, &req) {
return
}
rec, ok := h.repo.LatestRunEval(id)
if req.EvalID != "" {
rec, ok = h.repo.RunEval(req.EvalID)
}
if !ok || rec.RunID != id {
c.JSON(http.StatusNotFound, map[string]string{"error": "eval not found"})
return
}
if rec.Status != domain.RunEvalSucceeded {
c.JSON(http.StatusConflict, map[string]string{"error": "评测尚未完成"})
return
}
wanted := map[string]bool{}
for _, item := range req.RecommendationIDs {
wanted[strings.TrimSpace(item)] = true
}
if len(wanted) == 0 {
c.JSON(http.StatusBadRequest, map[string]string{"error": "请选择要应用的建议"})
return
}
projectID := run.ExecutionContext.ProjectID
changed := false
for i, item := range rec.Result.Recommendations {
if !wanted[item.ID] {
continue
}
if item.Status == domain.RunEvalRecApplied {
continue
}
if !item.Applyable() {
rec.Result.Recommendations[i].ApplyError = "这条建议只能查看,不能一键应用"
changed = true
continue
}
applied, err := h.applyOneRecommendation(run, projectID, item)
if err != nil {
rec.Result.Recommendations[i].ApplyError = err.Error()
changed = true
continue
}
now := time.Now().UTC()
applied.Status = domain.RunEvalRecApplied
applied.AppliedAt = &now
applied.ApplyError = ""
rec.Result.Recommendations[i] = applied
changed = true
}
if changed {
if err := h.repo.PutRunEval(rec); err != nil {
respond(c, err)
return
}
}
c.JSON(http.StatusOK, rec)
}
func (h *runsHandlers) applyOneRecommendation(run domain.Run, projectID string, rec domain.RunEvalRecommendation) (domain.RunEvalRecommendation, error) {
action := domain.NormalizeRunEvalAction(rec.Target, rec.Action)
switch {
case strings.HasPrefix(action, "workflow."):
wf, err := h.ensureProjectWorkflow(run, projectID, firstNonEmpty(rec.TargetID, run.WorkflowID))
if err != nil {
return rec, err
}
if err := runeval.ApplyRecommendation(rec, &wf, nil); err != nil {
return rec, err
}
if err := h.repo.PutWorkflow(wf); err != nil {
return rec, err
}
rec.AppliedTargetID = wf.ID
return rec, nil
case strings.HasPrefix(action, "agent."):
agentID := firstNonEmpty(rec.TargetID, agentIDFromRun(run, rec.NodeID))
agent, err := h.ensureProjectAgent(run, projectID, agentID)
if err != nil {
return rec, err
}
if err := runeval.ApplyRecommendation(rec, nil, &agent); err != nil {
return rec, err
}
if err := h.repo.PutAgent(agent); err != nil {
return rec, err
}
rec.AppliedTargetID = agent.ID
return rec, nil
default:
return rec, fmt.Errorf("unsupported action")
}
}
func (h *runsHandlers) ensureProjectWorkflow(run domain.Run, projectID, workflowID string) (domain.WorkflowDefinition, error) {
wf, ok := h.repo.Workflow(workflowID)
if !ok {
if run.WorkflowSnapshot.ID != "" {
wf, ok = run.WorkflowSnapshot, true
}
}
if !ok {
return domain.WorkflowDefinition{}, fmt.Errorf("SOP %q 不存在", workflowID)
}
if strings.TrimSpace(wf.Name) == "" {
wf.Name = firstNonEmpty(wf.ID, "workflow")
}
if !wf.Generic && (wf.ProjectID == "" || wf.ProjectID == projectID) {
return wf, nil
}
cloneID := runeval.CloneID(wf.ID, firstNonEmpty(projectID, "copy"))
if existing, exists := h.repo.Workflow(cloneID); exists {
return existing, nil
}
wf.ID = cloneID
wf.Name = strings.TrimSpace(wf.Name) + "(评测副本)"
wf.ProjectID = projectID
wf.Generic = false
wf.Shared = false
wf.Status = "draft"
wf.Revision = 0
wf.CreatedAt, wf.UpdatedAt = time.Time{}, time.Time{}
if err := h.repo.PutWorkflow(wf); err != nil {
return domain.WorkflowDefinition{}, err
}
stored, _ := h.repo.Workflow(cloneID)
return stored, nil
}
func (h *runsHandlers) ensureProjectAgent(run domain.Run, projectID, agentID string) (domain.AgentDefinition, error) {
agent, ok := h.repo.Agent(agentID)
if !ok {
return domain.AgentDefinition{}, fmt.Errorf("角色 %q 不存在", agentID)
}
if !agent.Shared && (agent.ProjectID == "" || agent.ProjectID == projectID) {
return agent, nil
}
cloneID := runeval.CloneID(agent.ID, firstNonEmpty(projectID, "copy"))
if existing, exists := h.repo.Agent(cloneID); exists {
return existing, nil
}
agent.ID = cloneID
agent.Name = strings.TrimSpace(agent.Name) + "(评测副本)"
agent.ProjectID = projectID
agent.Shared = false
agent.Version = 1
agent.UpdatedAt = time.Time{}
if err := h.repo.PutAgent(agent); err != nil {
return domain.AgentDefinition{}, err
}
if wf, err := h.ensureProjectWorkflow(run, projectID, run.WorkflowID); err == nil {
changed := false
for i, node := range wf.Nodes {
if node.AgentID == agentID {
wf.Nodes[i].AgentID = cloneID
changed = true
}
}
if changed {
_ = h.repo.PutWorkflow(wf)
}
}
stored, _ := h.repo.Agent(cloneID)
return stored, nil
}
func agentIDFromRun(run domain.Run, nodeID string) string {
for _, node := range run.WorkflowSnapshot.Nodes {
if node.ID == nodeID {
return node.AgentID
}
}
return ""
}
func (h *runsHandlers) launchRunEval(rec domain.RunEvalRecord, run domain.Run, user domain.User) {
hub := h.evalHub()
ctx, cancel := context.WithTimeout(context.Background(), runEvalTimeout)
job := &runEvalJob{
runID: rec.RunID,
evalID: rec.ID,
subs: map[chan runEvalJobEvent]struct{}{},
cancel: cancel,
done: make(chan struct{}),
}
hub.mu.Lock()
if old := hub.jobs[rec.RunID]; old != nil && old.cancel != nil {
old.cancel()
}
hub.jobs[rec.RunID] = job
hub.mu.Unlock()
go h.runEvalJob(ctx, job, rec, run, user)
}
func (h *runsHandlers) runEvalJob(ctx context.Context, job *runEvalJob, rec domain.RunEvalRecord, run domain.Run, user domain.User) {
defer close(job.done)
defer func() {
hub := h.evalHub()
hub.mu.Lock()
if hub.jobs[job.runID] == job {
delete(hub.jobs, job.runID)
}
hub.mu.Unlock()
}()
hub := h.evalHub()
select {
case hub.tokens <- struct{}{}:
defer func() { <-hub.tokens }()
case <-ctx.Done():
h.failRunEval(rec, "评测排队超时")
job.publish("error", map[string]string{"error": "评测排队超时"})
return
}
emit := func(event string, payload any) { job.publish(event, payload) }
emit("thought", map[string]string{"kind": "thinking", "text": "正在整理本次 SOP 轨迹…"})
exec := currentRunEvalExec()
if exec == nil {
exec = h.executeRunEval
}
result, err := exec(ctx, rec, run, user, emit)
if err != nil {
h.failRunEval(rec, err.Error())
job.publish("error", map[string]string{"error": err.Error()})
return
}
if saved, ok := h.repo.RunEval(rec.ID); ok {
rec = saved
}
rec.Status = domain.RunEvalSucceeded
rec.Score = result.Score
rec.Passed = result.Passed
rec.Result = result
rec.FinishedAt = time.Now().UTC()
if err := h.repo.PutRunEval(rec); err != nil {
h.failRunEval(rec, err.Error())
job.publish("error", map[string]string{"error": err.Error()})
return
}
job.publish("done", rec)
}
func (h *runsHandlers) executeRunEval(ctx context.Context, rec domain.RunEvalRecord, run domain.Run, user domain.User, emit func(string, any)) (domain.RunEvalResult, error) {
catalog := runeval.BuildCatalog(run, func(id string) (domain.AgentDefinition, bool) {
return h.repo.Agent(id)
})
facts := runeval.BuildFacts(run, catalog)
rec.Facts = facts
_ = h.repo.PutRunEval(rec)
emit("thought", map[string]string{"kind": "thinking", "text": "正在用 " + rec.Model + " 评测…"})
system, prompt := runeval.BuildPrompt(rec.Policy, facts)
raw, _, err := runAssistantCLI(ctx, assistantCLIRequest{Prompt: prompt, Model: rec.Model, SystemPrompt: system, UserID: user.ID}, user, func(ev assistantStreamEvent) {
if emit == nil {
return
}
if text := strings.TrimSpace(ev.Text); text != "" {
emit("thought", map[string]string{"kind": ev.Kind, "text": text})
}
})
if err != nil {
return domain.RunEvalResult{}, err
}
result, err := runeval.ParseModelResult(raw, rec.Policy)
if err != nil {
return domain.RunEvalResult{}, err
}
return result, nil
}
func (h *runsHandlers) failRunEval(rec domain.RunEvalRecord, message string) {
rec.Status = domain.RunEvalFailed
rec.Error = message
rec.FinishedAt = time.Now().UTC()
if err := h.repo.PutRunEval(rec); err != nil {
log.Printf("run eval persist failure %s: %v", rec.ID, err)
}
}
func (j *runEvalJob) publish(event string, payload any) {
j.mu.Lock()
defer j.mu.Unlock()
j.seq++
item := runEvalJobEvent{Seq: j.seq, Type: event, Payload: payload}
j.events = append(j.events, item)
for ch := range j.subs {
select {
case ch <- item:
default:
}
}
}
func (j *runEvalJob) subscribe() (chan runEvalJobEvent, []runEvalJobEvent) {
ch := make(chan runEvalJobEvent, 16)
j.mu.Lock()
defer j.mu.Unlock()
j.subs[ch] = struct{}{}
return ch, append([]runEvalJobEvent(nil), j.events...)
}
func (j *runEvalJob) unsubscribe(ch chan runEvalJobEvent) {
j.mu.Lock()
defer j.mu.Unlock()
delete(j.subs, ch)
close(ch)
}