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.

【架构优化】合并 engine.hasRunningNode 与 httpapi.runHasActiveNode 为 domain.Run.HasActiveNode (#571)

fx-kurumi05d5aafe72f8
diff --git a/internal/domain/run.go b/internal/domain/run.go
index 2a9ddce9..1a169f08 100644
--- a/internal/domain/run.go
+++ b/internal/domain/run.go
@@ -90,6 +90,17 @@ func (r Run) HistoricalGroup() bool {
return !r.IsWorkspace() && r.WorkflowSnapshot.CollaborationMode == "group"
}
+// HasActiveNode reports whether any node of the run is still executing: it is
+// running or paused for input that the agent asked for mid-step.
+func (r Run) HasActiveNode() bool {
+ for _, nr := range r.Nodes {
+ if nr != nil && (nr.Status == "running" || nr.Status == "pending_input") {
+ return true
+ }
+ }
+ return false
+}
+
// RepositoryContexts returns the frozen repositories of this run. New runs
// fill Repositories; legacy runs only carry the single Repository field.
func (r Run) RepositoryContexts() []RepositoryContext {
diff --git a/internal/domain/run_test.go b/internal/domain/run_test.go
index 51dd1054..16c9c9bf 100644
--- a/internal/domain/run_test.go
+++ b/internal/domain/run_test.go
@@ -24,3 +24,23 @@ func TestRunHumanEditable(t *testing.T) {
}
}
}
+
+func TestRunHasActiveNode(t *testing.T) {
+ cases := []struct {
+ name string
+ nodes map[string]*NodeRun
+ want bool
+ }{
+ {"no nodes", nil, false},
+ {"nil node", map[string]*NodeRun{"a": nil}, false},
+ {"running", map[string]*NodeRun{"a": {Status: "succeeded"}, "b": {Status: "running"}}, true},
+ {"pending input", map[string]*NodeRun{"a": nil, "b": {Status: "pending_input"}}, true},
+ {"waiting approval", map[string]*NodeRun{"a": {Status: "waiting_approval"}}, false},
+ {"finished", map[string]*NodeRun{"a": {Status: "succeeded"}, "b": {Status: "failed"}, "c": {Status: "cancelled"}}, false},
+ }
+ for _, c := range cases {
+ if got := (Run{Nodes: c.nodes}).HasActiveNode(); got != c.want {
+ t.Errorf("%s: HasActiveNode() = %v want %v", c.name, got, c.want)
+ }
+ }
+}
diff --git a/internal/engine/conversation_cli.go b/internal/engine/conversation_cli.go
index 750987a1..1637bca7 100644
--- a/internal/engine/conversation_cli.go
+++ b/internal/engine/conversation_cli.go
@@ -19,7 +19,7 @@ func (e *Engine) AcquireConversationCLI(ctx context.Context, id, root string) (r
return nil, nil, err
}
env.nodeMu.Lock()
- if env.activeExecutions.Load() > 0 || hasRunningNode(run) || e.workspaceTerminals.HasRunScope(id) {
+ if env.activeExecutions.Load() > 0 || run.HasActiveNode() || e.workspaceTerminals.HasRunScope(id) {
env.nodeMu.Unlock()
return nil, nil, fmt.Errorf("工作区仍有执行或终端占用,请结束后重试")
}
diff --git a/internal/engine/conversation_workspace.go b/internal/engine/conversation_workspace.go
index e5fd737f..e07e57c5 100644
--- a/internal/engine/conversation_workspace.go
+++ b/internal/engine/conversation_workspace.go
@@ -76,7 +76,7 @@ func (e *Engine) conversationWorkspaceIdle(run domain.Run) bool {
if e.WorkspaceActive != nil && e.WorkspaceActive(run) {
return false
}
- if run.Status == "running" || run.Status == "queued" || hasRunningNode(run) {
+ if run.Status == "running" || run.Status == "queued" || run.HasActiveNode() {
return false
}
if run.Status == "waiting" && !run.IsWorkspace() {
@@ -216,7 +216,7 @@ func (e *Engine) PrepareConversationWorkspace(ctx context.Context, id, token str
}
// Readers stay available during execution; never inject prior outputs while
// a node is currently expected to generate its own fresh deliverables.
- if hasRunningNode(run) || !run.IsWorkspace() && (run.Status == "running" || run.Status == "queued") {
+ if run.HasActiveNode() || !run.IsWorkspace() && (run.Status == "running" || run.Status == "queued") {
return nil, nil
}
return e.restoreArchivedWorkspaceFiles(ctx, run)
diff --git a/internal/engine/lifecycle.go b/internal/engine/lifecycle.go
index 23eb9c59..e35b487e 100644
--- a/internal/engine/lifecycle.go
+++ b/internal/engine/lifecycle.go
@@ -52,21 +52,12 @@ func resetInFlightNodesForResume(r *domain.Run, activity string) {
}
}
-func hasRunningNode(r domain.Run) bool {
- for _, nr := range r.Nodes {
- if nr != nil && (nr.Status == "running" || nr.Status == "pending_input") {
- return true
- }
- }
- return false
-}
-
// settleStatusForCompletedGraph reports the terminal run status when every
// snapshot node is already finished and nothing is in flight. An empty graph
// is not settled: ResumeInterruptedRuns uses that case to recover orphans
// whose workflow snapshot was never frozen.
func settleStatusForCompletedGraph(wf domain.WorkflowDefinition, r domain.Run) (status, msg string, ok bool) {
- if wf.CollaborationMode == "group" || len(wf.Nodes) == 0 || hasRunningNode(r) {
+ if wf.CollaborationMode == "group" || len(wf.Nodes) == 0 || r.HasActiveNode() {
return "", "", false
}
if allSucceeded(wf, r) {
diff --git a/internal/engine/parallel_branches_test.go b/internal/engine/parallel_branches_test.go
index 67c3db0f..67643a2e 100644
--- a/internal/engine/parallel_branches_test.go
+++ b/internal/engine/parallel_branches_test.go
@@ -307,7 +307,7 @@ func TestRetryAfterCancelResumesCancelledParallelSibling(t *testing.T) {
if err := e.Cancel(run.ID); err != nil {
t.Fatal(err)
}
- cancelled := waitRun(t, s, run.ID, 30*time.Second, func(r domain.Run) bool { return r.Status == "cancelled" && !hasRunningNode(r) })
+ cancelled := waitRun(t, s, run.ID, 30*time.Second, func(r domain.Run) bool { return r.Status == "cancelled" && !r.HasActiveNode() })
if cancelled.Nodes["left"].Status != "cancelled" || cancelled.Nodes["right"].Status != "cancelled" {
t.Fatalf("cancel left left=%s right=%s", cancelled.Nodes["left"].Status, cancelled.Nodes["right"].Status)
}
diff --git a/internal/engine/run_ops.go b/internal/engine/run_ops.go
index 39eb87c1..24c1af67 100644
--- a/internal/engine/run_ops.go
+++ b/internal/engine/run_ops.go
@@ -58,7 +58,7 @@ func (e *Engine) Cancel(runID string) error {
return fmt.Errorf("run not found")
}
if !isLiveStatus(r.Status) {
- if domain.TerminalRunStatus(r.Status) && hasRunningNode(r) {
+ if domain.TerminalRunStatus(r.Status) && r.HasActiveNode() {
e.forceTerminate(runID, "cancelled", "流水线已取消")
return nil
}
@@ -479,7 +479,7 @@ func (e *Engine) retryContext(ctx context.Context, runID, nodeID, reason, humanC
nodeStatus := r.Nodes[nodeID].Status
waitingRetry := r.Status == "waiting" && nodeStatus == "waiting_approval"
replaySucceeded := r.Status == "succeeded"
- if r.Status == "running" || hasRunningNode(r) {
+ if r.Status == "running" || r.HasActiveNode() {
return fmt.Errorf("run is still active")
}
if r.Status != "waiting" && r.Status != "failed" && r.Status != "cancelled" && !replaySucceeded {
@@ -822,7 +822,7 @@ func (e *Engine) RefreshRunSOP(runID string) error {
if !ok {
return fmt.Errorf("run not found")
}
- if r.Status == "running" || hasRunningNode(r) || (r.Status != "waiting" && !domain.TerminalRunStatus(r.Status)) {
+ if r.Status == "running" || r.HasActiveNode() || (r.Status != "waiting" && !domain.TerminalRunStatus(r.Status)) {
return fmt.Errorf("only a stopped run can update its SOP")
}
if e.executes() {
diff --git a/internal/engine/settle_active_node_test.go b/internal/engine/settle_active_node_test.go
new file mode 100644
index 00000000..974d42e8
--- /dev/null
+++ b/internal/engine/settle_active_node_test.go
@@ -0,0 +1,34 @@
+package engine
+
+import (
+ "testing"
+
+ "agentflow/internal/domain"
+)
+
+// A failed branch must not settle the run while a sibling node is still
+// running or waiting for input.
+func TestSettleStatusForCompletedGraphWaitsForActiveNodes(t *testing.T) {
+ wf := domain.WorkflowDefinition{ID: "wf", SandboxProfileID: "local", Nodes: []domain.WorkflowNode{{ID: "left", Type: "script"}, {ID: "right", Type: "agent"}}}
+ for _, active := range []string{"running", "pending_input"} {
+ run := domain.Run{ID: "settle-" + active, Status: "running", WorkflowSnapshot: wf, Nodes: map[string]*domain.NodeRun{
+ "left": {NodeID: "left", Status: "failed"},
+ "right": {NodeID: "right", Status: active},
+ }}
+ if status, _, ok := settleStatusForCompletedGraph(wf, run); ok {
+ t.Fatalf("%s sibling: graph settled as %q while a node is active", active, status)
+ }
+ run.Nodes["right"].Status = "succeeded"
+ if status, _, ok := settleStatusForCompletedGraph(wf, run); !ok || status != "failed" {
+ t.Fatalf("%s sibling: finished graph = %q %v, want failed", active, status, ok)
+ }
+ }
+ extra := domain.Run{ID: "settle-extra", Status: "running", WorkflowSnapshot: wf, Nodes: map[string]*domain.NodeRun{
+ "left": {NodeID: "left", Status: "succeeded"},
+ "right": {NodeID: "right", Status: "succeeded"},
+ "retry": {NodeID: "retry", Status: "running"},
+ }}
+ if _, _, ok := settleStatusForCompletedGraph(wf, extra); ok {
+ t.Fatal("graph settled while a node outside the snapshot is still running")
+ }
+}
diff --git a/internal/engine/state_helpers_cases_test.go b/internal/engine/state_helpers_cases_test.go
index 3717c38a..042e5994 100644
--- a/internal/engine/state_helpers_cases_test.go
+++ b/internal/engine/state_helpers_cases_test.go
@@ -32,7 +32,7 @@ func TestLifecycleResetSettleAndForceTerminate(t *testing.T) {
}
resetNodeForResume(&run, nil, "x")
resetNodeForResume(&run, run.Nodes["done"], "x")
- if !domain.TerminalRunStatus("cancelled") || domain.TerminalRunStatus("waiting") || hasRunningNode(run) {
+ if !domain.TerminalRunStatus("cancelled") || domain.TerminalRunStatus("waiting") || run.HasActiveNode() {
t.Fatal("status helpers")
}
run.Nodes["script"].Status, run.Nodes["agent"].Status = "succeeded", "succeeded"
diff --git a/internal/engine/workspace_checkpoint_transport.go b/internal/engine/workspace_checkpoint_transport.go
index c2938802..6b94aa7e 100644
--- a/internal/engine/workspace_checkpoint_transport.go
+++ b/internal/engine/workspace_checkpoint_transport.go
@@ -143,7 +143,7 @@ func (e *Engine) HandleWorkspaceCheckpoint(w http.ResponseWriter, r *http.Reques
http.Error(w, "invalid terminal request", 400)
return
}
- artifactsAllowed := request.Operation == domain.RunnerWorkspaceOperationArtifacts && (run.IsWorkspace() || run.Status != "running" && run.Status != "queued" && !hasRunningNode(run))
+ artifactsAllowed := request.Operation == domain.RunnerWorkspaceOperationArtifacts && (run.IsWorkspace() || run.Status != "running" && run.Status != "queued" && !run.HasActiveNode())
interactive := request.Operation == domain.RunnerWorkspaceOperationPreparationRecord || request.Operation == domain.RunnerWorkspaceOperationPrepare || request.Operation == domain.RunnerWorkspaceOperationPreparationStatus || request.Operation == domain.RunnerWorkspaceOperationTerminal
transferAux := transfer && request.Operation != domain.RunnerWorkspaceOperationCheckpointExport && request.Operation != domain.RunnerWorkspaceOperationCheckpointCommit
if !probe && !interactive && (sharesWorkspace(run) || !artifactsAllowed && !transferAux && !e.conversationWorkspaceIdle(run)) {
diff --git a/internal/engine/workspace_cleanup.go b/internal/engine/workspace_cleanup.go
index 047659d5..3d5200d8 100644
--- a/internal/engine/workspace_cleanup.go
+++ b/internal/engine/workspace_cleanup.go
@@ -314,7 +314,7 @@ func (e *Engine) DeleteRun(runID string) error {
if run.Status == "running" || run.Status == "waiting" || run.Status == "queued" {
return fmt.Errorf("run %s is %s: cancel it before deleting", runID, run.Status)
}
- if hasRunningNode(run) {
+ if run.HasActiveNode() {
return fmt.Errorf("运行 %s 仍有未结束的节点,请先停止后再删除", runID)
}
token, err := e.beginWorkspaceUseAfterCleanup(context.Background(), runID)
diff --git a/internal/engine/workspace_preparation.go b/internal/engine/workspace_preparation.go
index 519a1ff2..32303593 100644
--- a/internal/engine/workspace_preparation.go
+++ b/internal/engine/workspace_preparation.go
@@ -280,7 +280,7 @@ func (e *Engine) EnsureWorkspaceReady(ctx context.Context, id string) (runtime.W
if current, ok := e.repo.RunState(id); ok {
run = current
}
- if hasRunningNode(run) || env.activeExecutions.Load() > 0 || e.workspaceTerminals.HasRunScope(id) || e.WorkspaceActive != nil && e.WorkspaceActive(run) {
+ if run.HasActiveNode() || env.activeExecutions.Load() > 0 || e.workspaceTerminals.HasRunScope(id) || e.WorkspaceActive != nil && e.WorkspaceActive(run) {
state := runtime.ReadWorkspacePreparationStatus(env.Workspace(), env.ID())
epoch, err := runtime.ReadSandboxEnvironmentIdentity(ctx, env.sandbox)
// The environment agents already run in serves the IDE terminal too.
diff --git a/internal/httpapi/helpers_cases_test.go b/internal/httpapi/helpers_cases_test.go
index 30293bf4..f627b909 100644
--- a/internal/httpapi/helpers_cases_test.go
+++ b/internal/httpapi/helpers_cases_test.go
@@ -363,9 +363,9 @@ func TestRunAndTaskPureBranches(t *testing.T) {
t.Errorf("task status %q=%q", status, got)
}
}
- if !runHasActiveNode(domain.Run{Nodes: map[string]*domain.NodeRun{"n": {Status: "running"}}}) ||
- !runHasActiveNode(domain.Run{Nodes: map[string]*domain.NodeRun{"n": {Status: "pending_input"}}}) ||
- runHasActiveNode(domain.Run{Nodes: map[string]*domain.NodeRun{"n": {Status: "succeeded"}}}) {
+ if !(domain.Run{Nodes: map[string]*domain.NodeRun{"n": {Status: "running"}}}).HasActiveNode() ||
+ !(domain.Run{Nodes: map[string]*domain.NodeRun{"n": {Status: "pending_input"}}}).HasActiveNode() ||
+ (domain.Run{Nodes: map[string]*domain.NodeRun{"n": {Status: "succeeded"}}}).HasActiveNode() {
t.Fatal("active node detection")
}
issue := domain.Issue{Status: "todo"}
diff --git a/internal/httpapi/tasks.go b/internal/httpapi/tasks.go
index 59bbce78..59a675c9 100644
--- a/internal/httpapi/tasks.go
+++ b/internal/httpapi/tasks.go
@@ -52,7 +52,7 @@ func (h *tasksHandlers) settleIssueTasks(issueID string) {
continue
}
run, ok := h.repo.RunView(task.RunID)
- if !ok || runHasActiveNode(run) {
+ if !ok || run.HasActiveNode() {
continue
}
status := taskStatusFromRun(run.Status)
@@ -154,15 +154,6 @@ func taskStatusFromRun(runStatus string) string {
return map[string]string{"queued": "queued", "running": "running", "waiting": "running", "succeeded": "completed", "failed": "failed", "cancelled": "cancelled"}[runStatus]
}
-func runHasActiveNode(run domain.Run) bool {
- for _, nr := range run.Nodes {
- if nr != nil && (nr.Status == "running" || nr.Status == "pending_input") {
- return true
- }
- }
- return false
-}
-
func issueStatusFromLatestTask(issue domain.Issue, taskStatus string) string {
if strings.EqualFold(issue.Status, "closed") {
return "closed"
diff --git a/internal/httpapi/tasks_settle_active_node_test.go b/internal/httpapi/tasks_settle_active_node_test.go
new file mode 100644
index 00000000..34fded2b
--- /dev/null
+++ b/internal/httpapi/tasks_settle_active_node_test.go
@@ -0,0 +1,47 @@
+package httpapi
+
+import (
+ "testing"
+
+ "agentflow/internal/domain"
+ "agentflow/internal/repo"
+)
+
+// settleIssueTasks must not finish a Task while its terminal Run still has a
+// node in flight (e.g. a cancel that has not yet stopped the running step).
+func TestSettleIssueTasksWaitsForActiveNodes(t *testing.T) {
+ s, err := repo.OpenTest()
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(func() { s.Close() })
+ if err := s.PutIssue(domain.Issue{ID: "settle-issue", ProjectID: "platform", Title: "Settle", Status: "in_progress"}); err != nil {
+ t.Fatal(err)
+ }
+ h := &tasksHandlers{deps: &deps{repo: s}}
+ for _, active := range []string{"running", "pending_input"} {
+ runID, taskID := "settle-run-"+active, "settle-task-"+active
+ if err := s.PutRun(domain.Run{ID: runID, Status: "cancelled", ExecutionContext: domain.TelemetryContext{ProjectID: "platform"}, Nodes: map[string]*domain.NodeRun{
+ "done": {NodeID: "done", Status: "succeeded"},
+ "busy": {NodeID: "busy", Status: active},
+ }}); err != nil {
+ t.Fatal(err)
+ }
+ if err := s.PutTask(domain.Task{ID: taskID, IssueID: "settle-issue", RunID: runID, Status: "running"}); err != nil {
+ t.Fatal(err)
+ }
+ h.settleIssueTasks("settle-issue")
+ if task, ok := s.Task(taskID); !ok || task.Status != "running" {
+ t.Fatalf("%s node: task settled while run still active: %+v, found=%v", active, task, ok)
+ }
+ run, _ := s.Run(runID)
+ run.Nodes["busy"].Status = "cancelled"
+ if err := s.PutRun(run); err != nil {
+ t.Fatal(err)
+ }
+ h.settleIssueTasks("settle-issue")
+ if task, ok := s.Task(taskID); !ok || task.Status != "cancelled" {
+ t.Fatalf("%s node: task not settled after nodes stopped: %+v, found=%v", active, task, ok)
+ }
+ }
+}