kandev/apps/backend/internal/agentctl/server/api/mcp_mode_test.go

package api

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"reflect"
	"testing"

	"github.com/kandev/kandev/internal/agentctl/server/config"
	"github.com/kandev/kandev/internal/agentctl/server/process"
	"github.com/kandev/kandev/internal/common/mcpmode"
	"github.com/kandev/kandev/internal/mcp/plugintools"
	mcpserver "github.com/kandev/kandev/internal/mcp/server"
)

func newTestServerWithMCP(t *testing.T) *Server {
	t.Helper()
	log := newTestLogger()
	cfg := &config.InstanceConfig{
		Port:    0,
		WorkDir: "/tmp/test",
	}
	procMgr := process.NewManager(cfg, log)
	backend := mcpserver.NewChannelBackendClient(log)
	t.Cleanup(backend.Close)
	mcpServer := mcpserver.New(backend, "test-session", "test-task", 0, log, "", false, mcpserver.ModeTask)
	return NewServer(cfg, procMgr, mcpServer, nil, log)
}

func setMcpMode(t *testing.T, s *Server, mode string) *httptest.ResponseRecorder {
	t.Helper()
	body, err := json.Marshal(map[string]string{"mode": mode})
	if err != nil {
		t.Fatalf("marshal request: %v", err)
	}
	rec := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodPut, "/api/v1/mcp/mode", bytes.NewReader(body))
	req.Header.Set("Content-Type", "application/json")
	s.router.ServeHTTP(rec, req)
	return rec
}

func setMcpProviders(t *testing.T, s *Server, providers []string) *httptest.ResponseRecorder {
	t.Helper()
	body, err := json.Marshal(map[string][]string{"mcp_providers": providers})
	if err != nil {
		t.Fatalf("marshal request: %v", err)
	}
	rec := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodPut, "/api/v1/mcp/providers", bytes.NewReader(body))
	req.Header.Set("Content-Type", "application/json")
	s.router.ServeHTTP(rec, req)
	return rec
}

func TestHandleSetMcpMode_AcceptsSupportedModes(t *testing.T) {
	s := newTestServerWithMCP(t)

	for _, mode := range mcpmode.InstanceModes() {
		t.Run(mode, func(t *testing.T) {
			rec := setMcpMode(t, s, mode)
			if rec.Code != http.StatusOK {
				t.Fatalf("status = %d, want %d; body=%s", rec.Code, http.StatusOK, rec.Body.String())
			}

			var body struct {
				Mode string `json:"mode"`
			}
			if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
				t.Fatalf("unmarshal response: %v", err)
			}
			if body.Mode != mode {
				t.Fatalf("mode = %q, want %q", body.Mode, mode)
			}
		})
	}
}

// orchestratorEmittableModes is every non-default value the backend's
// orchestrator/executor resolveTaskSessionMCPMode can put on this route. The
// values come from the shared wire contract. The producer half of the pin is
// executor.TestMcpModeConstants_MatchTheAgentctlWireValues.
//
// handleSetMcpMode and that resolver are two allowlists over one field.
// v0.92.1 taught the resolver "automation" and left this one alone; the
// existing-workspace launch path calls SetMcpMode before starting the agent,
// so every automation-origin task failed with HTTP 400 at launch.
var orchestratorEmittableModes = []string{
	mcpmode.Config, mcpmode.Office, mcpmode.TaskTitlePending, mcpmode.Automation,
}

func TestHandleSetMcpMode_AcceptsEveryModeTheOrchestratorCanEmit(t *testing.T) {
	s := newTestServerWithMCP(t)

	for _, mode := range orchestratorEmittableModes {
		t.Run(mode, func(t *testing.T) {
			if rec := setMcpMode(t, s, mode); rec.Code != http.StatusOK {
				t.Fatalf("mode %q: status = %d, want %d; body=%s", mode, rec.Code, http.StatusOK, rec.Body.String())
			}
		})
	}
}

func TestHandleSetMcpMode_RejectsUnsupportedMode(t *testing.T) {
	s := newTestServerWithMCP(t)

	rec := setMcpMode(t, s, mcpserver.ModeExternal)
	if rec.Code != http.StatusBadRequest {
		t.Fatalf("status = %d, want %d; body=%s", rec.Code, http.StatusBadRequest, rec.Body.String())
	}
}

func TestHandleSetMcpProviders_NormalizesAndPreservesMode(t *testing.T) {
	log := newTestLogger()
	cfg := &config.InstanceConfig{Port: 0, WorkDir: "/tmp/test"}
	procMgr := process.NewManager(cfg, log)
	backend := mcpserver.NewChannelBackendClient(log)
	t.Cleanup(backend.Close)
	mcpServer := mcpserver.New(backend, "test-session", "test-task", 0, log, "", false, mcpserver.ModeTaskTitlePending, []string{"github"})
	s := NewServer(cfg, procMgr, mcpServer, nil, log)

	rec := setMcpProviders(t, s, []string{" GITLAB ", "unsupported", "gitlab"})
	if rec.Code != http.StatusOK {
		t.Fatalf("status = %d, want %d; body=%s", rec.Code, http.StatusOK, rec.Body.String())
	}

	var body struct {
		Providers []string `json:"mcp_providers"`
	}
	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
		t.Fatalf("unmarshal response: %v", err)
	}
	if got, want := body.Providers, []string{"gitlab"}; !reflect.DeepEqual(got, want) {
		t.Fatalf("providers = %v, want %v", got, want)
	}
}

func TestHandleSetPluginToolsReplacesLiveCatalog(t *testing.T) {
	s := newTestServerWithMCP(t)
	definition := plugintools.Definition{
		PluginID: "echo", LocalName: "echo", ExposedName: plugintools.ExposedName("echo", "echo"),
		Description: "Echo", Surfaces: []string{plugintools.SurfaceKanban},
		InputSchema: []byte(`{"type":"object"}`),
	}
	body, err := json.Marshal(plugintools.Snapshot{Generation: "g", Revision: 1, Tools: []plugintools.Definition{definition}})
	if err != nil {
		t.Fatal(err)
	}
	rec := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodPut, "/api/v1/mcp/plugin-tools", bytes.NewReader(body))
	req.Header.Set("Content-Type", "application/json")
	s.router.ServeHTTP(rec, req)
	if rec.Code != http.StatusOK {
		t.Fatalf("status = %d, body = %s", rec.Code, rec.Body.String())
	}
	var response struct {
		Generation string `json:"generation"`
		Revision   uint64 `json:"revision"`
	}
	if err := json.Unmarshal(rec.Body.Bytes(), &response); err != nil {
		t.Fatal(err)
	}
	if response.Generation != "g" || response.Revision != 1 {
		t.Fatalf("response = %#v", response)
	}
}