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.

37.6 KB
Raw Blame
package httpapi

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"agentflow/internal/domain"
	"agentflow/internal/engine"
	"agentflow/internal/repo"
	"agentflow/internal/runtime"
	"agentflow/internal/tracker"
)

func TestPutAgentValidatesEffortLevel(t *testing.T) {
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	if err := s.PutProject(domain.Project{ID: "gslb", Key: "GSLB", Name: "GSLB"}); err != nil {
		t.Fatal(err)
	}
	h := New(s, engine.New(s, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
	saved := requestJSON[domain.AgentDefinition](t, h, http.MethodPut, "/api/agents", domain.AgentDefinition{
		ID: "effort-role", Name: "Effort", Version: 1, ProjectID: "gslb", ExecutorID: "codex", Effort: "xhigh",
	}, http.StatusOK)
	if saved.Effort != "xhigh" {
		t.Fatalf("saved effort = %q, want xhigh", saved.Effort)
	}
	errBody := requestJSON[map[string]string](t, h, http.MethodPut, "/api/agents", domain.AgentDefinition{
		ID: "effort-role", Name: "Effort", Version: 2, ProjectID: "gslb", ExecutorID: "codex", Effort: "ultracode",
	}, http.StatusBadRequest)
	if !strings.Contains(errBody["error"], "思考强度") {
		t.Fatalf("error = %#v", errBody)
	}
}

func TestExecutorModelsCatalogListsPerCLI(t *testing.T) {
	t.Setenv("AGENTFLOW_ASSISTANT_MODEL", "")
	t.Setenv("AGENTFLOW_ASSISTANT_MODELS", "fast-model,test-model")
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	h := New(s, engine.New(s, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
	// The catalog is a public, non-sensitive list served without login.
	catalogs := requestEmptyJSON[map[string]executorModelCatalog](t, h, http.MethodGet, "/api/executor-models", http.StatusOK)
	cb, ok := catalogs["codebuddy"]
	if !ok || len(cb.Models) == 0 || cb.Default == "" {
		t.Fatalf("codebuddy catalog = %+v", cb)
	}
	if cb.Models[0].Credits != "" {
		t.Fatal("unconfigured public model must not claim a private price")
	}
	for _, model := range cb.Models {
		if model.ID == assistantDefaultModel {
			t.Fatal("the CodeBuddy CLI default must not be listed as a model")
		}
	}
	if cb.Models[0].ID != "fast-model" || cb.Models[0].Family != "codebuddy" {
		t.Fatalf("CodeBuddy routing model = %+v", cb.Models[0])
	}
	codex := catalogs["codex"]
	if len(codex.Models) < 2 || codex.Models[0].ID != "gpt-6.1-sol" || codex.Models[1].ID != "gpt-6.1-terra" || codex.Models[1].Name != "GPT-6.1 Terra" {
		t.Fatalf("codex catalog = %+v", codex.Models)
	}
	codexNames := make(map[string]string, len(codex.Models))
	for _, model := range codex.Models {
		codexNames[model.ID] = model.Name
	}
	for id, name := range map[string]string{"gpt-6.2-sol": "GPT-6.2 Sol", "gpt-6.2-astra": "GPT-6.2 Astra"} {
		if got := codexNames[id]; got != name {
			t.Errorf("Codex model %s has name %q, want %q", id, got, name)
		}
	}
	claude := catalogs["claude"]
	if len(claude.Models) < 2 || claude.Models[0].ID != "claude-fable-5-1" ||
		claude.Models[1].ID != "claude-fable-5-2" || claude.Models[1].Name != "Claude Fable 5.2" {
		t.Fatalf("claude catalog = %+v", claude.Models)
	}
	haiku := -1
	for i, model := range claude.Models {
		if model.ID == "claude-haiku-5-5" {
			haiku = i
		}
	}
	if haiku < 0 || haiku+1 >= len(claude.Models) || claude.Models[haiku].Name != "Claude Haiku 5.5" || claude.Models[haiku+1].ID != "claude-haiku-4-5" {
		t.Fatalf("claude catalog = %+v", claude.Models)
	}
}

func TestEnvironmentAssetsAreFilteredByProjectAndSharedScope(t *testing.T) {
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	for _, project := range []domain.Project{{ID: "alpha", Key: "ALPHA", Name: "Alpha"}, {ID: "beta", Key: "BETA", Name: "Beta"}} {
		if err := s.PutProject(project); err != nil {
			t.Fatal(err)
		}
	}
	for _, item := range []domain.DockerfileDefinition{
		{ID: "alpha-dockerfile", Name: "Alpha", ProjectID: "alpha", Content: "FROM alpine"},
		{ID: "beta-shared-dockerfile", Name: "Beta shared", ProjectID: "beta", Shared: true, Content: "FROM alpine"},
		{ID: "beta-private-dockerfile", Name: "Beta private", ProjectID: "beta", Content: "FROM alpine"},
	} {
		if err := s.PutDockerfile(item); err != nil {
			t.Fatal(err)
		}
	}
	h := New(s, engine.New(s, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
	items := requestEmptyJSON[[]domain.DockerfileDefinition](t, h, http.MethodGet, "/api/dockerfiles?projectId=alpha", http.StatusOK)
	visible := map[string]bool{}
	for _, item := range items {
		visible[item.ID] = true
	}
	if !visible["alpha-dockerfile"] || !visible["beta-shared-dockerfile"] || visible["beta-private-dockerfile"] {
		t.Fatalf("unexpected project catalog visibility: %#v", visible)
	}
}

func TestWorkflowAgentsAreFilteredAndValidatedByProject(t *testing.T) {
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	for _, project := range []domain.Project{{ID: "alpha", Key: "ALPHA", Name: "Alpha"}, {ID: "beta", Key: "BETA", Name: "Beta"}} {
		if err := s.PutProject(project); err != nil {
			t.Fatal(err)
		}
	}
	for _, agent := range []domain.AgentDefinition{
		{ID: "alpha-role", Name: "Alpha role", ProjectID: "alpha", Version: 1},
		{ID: "beta-shared-role", Name: "Beta shared", ProjectID: "beta", Shared: true, Version: 1},
		{ID: "beta-private-role", Name: "Beta private", ProjectID: "beta", Version: 1},
		{ID: "legacy-role", Name: "Legacy global", Version: 1},
	} {
		if err := s.PutAgent(agent); err != nil {
			t.Fatal(err)
		}
	}
	h := New(s, engine.New(s, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
	agents := requestEmptyJSON[[]domain.AgentDefinition](t, h, http.MethodGet, "/api/agents?projectId=alpha", http.StatusOK)
	visible := map[string]bool{}
	for _, agent := range agents {
		visible[agent.ID] = true
	}
	if !visible["alpha-role"] || !visible["beta-shared-role"] || visible["beta-private-role"] || visible["legacy-role"] {
		t.Fatalf("unexpected workflow role visibility: %#v", visible)
	}

	invalid := domain.WorkflowDefinition{
		ID: "alpha-flow", Name: "Alpha flow", ProjectID: "alpha", SandboxProfileID: "local",
		Nodes: []domain.WorkflowNode{{ID: "work", Name: "Work", Type: "agent", AgentID: "beta-private-role"}},
	}
	requestJSON[map[string]string](t, h, http.MethodPut, "/api/workflows", invalid, http.StatusBadRequest)
	invalid.Nodes[0].AgentID = "beta-shared-role"
	saved := requestJSON[domain.WorkflowDefinition](t, h, http.MethodPut, "/api/workflows", invalid, http.StatusOK)
	if saved.Nodes[0].AgentID != "beta-shared-role" {
		t.Fatalf("shared role was not saved: %+v", saved.Nodes)
	}
	legacyPayload := map[string]any{
		"id": "legacy-node-gate", "name": "Legacy node gate", "projectId": "alpha", "sandboxProfileId": "local",
		"nodes": []any{map[string]any{
			"id": "work", "name": "Work", "type": "agent", "agentId": "alpha-role",
			"verification": []any{map[string]any{"id": "obsolete", "mode": "command", "commands": []string{"false"}}},
		}},
	}
	stored := requestJSON[map[string]any](t, h, http.MethodPut, "/api/workflows", legacyPayload, http.StatusOK)
	nodes, _ := stored["nodes"].([]any)
	node, _ := nodes[0].(map[string]any)
	if _, exists := node["verification"]; exists {
		t.Fatalf("workflow API retained removed node verification: %#v", node)
	}
}

func TestSharingSandboxCascadesDependenciesAndSharedWorkflowRequiresSharedSandbox(t *testing.T) {
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	if err := s.PutProject(domain.Project{ID: "alpha", Key: "ALPHA", Name: "Alpha"}); err != nil {
		t.Fatal(err)
	}
	if err := s.PutDockerfile(domain.DockerfileDefinition{ID: "alpha-dockerfile", Name: "Alpha image", ProjectID: "alpha", Content: "FROM alpine"}); err != nil {
		t.Fatal(err)
	}
	if err := s.PutEnvironment(domain.EnvironmentDefinition{ID: "alpha-tools", Name: "Alpha tools", ProjectID: "alpha", InstallScript: "true"}); err != nil {
		t.Fatal(err)
	}
	h := New(s, engine.New(s, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
	requestJSON[map[string]bool](t, h, http.MethodPut, "/api/sandboxes", domain.SandboxProfile{
		ID: "alpha-container", Name: "Alpha container", ProjectID: "alpha", Shared: true, Driver: "docker", DockerfileID: "alpha-dockerfile",
	}, http.StatusOK)
	dockerfile, _ := s.Dockerfile("alpha-dockerfile")
	if !dockerfile.Shared {
		t.Fatal("sharing a sandbox did not share its Dockerfile")
	}
	requestJSON[map[string]bool](t, h, http.MethodPut, "/api/sandboxes", domain.SandboxProfile{
		ID: "alpha-process", Name: "Alpha process", ProjectID: "alpha", Driver: "bwrap", EnvironmentID: "alpha-tools",
	}, http.StatusOK)
	requestJSON[domain.WorkflowDefinition](t, h, http.MethodPut, "/api/workflows", domain.WorkflowDefinition{
		ID: "alpha-flow", Name: "Alpha flow", ProjectID: "alpha", Shared: true, SandboxProfileID: "alpha-process",
	}, http.StatusBadRequest)
	profile, _ := s.Sandbox("alpha-process")
	environment, _ := s.Environment("alpha-tools")
	if profile.Shared || environment.Shared {
		t.Fatalf("rejected workflow unexpectedly shared its environment chain: sandbox=%+v environment=%+v", profile, environment)
	}
}

func TestCatalogAgentsKeepsProjectScope(t *testing.T) {
	source := []domain.AgentDefinition{{
		ID: "gslb-fix", Name: "Fix", Version: 2, ProjectID: "gslb", Shared: true, PlatformMCP: true,
		Description:     strings.Repeat("x", 300),
		Prompt:          "fix",
		ArtifactOutputs: []domain.ArtifactContract{{Name: "plan", Path: "fix-plan.md"}},
		Verification: []domain.VerificationGate{{
			ID: "plan", Name: "Plan", Mode: "command",
			Commands: []string{"test -s fix-plan.md"}, ExecutionScope: domain.ExecutionScopeRun,
		}},
	}}
	got := catalogAgents(source)
	if len(got) != 1 || got[0].ProjectID != "gslb" || !got[0].Shared || got[0].Name != "Fix" {
		t.Fatalf("project scope stripped: %+v", got)
	}
	if !got[0].PlatformMCP {
		t.Fatalf("platform MCP binding lost in catalog agent: %+v", got[0])
	}
	if got[0].Prompt != "" {
		t.Fatalf("catalog agent should stay slim: %+v", got[0])
	}
	if len(got[0].ArtifactOutputs) != 1 || len(got[0].Verification) != 1 {
		t.Fatalf("catalog agent should keep validation summary: %+v", got[0])
	}
	if !strings.HasSuffix(got[0].Description, "…") || len(got[0].Description) >= len(source[0].Description) {
		t.Fatalf("description not clipped: %q", got[0].Description)
	}
	if source[0].Prompt == "" {
		t.Fatal("catalogAgents mutated source")
	}
}

func TestAgentCloneStampsProjectAndKeepsBody(t *testing.T) {
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	for _, project := range []domain.Project{{ID: "other", Key: "OTHER", Name: "Other"}, {ID: "gslb", Key: "GSLB", Name: "GSLB"}} {
		if err := s.PutProject(project); err != nil {
			t.Fatal(err)
		}
	}
	if err := s.PutAgent(domain.AgentDefinition{
		ID: "src-role", Name: "Source", Version: 3, ProjectID: "other", Shared: true,
		Prompt: "do it",
	}); err != nil {
		t.Fatal(err)
	}
	h := New(s, engine.New(s, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
	copied := requestJSON[domain.AgentDefinition](t, h, http.MethodPost, "/api/agents/src-role/clone", map[string]any{
		"id": "dst-role", "name": "Copy", "projectId": "gslb",
	}, http.StatusCreated)
	if copied.ID != "dst-role" || copied.Name != "Copy" || copied.ProjectID != "gslb" || copied.Shared || copied.Version != 1 {
		t.Fatalf("clone = %+v", copied)
	}
	if copied.Prompt != "do it" {
		t.Fatalf("clone dropped role prompt: %q", copied.Prompt)
	}
	src, ok := s.Agent("src-role")
	if !ok || !src.Shared || src.ProjectID != "other" || src.Version != 3 {
		t.Fatalf("source mutated: %+v", src)
	}
}

func TestAgentDeleteRequiresUnusedAndUnshared(t *testing.T) {
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	if err := s.PutProject(domain.Project{ID: "alpha", Key: "ALPHA", Name: "Alpha"}); err != nil {
		t.Fatal(err)
	}
	for _, agent := range []domain.AgentDefinition{
		{ID: "free-role", Name: "Free role", ProjectID: "alpha", Version: 1},
		{ID: "referenced-role", Name: "Referenced role", ProjectID: "alpha", Version: 1},
		{ID: "shared-role", Name: "Shared role", ProjectID: "alpha", Shared: true, Version: 1},
	} {
		if err := s.PutAgent(agent); err != nil {
			t.Fatal(err)
		}
	}
	h := New(s, engine.New(s, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
	saved := requestJSON[domain.WorkflowDefinition](t, h, http.MethodPut, "/api/workflows", domain.WorkflowDefinition{
		ID: "alpha-flow", Name: "Alpha flow", ProjectID: "alpha", SandboxProfileID: "local",
		Nodes: []domain.WorkflowNode{{ID: "work", Name: "Work", Type: "agent", AgentID: "referenced-role"}},
	}, http.StatusOK)
	if saved.Nodes[0].AgentID != "referenced-role" {
		t.Fatalf("workflow was not saved: %+v", saved)
	}

	// referenced agent must be rejected with 409
	requestEmptyJSON[map[string]any](t, h, http.MethodDelete, "/api/agents/referenced-role", http.StatusConflict)
	if _, ok := s.Agent("referenced-role"); !ok {
		t.Fatal("referenced agent was deleted despite workflow usage")
	}
	// shared agent must be rejected with 409
	requestEmptyJSON[map[string]any](t, h, http.MethodDelete, "/api/agents/shared-role", http.StatusConflict)
	if _, ok := s.Agent("shared-role"); !ok {
		t.Fatal("shared agent was deleted despite shared flag")
	}
	// unused, unshared agent is deleted with 204
	doDelete := func(path string) int {
		req := httptest.NewRequest(http.MethodDelete, path, nil)
		rec := httptest.NewRecorder()
		h.ServeHTTP(rec, req)
		return rec.Code
	}
	if code := doDelete("/api/agents/free-role"); code != http.StatusNoContent {
		t.Fatalf("free agent delete status = %d", code)
	}
	if _, ok := s.Agent("free-role"); ok {
		t.Fatal("free agent was not deleted")
	}
	// deleting again returns 404
	if code := doDelete("/api/agents/free-role"); code != http.StatusNotFound {
		t.Fatalf("repeat delete status = %d", code)
	}
}

func TestCatalogAssetDeleteRequiresUnusedAndUnshared(t *testing.T) {
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	if err := s.PutProject(domain.Project{ID: "alpha", Key: "ALPHA", Name: "Alpha"}); err != nil {
		t.Fatal(err)
	}
	must := func(err error) {
		t.Helper()
		if err != nil {
			t.Fatal(err)
		}
	}
	must(s.PutRule(domain.RuleDefinition{ID: "free-rule", Name: "Free rule", ProjectID: "alpha"}))
	must(s.PutRule(domain.RuleDefinition{ID: "used-rule", Name: "Used rule", ProjectID: "alpha"}))
	must(s.PutRule(domain.RuleDefinition{ID: "shared-rule", Name: "Shared rule", ProjectID: "alpha", Shared: true}))
	must(s.PutSkill(domain.SkillDefinition{ID: "free-skill", Name: "Free skill", ProjectID: "alpha"}))
	must(s.PutSkill(domain.SkillDefinition{ID: "used-skill", Name: "Used skill", ProjectID: "alpha"}))
	must(s.PutSkill(domain.SkillDefinition{ID: "shared-skill", Name: "Shared skill", ProjectID: "alpha", Shared: true}))
	must(s.PutSkillFiles("free-skill", []repo.SkillFileInput{{Path: "SKILL.md", Content: []byte("# free\n")}}))
	must(s.PutDockerfile(domain.DockerfileDefinition{ID: "free-df", Name: "Free df", ProjectID: "alpha", Content: "FROM scratch"}))
	must(s.PutDockerfile(domain.DockerfileDefinition{ID: "used-df", Name: "Used df", ProjectID: "alpha", Content: "FROM scratch"}))
	must(s.PutDockerfile(domain.DockerfileDefinition{ID: "shared-df", Name: "Shared df", ProjectID: "alpha", Shared: true, Content: "FROM scratch"}))
	must(s.PutEnvironment(domain.EnvironmentDefinition{ID: "free-env", Name: "Free env", ProjectID: "alpha"}))
	must(s.PutEnvironment(domain.EnvironmentDefinition{ID: "used-env", Name: "Used env", ProjectID: "alpha"}))
	must(s.PutEnvironment(domain.EnvironmentDefinition{ID: "shared-env", Name: "Shared env", ProjectID: "alpha", Shared: true}))
	must(s.PutSandbox(domain.SandboxProfile{ID: "free-box", Name: "Free box", ProjectID: "alpha", Driver: "local"}))
	must(s.PutSandbox(domain.SandboxProfile{ID: "used-box", Name: "Used box", ProjectID: "alpha", Driver: "local"}))
	must(s.PutSandbox(domain.SandboxProfile{ID: "shared-box", Name: "Shared box", ProjectID: "alpha", Shared: true, Driver: "local"}))
	must(s.PutSandbox(domain.SandboxProfile{ID: "df-box", Name: "DF box", ProjectID: "alpha", Driver: "docker", DockerfileID: "used-df"}))
	must(s.PutSandbox(domain.SandboxProfile{ID: "env-box", Name: "Env box", ProjectID: "alpha", Driver: "seatbelt", EnvironmentID: "used-env"}))
	must(s.PutAgent(domain.AgentDefinition{
		ID: "asset-user", Name: "Asset user", ProjectID: "alpha", Version: 1,
		Rules: []string{"used-rule"}, Skills: []string{"used-skill"},
	}))
	h := New(s, engine.New(s, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
	requestJSON[domain.WorkflowDefinition](t, h, http.MethodPut, "/api/workflows", domain.WorkflowDefinition{
		ID: "alpha-flow", Name: "Alpha flow", ProjectID: "alpha", SandboxProfileID: "used-box",
		Nodes: []domain.WorkflowNode{{ID: "work", Name: "Work", Type: "agent", AgentID: "asset-user"}},
	}, http.StatusOK)

	doDelete := func(path string) int {
		t.Helper()
		req := httptest.NewRequest(http.MethodDelete, path, nil)
		rec := httptest.NewRecorder()
		h.ServeHTTP(rec, req)
		return rec.Code
	}
	assertConflict := func(path string) {
		t.Helper()
		req := httptest.NewRequest(http.MethodDelete, path, nil)
		rec := httptest.NewRecorder()
		h.ServeHTTP(rec, req)
		if rec.Code != http.StatusConflict {
			t.Fatalf("%s status = %d, want 409; body %s", path, rec.Code, rec.Body.String())
		}
	}
	assertGone := func(path string, stillThere func() bool, label string) {
		t.Helper()
		if code := doDelete(path); code != http.StatusNoContent {
			t.Fatalf("%s status = %d, want 204", path, code)
		}
		if stillThere() {
			t.Fatalf("%s was not deleted", label)
		}
		if code := doDelete(path); code != http.StatusNotFound {
			t.Fatalf("repeat %s status = %d, want 404", path, code)
		}
	}

	if code := doDelete("/api/rules"); code != http.StatusBadRequest {
		t.Fatalf("missing id status = %d", code)
	}
	assertConflict("/api/rules?id=used-rule")
	assertConflict("/api/rules?id=shared-rule")
	assertGone("/api/rules?id=free-rule", func() bool { _, ok := s.Rule("free-rule"); return ok }, "free rule")

	assertConflict("/api/skills?id=used-skill")
	assertConflict("/api/skills?id=shared-skill")
	assertGone("/api/skills?id=free-skill", func() bool { _, ok := s.Skill("free-skill"); return ok }, "free skill")
	if _, ok := s.SkillFileContent("free-skill", "SKILL.md"); ok {
		t.Fatal("skill_files rows were not cascaded")
	}

	assertConflict("/api/dockerfiles?id=used-df")
	assertConflict("/api/dockerfiles?id=shared-df")
	assertGone("/api/dockerfiles?id=free-df", func() bool { _, ok := s.Dockerfile("free-df"); return ok }, "free dockerfile")

	assertConflict("/api/environments?id=used-env")
	assertConflict("/api/environments?id=shared-env")
	assertGone("/api/environments?id=free-env", func() bool { _, ok := s.Environment("free-env"); return ok }, "free environment")

	assertConflict("/api/sandboxes?id=used-box")
	assertConflict("/api/sandboxes?id=shared-box")
	assertConflict("/api/sandboxes?id=local")
	assertConflict("/api/sandboxes?id=" + repo.GenericDockerSandboxID)
	assertConflict("/api/dockerfiles?id=" + repo.GenericBackendDockerfileID)
	assertGone("/api/sandboxes?id=free-box", func() bool { _, ok := s.Sandbox("free-box"); return ok }, "free sandbox")
}

func TestSharingAgentCascadesToOwnedRulesAndSkills(t *testing.T) {
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	if err := s.PutProject(domain.Project{ID: "gslb", Key: "GSLB", Name: "GSLB"}); err != nil {
		t.Fatal(err)
	}
	if err := s.PutRule(domain.RuleDefinition{ID: "owned-rule", Name: "Owned rule", ProjectID: "gslb"}); err != nil {
		t.Fatal(err)
	}
	if err := s.PutSkill(domain.SkillDefinition{ID: "owned-skill", Name: "Owned skill", ProjectID: "gslb"}); err != nil {
		t.Fatal(err)
	}
	h := New(s, engine.New(s, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
	requestJSON[domain.AgentDefinition](t, h, http.MethodPut, "/api/agents", domain.AgentDefinition{
		ID: "shared-role", Name: "Shared", Version: 1, ProjectID: "gslb", Shared: true,
		Rules: []string{"owned-rule"}, Skills: []string{"owned-skill"}, ExecutorID: "codebuddy",
	}, http.StatusOK)
	rule, _ := s.Rule("owned-rule")
	skill, _ := s.Skill("owned-skill")
	if !rule.Shared || !skill.Shared {
		t.Fatalf("dependencies were not shared: rule=%+v skill=%+v", rule, skill)
	}
}

func TestPutAgentRejectsCommandGateWithoutExecutionScope(t *testing.T) {
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	if err := s.PutProject(domain.Project{ID: "gslb", Key: "GSLB", Name: "GSLB"}); err != nil {
		t.Fatal(err)
	}
	h := New(s, engine.New(s, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
	errBody := requestJSON[map[string]string](t, h, http.MethodPut, "/api/agents", domain.AgentDefinition{
		ID: "scoped-role", Name: "Scoped", Version: 1, ProjectID: "gslb", ExecutorID: "codebuddy",
		Verification: []domain.VerificationGate{{ID: "plan", Name: "plan", Mode: "command", Commands: []string{`test -f fix-plan.md`}}},
	}, http.StatusBadRequest)
	if !strings.Contains(errBody["error"], "executionScope") {
		t.Fatalf("error = %#v", errBody)
	}
	saved := requestJSON[domain.AgentDefinition](t, h, http.MethodPut, "/api/agents", domain.AgentDefinition{
		ID: "scoped-role", Name: "Scoped", Version: 1, ProjectID: "gslb", ExecutorID: "codebuddy",
		Verification: []domain.VerificationGate{{ID: "plan", Name: "plan", Mode: "command", ExecutionScope: domain.ExecutionScopeRun, Commands: []string{`test -f fix-plan.md`}}},
	}, http.StatusOK)
	if len(saved.Verification) != 1 || saved.Verification[0].ExecutionScope != domain.ExecutionScopeRun {
		t.Fatalf("saved gates = %#v", saved.Verification)
	}
}

func TestCloneAgentMCPServersCopiesByTargetScope(t *testing.T) {
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	for _, server := range []domain.MCPServerDefinition{
		{ID: "project-source", Name: "Project", Scope: "project", ProjectID: "source", Transport: "http", URL: "https://example.com/project"},
		{ID: "personal-source", Name: "Personal", Scope: "personal", OwnerUserID: 9, Transport: "http", URL: "https://example.com/personal"},
	} {
		if err := s.PutMCPServer(server); err != nil {
			t.Fatal(err)
		}
	}
	server := &Server{deps: &deps{repo: s}}
	server.catalog = &catalogHandlers{deps: server.deps}
	ids, err := server.catalog.cloneAgentMCPServers([]string{"project-source", "personal-source"}, "target", 2)
	if err != nil {
		t.Fatal(err)
	}
	if len(ids) != 2 {
		t.Fatalf("cloned ids = %#v", ids)
	}
	project, ok := s.MCPServer(ids[0])
	if !ok || project.Scope != "project" || project.ProjectID != "target" || project.OwnerUserID != 0 {
		t.Fatalf("project MCP copy = %+v", project)
	}
	personal, ok := s.MCPServer(ids[1])
	if !ok || personal.Scope != "personal" || personal.OwnerUserID != 2 || personal.ProjectID != "" {
		t.Fatalf("personal MCP copy = %+v", personal)
	}
}

func TestRunListFallsBackToIssueProject(t *testing.T) {
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	now := time.Now().UTC()
	if err := s.PutIssue(domain.Issue{ID: "iss-legacy", ProjectID: "gslb", Title: "legacy"}); err != nil {
		t.Fatal(err)
	}
	if err := s.PutRun(domain.Run{
		ID: "legacy-run", WorkflowID: "issue-fix-production", Status: "succeeded",
		ExecutionContext: domain.TelemetryContext{IssueID: "iss-legacy"},
		CreatedAt:        now, UpdatedAt: now,
	}); err != nil {
		t.Fatal(err)
	}
	h := New(s, engine.New(s, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
	listed := requestJSON[[]domain.Run](t, h, http.MethodGet, "/api/runs?projectId=gslb", nil, http.StatusOK)
	if len(listed) != 1 || listed[0].ID != "legacy-run" {
		t.Fatalf("gslb run list = %+v", listed)
	}
	other := requestJSON[[]domain.Run](t, h, http.MethodGet, "/api/runs?projectId=platform", nil, http.StatusOK)
	for _, item := range other {
		if item.ID == "legacy-run" {
			t.Fatal("legacy run leaked into another project list")
		}
	}
}

func TestBootstrapAgentsKeepProjectScope(t *testing.T) {
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	if err := s.PutAgent(domain.AgentDefinition{
		ID: "owned-role", Name: "Owned", ProjectID: "gslb", Shared: true, Prompt: "do not leak",
		ArtifactOutputs: []domain.ArtifactContract{{Name: "report", Path: "report.md", Required: true}},
		Verification:    []domain.VerificationGate{{ID: "report", Name: "report", Mode: "command", Commands: []string{"test -s report.md"}, ExecutionScope: domain.ExecutionScopeRun}},
	}); err != nil {
		t.Fatal(err)
	}
	h := New(s, engine.New(s, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
	boot := requestEmptyJSON[map[string]any](t, h, http.MethodGet, "/api/bootstrap", http.StatusOK)
	raw, _ := boot["agents"].([]any)
	var found map[string]any
	for _, item := range raw {
		agent, _ := item.(map[string]any)
		if agent["id"] == "owned-role" {
			found = agent
			break
		}
	}
	if found == nil {
		t.Fatal("bootstrap missing owned-role")
	}
	if found["projectId"] != "gslb" || found["shared"] != true {
		t.Fatalf("bootstrap dropped project scope: %+v", found)
	}
	if _, leaked := found["prompt"]; leaked {
		t.Fatalf("bootstrap leaked the role prompt: %+v", found)
	}
	if artifacts, ok := found["artifactOutputs"].([]any); !ok || len(artifacts) != 1 {
		t.Fatalf("bootstrap dropped role artifact contracts: %+v", found)
	}
	if gates, ok := found["verification"].([]any); !ok || len(gates) != 1 {
		t.Fatalf("bootstrap dropped role verification gates: %+v", found)
	}
}

func TestProjectDefaultRepositoryMustAlreadyExist(t *testing.T) {
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	if err := s.PutProject(domain.Project{ID: "other", Key: "OTHER", Name: "Other"}); err != nil {
		t.Fatal(err)
	}
	if err := s.PutRepository(domain.Repository{ID: "other-repo", ProjectID: "other", Name: "other", GongfengProjectID: "other/repo"}); err != nil {
		t.Fatal(err)
	}
	h := New(s, engine.New(s, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")

	missing := requestJSON[map[string]string](t, h, http.MethodPost, "/api/projects", domain.Project{
		ID: "onboard", Key: "ONB", Name: "Onboard", DefaultRepositoryID: "onboard-repo",
	}, http.StatusBadRequest)
	if missing["error"] != "default repository must belong to project" {
		t.Fatalf("missing default repo: %+v", missing)
	}

	denied := requestJSON[map[string]string](t, h, http.MethodPost, "/api/projects", domain.Project{
		ID: "stolen", Key: "STL", Name: "Stolen", DefaultRepositoryID: "other-repo",
	}, http.StatusBadRequest)
	if denied["error"] != "default repository must belong to project" {
		t.Fatalf("wrong-project default repo: %+v", denied)
	}

	created := requestJSON[domain.Project](t, h, http.MethodPost, "/api/projects", domain.Project{
		ID: "onboard", Key: "ONB", Name: "Onboard",
	}, http.StatusOK)
	if created.DefaultRepositoryID != "" {
		t.Fatalf("new project must not carry a default repo, got %q", created.DefaultRepositoryID)
	}
	repo := requestJSON[domain.Repository](t, h, http.MethodPost, "/api/repositories", map[string]any{
		"id": "onboard-repo", "projectId": "onboard", "repoUrl": "https://git.example.com/onboard/app",
	}, http.StatusOK)
	bound := requestJSON[domain.Project](t, h, http.MethodPut, "/api/projects", domain.Project{
		ID: "onboard", Name: "Onboard", DefaultRepositoryID: repo.ID,
	}, http.StatusOK)
	if bound.DefaultRepositoryID != "onboard-repo" {
		t.Fatalf("default repo after create: %q", bound.DefaultRepositoryID)
	}
}

func TestNewProjectDefaultsToGenericBackendDeliverySOP(t *testing.T) {
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	h := New(s, engine.New(s, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
	created := requestJSON[domain.Project](t, h, http.MethodPost, "/api/projects", domain.Project{ID: "fresh", Key: "FRESH", Name: "Fresh"}, http.StatusOK)
	if created.WorkflowID != repo.GenericBackendDeliveryWorkflowID {
		t.Fatalf("new project should default to the LoopForge SOP, got %q", created.WorkflowID)
	}
	assertProjectHasDefaultTrackerMCPs(t, s, "fresh")
	// 显式指定或修改 SOP 不被覆盖。
	updated := requestJSON[domain.Project](t, h, http.MethodPut, "/api/projects", domain.Project{ID: "fresh", Name: "Fresh 2", WorkflowID: "custom-sop"}, http.StatusOK)
	if updated.WorkflowID != "custom-sop" {
		t.Fatalf("explicit SOP must be kept, got %q", updated.WorkflowID)
	}
}

func TestRepositoryOneLinkSetup(t *testing.T) {
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	h := New(s, engine.New(s, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
	requestJSON[domain.Project](t, h, http.MethodPost, "/api/projects", domain.Project{ID: "linkproj", Key: "LINK", Name: "Link"}, http.StatusOK)

	// 只粘贴一个工蜂链接:自动补项目路径、仓库名、URL,主分支默认 master。
	created := requestJSON[domain.Repository](t, h, http.MethodPost, "/api/repositories", map[string]any{
		"projectId": "linkproj",
		"repoUrl":   "https://git.example.com/infra/gateway/-/tree/master",
	}, http.StatusOK)
	if created.GongfengProjectID != "infra/gateway" || created.Name != "gateway" {
		t.Fatalf("unexpected parse: %+v", created)
	}
	if created.DefaultBranch != "master" {
		t.Fatalf("default branch = %q, want master", created.DefaultBranch)
	}
	if created.IntegrateBranch != "" {
		t.Fatalf("new repo must not invent an integrate branch, got %q", created.IntegrateBranch)
	}
	if created.WebURL != "https://git.example.com/infra/gateway" || created.CloneURL != "https://git.example.com/infra/gateway.git" {
		t.Fatalf("unexpected urls: %+v", created)
	}

	// scp 形式同样可解析,显式字段优先于解析结果。
	updated := requestJSON[domain.Repository](t, h, http.MethodPost, "/api/repositories", map[string]any{
		"projectId":     "linkproj",
		"repoUrl":       "[email protected]:infra/storage.git",
		"name":          "存储",
		"defaultBranch": "release",
	}, http.StatusOK)
	if updated.Provider != domain.RepositoryProviderSSH || updated.GongfengProjectID != "" || updated.Name != "存储" || updated.DefaultBranch != "release" {
		t.Fatalf("unexpected scp parse / field priority: %+v", updated)
	}
	if updated.CloneURL != "[email protected]:infra/storage.git" {
		t.Fatalf("ssh paste should keep ssh clone url, got %q", updated.CloneURL)
	}

	cloned := requestJSON[domain.Repository](t, h, http.MethodPost, "/api/repositories", map[string]any{
		"projectId": "linkproj",
		"repoUrl":   "git clone [email protected]:infra/dns.git",
	}, http.StatusOK)
	if cloned.Provider != domain.RepositoryProviderSSH || cloned.GongfengProjectID != "" || cloned.CloneURL != "[email protected]:infra/dns.git" {
		t.Fatalf("git clone prefix was not parsed: %+v", cloned)
	}

	// 项目 ID 字段本身粘贴完整链接(内联行/弹窗都可能发生):必须规范化为
	// group/repo 而不是把 URL 当作项目路径入库,否则同步、建分支和 MR 全挂。
	pasted := requestJSON[domain.Repository](t, h, http.MethodPost, "/api/repositories", map[string]any{
		"projectId":         "linkproj",
		"gongfengProjectId": "https://git.example.com/infra/cache",
	}, http.StatusOK)
	if pasted.GongfengProjectID != "infra/cache" {
		t.Fatalf("full link in project id must normalize, got %q", pasted.GongfengProjectID)
	}
	if pasted.WebURL != "https://git.example.com/infra/cache" || pasted.CloneURL != "https://git.example.com/infra/cache.git" {
		t.Fatalf("urls derived from normalized id are wrong: %+v", pasted)
	}

	// 链接形态但解析失败(非工蜂域名、缺项目路径等)必须 400,绝不能把 URL 当项目路径落库。
	for _, bad := range []string{
		"https://gitlab.invalid/infra/cache",
		"[email protected]:infra/cache.git",
		"https://git.example.com",
		"https://",
		"infra/../etc",
		"infra/repo name",
		`infra\repo`,
	} {
		resp := requestJSON[map[string]string](t, h, http.MethodPost, "/api/repositories", map[string]any{
			"projectId":         "linkproj",
			"gongfengProjectId": bad,
		}, http.StatusBadRequest)
		if resp["error"] == "" {
			t.Fatalf("expected error message for %q", bad)
		}
	}

	// 普通项目路径与数字 ID 保持兼容。
	for _, good := range []string{"tencent/infra/gateway", "12345", "legacy-project_id"} {
		stored := requestJSON[domain.Repository](t, h, http.MethodPost, "/api/repositories", map[string]any{
			"projectId":         "linkproj",
			"gongfengProjectId": good,
		}, http.StatusOK)
		if stored.GongfengProjectID != good {
			t.Fatalf("plain path %q must be stored as-is, got %q", good, stored.GongfengProjectID)
		}
	}
}

func TestGlobalRuleWorkflowBinding(t *testing.T) {
	s, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })
	if err := s.PutProject(domain.Project{ID: "alpha", Key: "ALPHA", Name: "Alpha"}); err != nil {
		t.Fatal(err)
	}
	if err := s.PutProject(domain.Project{ID: "beta", Key: "BETA", Name: "Beta"}); err != nil {
		t.Fatal(err)
	}
	if err := s.PutWorkflow(domain.WorkflowDefinition{
		ID: "alpha-sop", Name: "Alpha SOP", ProjectID: "alpha", SandboxProfileID: "local",
		Nodes: []domain.WorkflowNode{{ID: "dev", Name: "实现", Type: "agent", AgentID: "developer"}},
	}); err != nil {
		t.Fatal(err)
	}
	if err := s.PutWorkflow(domain.WorkflowDefinition{
		ID: "beta-private", Name: "Beta private", ProjectID: "beta", SandboxProfileID: "local",
		Nodes: []domain.WorkflowNode{{ID: "dev", Name: "实现", Type: "agent", AgentID: "developer"}},
	}); err != nil {
		t.Fatal(err)
	}
	h := New(s, engine.New(s, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
	requestJSON[map[string]bool](t, h, http.MethodPut, "/api/rules", domain.RuleDefinition{
		ID: "alpha-global", Name: "全局约束", ProjectID: "alpha", Content: "所有节点都要遵守", Priority: 50,
		Global: true, WorkflowIDs: []string{" alpha-sop ", "alpha-sop", ""},
	}, http.StatusOK)
	saved, ok := s.Rule("alpha-global")
	if !ok || !saved.Global || len(saved.WorkflowIDs) != 1 || saved.WorkflowIDs[0] != "alpha-sop" {
		t.Fatalf("saved rule = %#v", saved)
	}
	missing := requestJSON[map[string]string](t, h, http.MethodPut, "/api/rules", domain.RuleDefinition{
		ID: "alpha-global", Name: "全局约束", ProjectID: "alpha", Content: "所有节点都要遵守",
		Global: true, WorkflowIDs: []string{"missing-sop"},
	}, http.StatusBadRequest)
	if missing["error"] == "" {
		t.Fatal("expected missing SOP error")
	}
	foreign := requestJSON[map[string]string](t, h, http.MethodPut, "/api/rules", domain.RuleDefinition{
		ID: "alpha-global", Name: "全局约束", ProjectID: "alpha", Content: "所有节点都要遵守",
		Global: true, WorkflowIDs: []string{"beta-private"},
	}, http.StatusBadRequest)
	if foreign["error"] == "" {
		t.Fatal("expected foreign SOP error")
	}
	requestJSON[map[string]bool](t, h, http.MethodPut, "/api/rules", domain.RuleDefinition{
		ID: "alpha-global", Name: "全局约束", ProjectID: "alpha", Content: "所有节点都要遵守",
		Global: false, WorkflowIDs: []string{"alpha-sop"},
	}, http.StatusOK)
	cleared, _ := s.Rule("alpha-global")
	if cleared.Global || len(cleared.WorkflowIDs) != 0 {
		t.Fatalf("turning the switch off must drop SOP bindings: %#v", cleared)
	}
}

func TestExecutorModelsCatalogUsesOnlyTheEditorsSavedModels(t *testing.T) {
	assistant, user := workbenchFixture(t)
	user = domain.User{
		LoginName:        "personal-catalog",
		CodexAPIKey:      "fixture-secret",
		CodexModels:      []domain.CLIModel{{ID: "gateway/second", Name: "Second"}, {ID: "gateway/first"}},
		ClaudeCodeModels: []domain.CLIModel{{ID: "custom-sonnet", Name: "Personal Sonnet"}},
		AgentCLICredentials: map[string]domain.AgentCLICredential{
			"opencode": {Models: []domain.CLIModel{{ID: "alibaba/qwen3.7-plus", Name: "Qwen3.7 Plus"}}},
		},
	}
	if err := assistant.repo.PutUser(user); err != nil {
		t.Fatal(err)
	}
	user, _ = assistant.repo.UserByLoginName(user.LoginName)
	handler := &catalogHandlers{deps: assistant.deps}
	c, rec := workbenchContext(user, "GET", "/api/executor-models", bytes.NewBuffer(nil))
	handler.executorModels(c)
	var catalogs map[string]executorModelCatalog
	if rec.Code != http.StatusOK || json.Unmarshal(rec.Body.Bytes(), &catalogs) != nil {
		t.Fatalf("catalog request: %d %s", rec.Code, rec.Body)
	}
	if rec.Header().Get("Cache-Control") != "private, no-store" || strings.Contains(rec.Body.String(), "fixture-secret") {
		t.Fatal("personal model catalog or credentials were cacheable or leaked")
	}
	if models := catalogs["codex"].Models; len(models) != 2 || models[0].Name != "Second" || models[1].ID != "gateway/first" || models[1].Name != "gateway/first" {
		t.Fatalf("Codex models = %+v", models)
	}
	if models := catalogs["claude"].Models; len(models) != 1 || models[0].Name != "Personal Sonnet" {
		t.Fatalf("Claude models = %+v", models)
	}
	if models := catalogs["opencode"].Models; len(models) != 1 || models[0].Name != "Qwen3.7 Plus" || models[0].Family != "qwen" {
		t.Fatalf("OpenCode models = %+v", models)
	}
	if !catalogs["codex"].CustomModel || len(catalogs["codex"].Efforts) == 0 {
		t.Fatalf("built-in Codex options disappeared: %+v", catalogs["codex"])
	}
	other, _ := assistant.repo.UserByLoginName("workbench-owner")
	c, rec = workbenchContext(other, "GET", "/api/executor-models", bytes.NewBuffer(nil))
	handler.executorModels(c)
	if rec.Code != http.StatusOK || strings.Contains(rec.Body.String(), "gateway/second") || !strings.Contains(rec.Body.String(), "gpt-6.1-sol") {
		t.Fatalf("other user did not receive built-in models: %d %s", rec.Code, rec.Body)
	}
}