Skip to content

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

6.7 KB
Raw Blame
package bridge

import (
	"context"
	"encoding/json"
	"fmt"
	"time"

	"github.com/chromedp/chromedp"
)

const checkableStateJS = `function() {
	var tag = this.tagName ? this.tagName.toLowerCase() : "";
	var type = (this.type || "").toLowerCase();
	if (tag === "input" && (type === "checkbox" || type === "radio")) {
		return {kind: type, state: this.checked ? "true" : "false"};
	}
	var role = (this.getAttribute && this.getAttribute("role") || "").toLowerCase();
	if (role === "checkbox") {
		var aria = (this.getAttribute("aria-checked") || "").toLowerCase();
		if (aria === "true" || aria === "false" || aria === "mixed") {
			return {kind: "aria-checkbox", state: aria};
		}
		return {error: "role=checkbox requires aria-checked=true, false, or mixed"};
	}
	return {error: "element is not a checkbox, radio, or role=checkbox control (got " + tag + "[type=" + type + "][role=" + role + "])"};
}`

type checkableState struct {
	Error string `json:"error"`
	Kind  string `json:"kind"`
	State string `json:"state"`
}

func readCheckableState(ctx context.Context, objectID string) (checkableState, error) {
	var callResult json.RawMessage
	err := chromedp.Run(ctx, chromedp.ActionFunc(func(ctx context.Context) error {
		return chromedp.FromContext(ctx).Target.Execute(ctx, "Runtime.callFunctionOn", map[string]any{
			"functionDeclaration": checkableStateJS,
			"objectId":            objectID,
			"returnByValue":       true,
		}, &callResult)
	}))
	if err != nil {
		return checkableState{}, err
	}
	var response struct {
		Result struct {
			Value json.RawMessage `json:"value"`
		} `json:"result"`
	}
	if err := json.Unmarshal(callResult, &response); err != nil {
		return checkableState{}, err
	}
	var state checkableState
	if err := json.Unmarshal(response.Result.Value, &state); err != nil {
		return checkableState{}, err
	}
	if state.Error != "" {
		return checkableState{}, fmt.Errorf("%s", state.Error)
	}
	return state, nil
}

func (b *Bridge) actionFocus(ctx context.Context, req ActionRequest) (map[string]any, error) {
	if req.Selector != "" {
		return map[string]any{"focused": true}, chromedp.Run(ctx, chromedp.Focus(req.Selector, chromedp.ByQuery))
	}
	if req.NodeID > 0 {
		return map[string]any{"focused": true}, focusBackendNode(ctx, req.NodeID)
	}
	return map[string]any{"focused": true}, nil
}

func (b *Bridge) actionSelect(ctx context.Context, req ActionRequest) (map[string]any, error) {
	val, supplied := SelectValue(req)
	if !supplied {
		return nil, fmt.Errorf(`select requires "value" (or "text"); send "value": "" to select an empty-valued option`)
	}
	// Both paths route through SelectByNodeID so they share its
	// value-then-text match fallback. This lets callers pass either the
	// `<option value="...">` attribute or the option's visible text.
	if req.NodeID > 0 {
		return map[string]any{"selected": val}, SelectByNodeID(ctx, req.NodeID, val)
	}
	if req.Selector != "" {
		node, err := firstNodeBySelector(ctx, req.Selector)
		if err != nil {
			return nil, err
		}
		return map[string]any{"selected": val}, SelectByNodeID(ctx, int64(node.BackendNodeID), val)
	}
	return nil, NewInvalidActionRequestError("need selector or ref")
}

func (b *Bridge) actionCheck(ctx context.Context, req ActionRequest) (map[string]any, error) {
	return checkUncheck(ctx, req, true)
}

func (b *Bridge) actionUncheck(ctx context.Context, req ActionRequest) (map[string]any, error) {
	return checkUncheck(ctx, req, false)
}

// checkUncheck implements both check and uncheck actions.
// If wantChecked is true, it ensures the element is checked; if false, unchecked.
// It only clicks if the current state differs from the desired state.
func checkUncheck(ctx context.Context, req ActionRequest, wantChecked bool) (map[string]any, error) {
	// Resolve the element to an objectId via backendNodeId or CSS selector.
	var resolveJS string
	if req.NodeID > 0 {
		// Resolve via backendNodeId using DOM.resolveNode (done below).
	} else if req.Selector != "" {
		resolveJS = req.Selector
	} else {
		return nil, NewInvalidActionRequestError("need selector, ref, or nodeId")
	}

	var objectID string
	err := chromedp.Run(ctx, chromedp.ActionFunc(func(ctx context.Context) error {
		if req.NodeID > 0 {
			var result json.RawMessage
			if err := chromedp.FromContext(ctx).Target.Execute(ctx, "DOM.resolveNode", map[string]any{
				"backendNodeId": req.NodeID,
			}, &result); err != nil {
				return err
			}
			var resolved struct {
				Object struct {
					ObjectID string `json:"objectId"`
				} `json:"object"`
			}
			if err := json.Unmarshal(result, &resolved); err != nil {
				return err
			}
			objectID = resolved.Object.ObjectID
			return nil
		}
		// CSS selector path
		var evalResult json.RawMessage
		if err := chromedp.FromContext(ctx).Target.Execute(ctx, "Runtime.evaluate", map[string]any{
			"expression":    fmt.Sprintf(`document.querySelector(%q)`, resolveJS),
			"returnByValue": false,
		}, &evalResult); err != nil {
			return err
		}
		var er struct {
			Result struct {
				ObjectID string `json:"objectId"`
				Type     string `json:"type"`
				Subtype  string `json:"subtype"`
			} `json:"result"`
		}
		if err := json.Unmarshal(evalResult, &er); err != nil {
			return err
		}
		if er.Result.ObjectID == "" || er.Result.Subtype == "null" {
			return fmt.Errorf("element not found: %s", resolveJS)
		}
		objectID = er.Result.ObjectID
		return nil
	}))
	if err != nil {
		return nil, err
	}

	state, err := readCheckableState(ctx, objectID)
	if err != nil {
		return nil, err
	}
	desired := "false"
	if wantChecked {
		desired = "true"
	}

	// Click only if state needs to change. Use the JS-dispatch path so the
	// toggle isn't gated on the headless=new CDP renderer ack chain.
	if state.State != desired {
		if req.NodeID > 0 {
			if err := JSClickByBackendNode(ctx, req.NodeID); err != nil {
				return nil, err
			}
		} else {
			node, err := firstNodeBySelector(ctx, req.Selector)
			if err != nil {
				return nil, err
			}
			if err := JSClickByBackendNode(ctx, int64(node.BackendNodeID)); err != nil {
				return nil, err
			}
		}
	}

	// Framework-backed ARIA controls often update state on the next task. Poll
	// briefly and report the observed value instead of claiming the requested
	// state without proof.
	deadline := time.Now().Add(500 * time.Millisecond)
	for {
		observed, observeErr := readCheckableState(ctx, objectID)
		if observeErr == nil && observed.State == desired {
			return map[string]any{
				"checked":     wantChecked,
				"controlType": observed.Kind,
				"verified":    true,
			}, nil
		}
		if time.Now().After(deadline) {
			if observeErr != nil {
				return nil, fmt.Errorf("verify checked state: %w", observeErr)
			}
			return nil, fmt.Errorf("checked state remained %q after requesting %q", observed.State, desired)
		}
		select {
		case <-ctx.Done():
			return nil, ctx.Err()
		case <-time.After(25 * time.Millisecond):
		}
	}
}