feat(browser): browser/evaluate connector — completes declarative action set

Author: Michael McNees

packages/engine/internal/connector/browser_declarative.go

@@ -221,6 +221,37 @@ func (c *BrowserNavigateConnector) Execute(ctx context.Context, params map[strin
 	return out, nil
 }
 
+// BrowserEvaluateConnector implements browser/evaluate.
+type BrowserEvaluateConnector struct{}
+
+func (c *BrowserEvaluateConnector) Execute(ctx context.Context, params map[string]any) (map[string]any, error) {
+	expression, _ := params["expression"].(string)
+	if strings.TrimSpace(expression) == "" {
+		return nil, fmt.Errorf("browser/evaluate: expression is required")
+	}
+	session, err := extractSession(params)
+	if err != nil {
+		return nil, fmt.Errorf("browser/evaluate: %w", err)
+	}
+	// expression is embedded verbatim as a JS expression — callers are responsible for valid JS.
+	snippet := fmt.Sprintf("actionData.result = await page.evaluate(() => { return (%s); });\n", expression)
+	script, err := buildDeclarativeScript(snippet, session, extractTimeoutMs(params), false)
+	if err != nil {
+		return nil, fmt.Errorf("browser/evaluate: %w", err)
+	}
+	envelope, err := executeBrowserScript(ctx, script, params)
+	if err != nil {
+		return nil, fmt.Errorf("browser/evaluate: %w", err)
+	}
+	out := map[string]any{"session_state": envelope["session_state"]}
+	if data, ok := envelope["data"].(map[string]any); ok {
+		if v, ok := data["result"]; ok {
+			out["result"] = v
+		}
+	}
+	return out, nil
+}
+
 // BrowserWaitConnector implements browser/wait.
 // Exactly one of selector, url_pattern, or duration_ms must be provided.
 type BrowserWaitConnector struct{}

packages/engine/internal/connector/browser_declarative_test.go

@@ -431,3 +431,49 @@ func TestBrowserWait_InvalidSession(t *testing.T) {
 		t.Fatal("expected error for invalid session_state")
 	}
 }
+
+func TestBrowserEvaluate_MissingExpression(t *testing.T) {
+	c := &BrowserEvaluateConnector{}
+	_, err := c.Execute(context.Background(), map[string]any{})
+	if err == nil {
+		t.Fatal("expected error for missing expression")
+	}
+	if !strings.Contains(err.Error(), "expression is required") {
+		t.Errorf("error = %q, want 'expression is required'", err)
+	}
+}
+
+func TestBrowserEvaluate_EmptyExpression(t *testing.T) {
+	c := &BrowserEvaluateConnector{}
+	_, err := c.Execute(context.Background(), map[string]any{
+		"expression": "   ",
+	})
+	if err == nil {
+		t.Fatal("expected error for blank expression")
+	}
+}
+
+func TestBrowserEvaluate_InvalidSession(t *testing.T) {
+	c := &BrowserEvaluateConnector{}
+	_, err := c.Execute(context.Background(), map[string]any{
+		"expression":    "document.title",
+		"session_state": false,
+	})
+	if err == nil {
+		t.Fatal("expected error for invalid session_state")
+	}
+}
+
+func TestBrowserEvaluate_ScriptContainsExpression(t *testing.T) {
+	snippet := "actionData.result = await page.evaluate(() => { return (document.title); });\n"
+	script, err := buildDeclarativeScript(snippet, nil, 30000, false)
+	if err != nil {
+		t.Fatalf("buildDeclarativeScript: %v", err)
+	}
+	if !strings.Contains(script, "document.title") {
+		t.Error("script should contain the expression")
+	}
+	if !strings.Contains(script, "page.evaluate") {
+		t.Error("script should use page.evaluate")
+	}
+}

packages/engine/internal/connector/connector.go

@@ -46,6 +46,7 @@ func NewRegistry() *Registry {
 	r.Register("browser/extract", &BrowserExtractConnector{})
 	r.Register("browser/screenshot", &BrowserScreenshotConnector{})
 	r.Register("browser/wait", &BrowserWaitConnector{})
+	r.Register("browser/evaluate", &BrowserEvaluateConnector{})
 	r.Register("github/create_issue", &GitHubCreateIssueConnector{})
 	r.Register("github/dispatch", &GitHubDispatchConnector{})
 	r.Register("github/dispatch_workflow", &GitHubDispatchWorkflowConnector{})