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.goindex dfb64552..37de7ea2 100644--- a/internal/browserops/browserops.go+++ b/internal/browserops/browserops.go@@ -35,6 +35,10 @@ type StaticActionRequest struct {Ref stringText stringValue 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 stringdiff --git a/internal/browsers/ghostchrome/bridgekit/action_request_conversion_test.go b/internal/browsers/ghostchrome/bridgekit/action_request_conversion_test.gonew file mode 100644index 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.goindex 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)})}