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.

10.2 KB
Raw Blame
package runtime

import (
	"context"
	"encoding/json"
	"io"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	goruntime "runtime"
	"strings"
	"testing"

	"agentflow/internal/domain"
)

func TestMain(m *testing.M) {
	if RunMCPCallCLI(os.Args[1:]) || RunGitHelperCLI(os.Args[1:]) {
		return
	}
	os.Exit(m.Run())
}

func TestMCPCallAliasesMatchURLAndInstallID(t *testing.T) {
	server := mcpCallServer{
		ID:       "mcp-2214-project-dns",
		Name:     "Config Center MCP",
		MarketID: "2214",
		URL:      "https://mcp-gateway.example.com/configcenter",
		Aliases: mcpCallAliases(domain.MCPServerDefinition{
			ID: "mcp-2214-project-dns", Name: "Config Center MCP", MarketID: "2214", URL: "https://mcp-gateway.example.com/configcenter",
		}),
	}
	got, err := matchMCPCallServer([]mcpCallServer{server}, "configcenter")
	if err != nil || got.ID != server.ID {
		t.Fatalf("configcenter = %+v err=%v aliases=%v", got, err, server.Aliases)
	}
	got, err = matchMCPCallServer([]mcpCallServer{server}, "2214")
	if err != nil || got.ID != server.ID {
		t.Fatalf("2214 = %+v err=%v", got, err)
	}
}

func TestMCPCallCLIInvokesBoundHTTPServer(t *testing.T) {
	gateway := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Header.Get("Authorization") != "Bearer mcp-token" {
			http.Error(w, "unauthorized", http.StatusUnauthorized)
			return
		}
		var req struct {
			ID     int64  `json:"id"`
			Method string `json:"method"`
		}
		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
			t.Fatal(err)
		}
		w.Header().Set("Content-Type", "application/json")
		switch req.Method {
		case "initialize":
			w.Write([]byte(`{"jsonrpc":"2.0","id":1,"result":{}}`))
		case "notifications/initialized":
			w.WriteHeader(http.StatusAccepted)
		case "tools/call":
			w.Write([]byte(`{"jsonrpc":"2.0","id":2,"result":{"content":[{"type":"text","text":"env-ok"}]}}`))
		default:
			t.Fatalf("method %s", req.Method)
		}
	}))
	t.Cleanup(gateway.Close)

	workspace := t.TempDir()
	sb := &localSandbox{workspace: workspace}
	assets := domain.AgentAssetBundle{MCPServers: []domain.MCPServerDefinition{{
		ID: "mcp-2214-project-dns", Name: "Config Center MCP", MarketID: "2214", Transport: "http",
		URL: gateway.URL, Headers: map[string]string{"Authorization": "Bearer mcp-token"},
	}}}
	env, err := ScriptMCPEnvironment(sb, workspace, assets.MCPServers)
	if err != nil {
		t.Fatal(err)
	}
	for key, value := range env {
		t.Setenv(key, value)
	}
	stdout, stderr, code := captureMCPCall(t, []string{"call", "2214", "get_config", `{"group":"demodns_intl.demodns_api"}`})
	if code != 0 {
		t.Fatalf("exit %d stderr=%q stdout=%q", code, stderr, stdout)
	}
	if strings.TrimSpace(stdout) != "env-ok" {
		t.Fatalf("stdout = %q", stdout)
	}
}

func TestMCPCallRequiresPersonalCredentialAtCallTime(t *testing.T) {
	workspace := t.TempDir()
	sb := &localSandbox{workspace: workspace}
	assets, err := BindGitHubMCPHeaders(domain.AgentAssetBundle{MCPServers: []domain.MCPServerDefinition{{
		ID: "github", Name: "GitHub", Transport: "http", URL: "https://api.githubcopilot.com/mcp/", AuthType: "github-token",
	}}}, "", false)
	if err != nil {
		t.Fatal(err)
	}
	env, err := ScriptMCPEnvironment(sb, workspace, assets.MCPServers)
	if err != nil {
		t.Fatal(err)
	}
	for key, value := range env {
		t.Setenv(key, value)
	}
	_, stderr, code := captureMCPCall(t, []string{"call", "github", "search"})
	if code != 1 || !strings.Contains(stderr, "需要 GitHub Git Token") {
		t.Fatalf("exit %d stderr = %q", code, stderr)
	}
}

func TestBindMCPWritesWorkspaceBinWithoutPATH(t *testing.T) {
	workspace := t.TempDir()
	sb := &localSandbox{workspace: workspace, environment: map[string]string{"PATH": "/usr/bin"}}
	command := CommandSpec{Argv: []string{"sh", "-lc", "agentflow mcp list"}, CredentialBindings: []CredentialBinding{BindMCP}}
	bound, err := bindCommand(sb, workspace, command, RunCredentials{MCPServers: []domain.MCPServerDefinition{{
		ID: "tapd", Name: "TAPD", Transport: "http", URL: "https://example.com/tapd",
	}}})
	if err != nil {
		t.Fatal(err)
	}
	if _, ok := bound.environment["PATH"]; ok {
		t.Fatalf("local unisolated MCP bind must not rewrite PATH, got %q", bound.environment["PATH"])
	}
	helper := filepath.Join(workspace, ".agentflow", "runtime", "bin", "agentflow")
	if _, err := os.Stat(helper); err != nil {
		t.Fatal(err)
	}
	if bound.environment[mcpCallBinEnv] != helper {
		t.Fatalf("AGENTFLOW_BIN = %q want %q", bound.environment[mcpCallBinEnv], helper)
	}
	if bound.environment[mcpCallConfigEnv] == "" {
		t.Fatal("missing MCP config env")
	}
	if len(bound.Argv) < 3 || !strings.Contains(bound.Argv[2], "agentflow()") {
		t.Fatalf("local shell should define agentflow function, argv=%v", bound.Argv)
	}
	raw, err := os.ReadFile(bound.environment[mcpCallConfigEnv])
	if err != nil {
		t.Fatal(err)
	}
	if strings.Contains(string(raw), "Authorization") && strings.Contains(string(raw), "Bearer") {
		t.Fatal("unbound custom MCP should not carry a personal bearer")
	}
}

func TestDockerMCPCallPointsAtWorkspaceBin(t *testing.T) {
	provideDockerHelperFixture(t)
	workspace := t.TempDir()
	sb := &localSandbox{workspace: workspace, driver: "docker"}
	env, err := ScriptMCPEnvironment(sb, workspace, []domain.MCPServerDefinition{{
		ID: "tapd", Name: "TAPD", Transport: "http", URL: "https://example.com/tapd",
	}})
	if err != nil {
		t.Fatal(err)
	}
	if _, ok := env["PATH"]; ok {
		t.Fatalf("docker MCP env must not set PATH (login shell would replace it with the host PATH), got %q", env["PATH"])
	}
	want := "/workspace/.agentflow/runtime/bin/agentflow"
	if env[mcpCallBinEnv] != want {
		t.Fatalf("AGENTFLOW_BIN = %q want %q", env[mcpCallBinEnv], want)
	}
	if env[mcpCallConfigEnv] != "/workspace/.agentflow/runtime/mcp-servers.json" {
		t.Fatalf("config = %q", env[mcpCallConfigEnv])
	}
	wrapper, err := os.ReadFile(filepath.Join(workspace, ".agentflow", "runtime", "bin", "agentflow"))
	if err != nil {
		t.Fatal(err)
	}
	text := string(wrapper)
	if !strings.Contains(text, "/workspace/.agentflow/runtime/bin/agentflow-helper") {
		t.Fatalf("docker wrapper should exec the workspace helper, got %s", text)
	}
	if strings.Contains(text, "/data/app/skillhub-agent") {
		t.Fatal("docker wrapper must not exec the host platform binary")
	}
	argv := BindMCPCallArgv(sb, []string{"sh", "-lc", "agentflow mcp list"})
	if argv[1] != "-lc" || strings.Contains(argv[2], "agentflow()") {
		t.Fatalf("docker argv is rewritten by dockerWorkspaceExecArgv, BindMCPCallArgv should leave it, got %v", argv)
	}
}

func provideDockerHelperFixture(t *testing.T) {
	t.Helper()
	if goruntime.GOOS == "linux" {
		return
	}
	pattern := filepath.Join(t.TempDir(), "helper-{os}-{arch}")
	path := strings.NewReplacer("{os}", "linux", "{arch}", goruntime.GOARCH).Replace(pattern)
	if err := os.WriteFile(path, []byte("#!/bin/sh\nexit 0\n"), 0o755); err != nil {
		t.Fatal(err)
	}
	t.Setenv("AGENTFLOW_RUNNER_BINARY", pattern)
}

func TestProcessSandboxMCPCallUsesAbsoluteManagedLauncher(t *testing.T) {
	workspace := t.TempDir()
	sb := &localSandbox{workspace: workspace, driver: "bwrap"}
	env, err := PrepareMCPCall(sb, workspace, []domain.MCPServerDefinition{{
		ID: "replace-batch", Name: "Replace Batch", Transport: "stdio", Command: "python3", Args: []string{"server.py"}, FileRefs: []domain.MCPFileRef{{Path: "server.py"}},
	}})
	if err != nil {
		t.Fatal(err)
	}
	raw, err := os.ReadFile(env[mcpCallConfigEnv])
	if err != nil {
		t.Fatal(err)
	}
	var cfg mcpCallConfigFile
	if err := json.Unmarshal(raw, &cfg); err != nil {
		t.Fatal(err)
	}
	want := filepath.Join(workspace, ".agentflow", "mcp-runtime", "replace-batch", "launch")
	if len(cfg.Servers) != 1 || cfg.Servers[0].Command != want || cfg.Servers[0].CWD != "" || len(cfg.Servers[0].Args) != 0 {
		t.Fatalf("managed stdio config = %#v, want command %q", cfg.Servers, want)
	}
}

func captureMCPCall(t *testing.T, args []string) (string, string, int) {
	t.Helper()
	oldOut, oldErr := os.Stdout, os.Stderr
	outR, outW, err := os.Pipe()
	if err != nil {
		t.Fatal(err)
	}
	errR, errW, err := os.Pipe()
	if err != nil {
		t.Fatal(err)
	}
	os.Stdout, os.Stderr = outW, errW
	code := mcpCallMain(args)
	_ = outW.Close()
	_ = errW.Close()
	os.Stdout, os.Stderr = oldOut, oldErr
	stdout, err := io.ReadAll(outR)
	if err != nil {
		t.Fatal(err)
	}
	stderr, err := io.ReadAll(errR)
	if err != nil {
		t.Fatal(err)
	}
	_ = outR.Close()
	_ = errR.Close()
	return string(stdout), string(stderr), code
}

func TestHookScriptCanCallMCP(t *testing.T) {
	workspace := t.TempDir()
	configRoot := filepath.Join(workspace, ".agentflow", "config", "reviewer")
	if err := os.MkdirAll(configRoot, 0o700); err != nil {
		t.Fatal(err)
	}
	hook := domain.AgentHook{ID: "audit", Event: "Stop", Language: "shell", Script: "agentflow mcp list > hook-mcp.json\n"}
	compiled, err := materializeAgentHooks(workspace, configRoot, ".agentflow/reviewer", "codebuddy", []domain.AgentHook{hook})
	if err != nil || len(compiled) != 1 {
		t.Fatalf("compile hook: %v %#v", err, compiled)
	}
	sb := &localSandbox{workspace: workspace}
	command := CommandSpec{Argv: []string{"sh", "-lc", compiled[0].Command}, CredentialBindings: []CredentialBinding{BindMCP}}
	bound, err := bindCommand(sb, workspace, command, RunCredentials{MCPServers: []domain.MCPServerDefinition{{
		ID: "tapd", Name: "TAPD", MarketID: "70", Transport: "http", URL: "https://example.com/tapd",
	}}})
	if err != nil {
		t.Fatal(err)
	}
	if _, err := sb.Exec(context.Background(), bound, nil); err != nil {
		t.Fatalf("hook exec: %v", err)
	}
	raw, err := os.ReadFile(filepath.Join(workspace, "hook-mcp.json"))
	if err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(string(raw), "tapd") {
		t.Fatalf("hook mcp list = %s", raw)
	}
}

func TestMCPCallPreambleDoesNotRewriteProviderOrPythonConfig(t *testing.T) {
	for _, argv := range [][]string{
		{"codex", "exec", "-c", `model_provider="actor_gateway"`, "prompt"},
		{"/usr/bin/python3", "-c", "print('ok')"},
	} {
		got, injected := injectShellPreamble(argv, localMCPCallPreamble)
		if injected || strings.Join(got, "\x00") != strings.Join(argv, "\x00") {
			t.Fatalf("non-shell arguments modified: %v", got)
		}
	}
	got, injected := injectShellPreamble([]string{"/bin/bash", "-lc", "agentflow mcp list"}, localMCPCallPreamble)
	if !injected || !strings.Contains(got[2], "agentflow()") {
		t.Fatal("shell helper was not installed")
	}
}