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 repo
import (
"encoding/json"
"errors"
"fmt"
"os"
"strings"
"testing"
"time"
"agentflow/internal/domain"
)
func TestMySQLReadsObserveExternalChangesWithoutReload(t *testing.T) {
dsn := os.Getenv("AGENTFLOW_TEST_MYSQL_DSN")
if dsn == "" {
t.Skip("AGENTFLOW_TEST_MYSQL_DSN is not set")
}
s, err := Open(dsn)
if err != nil {
t.Fatal(err)
}
defer s.Close()
suffix := time.Now().UTC().UnixNano()
rule := domain.RuleDefinition{ID: fmt.Sprintf("direct-rule-%d", suffix), Name: "before", Content: "before"}
runID := fmt.Sprintf("direct-run-%d", suffix)
defer func() {
_ = s.DB.Exec(`DELETE FROM run_artifacts WHERE run_id=?`, runID)
_ = s.DB.Exec(`DELETE FROM run_logs WHERE run_id=?`, runID)
_ = s.DB.Exec(`DELETE FROM run_telemetry WHERE run_id=?`, runID)
_ = s.DB.Exec(`DELETE FROM run_events WHERE run_id=?`, runID)
_ = s.DB.Exec(`DELETE FROM run_nodes WHERE run_id=?`, runID)
_ = s.DB.Exec(`DELETE FROM runs WHERE id=?`, runID)
_ = s.DB.Exec(`DELETE FROM rules WHERE id=?`, rule.ID)
}()
if err := s.PutRule(rule); err != nil {
t.Fatal(err)
}
rule.Name = "changed outside Store"
rule.Content = "database wins"
raw, err := json.Marshal(rule)
if err != nil {
t.Fatal(err)
}
if err := s.DB.Exec(`UPDATE rules SET name=?, payload=? WHERE id=?`, rule.Name, raw, rule.ID).Error; err != nil {
t.Fatal(err)
}
got, ok := s.Rule(rule.ID)
if !ok || got.Name != rule.Name || got.Content != rule.Content {
t.Fatalf("read did not observe direct MySQL update: ok=%v got=%+v", ok, got)
}
run := domain.Run{
ID: runID,
WorkflowID: runID,
Status: "running",
Nodes: map[string]*domain.NodeRun{"node": {NodeID: "node", Status: "running"}},
Telemetry: []domain.TelemetryEvent{{ID: "telemetry", Sequence: 1, Source: domain.TelemetrySource{Adapter: "live-test"}}},
TelemetrySequence: 1,
Logs: []domain.LogRecord{{ID: "log", Sequence: 1, Level: "warn"}},
LogSequence: 1,
Artifacts: []domain.Artifact{{ID: "artifact", RunID: runID, NodeID: "node", Name: "report", Path: "report.md"}},
}
if err := s.PutRun(run); err != nil {
t.Fatal(err)
}
statuses := s.RunStatuses()
if statuses[run.ID] != "running" {
t.Fatalf("RunStatuses did not read the persisted status: %+v", statuses)
}
runs := s.Runs()
var listed *domain.Run
for i := range runs {
if runs[i].ID == run.ID {
listed = &runs[i]
break
}
}
if listed == nil || listed.Nodes["node"] == nil || listed.Nodes["node"].Status != "running" {
t.Fatalf("Runs did not batch-hydrate the persisted node: %+v", listed)
}
summaries, err := s.RunSummaries()
if err != nil {
t.Fatal(err)
}
var summary *domain.Run
for i := range summaries {
if summaries[i].ID == run.ID {
summary = &summaries[i]
break
}
}
if summary == nil || summary.Nodes["node"] == nil || summary.Nodes["node"].Status != "running" {
t.Fatalf("RunSummaries did not retain node status: %+v", summary)
}
if summary.Nodes["node"].Output != "" || summary.WorkflowSnapshot.ID != "" {
t.Fatalf("RunSummaries transferred heavy fields: %+v", summary)
}
if summary.ArtifactCount != 1 || len(summary.Artifacts) != 0 {
t.Fatalf("RunSummaries did not reduce artifacts to a count: %+v", summary)
}
analytics := s.Analytics(domain.AnalyticsFilter{WorkflowID: runID})
if analytics.Coverage.AdapterEvents["live-test"] != 1 || analytics.Coverage.LogLevels["warn"] != 1 {
t.Fatalf("Analytics did not aggregate MySQL coverage: %+v", analytics.Coverage)
}
var persistedStatus string
if err := s.DB.Raw(`SELECT status FROM runs WHERE id=?`, run.ID).Scan(&persistedStatus).Error; err != nil || persistedStatus != "running" {
t.Fatalf("PutRun did not synchronously reach MySQL: status=%q err=%v", persistedStatus, err)
}
if err := s.DB.Exec(`UPDATE runs SET status='failed' WHERE id=?`, run.ID).Error; err != nil {
t.Fatal(err)
}
if gotStatus := s.RunStatuses()[run.ID]; gotStatus != "failed" {
t.Fatalf("RunStatuses did not observe direct MySQL update: %q", gotStatus)
}
if gotRun, ok := s.Run(run.ID); !ok || gotRun.Status != "failed" {
t.Fatalf("Run did not observe direct MySQL update: ok=%v run=%+v", ok, gotRun)
}
}
func TestMySQLMCPFilesRoundTrip(t *testing.T) {
dsn := os.Getenv("AGENTFLOW_TEST_MYSQL_DSN")
if dsn == "" {
t.Skip("AGENTFLOW_TEST_MYSQL_DSN is not set")
}
s, err := Open(dsn)
if err != nil {
t.Fatal(err)
}
defer s.Close()
id := fmt.Sprintf("mysql-mcp-files-%d", time.Now().UTC().UnixNano())
server := domain.MCPServerDefinition{ID: id, Name: "MySQL MCP files", Transport: "stdio", Command: "python3"}
if err := s.PutMCPServer(server); err != nil {
t.Fatal(err)
}
defer func() { _ = s.DeleteMCPServer(id) }()
if err := s.PutMCPFiles(id, []SkillFileInput{{Path: "server.py", Content: []byte("print('ok')\n"), Mode: 0o755}}); err != nil {
t.Fatal(err)
}
stored, ok := s.MCPServer(id)
if !ok || len(stored.FileRefs) != 1 || stored.FileRefs[0].Path != "server.py" || stored.FileRefs[0].Mode != 0o755 {
t.Fatalf("stored=%+v ok=%v", stored, ok)
}
content, ok := s.MCPFileContent(id, "server.py")
if !ok || string(content) != "print('ok')\n" {
t.Fatalf("content=%q ok=%v", content, ok)
}
}
func TestMySQLRunnerTaskCompletionScrubsCredentials(t *testing.T) {
dsn := os.Getenv("AGENTFLOW_TEST_MYSQL_DSN")
if dsn == "" {
t.Skip("AGENTFLOW_TEST_MYSQL_DSN is not set")
}
s, err := Open(dsn)
if err != nil {
t.Fatal(err)
}
defer s.Close()
suffix := time.Now().UTC().UnixNano()
taskID := fmt.Sprintf("credential-task-%d", suffix)
runnerID := fmt.Sprintf("credential-runner-%d", suffix)
defer func() { _ = s.DB.Exec(`DELETE FROM runner_tasks WHERE id=?`, taskID) }()
task := domain.RunnerTask{
ID: taskID, RunnerID: runnerID, Provider: "codex", Status: domain.RunnerTaskQueued, MaxAttempts: 1,
Sandbox: &domain.RunnerSandboxSpec{Profile: domain.SandboxProfile{ID: "runner-docker", Driver: "docker"}},
Invocation: &domain.RunnerInvocation{
CredentialSource: domain.RuntimeAuthPersonal,
CodexAPIKey: "codex-secret",
CodexBaseURL: "https://gateway.example/v1",
Repository: &domain.RunnerRepository{CloneURL: "https://example.com/repo.git", GitToken: "git-secret"},
GitSSHUserID: 42,
GitSSHKeys: map[string]string{"[email protected]:team/app.git": "ssh-key-must-not-be-queued"},
},
}
if err := s.PutRunnerTask(task); err != nil {
t.Fatal(err)
}
claimed, ok, err := s.ClaimRunnerTask(runnerID, []string{"codex"}, time.Now().UTC(), time.Minute)
if err != nil || !ok {
t.Fatalf("claim: ok=%v err=%v", ok, err)
}
if claimed.Sandbox == nil || claimed.Sandbox.Profile.Driver != "docker" {
t.Fatalf("claimed task lost runner sandbox: %+v", claimed.Sandbox)
}
if claimed.Invocation == nil || len(claimed.Invocation.GitSSHKeys) != 0 || claimed.Invocation.GitSSHUserID != 42 {
t.Fatal("queue must retain the SSH credential reference only")
}
if err := s.CompleteRunnerTask(claimed.ID, runnerID, domain.RunnerTaskSuccess, nil, "done", "", nil, nil, time.Now().UTC()); err != nil {
t.Fatal(err)
}
var payload string
if err := s.DB.Raw(`SELECT payload FROM runner_tasks WHERE id=?`, taskID).Scan(&payload).Error; err != nil {
t.Fatal(err)
}
if strings.Contains(payload, "codex-secret") || strings.Contains(payload, "git-secret") || strings.Contains(payload, "gateway.example") || strings.Contains(payload, "gitSsh") {
t.Fatalf("completed task retained credential material: %s", payload)
}
}
func TestMySQLGitSSHCredentialLifecycle(t *testing.T) {
dsn := os.Getenv("AGENTFLOW_TEST_MYSQL_DSN")
if dsn == "" {
t.Skip("AGENTFLOW_TEST_MYSQL_DSN is not set")
}
s, err := Open(dsn)
if err != nil {
t.Fatal(err)
}
defer s.Close()
login := fmt.Sprintf("git-ssh-%d", time.Now().UnixNano())
if err := s.PutUser(domain.User{LoginName: login}); err != nil {
t.Fatal(err)
}
user, ok := s.UserByLoginName(login)
if !ok {
t.Fatal("test user not found")
}
defer func() {
_ = s.DB.Exec(`DELETE FROM user_git_ssh_keys WHERE user_id=?`, user.ID).Error
_ = s.DB.Exec(`DELETE FROM user_git_http_credentials WHERE user_id=?`, user.ID).Error
_ = s.DB.Exec(`DELETE FROM user_configs WHERE user_id=?`, user.ID).Error
_ = s.DB.Exec(`DELETE FROM users WHERE id=?`, user.ID).Error
}()
if err := s.SaveGitHTTPCredential(user.ID, "", domain.GitHTTPCredentialSecret{GitHTTPCredential: domain.GitHTTPCredential{Host: "github.com", Name: "GitHub", Platform: domain.GitPlatformGitHub}, Token: "test-only-token"}); err != nil {
t.Fatal(err)
}
const first = "[email protected]:team/app.git"
const sameHost = "[email protected]:other/repo.git"
const second = "ssh://[email protected]:2222/team/app.git"
const missing = "[email protected]:team/app.git"
if err := s.SaveGitSSHKey(user.ID, "", "gitlab.example.org", "GitLab", "test-only first key"); err != nil {
t.Fatal(err)
}
if stored, ok := s.User(user.ID); !ok || !stored.GitSSHKeyConfigured {
t.Fatal("stored SSH host key is missing its configured flag")
}
if err := s.SaveGitSSHKey(user.ID, "", "GITLAB.EXAMPLE.ORG:22", "Duplicate", "test-only duplicate key"); !errors.Is(err, ErrGitSSHKeyExists) {
t.Fatalf("duplicate host: %v", err)
}
if err := s.SaveGitSSHKey(user.ID, "", "git.example.org:2222", "Other host", "test-only second key"); err != nil {
t.Fatal(err)
}
keys, err := s.GitSSHKeyDescriptions(user.ID)
if err != nil || len(keys) != 2 || keys[0].Host != "gitlab.example.org:22" || keys[1].Host != "git.example.org:2222" {
t.Fatalf("list SSH host key metadata: %+v (%v)", keys, err)
}
if err := s.SaveGitSSHKey(user.ID, keys[0].ID, keys[0].Host, "GitLab", ""); err != nil {
t.Fatalf("unchanged key update: %v", err)
}
selected := s.GitSSHKeysForRemotes(user.ID, []string{first, sameHost, second, missing})
if selected[first] != "test-only first key" || selected[sameHost] != selected[first] || selected[second] != "test-only second key" || selected[missing] != "" {
t.Fatal("host matching, shared key or port isolation failed")
}
if err := s.SaveGitSSHKey(user.ID, keys[0].ID, keys[0].Host, "New name", "rotated key"); err != nil {
t.Fatal(err)
}
selected = s.GitSSHKeysForRemotes(user.ID, []string{first, second})
if selected[first] != "rotated key" || selected[second] != "test-only second key" {
t.Fatal("rotation changed a different host's key")
}
for _, key := range keys {
if err := s.DeleteGitSSHKey(user.ID, key.ID); err != nil {
t.Fatal(err)
}
}
if user, _ := s.User(user.ID); user.GitSSHKeyConfigured || user.GitToken != "test-only token" {
t.Fatal("deleting SSH keys changed the token or left the configured flag set")
}
}