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 runner
import (
"agentflow/internal/domain"
"agentflow/internal/runtime"
"context"
"os"
"path/filepath"
"testing"
"time"
)
func TestWorkspaceWriteFenceExcludesTasksAndStaleWrites(t *testing.T) {
root := t.TempDir()
workspace := filepath.Join(root, "runs", "fenced")
if err := os.MkdirAll(workspace, 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(workspace, "note.txt"), []byte("before"), 0600); err != nil {
t.Fatal(err)
}
d := &Daemon{cfg: Config{DefaultWorkspaceRoot: root}}
req := domain.RunnerWorkspaceRequest{RunID: "fenced", RunStatus: "waiting", Operation: domain.RunnerWorkspaceOperationWrite, Path: "note.txt", Content: "after", ExpectedSHA256: runtime.WorkspaceContentSHA("before")}
gate := d.workspaceGate(req.RunID)
gate.RLock()
blocked := d.readRunnerWorkspace(context.Background(), req)
gate.RUnlock()
if blocked.Status != 409 {
t.Fatalf("active task allowed write: %+v", blocked)
}
if result := d.readRunnerWorkspace(context.Background(), req); result.Status != 200 {
t.Fatalf("write: %+v", result)
}
if result := d.readRunnerWorkspace(context.Background(), req); result.Status != 409 {
t.Fatal("stale write allowed")
}
// A late remote file operation keeps the runner-local fence even after the
// API has stopped waiting. A new task cannot enter until it actually ends.
gate.Lock()
entered := make(chan struct{})
done := make(chan struct{})
go func() { gate.RLock(); close(entered); gate.RUnlock(); close(done) }()
select {
case <-entered:
t.Fatal("task overlapped pending file operation")
case <-time.After(40 * time.Millisecond):
}
gate.Unlock()
<-done
}
func TestWorkspaceTerminalFenceAllowsOwnerSaveAndClosesOnRelease(t *testing.T) {
root := t.TempDir()
workspace := filepath.Join(root, "runs", "terminal", "workspace")
os.MkdirAll(workspace, 0700)
os.WriteFile(filepath.Join(workspace, "note.txt"), []byte("before"), 0600)
d := &Daemon{cfg: Config{DefaultWorkspaceRoot: root}}
req := domain.RunnerWorkspaceRequest{RunID: "terminal", WorkspaceLayout: domain.RunnerWorkspaceLayoutShared, RunStatus: "waiting", Operation: domain.RunnerWorkspaceOperationTerminal, Sandbox: &domain.RunnerSandboxSpec{Profile: domain.SandboxProfile{Driver: "local"}}, Workflow: &domain.WorkflowDefinition{}, TerminalOwner: 7, Terminal: &domain.WorkspaceTerminalRequest{Operation: "open", ExpiresAt: time.Now().Add(time.Minute)}}
opened := d.readRunnerWorkspace(context.Background(), req)
if opened.Status != 200 {
t.Fatal(opened)
}
defer d.workspaceTerminals.CloseScope("terminal:7")
gate := d.workspaceGate(req.RunID)
if gate.TryRLock() {
gate.RUnlock()
t.Fatal("agent could enter while human shell active")
}
write := domain.RunnerWorkspaceRequest{RunID: req.RunID, WorkspaceLayout: domain.RunnerWorkspaceLayoutShared, RunStatus: "waiting", Operation: domain.RunnerWorkspaceOperationWrite, TerminalOwner: 7, Path: "note.txt", Content: "edited", ExpectedSHA256: runtime.WorkspaceContentSHA("before")}
if res := d.readRunnerWorkspace(context.Background(), write); res.Status != 200 {
t.Fatal("owner could not save with terminal open", res)
}
write.TerminalOwner = 8
if res := d.readRunnerWorkspace(context.Background(), write); res.Status != 409 {
t.Fatal("other user bypassed terminal fence", res)
}
req.Terminal.Operation = "close-all"
if res := d.readRunnerWorkspace(context.Background(), req); res.Status != 200 {
t.Fatal(res)
}
if !gate.TryRLock() {
t.Fatal("terminal fence not released")
}
gate.RUnlock()
}
func TestMainBotConversationWorkspaceWriterKeepsHashChecks(t *testing.T) {
root := t.TempDir()
workspace := filepath.Join(root, "runs", "group-write")
if err := os.MkdirAll(workspace, 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(workspace, "note.txt"), []byte("before"), 0600); err != nil {
t.Fatal(err)
}
d := &Daemon{cfg: Config{DefaultWorkspaceRoot: root}}
req := domain.RunnerWorkspaceRequest{RunID: "group-write", RunStatus: "running", Operation: domain.RunnerWorkspaceOperationWrite, Path: "note.txt", Content: "after", ExpectedSHA256: runtime.WorkspaceContentSHA("before")}
gate := d.workspaceGate(req.RunID)
gate.RLock()
defer gate.RUnlock()
if result := d.readRunnerWorkspace(context.Background(), req); result.Status != 409 {
t.Fatal("ordinary writer bypassed active SOP", result)
}
req.RunKind = domain.RunKindWorkspace
if result := d.readRunnerWorkspace(context.Background(), req); result.Status != 200 {
t.Fatal("group write blocked", result)
}
if result := d.readRunnerWorkspace(context.Background(), req); result.Status != 409 {
t.Fatal("stale group write overwrote file", result)
}
}