Skip to content

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

fix: the ghost-chrome adapter hand-copies five ActionRequest fields and drops HasText, so a legitimate clear is refused on the path nothing pins (PIN-207)

Luigi Agosti713662689ae1
diff --git a/internal/browserops/browserops.go b/internal/browserops/browserops.go
index dfb64552..37de7ea2 100644
--- a/internal/browserops/browserops.go
+++ b/internal/browserops/browserops.go
@@ -35,6 +35,10 @@ type StaticActionRequest struct {
Ref string
Text string
Value string
+ // HasText carries the presence bit that separates "clear this field" from "no text
+ // ever arrived". Without it a legitimate clear crossing this subset arrives as
+ // Text:"" with nothing to say it was supplied, and the bridge refuses the fill.
+ HasText bool
}
type Capability string
diff --git a/internal/browsers/ghostchrome/bridgekit/action_request_conversion_test.go b/internal/browsers/ghostchrome/bridgekit/action_request_conversion_test.go
new file mode 100644
index 00000000..69398fc4
--- /dev/null
+++ b/internal/browsers/ghostchrome/bridgekit/action_request_conversion_test.go
@@ -0,0 +1,288 @@
+package bridgekit
+
+import (
+ "context"
+ "reflect"
+ "sort"
+ "strings"
+ "testing"
+
+ "github.com/pinchtab/pinchtab/internal/bridge"
+ "github.com/pinchtab/pinchtab/internal/browsers/ghostchrome"
+)
+
+// recordingBridgeAPI captures the bridge.ActionRequest that reaches Chrome. It is the only
+// place the crossed request can be read: everything before it is the adapter's own copy.
+type recordingBridgeAPI struct {
+ bridge.BridgeAPI // nil — panics on anything this test does not drive
+ got bridge.ActionRequest
+ calls int
+}
+
+func (r *recordingBridgeAPI) ExecuteAction(_ context.Context, _ string, req bridge.ActionRequest) (map[string]any, error) {
+ r.got = req
+ r.calls++
+ return map[string]any{"filled": true}, nil
+}
+
+// newProxyWithoutFallback builds the route the production caller currently hides: no static
+// browser, so nothing is served statically, and no fallback closure, so the proxy converts
+// the request back itself instead of replaying the original. That branch is unreachable at
+// HEAD only because the single caller passes a closure; the signature invites a nil, and the
+// closure reads as redundant to anyone tidying up.
+func newProxyWithoutFallback(api *recordingBridgeAPI) *ghostchrome.BridgeProxy {
+ return ghostchrome.NewBridgeProxy(&chromeActionAdapter{BridgeAPI: api}, nil, func() error { return nil })
+}
+
+// An explicit empty text is a request to CLEAR the field, and the bridge refuses a fill that
+// carries no text at all. Both facts are only distinguishable by the presence bit, so a
+// conversion that drops it turns a documented operation into a refusal.
+func TestAnExplicitClearSurvivesTheAdapterWithNoFallbackClosure(t *testing.T) {
+ api := &recordingBridgeAPI{}
+ proxy := newProxyWithoutFallback(api)
+
+ _, err := proxy.ExecuteAction(context.Background(), ghostchrome.ActionFill, ghostchrome.ActionRequest{
+ TabID: "tab-1",
+ Kind: ghostchrome.ActionFill,
+ Ref: "e5",
+ Text: "",
+ HasText: true,
+ }, nil)
+ if err != nil {
+ t.Fatalf("ExecuteAction: %v", err)
+ }
+ if api.calls != 1 {
+ t.Fatalf("Chrome saw %d requests, want 1; the test is not driving the no-fallback branch", api.calls)
+ }
+ if !api.got.HasText {
+ t.Error("the clear crossed the adapter with HasText false, so the bridge cannot tell it from a fill whose text never arrived")
+ }
+ if err := bridge.ValidateFillAction(ghostchrome.ActionFill, api.got); err != nil {
+ t.Errorf("the crossed request is refused by the bridge: %v", err)
+ }
+}
+
+// The other half of the pair. A conversion that hardcoded HasText true would pass the test
+// above and destroy the refusal this bit exists to make possible.
+func TestAFillWhoseTextNeverArrivedIsStillRefusedAfterCrossingTheAdapter(t *testing.T) {
+ api := &recordingBridgeAPI{}
+ proxy := newProxyWithoutFallback(api)
+
+ _, err := proxy.ExecuteAction(context.Background(), ghostchrome.ActionFill, ghostchrome.ActionRequest{
+ TabID: "tab-1",
+ Kind: ghostchrome.ActionFill,
+ Ref: "e5",
+ }, nil)
+ if err != nil {
+ t.Fatalf("ExecuteAction: %v", err)
+ }
+ if api.got.HasText {
+ t.Fatal("a request that supplied no text arrived as supplied")
+ }
+ if err := bridge.ValidateFillAction(ghostchrome.ActionFill, api.got); err == nil {
+ t.Error("the bridge accepts a fill whose text never arrived, so the presence bit has stopped meaning anything")
+ }
+}
+
+// Both directions: the adapter converts DOWN to the static subset on the way in and the
+// proxy converts back UP on the way out, so a bit dropped by either conversion is lost.
+//
+// It drives the two conversions directly rather than BridgeAdapter.ExecuteAction, because
+// that entry point cannot show the round trip: it always passes the fallback closure, which
+// replays the ORIGINAL request and hides whatever the down-conversion dropped. That masking
+// is the defect this card is about, so a test routed through it would prove nothing.
+func TestTheClearSurvivesBothConversions(t *testing.T) {
+ original := bridge.ActionRequest{TabID: "tab-1", Kind: ghostchrome.ActionFill, Ref: "e5", HasText: true}
+
+ crossed := bridgeActionRequest(staticActionRequest(original))
+
+ if !crossed.HasText {
+ t.Error("the presence bit did not survive bridge -> static -> bridge")
+ }
+ if err := bridge.ValidateFillAction(ghostchrome.ActionFill, crossed); err != nil {
+ t.Errorf("the round-tripped clear is refused by the bridge: %v", err)
+ }
+}
+
+// The single production caller passes a closure carrying the ORIGINAL request, which is why
+// the lossy branch is unreached today. Nothing asserted that, so a caller passing nil — or a
+// tidy-up deleting the closure as redundant — silently narrowed every request to the static
+// subset. This asserts the property rather than relying on it.
+func TestTheFallbackClosureDeliversTheWholeRequest(t *testing.T) {
+ api := &recordingBridgeAPI{}
+ adapter := &BridgeAdapter{
+ BridgeAPI: api,
+ proxy: ghostchrome.NewBridgeProxy(&chromeActionAdapter{BridgeAPI: api}, nil, func() error { return nil }),
+ }
+
+ original := bridge.ActionRequest{
+ TabID: "tab-1",
+ Kind: ghostchrome.ActionFill,
+ Ref: "e5",
+ Text: "hello",
+ HasText: true,
+ NodeID: 42,
+ Submit: true,
+ Owner: "agent-1",
+ HasXY: true,
+ X: 10,
+ Y: 20,
+ }
+ if _, err := adapter.ExecuteAction(context.Background(), ghostchrome.ActionFill, original); err != nil {
+ t.Fatalf("ExecuteAction: %v", err)
+ }
+ if !reflect.DeepEqual(api.got, original) {
+ t.Errorf("Chrome received %+v, want the original request %+v; the fallback no longer replays what the caller sent, so every field outside the static subset is lost", api.got, original)
+ }
+}
+
+// notCarriedToTheStaticRequest names every bridge.ActionRequest field the static subset
+// deliberately does not carry, with the reason at the entry. It is checked in BOTH
+// directions: a field that is neither carried nor listed fails, and a listed field that no
+// longer exists fails too.
+//
+// This is the guard the hand-written literals lacked. HasXY and then HasText were each
+// dropped from a five-field copy and nobody noticed until presence started mattering; a new
+// field now has to be classified before it can land.
+var notCarriedToTheStaticRequest = map[string]string{
+ "Selector": reasonRefOnly,
+ "Key": reasonChromeOnly,
+ "NodeID": reasonChromeOnly,
+ "X": reasonChromeOnly,
+ "Y": reasonChromeOnly,
+ "HasXY": reasonChromeOnly,
+ "Button": reasonChromeOnly,
+ "Mode": reasonChromeOnly,
+ "FrameW": reasonChromeOnly,
+ "FrameH": reasonChromeOnly,
+ "Modifiers": reasonChromeOnly,
+ "ScrollX": reasonChromeOnly,
+ "ScrollY": reasonChromeOnly,
+ "HasScroll": reasonChromeOnly,
+ "DeltaX": reasonChromeOnly,
+ "DeltaY": reasonChromeOnly,
+ "HasDelta": reasonChromeOnly,
+ "DragX": reasonChromeOnly,
+ "DragY": reasonChromeOnly,
+ "ToSelector": reasonChromeOnly,
+ "ToNodeID": reasonChromeOnly,
+ "ToX": reasonChromeOnly,
+ "ToY": reasonChromeOnly,
+ "HasToXY": reasonChromeOnly,
+ "WaitNav": reasonNoLiveRenderer,
+ "Fast": reasonNoLiveRenderer,
+ "Owner": reasonHandlerOnly,
+ "Submit": reasonNoLiveRenderer,
+ "DismissBanners": reasonHandlerOnly,
+ "DismissKnownInterstitials": reasonHandlerOnly,
+ "Humanize": reasonNoLiveRenderer,
+ "AutoSwitch": reasonNoLiveRenderer,
+ "DialogAction": reasonNoLiveRenderer,
+ "DialogText": reasonNoLiveRenderer,
+ "Browser": reasonRoutingDecided,
+}
+
+const (
+ reasonRefOnly = "the static browser targets by ref only; a selector request routes to Chrome"
+ reasonChromeOnly = "meaningless to the static DOM: it addresses or dispatches through CDP"
+ reasonNoLiveRenderer = "the static browser has no live renderer to wait on, navigate or dialog"
+ reasonHandlerOnly = "the handler layer reads it; the bridge and the static path never do"
+ reasonRoutingDecided = "already decided upstream — this request has been routed to ghost-chrome"
+)
+
+// Every field of ActionRequest is either carried by the conversions or classified above.
+// The failure names the field, which is the information a count guard cannot carry: "21
+// fields, expected 20" sends the reader hunting, "HasText is not carried" does not.
+func TestEveryActionRequestFieldIsCarriedOrClassified(t *testing.T) {
+ carried := fieldNames(reflect.TypeOf(ghostchrome.ActionRequest{}))
+ all := fieldNames(reflect.TypeOf(bridge.ActionRequest{}))
+
+ var unclassified []string
+ for name := range all {
+ if carried[name] || notCarriedToTheStaticRequest[name] != "" {
+ continue
+ }
+ unclassified = append(unclassified, name)
+ }
+ if len(unclassified) > 0 {
+ sort.Strings(unclassified)
+ t.Errorf("ActionRequest.%s is neither carried to the static request nor listed as deliberately dropped; add the field to both conversions or classify it with a reason",
+ strings.Join(unclassified, ", ActionRequest."))
+ }
+
+ for name := range notCarriedToTheStaticRequest {
+ if !all[name] {
+ t.Errorf("%q is listed as deliberately dropped but ActionRequest has no such field; the entry is stale", name)
+ }
+ if carried[name] {
+ t.Errorf("%q is listed as deliberately dropped and is also carried by the static request; one of the two is wrong", name)
+ }
+ }
+}
+
+// The classification above says which fields cross. This says they actually DO, in both
+// directions, by driving the conversions with a value in every field — the check the
+// hand-written literals never had, and the one that reds the moment a field is added to the
+// static subset and forgotten in a copy.
+func TestBothConversionsCarryEveryStaticField(t *testing.T) {
+ static := ghostchrome.ActionRequest{}
+ fillEveryField(t, reflect.ValueOf(&static).Elem())
+
+ up := bridgeActionRequest(static)
+ assertStaticFieldsEqual(t, "static -> bridge", reflect.ValueOf(static), reflect.ValueOf(up))
+
+ down := staticActionRequest(up)
+ assertStaticFieldsEqual(t, "bridge -> static", reflect.ValueOf(up), reflect.ValueOf(down))
+ if !reflect.DeepEqual(static, down) {
+ t.Errorf("round trip = %+v, want %+v", down, static)
+ }
+}
+
+// fillEveryField sets a distinct non-zero value in each field, so a field the conversion
+// forgets arrives as a zero the comparison can see. A shared value would let a copy of the
+// WRONG field pass.
+func fillEveryField(t *testing.T, v reflect.Value) {
+ t.Helper()
+ for i := 0; i < v.NumField(); i++ {
+ field := v.Field(i)
+ switch field.Kind() {
+ case reflect.String:
+ field.SetString(v.Type().Field(i).Name + "-value")
+ case reflect.Bool:
+ field.SetBool(true)
+ case reflect.Int, reflect.Int64:
+ field.SetInt(int64(i + 1))
+ case reflect.Float64:
+ field.SetFloat(float64(i + 1))
+ default:
+ t.Fatalf("field %s has kind %s, which this test does not know how to populate; extend it rather than skipping the field",
+ v.Type().Field(i).Name, field.Kind())
+ }
+ }
+}
+
+// assertStaticFieldsEqual compares the fields of the static subset, whichever side is the
+// richer struct: those are exactly the fields both conversions are required to carry, and
+// the ones outside it are classified by the table above.
+func assertStaticFieldsEqual(t *testing.T, direction string, from, to reflect.Value) {
+ t.Helper()
+ subset := reflect.TypeOf(ghostchrome.ActionRequest{})
+ for i := 0; i < subset.NumField(); i++ {
+ name := subset.Field(i).Name
+ source, target := from.FieldByName(name), to.FieldByName(name)
+ if !source.IsValid() || !target.IsValid() {
+ t.Fatalf("%s: %s is missing from one side of the conversion", direction, name)
+ }
+ if !reflect.DeepEqual(source.Interface(), target.Interface()) {
+ t.Errorf("%s: %s = %v, want %v; the conversion does not copy it", direction, name, target.Interface(), source.Interface())
+ }
+ }
+}
+
+func fieldNames(t reflect.Type) map[string]bool {
+ names := map[string]bool{}
+ for i := 0; i < t.NumField(); i++ {
+ names[t.Field(i).Name] = true
+ }
+ return names
+}
diff --git a/internal/browsers/ghostchrome/bridgekit/bridge_adapter.go b/internal/browsers/ghostchrome/bridgekit/bridge_adapter.go
index e39debcc..d6dcc8da 100644
--- a/internal/browsers/ghostchrome/bridgekit/bridge_adapter.go
+++ b/internal/browsers/ghostchrome/bridgekit/bridge_adapter.go
@@ -39,13 +39,33 @@ func (a *chromeActionAdapter) TabContext(tabID string) (context.Context, string,
}
func (a *chromeActionAdapter) ExecuteAction(ctx context.Context, kind string, req ghostchrome.ActionRequest) (map[string]any, error) {
- return a.BridgeAPI.ExecuteAction(ctx, kind, bridge.ActionRequest{
- TabID: req.TabID,
- Kind: req.Kind,
- Ref: req.Ref,
- Text: req.Text,
- Value: req.Value,
- })
+ return a.BridgeAPI.ExecuteAction(ctx, kind, bridgeActionRequest(req))
+}
+
+// The two conversions are named and paired so the field lists sit side by side: every field
+// of the static subset must appear in both, which is what a census can check. HasText and
+// HasXY were each dropped from a hand-written literal, and a dropped presence bit turns a
+// legitimate clear into a refused request.
+func bridgeActionRequest(req ghostchrome.ActionRequest) bridge.ActionRequest {
+ return bridge.ActionRequest{
+ TabID: req.TabID,
+ Kind: req.Kind,
+ Ref: req.Ref,
+ Text: req.Text,
+ Value: req.Value,
+ HasText: req.HasText,
+ }
+}
+
+func staticActionRequest(req bridge.ActionRequest) ghostchrome.ActionRequest {
+ return ghostchrome.ActionRequest{
+ TabID: req.TabID,
+ Kind: req.Kind,
+ Ref: req.Ref,
+ Text: req.Text,
+ Value: req.Value,
+ HasText: req.HasText,
+ }
}
type BridgeAdapter struct {
@@ -113,13 +133,7 @@ func (a *BridgeAdapter) TabContext(tabID string) (*bridge.TabHandle, string, err
}
func (a *BridgeAdapter) ExecuteAction(ctx context.Context, kind string, req bridge.ActionRequest) (map[string]any, error) {
- return a.proxy.ExecuteAction(ctx, kind, ghostchrome.ActionRequest{
- TabID: req.TabID,
- Kind: req.Kind,
- Ref: req.Ref,
- Text: req.Text,
- Value: req.Value,
- }, func(ctx context.Context) (map[string]any, error) {
+ return a.proxy.ExecuteAction(ctx, kind, staticActionRequest(req), func(ctx context.Context) (map[string]any, error) {
return a.BridgeAPI.ExecuteAction(ctx, kind, req)
})
}