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 (
"context"
"encoding/json"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"agentflow/internal/domain"
"agentflow/internal/runtime"
)
func TestReadRunnerWorkspaceProvidesBoundedReadOnlyViews(t *testing.T) {
root := t.TempDir()
workspace := filepath.Join(root, "runs", "run-safe", "workspace")
if err := os.MkdirAll(workspace, 0o755); err != nil {
t.Fatal(err)
}
git := func(args ...string) {
cmd := exec.Command("git", append([]string{"-C", workspace}, args...)...)
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("git %v: %v\n%s", args, err, out)
}
}
git("init", "-q")
git("config", "user.name", "Runner Test")
git("config", "user.email", "[email protected]")
if err := os.WriteFile(filepath.Join(workspace, "main.go"), []byte("package main\n\nfunc value() int { return 1 }\n"), 0o644); err != nil {
t.Fatal(err)
}
git("add", "main.go")
git("commit", "-qm", "base")
if err := os.WriteFile(filepath.Join(workspace, "main.go"), []byte("package main\n\nfunc value() int { return 2 }\n"), 0o644); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(workspace, ".env"), []byte("SECRET=hidden\n"), 0o600); err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(filepath.Join(workspace, ".agentflow"), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(workspace, ".agentflow", "session.json"), []byte("generated metadata\n"), 0o600); err != nil {
t.Fatal(err)
}
d := &Daemon{cfg: Config{DefaultWorkspaceRoot: root}}
request := domain.RunnerWorkspaceRequest{RunID: "run-safe", RunStatus: "failed", WorkspaceLayout: domain.RunnerWorkspaceLayoutShared}
request.Operation = domain.RunnerWorkspaceOperationInfo
info := d.readRunnerWorkspace(context.Background(), request)
if info.Error != "" {
t.Fatal(info.Error)
}
var infoPayload struct {
Available bool `json:"available"`
Changes []runnerWorkspaceChange `json:"changes"`
Repositories []string `json:"repositories"`
}
if err := json.Unmarshal(info.Payload, &infoPayload); err != nil {
t.Fatal(err)
}
if !infoPayload.Available || len(infoPayload.Changes) != 1 || infoPayload.Changes[0].Path != "main.go" {
t.Fatalf("unexpected info payload: %+v", infoPayload)
}
if len(infoPayload.Repositories) != 1 || infoPayload.Repositories[0] != "workspace" || infoPayload.Changes[0].Repository != "workspace" {
t.Fatalf("root git workspace should report a single repository, got %+v", infoPayload)
}
request.Operation = domain.RunnerWorkspaceOperationTree
tree := d.readRunnerWorkspace(context.Background(), request)
var treePayload struct {
Entries []runnerWorkspaceEntry `json:"entries"`
}
if err := json.Unmarshal(tree.Payload, &treePayload); err != nil {
t.Fatal(err)
}
for _, entry := range treePayload.Entries {
if entry.Path == ".env" || entry.Path == ".git" || entry.Path == ".agentflow" || strings.HasPrefix(entry.Path, ".agentflow/") {
t.Fatalf("sensitive path leaked in tree: %+v", entry)
}
}
request.Operation = domain.RunnerWorkspaceOperationDiff
request.Path = "main.go"
diff := d.readRunnerWorkspace(context.Background(), request)
if diff.Error != "" {
t.Fatal(diff.Error)
}
var diffPayload struct {
Original string `json:"original"`
Modified string `json:"modified"`
Diff string `json:"diff"`
}
if err := json.Unmarshal(diff.Payload, &diffPayload); err != nil {
t.Fatal(err)
}
if diffPayload.Original == diffPayload.Modified || diffPayload.Diff == "" {
t.Fatalf("expected original and modified diff, got %+v", diffPayload)
}
request.Operation = domain.RunnerWorkspaceOperationFile
request.Path = "../outside"
if response := d.readRunnerWorkspace(context.Background(), request); response.Error == "" {
t.Fatal("path traversal should be rejected")
}
request.Path = ".env"
if response := d.readRunnerWorkspace(context.Background(), request); response.Error == "" {
t.Fatal("sensitive file should be rejected")
}
request.Operation = domain.RunnerWorkspaceOperationLog
request.Path = ""
logResp := d.readRunnerWorkspace(context.Background(), request)
if logResp.Error != "" {
t.Fatal(logResp.Error)
}
var logPayload struct {
Commits []runnerWorkspaceCommit `json:"commits"`
}
if err := json.Unmarshal(logResp.Payload, &logPayload); err != nil {
t.Fatal(err)
}
if len(logPayload.Commits) == 0 || logPayload.Commits[0].ID == "" {
t.Fatalf("unexpected log payload: %+v", logPayload)
}
request.Operation = domain.RunnerWorkspaceOperationCommit
request.Ref = logPayload.Commits[0].ID
commitResp := d.readRunnerWorkspace(context.Background(), request)
if commitResp.Error != "" {
t.Fatal(commitResp.Error)
}
}
func TestRunnerWorkspaceRejectsUnsafeRunID(t *testing.T) {
d := &Daemon{cfg: Config{DefaultWorkspaceRoot: t.TempDir()}}
response := d.readRunnerWorkspace(context.Background(), domain.RunnerWorkspaceRequest{
RunID: "../escape", Operation: domain.RunnerWorkspaceOperationInfo, WorkspaceLayout: domain.RunnerWorkspaceLayoutShared,
})
if response.Error == "" {
t.Fatal("unsafe run id should be rejected")
}
}
func TestRunnerRefillsArchivedFilesWithoutOverwritingEdits(t *testing.T) {
root := t.TempDir()
workspace := filepath.Join(root, "runs", "legacy-reports", "workspace")
if err := os.MkdirAll(workspace, 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(workspace, "change-report.md"), []byte("new edits"), 0600); err != nil {
t.Fatal(err)
}
d := &Daemon{cfg: Config{DefaultWorkspaceRoot: root}}
files := []domain.WorkspaceArtifactFile{{Path: "design.md", Content: "design", SHA256: runtime.WorkspaceContentSHA("design")}, {Path: "change-report.md", Content: "old", SHA256: runtime.WorkspaceContentSHA("old")}}
req := domain.RunnerWorkspaceRequest{RunID: "legacy-reports", RunStatus: "waiting", WorkspaceLayout: domain.RunnerWorkspaceLayoutShared, Operation: domain.RunnerWorkspaceOperationArtifacts, ArtifactFiles: files}
gate := d.workspaceGate(req.RunID)
gate.RLock()
result := d.readRunnerWorkspace(context.Background(), req)
gate.RUnlock()
if result.Status != 409 {
t.Fatal("active execution not fenced", result)
}
req.RunStatus = "running"
if result = d.readRunnerWorkspace(context.Background(), req); result.Status != 409 {
t.Fatal("active SOP accepted", result)
}
req.RunStatus = "waiting"
result = d.readRunnerWorkspace(context.Background(), req)
var payload struct {
Restored []string `json:"restoredArtifacts"`
}
if result.Error != "" || json.Unmarshal(result.Payload, &payload) != nil || len(payload.Restored) != 1 || payload.Restored[0] != "design.md" {
t.Fatal(result, payload)
}
got, _ := os.ReadFile(filepath.Join(workspace, "change-report.md"))
if string(got) != "new edits" {
t.Fatal("overwrote newer report")
}
// Task execution receives the same refill even if no Main Bot/IDE operation preceded it.
if err := os.Remove(filepath.Join(workspace, "design.md")); err != nil {
t.Fatal(err)
}
inv := &domain.RunnerInvocation{ArchivedFiles: files, Inputs: []domain.RunnerInputFile{{Path: ".agentflow/inputs/design/design.md", Content: "readonly input"}}}
if err := prepareInvocationWorkspace(workspace, inv); err != nil {
t.Fatal(err)
}
got, _ = os.ReadFile(filepath.Join(workspace, "design.md"))
if string(got) != "design" {
t.Fatal("task cannot read original report path")
}
got, _ = os.ReadFile(filepath.Join(workspace, "change-report.md"))
if string(got) != "new edits" {
t.Fatal("task overwrote current file")
}
}
// Node-created files registered with `git add -N` have an empty diff base.
func TestRunnerReadWorkspaceBaseFileForIntentToAdd(t *testing.T) {
root := t.TempDir()
git := func(args ...string) {
t.Helper()
if out, err := exec.Command("git", append([]string{"-C", root}, args...)...).CombinedOutput(); err != nil {
t.Fatalf("git %v: %v: %s", args, err, out)
}
}
write := func(name, content string) {
t.Helper()
if err := os.WriteFile(filepath.Join(root, name), []byte(content), 0o600); err != nil {
t.Fatal(err)
}
}
git("init", "-q")
git("config", "user.email", "[email protected]")
git("config", "user.name", "t")
write("README.md", "baseline\n")
git("add", "README.md")
git("commit", "-qm", "init")
write("README.md", "baseline\nhuman\n")
write("node.txt", "one\n")
git("add", "-N", "node.txt")
for path, want := range map[string]string{"README.md": "baseline\n", "node.txt": ""} {
got, truncated, err := runnerReadWorkspaceBaseFile(context.Background(), root, nil, path)
if err != nil || truncated || got != want {
t.Fatalf("%s: base=%q truncated=%v err=%v", path, got, truncated, err)
}
}
}