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.

15.1 KB
Raw Blame
package httpapi

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"

	"agentflow/internal/domain"
	"agentflow/internal/repo"
)

func TestClarifyAllowedModelFallsBackToCatalog(t *testing.T) {
	t.Setenv("AGENTFLOW_ASSISTANT_MODELS", "public-model")
	if got := clarifyAllowedModel(""); got != clarifyDefaultModel {
		t.Fatalf("empty model = %q", got)
	}
	if got := clarifyAllowedModel("not-a-model"); got != clarifyDefaultModel {
		t.Fatalf("unknown model = %q", got)
	}
	if got := clarifyAllowedModel("public-model"); got != "public-model" {
		t.Fatalf("listed model = %q", got)
	}
}

func TestClarifyCommandKeepsReadGrepGlob(t *testing.T) {
	command, err := prepareClarifyCommand("codebuddy", clarifyDefaultModel, "prompt", "clarify-test", "af1", false)
	if err != nil {
		t.Fatal(err)
	}
	foundSession, foundResume, foundNoPersist := false, false, false
	for i, arg := range command.Argv {
		if arg == "--tools" && i+1 < len(command.Argv) {
			tools := command.Argv[i+1]
			if tools != "" && tools != "default" {
				t.Fatalf("--tools %q hides MCP", tools)
			}
		}
		if arg == "--session-id" && i+1 < len(command.Argv) && command.Argv[i+1] == "af1" {
			foundSession = true
		}
		if arg == "--resume" {
			foundResume = true
		}
		if arg == "--no-session-persistence" {
			foundNoPersist = true
		}
		if arg == "--model" && i+1 < len(command.Argv) && command.Argv[i+1] != clarifyDefaultModel {
			t.Fatalf("model = %q", command.Argv[i+1])
		}
	}
	if !foundSession {
		t.Fatalf("missing --session-id af1: %v", command.Argv)
	}
	if foundResume {
		t.Fatalf("first turn should not --resume: %v", command.Argv)
	}
	if foundNoPersist {
		t.Fatalf("session persistence should stay enabled: %v", command.Argv)
	}
}

func TestPrepareClarifyCommandSubmitOnlyDisallowsRead(t *testing.T) {
	command, err := prepareClarifyCommandWith(clarifyCommandOpts{
		Bin: "codebuddy", Model: clarifyDefaultModel, Prompt: "submit", RunID: "clarify-test", SessionID: "af1",
		Native: true, SubmitOnly: true,
	})
	if err != nil {
		t.Fatal(err)
	}
	denied, ok := argvFlagValue(command.Argv, "--disallowedTools")
	if !ok || !strings.Contains(denied, "Read") || !strings.Contains(denied, "Grep") {
		t.Fatalf("submit-only must deny Read/Grep: %q argv=%v", denied, command.Argv)
	}
}

func TestPrepareClarifyCommandResumeUsesResumeFlag(t *testing.T) {
	command, err := prepareClarifyCommand("codebuddy", clarifyDefaultModel, "继续", "clarify-test", "af1", true)
	if err != nil {
		t.Fatal(err)
	}
	foundResume, foundSession := false, false
	for i, arg := range command.Argv {
		if arg == "--resume" && i+1 < len(command.Argv) && command.Argv[i+1] == "af1" {
			foundResume = true
		}
		if arg == "--session-id" {
			foundSession = true
		}
		if arg == "--no-session-persistence" {
			t.Fatalf("resume turn still has --no-session-persistence: %v", command.Argv)
		}
	}
	if !foundResume {
		t.Fatalf("missing --resume af1: %v", command.Argv)
	}
	if foundSession {
		t.Fatalf("resume turn should not also pass --session-id: %v", command.Argv)
	}
}

func TestStripClarifyMCPCalls(t *testing.T) {
	parsed := map[string]any{
		"summary": "need comments",
		"mcpCalls": []any{
			map[string]any{"server": "tapd-p", "tool": "comments_get", "arguments": map[string]any{"workspace_id": "101"}},
		},
	}
	stripped := stripClarifyMCPCalls(parsed).(map[string]any)
	if _, ok := stripped["mcpCalls"]; ok {
		t.Fatal("mcpCalls should be stripped")
	}
	if stripped["summary"] != "need comments" {
		t.Fatalf("summary=%v", stripped["summary"])
	}
}

func TestWrapClarifyTAPDCallKeepsLongIDs(t *testing.T) {
	const storyID = "1010000000100001332"
	got := wrapClarifyTAPDCall(assistantMCPCall{
		Server: "tapd-p",
		Tool:   "stories_get",
		Arguments: map[string]any{
			"workspace_id": json.Number("10000000"),
			"id":           json.Number(storyID),
		},
	})
	args, _ := got.Arguments["tool_args"].(map[string]any)
	if fmt.Sprint(args["id"]) != storyID {
		t.Fatalf("id=%v want %s (float64 would truncate to ...100)", args["id"], storyID)
	}
	if fmt.Sprint(args["workspace_id"]) != "10000000" {
		t.Fatalf("workspace_id=%v", args["workspace_id"])
	}
}

func TestWrapClarifyTAPDCallUsesProxy(t *testing.T) {
	got := wrapClarifyTAPDCall(assistantMCPCall{Server: "tapd-p", Tool: "comments_list", Arguments: map[string]any{"workspace_id": "101", "entry_type": "story", "entry_id": "202"}})
	if got.Tool != "proxy_execute_tool" {
		t.Fatalf("tool=%q", got.Tool)
	}
	if got.Arguments["tool_name"] != "comments_get" {
		t.Fatalf("inner tool=%v", got.Arguments["tool_name"])
	}
	args, _ := got.Arguments["tool_args"].(map[string]any)
	if args["entry_id"] != "202" {
		t.Fatalf("tool_args=%v", got.Arguments["tool_args"])
	}
	if _, ok := got.Arguments["params"]; ok {
		t.Fatalf("params leaked: %v", got.Arguments)
	}
}

func TestWrapClarifyTAPDCallRewritesParamsToToolArgs(t *testing.T) {
	const storyID = "1010000000100001332"
	got := wrapClarifyTAPDCall(assistantMCPCall{
		Server: "tapd-p",
		Tool:   "proxy_execute_tool",
		Arguments: map[string]any{
			"tool_name": "stories_get",
			"params":    map[string]any{"workspace_id": json.Number("10000000"), "id": json.Number(storyID), "limit": 1},
		},
	})
	if got.Tool != "proxy_execute_tool" {
		t.Fatalf("tool=%q", got.Tool)
	}
	if _, ok := got.Arguments["params"]; ok {
		t.Fatalf("params should be rewritten: %v", got.Arguments)
	}
	args, _ := got.Arguments["tool_args"].(map[string]any)
	if fmt.Sprint(args["id"]) != storyID || fmt.Sprint(args["workspace_id"]) != "10000000" {
		t.Fatalf("tool_args=%v", args)
	}
}

func TestClarifyMCPRejectsWrites(t *testing.T) {
	if !clarifyMCPCallWrite("tapd", wrapClarifyTAPDCall(assistantMCPCall{Tool: "comments_create", Arguments: map[string]any{"description": "x"}})) {
		t.Fatal("comments_create must be blocked")
	}
	if clarifyMCPCallWrite("tapd", wrapClarifyTAPDCall(assistantMCPCall{Tool: "comments_get", Arguments: map[string]any{"entry_id": "1"}})) {
		t.Fatal("comments_get must stay allowed")
	}
	if !clarifyMCPWriteName("saveDocument") || !clarifyMCPWriteName("create_issue_note") {
		t.Fatal("wiki/gongfeng writes must be blocked")
	}
}

func TestHydrateClarifyIssueFromDraftText(t *testing.T) {
	tapd := domain.Issue{Title: "x", Description: "见 https://tapd.example.com/tapd_fe/10000000/story/detail/1010000000100000555"}
	hydrateClarifyIssueFromText(&tapd)
	if tapd.Source != "tapd" || tapd.ExternalRef == nil || tapd.ExternalRef.ExternalID != "1010000000100000555" {
		t.Fatalf("tapd hydrate=%+v ref=%+v", tapd.Source, tapd.ExternalRef)
	}
	gf := domain.Issue{Title: "x", Description: "见 https://git.example.com/gslb/gslbweb/-/issues/18"}
	hydrateClarifyIssueFromText(&gf)
	if gf.Source != "gongfeng" || gf.ExternalRef == nil || gf.ExternalRef.ExternalIID != 18 {
		t.Fatalf("gongfeng hydrate=%+v ref=%+v", gf.Source, gf.ExternalRef)
	}
	if path := gongfengProjectPathFromClarifyURL(gf.ExternalRef.ExternalURL); path != "gslb/gslbweb" {
		t.Fatalf("gongfeng path=%q", path)
	}
}

func TestClarifyMCPInstructionsRequireTAPDComments(t *testing.T) {
	st, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(st.Close)
	user, ok := st.UserByLoginName("demo-owner")
	if !ok {
		t.Fatal("seed user")
	}
	if err := st.PutMCPServer(domain.MCPServerDefinition{ID: "mcp-70-project-platform", Name: "TAPD MCP", ProjectID: "platform", MarketID: "70", Scope: "project", Transport: "http", URL: "https://example.test/tapd"}); err != nil {
		t.Fatal(err)
	}
	if err := st.PutMCPServer(domain.MCPServerDefinition{ID: "mcp-wiki-project-platform", Name: "Wiki", ProjectID: "platform", MarketID: "58", Scope: "project", Transport: "http", URL: "https://example.test/wiki"}); err != nil {
		t.Fatal(err)
	}
	h := &streamHandlers{deps: &deps{repo: st}}
	issue := domain.Issue{
		ProjectID: "platform", Source: "tapd", Title: "读评论",
		Description: "方案见 https://wiki.example.com/pages/viewpage.action?pageId=999001",
		ExternalRef: &domain.ExternalRef{Source: "tapd", ExternalID: "1010000000100000555", ExternalType: "story", ExternalURL: "https://tapd.example.com/tapd_fe/10000000/story/detail/1010000000100000555"},
	}
	prompt := h.clarifyMCPInstructions(issue, user, false)
	for _, want := range []string{"submit_clarification", "tapd__proxy_execute_tool", "comments_get", "stories_get", "Wiki(id=mcp-wiki-project-platform", "其他已安装的 HTTP MCP"} {
		if !strings.Contains(prompt, want) {
			t.Fatalf("prompt missing %q:\n%s", want, prompt)
		}
	}
	if strings.Contains(prompt, "getDocument") || strings.Contains(prompt, "docid=") {
		t.Fatalf("a generic wiki MCP must not get vendor-specific document instructions:\n%s", prompt)
	}
	if strings.Contains(prompt, "mcpCalls") {
		t.Fatalf("clarify instructions still mention mcpCalls:\n%s", prompt)
	}
	empty := h.clarifyMCPInstructions(domain.Issue{ProjectID: "platform", Source: "local", Title: "x"}, user, false)
	if strings.Contains(empty, "comments_get") {
		t.Fatalf("local issue should not require TAPD comments:\n%s", empty)
	}
	draft := domain.Issue{ProjectID: "platform", Title: "新建", Description: "参考 https://tapd.example.com/tapd_fe/10000000/story/detail/1010000000100000555"}
	hydrateClarifyIssueFromText(&draft)
	draftPrompt := h.clarifyMCPInstructions(draft, user, false)
	for _, want := range []string{"stories_get", "comments_get", "1010000000100000555"} {
		if !strings.Contains(draftPrompt, want) {
			t.Fatalf("draft with TAPD URL missing %q:\n%s", want, draftPrompt)
		}
	}
	plainDraft := h.clarifyMCPInstructions(domain.Issue{ProjectID: "platform", Title: "纯新建"}, user, false)
	if !strings.Contains(plainDraft, "尚未建单的需求草稿") || strings.Contains(plainDraft, "先静默读取原单和评论") {
		t.Fatalf("plain draft should not force TAPD fetch:\n%s", plainDraft)
	}
	resumed := h.clarifyMCPInstructions(issue, user, true)
	if strings.Contains(resumed, "先静默读取原单和评论") {
		t.Fatalf("resumed clarify should not re-read TAPD:\n%s", resumed)
	}
	if !strings.Contains(resumed, "不要再重拉原单和评论") {
		t.Fatalf("resumed clarify missing skip hint:\n%s", resumed)
	}
	native := h.clarifyMCPInstructionsFor(issue, user, false)
	if strings.Contains(native, "mcpCalls") || strings.Contains(native, "不要输出 JSON") || strings.Contains(native, `{"tool_name"`) {
		t.Fatalf("native MCP instructions still mention JSON protocol:\n%s", native)
	}
	if !strings.Contains(native, "submit_clarification") || !strings.Contains(native, "tapd__proxy_execute_tool") {
		t.Fatalf("native MCP instructions missing tools:\n%s", native)
	}
}

func TestClarifyMCPInstructionsReadTAPDTask(t *testing.T) {
	st, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(st.Close)
	user, _ := st.UserByLoginName("demo-owner")
	if err := st.PutMCPServer(domain.MCPServerDefinition{ID: "tapd-task", Name: "TAPD MCP", ProjectID: "platform", MarketID: "70", Scope: "project", Transport: "http", URL: "https://example.test/tapd"}); err != nil {
		t.Fatal(err)
	}
	issue := domain.Issue{ProjectID: "platform", Source: "tapd", ExternalRef: &domain.ExternalRef{
		Source: "tapd", ExternalID: "1010000000100001332", ExternalType: "task",
		ExternalURL: "https://tapd.example.com/tapd_fe/10000000/task/detail/1010000000100001332",
	}}
	h := &streamHandlers{deps: &deps{repo: st}}
	prompt := h.clarifyMCPInstructions(issue, user, false)
	for _, want := range []string{"tool_name=tasks_get", "tool_args.entry_type=task", "tool_args.entry_id=1010000000100001332", "tool_args.workspace_id=10000000"} {
		if !strings.Contains(prompt, want) {
			t.Fatalf("task prompt missing %q: %s", want, prompt)
		}
	}
	if strings.Contains(prompt, "tool_name=stories_get") || strings.Contains(prompt, "tool_name=bugs_get") {
		t.Fatalf("task prompt uses another entity's getter: %s", prompt)
	}
	call := wrapClarifyTAPDCall(assistantMCPCall{Tool: "tasks_list", Arguments: map[string]any{
		"workspace_id": json.Number("10000000"), "id": json.Number("1010000000100001332"),
	}})
	args, _ := call.Arguments["tool_args"].(map[string]any)
	if call.Tool != "proxy_execute_tool" || call.Arguments["tool_name"] != "tasks_get" || args["id"] != "1010000000100001332" {
		t.Fatalf("task call must use tasks_get and string IDs: %+v", call)
	}
	if !clarifyMCPWriteName("tasks_update") {
		t.Fatal("task updates must remain blocked in read-only clarification")
	}
}

func TestClarifyMCPInstructionsRequireGongfengIssue(t *testing.T) {
	st, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(st.Close)
	user, ok := st.UserByLoginName("demo-owner")
	if !ok {
		t.Fatal("seed user")
	}
	if err := st.PutMCPServer(domain.MCPServerDefinition{ID: "mcp-61-project-platform", Name: "Gongfeng MCP", ProjectID: "platform", MarketID: "61", Scope: "project", Transport: "http", URL: "https://example.test/gf"}); err != nil {
		t.Fatal(err)
	}
	if err := st.PutRepository(domain.Repository{ID: "repo-gf", ProjectID: "platform", Name: "svc", GongfengProjectID: "dns/svc"}); err != nil {
		t.Fatal(err)
	}
	h := &streamHandlers{deps: &deps{repo: st}}
	issue := domain.Issue{
		ProjectID: "platform", Source: "gongfeng", Kind: "issue", RepositoryID: "repo-gf",
		ExternalRef: &domain.ExternalRef{Source: "gongfeng", ExternalID: "88", ExternalIID: 12, ExternalType: "issue"},
	}
	prompt := h.clarifyMCPInstructions(issue, user, false)
	for _, want := range []string{"get_issue_detail", "get_issue_notes", "dns/svc", "issue_iid=12", "issue_id=88"} {
		if !strings.Contains(prompt, want) {
			t.Fatalf("prompt missing %q:\n%s", want, prompt)
		}
	}
}

func TestDispatchClarifyMCPCallReadOnlyTAPD(t *testing.T) {
	st, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(st.Close)
	user, ok := st.UserByLoginName("demo-owner")
	if !ok {
		t.Fatal("seed user")
	}
	var tools []string
	gateway := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		body, _ := io.ReadAll(r.Body)
		var req struct {
			Method string `json:"method"`
			Params struct {
				Name string         `json:"name"`
				Args map[string]any `json:"arguments"`
			} `json:"params"`
		}
		_ = json.Unmarshal(body, &req)
		w.Header().Set("Content-Type", "application/json")
		switch req.Method {
		case "tools/call":
			tools = append(tools, req.Params.Name)
			inner, _ := req.Params.Args["tool_name"].(string)
			_, _ = w.Write([]byte(`{"jsonrpc":"2.0","id":1,"result":{"content":[{"type":"text","text":"ok ` + inner + `"}]}}`))
		default:
			_, _ = w.Write([]byte(`{"jsonrpc":"2.0","id":1,"result":{}}`))
		}
	}))
	t.Cleanup(gateway.Close)
	if err := st.PutMCPServer(domain.MCPServerDefinition{ID: "tapd-p", Name: "TAPD", ProjectID: "platform", MarketID: "70", Scope: "project", Transport: "http", URL: gateway.URL}); err != nil {
		t.Fatal(err)
	}
	h := &streamHandlers{deps: &deps{repo: st}}
	asst := &assistantHandlers{deps: h.deps}
	got, err := h.dispatchClarifyMCPCall(asst, user, "platform", assistantMCPCall{
		Server: "tapd-p", Tool: "comments_get", Arguments: map[string]any{"workspace_id": "101", "entry_type": "story", "entry_id": "202"},
	}, nil)
	if err != nil || !strings.Contains(got, "ok comments_get") {
		t.Fatalf("read call: %q %v tools=%v", got, err, tools)
	}
	if _, err := h.dispatchClarifyMCPCall(asst, user, "platform", assistantMCPCall{
		Server: "tapd-p", Tool: "comments_create", Arguments: map[string]any{"description": "nope"},
	}, nil); err == nil || !strings.Contains(err.Error(), "只读") {
		t.Fatalf("write should be rejected: %v", err)
	}
}