2779fb24aa
Lay the backend groundwork so the existing mock-agent can run inside local_docker containers — needed for real-Docker E2E tests that don't require Anthropic/OpenAI API keys. Container builder bind-mounts a host mock-agent binary at /usr/local/bin/mock-agent when KANDEV_MOCK_AGENT_LINUX_BINARY is set (or build/mock-agent-linux-amd64 sits next to the kandev binary), the same pattern already used for agentctl. MockAgent.BuildCommand always resolves via PATH so the same command works on host (E2E PATH includes bin/) and in containers (mounted at /usr/local/bin/mock-agent). Mock now declares non-nil empty RemoteAuth so it counts as a remote-capable agent. The remoteauth catalog includes specs even with zero methods, and the frontend gating helper treats an empty-method spec as "no credentials needed" — letting mock-agent pass the configure-on-executor check that hides uncatalogued agents on remote executors. repositoryCloneURL falls back to the local origin remote URL when the repo has no provider info, so local-only repos with a real remote (including file:// remotes used in E2E) work on remote executors that clone inside the container. Makefile: build-mock-agent-linux target mirrors build-agentctl-linux.
134 lines
4.1 KiB
Go
134 lines
4.1 KiB
Go
package agents
|
|
|
|
import (
|
|
"context"
|
|
_ "embed"
|
|
"time"
|
|
|
|
"github.com/kandev/kandev/pkg/agent"
|
|
)
|
|
|
|
//go:embed logos/mock_light.svg
|
|
var mockLogoLight []byte
|
|
|
|
//go:embed logos/mock_dark.svg
|
|
var mockLogoDark []byte
|
|
|
|
var (
|
|
_ Agent = (*MockAgent)(nil)
|
|
_ PassthroughAgent = (*MockAgent)(nil)
|
|
_ InferenceAgent = (*MockAgent)(nil)
|
|
)
|
|
|
|
type MockAgent struct {
|
|
StandardPassthrough
|
|
enabled bool
|
|
binaryPath string
|
|
supportsMCP bool
|
|
}
|
|
|
|
func NewMockAgent() *MockAgent {
|
|
return &MockAgent{
|
|
StandardPassthrough: StandardPassthrough{
|
|
Cfg: PassthroughConfig{
|
|
Supported: true,
|
|
Label: "TUI Passthrough",
|
|
Description: "Terminal UI mode for testing",
|
|
PassthroughCmd: NewCommand("mock-agent", "--tui"),
|
|
ModelFlag: NewParam("--model", "{model}"),
|
|
PromptFlag: NewParam("--prompt", "{prompt}"),
|
|
SessionResumeFlag: NewParam("--resume"),
|
|
ResumeFlag: NewParam("-c"),
|
|
IdleTimeout: 2 * time.Second,
|
|
BufferMaxBytes: DefaultBufferMaxBytes,
|
|
},
|
|
},
|
|
supportsMCP: true,
|
|
}
|
|
}
|
|
|
|
// SetEnabled enables or disables the mock agent at runtime.
|
|
func (a *MockAgent) SetEnabled(enabled bool) { a.enabled = enabled }
|
|
|
|
// SetBinaryPath overrides the mock-agent binary path.
|
|
// Also updates the passthrough command to use the same binary.
|
|
func (a *MockAgent) SetBinaryPath(path string) {
|
|
a.binaryPath = path
|
|
a.Cfg.PassthroughCmd = NewCommand(path, "--tui")
|
|
}
|
|
|
|
// SetSupportsMCP controls whether the mock agent reports MCP support.
|
|
// Defaults to true so plan mode workflow events work in E2E tests.
|
|
func (a *MockAgent) SetSupportsMCP(v bool) { a.supportsMCP = v }
|
|
|
|
// SupportsMCPEnabled reports the current MCP support setting.
|
|
func (a *MockAgent) SupportsMCPEnabled() bool { return a.supportsMCP }
|
|
|
|
func (a *MockAgent) ID() string { return "mock-agent" }
|
|
func (a *MockAgent) Name() string { return "Mock Agent" }
|
|
func (a *MockAgent) DisplayName() string { return "Mock" }
|
|
func (a *MockAgent) Description() string {
|
|
return "Mock agent for testing. Generates simulated responses with all message types."
|
|
}
|
|
func (a *MockAgent) Enabled() bool { return a.enabled }
|
|
func (a *MockAgent) DisplayOrder() int { return 99 }
|
|
|
|
func (a *MockAgent) Logo(v LogoVariant) []byte {
|
|
if v == LogoDark {
|
|
return mockLogoDark
|
|
}
|
|
return mockLogoLight
|
|
}
|
|
|
|
func (a *MockAgent) IsInstalled(ctx context.Context) (*DiscoveryResult, error) {
|
|
// Mock agent is always "available" when enabled (forced by settings controller).
|
|
return &DiscoveryResult{Available: true, SupportsMCP: a.supportsMCP}, nil
|
|
}
|
|
|
|
func (a *MockAgent) BuildCommand(opts CommandOptions) Command {
|
|
// Always resolve via PATH: works on the host (E2E PATH includes the
|
|
// kandev bin dir) and inside Docker containers (mock-agent is
|
|
// bind-mounted at /usr/local/bin/mock-agent for E2E).
|
|
return Cmd("mock-agent").Build()
|
|
}
|
|
|
|
func (a *MockAgent) Runtime() *RuntimeConfig {
|
|
canRecover := true
|
|
return &RuntimeConfig{
|
|
Cmd: Cmd("mock-agent").Build(),
|
|
WorkingDir: "{workspace}",
|
|
Env: map[string]string{},
|
|
ResourceLimits: ResourceLimits{MemoryMB: 512, CPUCores: 0.5, Timeout: time.Hour},
|
|
Protocol: agent.ProtocolACP,
|
|
SessionConfig: SessionConfig{
|
|
CanRecover: &canRecover,
|
|
},
|
|
}
|
|
}
|
|
|
|
// RemoteAuth returns a non-nil empty spec so the mock agent counts as a
|
|
// remote-capable agent (it's runnable inside Docker for E2E tests) but
|
|
// requires no credentials. The empty methods list signals "no auth needed".
|
|
func (a *MockAgent) RemoteAuth() *RemoteAuth { return &RemoteAuth{} }
|
|
|
|
func (a *MockAgent) InstallScript() string { return "" }
|
|
|
|
func (a *MockAgent) PermissionSettings() map[string]PermissionSetting {
|
|
return emptyPermSettings
|
|
}
|
|
|
|
// InferenceConfig enables one-shot inference via ACP. The mock-agent binary
|
|
// advertises its available models in the session/new response, so the host
|
|
// utility capability probe populates them into the cache without any static
|
|
// model list here.
|
|
func (a *MockAgent) InferenceConfig() *InferenceConfig {
|
|
binary := "mock-agent"
|
|
if a.binaryPath != "" {
|
|
binary = a.binaryPath
|
|
}
|
|
return &InferenceConfig{
|
|
Supported: true,
|
|
Command: NewCommand(binary),
|
|
}
|
|
}
|