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.
JavaScript agent-orchestrationagentic-workflowai-agentsai-codingclaude-codecode-reviewcodebuddycodexcoding-agentscursordeveloper-toolshuman-on-the-loopllmmcpmulti-agentsdlcself-hostedsopworkflow-automationworkflow-engine
package runtime
import (
"context"
"encoding/json"
"errors"
"io/fs"
"os"
"path/filepath"
"strings"
"sync"
"testing"
"time"
"agentflow/internal/domain"
)
func TestMaterializeInvocationInjectsBrowserMCP(t *testing.T) {
workspace := t.TempDir()
browser := domain.MCPServerDefinition{ID: BrowserMCPServerID, Name: "Agent 浏览器", Transport: "http", URL: "http://127.0.0.1:8931/mcp"}
compiled, err := materializeInvocation(workspace, "invoke-browser", domain.ExecutorDefinition{Kind: "codebuddy"}, domain.AgentDefinition{ID: "dev", Name: "Dev"}, domain.AgentAssetBundle{}, InvocationOptions{BrowserMCP: &browser})
if err != nil {
t.Fatal(err)
}
raw, err := os.ReadFile(filepath.Join(workspace, filepath.FromSlash(compiled.AgentRoot), "mcp.json"))
if err != nil {
t.Fatal(err)
}
if !strings.Contains(string(raw), BrowserMCPServerID) || !strings.Contains(string(raw), "http://127.0.0.1:8931/mcp") {
t.Fatalf("mcp config missing browser server:\n%s", raw)
}
hinted := false
_ = filepath.WalkDir(workspace, func(path string, d fs.DirEntry, err error) error {
if err == nil && !d.IsDir() {
if body, readErr := os.ReadFile(path); readErr == nil && strings.Contains(string(body), "mcp__"+BrowserMCPServerID+"__") {
hinted = true
}
}
return nil
})
if !hinted {
t.Fatal("agent instructions do not explain the browser MCP")
}
}
func TestBrowserWantedForExecutor(t *testing.T) {
t.Setenv("AGENTFLOW_BROWSER", "")
if BrowserWantedForExecutor("mock") || BrowserWantedForExecutor("codebuddy") {
t.Fatal("default under go test: no executor launches a browser")
}
t.Setenv("AGENTFLOW_BROWSER", "always")
if !BrowserWantedForExecutor("mock") || !BrowserWantedForExecutor("codebuddy") {
t.Fatal("always forces every executor")
}
t.Setenv("AGENTFLOW_BROWSER", "off")
if BrowserWantedForExecutor("codebuddy") {
t.Fatal("off disables browsers")
}
}
type testSandboxWrapper struct {
Sandbox
}
func (w testSandboxWrapper) Unwrap() Sandbox { return w.Sandbox }
func TestEnsureSandboxBrowserUnwrapsAndSkipsUnknownSandboxes(t *testing.T) {
if _, ok := unwrapSandbox(WithSandboxCredentials(&dockerSandbox{id: "x"}, RunCredentials{})).(*dockerSandbox); !ok {
t.Fatal("managed sandbox must unwrap to its docker sandbox")
}
nested := testSandboxWrapper{Sandbox: WithSandboxCredentials(&dockerSandbox{id: "nested"}, RunCredentials{})}
if _, ok := unwrapSandbox(nested).(*dockerSandbox); !ok {
t.Fatal("nested Unwrap wrapper must unwrap to its docker sandbox")
}
var typedNil *managedSandbox
if got := unwrapSandbox(typedNil); got != nil {
t.Fatalf("typed nil managedSandbox unwrapped to %T, want nil", got)
}
sb := &capturingSandbox{workspace: t.TempDir()}
var events []domain.TelemetryEvent
if got := EnsureSandboxBrowser(context.Background(), sb, sb.workspace, "run-1", func(e domain.TelemetryEvent) { events = append(events, e) }); got != nil || len(events) != 0 {
t.Fatalf("unknown sandbox got browser=%v events=%v", got, events)
}
if got := EnsureSandboxBrowser(context.Background(), sb, sb.workspace, "", nil); got != nil {
t.Fatal("a browser needs a run to belong to")
}
}
func TestHandleBrowserReportsMissingBrowser(t *testing.T) {
state, err := HandleBrowser(context.Background(), "no-such-run-"+t.Name(), domain.BrowserRequest{Operation: "status"})
if err != nil || state.Available || !strings.Contains(state.Reason, "尚未启动") {
t.Fatalf("state=%+v err=%v", state, err)
}
}
type fakeCDPTransport struct {
mu sync.Mutex
sent []cdpMessage
replies chan []byte
closed chan struct{}
once sync.Once
// results answers methods with a canned result instead of {}.
results map[string]string
}
func newFakeCDPTransport() *fakeCDPTransport {
return &fakeCDPTransport{replies: make(chan []byte, 64), closed: make(chan struct{})}
}
func (f *fakeCDPTransport) read() ([]byte, error) {
select {
case msg := <-f.replies:
return msg, nil
case <-f.closed:
return nil, errors.New("closed")
}
}
func (f *fakeCDPTransport) write(body []byte) error {
var msg cdpMessage
if err := json.Unmarshal(body, &msg); err != nil {
return err
}
f.mu.Lock()
f.sent = append(f.sent, msg)
f.mu.Unlock()
result := `{}`
if r := f.results[msg.Method]; r != "" {
result = r
}
reply, _ := json.Marshal(cdpMessage{ID: msg.ID, Result: json.RawMessage(result)})
f.replies <- reply
return nil
}
func (f *fakeCDPTransport) close() error {
f.once.Do(func() { close(f.closed) })
return nil
}
func TestBrowserViewInputMapsToCDP(t *testing.T) {
transport := newFakeCDPTransport()
view := &browserView{targets: map[string]*browserTarget{}, changed: make(chan struct{}), session: "page-1", active: "t1", width: 1000, height: 500}
view.client = newCDPClient(transport, view.onEvent)
defer view.client.close()
err := view.input(context.Background(), []domain.BrowserInputEvent{
{Type: "mouse", Action: "down", X: 0.5, Y: 0.25, Button: "left", Buttons: 1, ClickCount: 1},
{Type: "wheel", X: 2, Y: -1, DeltaY: 120},
{Type: "key", Action: "down", Key: "a", Code: "KeyA", KeyCode: 65, Text: "a"},
{Type: "key", Action: "down", Key: "Backspace", Code: "Backspace", KeyCode: 8},
{Type: "text", Text: "你好"},
})
if err != nil {
t.Fatal(err)
}
transport.mu.Lock()
defer transport.mu.Unlock()
// The wheel also switches the screencast to light frames; only input
// events are checked here.
var sent []cdpMessage
for _, msg := range transport.sent {
if strings.HasPrefix(msg.Method, "Input.") {
sent = append(sent, msg)
}
}
if len(sent) != 5 {
t.Fatalf("sent %d input messages: %+v", len(sent), transport.sent)
}
params := func(i int) map[string]any {
var out map[string]any
_ = json.Unmarshal(sent[i].Params, &out)
return out
}
for _, msg := range sent {
if msg.SessionID != "page-1" {
t.Fatalf("input must target the attached page session: %+v", msg)
}
}
if p := params(0); sent[0].Method != "Input.dispatchMouseEvent" || p["type"] != "mousePressed" || p["x"] != 500.0 || p["y"] != 125.0 {
t.Fatalf("mouse: %s %v", transport.sent[0].Method, p)
}
if p := params(1); p["type"] != "mouseWheel" || p["x"] != 1000.0 || p["y"] != 0.0 || p["deltaY"] != 120.0 {
t.Fatalf("wheel coordinates must clamp to the frame: %v", p)
}
if p := params(2); p["type"] != "keyDown" || p["text"] != "a" {
t.Fatalf("printable key: %v", p)
}
if p := params(3); p["type"] != "rawKeyDown" || p["text"] != nil {
t.Fatalf("control key: %v", p)
}
if p := params(4); sent[4].Method != "Input.insertText" || p["text"] != "你好" {
t.Fatalf("text: %s %v", sent[4].Method, p)
}
}
func TestBrowserViewReportsScrollAndContentSize(t *testing.T) {
transport := newFakeCDPTransport()
transport.results = map[string]string{"Page.getLayoutMetrics": `{"cssContentSize":{"width":1000,"height":3200}}`}
view := &browserView{targets: map[string]*browserTarget{}, changed: make(chan struct{}), session: "page-1", active: "t1"}
view.client = newCDPClient(transport, view.onEvent)
defer view.client.close()
frame, _ := json.Marshal(map[string]any{"data": "AAAA", "sessionId": 7, "metadata": map[string]any{"deviceWidth": 1000, "deviceHeight": 800, "scrollOffsetX": 0, "scrollOffsetY": 640}})
view.onEvent(cdpMessage{Method: "Page.screencastFrame", SessionID: "page-1", Params: frame})
deadline := time.Now().Add(2 * time.Second)
for {
state := view.state(0)
if state.ContentHeight == 3200 {
if state.ScrollY != 640 || state.Height != 800 || state.ContentWidth != 1000 {
t.Fatalf("state %+v", state)
}
break
}
if time.Now().After(deadline) {
t.Fatalf("content size never arrived: %+v", state)
}
time.Sleep(10 * time.Millisecond)
}
// A second frame within the refresh interval does not read metrics again.
view.onEvent(cdpMessage{Method: "Page.screencastFrame", SessionID: "page-1", Params: frame})
time.Sleep(50 * time.Millisecond)
transport.mu.Lock()
defer transport.mu.Unlock()
reads := 0
for _, msg := range transport.sent {
if msg.Method == "Page.getLayoutMetrics" {
reads++
}
}
if reads != 1 {
t.Fatalf("layout metric reads: %d", reads)
}
}
func TestBrowserDeviceScale(t *testing.T) {
for raw, want := range map[string]string{"": "2", "1.5": "1.5", "3": "3", "0.5": "2", "x": "2", "4": "2"} {
t.Setenv("AGENTFLOW_BROWSER_SCALE", raw)
if got := BrowserDeviceScale(); got != want {
t.Fatalf("%q: %s", raw, got)
}
}
}
func TestAgentScreenshotsStayInCSSPixels(t *testing.T) {
transport := newFakeCDPTransport()
transport.results = map[string]string{
"Page.getLayoutMetrics": `{"cssVisualViewport":{"pageX":0,"pageY":300,"clientWidth":1280,"clientHeight":800}}`,
"Runtime.evaluate": `{"result":{"value":2}}`,
"Page.captureScreenshot": `{"data":"AAAA"}`,
}
view := &browserView{targets: map[string]*browserTarget{}, changed: make(chan struct{}), session: "page-1", active: "t1"}
view.client = newCDPClient(transport, view.onEvent)
defer view.client.close()
if data, err := view.screenshot(context.Background()); err != nil || data != "AAAA" {
t.Fatalf("data=%q err=%v", data, err)
}
transport.mu.Lock()
defer transport.mu.Unlock()
last := transport.sent[len(transport.sent)-1]
var params struct {
Clip map[string]float64 `json:"clip"`
}
_ = json.Unmarshal(last.Params, ¶ms)
if last.Method != "Page.captureScreenshot" || params.Clip["scale"] != 0.5 || params.Clip["y"] != 300 || params.Clip["width"] != 1280 {
t.Fatalf("%s %s", last.Method, last.Params)
}
}
func TestBrowserViewCapturesLighterFramesWhileScrolling(t *testing.T) {
settle := browserMotionSettle
browserMotionSettle = 60 * time.Millisecond
defer func() { browserMotionSettle = settle }()
transport := newFakeCDPTransport()
view := &browserView{targets: map[string]*browserTarget{}, changed: make(chan struct{}), session: "page-1", active: "t1", width: 1000, height: 500, frameWidth: 1600}
view.client = newCDPClient(transport, view.onEvent)
defer view.client.close()
starts := func() []map[string]any {
transport.mu.Lock()
defer transport.mu.Unlock()
var out []map[string]any
for _, msg := range transport.sent {
if msg.Method == "Page.startScreencast" {
var p map[string]any
_ = json.Unmarshal(msg.Params, &p)
out = append(out, p)
}
}
return out
}
wheel := []domain.BrowserInputEvent{{Type: "wheel", X: 0.5, Y: 0.5, DeltaY: 100}}
ctx := context.Background()
// Hovering and clicking keep sharp frames.
if err := view.input(ctx, []domain.BrowserInputEvent{{Type: "mouse", Action: "move", X: 0.5, Y: 0.5}, {Type: "mouse", Action: "down", X: 0.5, Y: 0.5, Buttons: 1}}); err != nil {
t.Fatal(err)
}
if got := starts(); len(got) != 0 {
t.Fatalf("hover restarted the screencast: %v", got)
}
// A scroll switches to light frames once, however many follow.
for range 3 {
if err := view.input(ctx, wheel); err != nil {
t.Fatal(err)
}
time.Sleep(20 * time.Millisecond)
}
got := starts()
if len(got) != 1 || got[0]["maxWidth"] != 800.0 || got[0]["quality"] != 60.0 {
t.Fatalf("scroll frames: %v", got)
}
// Quiet input returns to sharp frames at the panel width.
deadline := time.Now().Add(2 * time.Second)
for len(starts()) < 2 && time.Now().Before(deadline) {
time.Sleep(10 * time.Millisecond)
}
got = starts()
if len(got) != 2 || got[1]["maxWidth"] != 1600.0 || got[1]["quality"] != 80.0 {
t.Fatalf("settled frames: %v", got)
}
// Dragging counts as motion too.
if err := view.input(ctx, []domain.BrowserInputEvent{{Type: "mouse", Action: "move", X: 0.4, Y: 0.5, Buttons: 1}}); err != nil {
t.Fatal(err)
}
if got := starts(); len(got) != 3 || got[2]["quality"] != 60.0 {
t.Fatalf("drag frames: %v", got)
}
}