High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.
package orchestrator
import (
"encoding/json"
"fmt"
"io"
"net"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"sync/atomic"
"testing"
"github.com/pinchtab/pinchtab/internal/config"
"github.com/pinchtab/pinchtab/internal/activity"
"github.com/pinchtab/pinchtab/internal/bridge"
"github.com/pinchtab/pinchtab/internal/handlers"
"github.com/pinchtab/pinchtab/internal/session"
)
func TestFindRunningInstanceByTabID_SeesTransientTabs(t *testing.T) {
cases := []struct {
name string
url func(port string) string
}{
{name: "about:blank", url: func(string) string { return "about:blank" }},
{name: "file", url: func(string) string { return "file:///tmp/page.html" }},
{name: "own port", url: func(port string) string { return "http://localhost:" + port + "/dashboard" }},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
orig := processAliveFunc
processAliveFunc = func(int) bool { return true }
defer func() { processAliveFunc = orig }()
o := NewOrchestrator(t.TempDir())
addInstance := func(id string, tabURL func(port string) string) {
var port atomic.Value
backend, p := startLocalHTTPServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/tabs" {
http.NotFound(w, r)
return
}
own, _ := port.Load().(string)
u := tabURL(own)
tabs := []map[string]string{}
if r.URL.Query().Get(handlers.IncludeTransientTabsQuery) == "1" || !bridge.IsTransientURL(u, own) {
tabs = append(tabs, map[string]string{"id": id + "-tab", "url": u})
}
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(map[string]any{"tabs": tabs})
}))
t.Cleanup(backend.Close)
port.Store(p)
o.instances[id] = &InstanceInternal{
Instance: bridge.Instance{ID: id, Status: "running", Port: p},
URL: "http://localhost:" + p,
cmd: &mockCmd{pid: 1234, isAlive: true},
}
}
addInstance("inst_real", func(string) string { return "https://example.com/" })
addInstance("inst_transient", tc.url)
inst, err := o.findRunningInstanceByTabID("inst_transient-tab")
if err != nil {
t.Fatalf("findRunningInstanceByTabID: %v", err)
}
if inst.ID != "inst_transient" {
t.Fatalf("owner = %q, want inst_transient", inst.ID)
}
})
}
}
func TestProxyResponseTracksOnlySuccessfullyCreatedSessionTabs(t *testing.T) {
o := NewOrchestrator(t.TempDir())
created := func(sessionID, instanceID, tabID string) {
t.Helper()
req := httptest.NewRequest(http.MethodPost, "/tab", nil)
req = session.WithSession(req, &session.Session{ID: sessionID})
resp := &http.Response{StatusCode: http.StatusOK, Header: http.Header{}}
resp.Header.Set(activity.HeaderPTTabID, tabID)
resp.Header.Set(activity.HeaderPTTabCreated, "true")
o.handleProxyResponseHeaders(req, resp, instanceID)
}
created("ses_1", "inst_a", "tab_2")
created("ses_1", "inst_a", "tab_1")
created("ses_2", "inst_b", "tab_3")
// Merely using another tab must not silently claim it for this session.
used := httptest.NewRequest(http.MethodGet, "/tabs/tab_foreign/title", nil)
used = session.WithSession(used, &session.Session{ID: "ses_1"})
usedResp := &http.Response{StatusCode: http.StatusOK, Header: http.Header{}}
usedResp.Header.Set(activity.HeaderPTTabID, "tab_foreign")
o.handleProxyResponseHeaders(used, usedResp, "inst_b")
if got := o.SessionTabIDs("ses_1"); len(got) != 2 || got[0] != "tab_1" || got[1] != "tab_2" {
t.Fatalf("ses_1 tabs = %v, want [tab_1 tab_2]", got)
}
if got := o.SessionTabIDs("ses_2"); len(got) != 1 || got[0] != "tab_3" {
t.Fatalf("ses_2 tabs = %v, want [tab_3]", got)
}
closed := httptest.NewRequest(http.MethodPost, "/tabs/tab_1/close", nil)
closed.SetPathValue("id", "tab_1")
closed = session.WithSession(closed, &session.Session{ID: "ses_2"})
closedResp := &http.Response{StatusCode: http.StatusOK, Header: http.Header{}}
closedResp.Header.Set(activity.HeaderPTTabID, "tab_1")
o.handleProxyResponseHeaders(closed, closedResp, "inst_a")
if got := o.SessionTabIDs("ses_1"); len(got) != 1 || got[0] != "tab_2" {
t.Fatalf("ses_1 tabs after close = %v, want [tab_2]", got)
}
if got := o.SessionTabIDs("ses_2"); len(got) != 1 || got[0] != "tab_3" {
t.Fatalf("close crossed session boundary: ses_2 tabs = %v", got)
}
}
func startLocalHTTPServer(t *testing.T, h http.Handler) (*httptest.Server, string) {
t.Helper()
ln, err := net.Listen("tcp", "localhost:0")
if err != nil {
t.Fatalf("listen: %v", err)
}
server := httptest.NewUnstartedServer(h)
server.Listener = ln
server.Start()
return server, fmt.Sprintf("%d", ln.Addr().(*net.TCPAddr).Port)
}
func TestProxyTabRequest_FallsBackToOnlyRunningInstance(t *testing.T) {
backend, port := startLocalHTTPServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
_, _ = io.WriteString(w, `{"ok":true}`)
}))
defer backend.Close()
o := NewOrchestrator(t.TempDir())
o.client = backend.Client()
o.instances["inst_1"] = &InstanceInternal{
Instance: bridge.Instance{ID: "inst_1", Status: "running", Port: port},
URL: "http://localhost:" + port,
cmd: &mockCmd{pid: 1234, isAlive: true},
}
req := httptest.NewRequest(http.MethodGet, "/tabs/ABC123/snapshot", nil)
req.SetPathValue("id", "ABC123")
w := httptest.NewRecorder()
orig := processAliveFunc
processAliveFunc = func(pid int) bool { return true }
defer func() { processAliveFunc = orig }()
o.proxyTabRequest(w, req)
resp := w.Result()
if resp.StatusCode != http.StatusOK {
t.Fatalf("status = %d, want 200", resp.StatusCode)
}
}
func TestRegisterHandlers_TabCloseUsesGenericProxyAndInvalidatesCache(t *testing.T) {
var closed atomic.Bool
var closePath atomic.Value
var closeAuth atomic.Value
backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch r.URL.Path {
case "/tabs":
w.Header().Set("Content-Type", "application/json")
if closed.Load() {
_, _ = io.WriteString(w, `{"tabs":[]}`)
return
}
_, _ = io.WriteString(w, `{"tabs":[{"id":"tab-close","url":"about:blank"}]}`)
case "/tabs/tab-close/close":
closePath.Store(r.URL.Path)
closeAuth.Store(r.Header.Get("Authorization"))
closed.Store(true)
w.Header().Set("Content-Type", "application/json")
_, _ = io.WriteString(w, `{"closed":true,"tabId":"tab-close"}`)
default:
http.NotFound(w, r)
}
}))
defer backend.Close()
o := NewOrchestrator(t.TempDir())
o.client = backend.Client()
o.ApplyRuntimeConfig(&config.RuntimeConfig{Token: "child-token"})
inst := bridge.Instance{ID: "inst_1", Status: "running", URL: backend.URL}
o.instances["inst_1"] = &InstanceInternal{
Instance: inst,
URL: backend.URL,
cmd: &mockCmd{pid: 1234, isAlive: true},
}
o.instanceMgr.Repo.Add(&inst)
o.instanceMgr.RegisterTab("tab-close", "inst_1")
mux := http.NewServeMux()
o.RegisterHandlers(mux)
req := httptest.NewRequest(http.MethodPost, "/tabs/tab-close/close", nil)
w := httptest.NewRecorder()
mux.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, want 200: %s", w.Code, w.Body.String())
}
if got, _ := closePath.Load().(string); got != "/tabs/tab-close/close" {
t.Fatalf("close path = %q, want /tabs/tab-close/close", got)
}
if got, _ := closeAuth.Load().(string); got != "Bearer child-token" {
t.Fatalf("authorization = %q, want Bearer child-token", got)
}
if _, err := o.instanceMgr.FindInstanceByTabID("tab-close"); err == nil {
t.Fatal("expected closed tab to be invalidated from locator cache")
}
}
func TestProxyToURL_CloseShorthandInvalidatesCacheFromResponseHeader(t *testing.T) {
backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/close" {
http.NotFound(w, r)
return
}
w.Header().Set(activity.HeaderPTTabID, "tab-close")
w.Header().Set("Content-Type", "application/json")
_, _ = io.WriteString(w, `{"closed":true,"tabId":"tab-close"}`)
}))
defer backend.Close()
o := NewOrchestrator(t.TempDir())
o.client = backend.Client()
inst := bridge.Instance{ID: "inst_1", Status: "running", URL: backend.URL}
o.instances["inst_1"] = &InstanceInternal{
Instance: inst,
URL: backend.URL,
cmd: &mockCmd{pid: 1234, isAlive: true},
}
o.instanceMgr.Repo.Add(&inst)
o.instanceMgr.RegisterTab("tab-close", "inst_1")
targetURL, err := url.Parse(backend.URL + "/close")
if err != nil {
t.Fatalf("parse target: %v", err)
}
req := httptest.NewRequest(http.MethodPost, "/close", strings.NewReader(`{"tabId":"tab-close"}`))
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
o.proxyToURL(w, req, targetURL)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, want 200: %s", w.Code, w.Body.String())
}
if _, err := o.instanceMgr.FindInstanceByTabID("tab-close"); err == nil {
t.Fatal("expected closed tab to be invalidated from locator cache")
}
}
func TestSingleRunningInstance_MultipleInstancesReturnsNil(t *testing.T) {
o := NewOrchestrator(t.TempDir())
o.instances["inst_1"] = &InstanceInternal{Instance: bridge.Instance{ID: "inst_1", Status: "running"}, cmd: &mockCmd{pid: 1, isAlive: true}}
o.instances["inst_2"] = &InstanceInternal{Instance: bridge.Instance{ID: "inst_2", Status: "running"}, cmd: &mockCmd{pid: 2, isAlive: true}}
orig := processAliveFunc
processAliveFunc = func(pid int) bool { return true }
defer func() { processAliveFunc = orig }()
if got := o.singleRunningInstance(); got != nil {
t.Fatalf("expected nil, got %v", got.ID)
}
}
func TestSingleRunningInstance_IgnoresStopped(t *testing.T) {
o := NewOrchestrator(t.TempDir())
o.instances["inst_1"] = &InstanceInternal{Instance: bridge.Instance{ID: "inst_1", Status: "running"}, cmd: &mockCmd{pid: 1, isAlive: true}}
o.instances["inst_2"] = &InstanceInternal{Instance: bridge.Instance{ID: "inst_2", Status: "stopped"}}
orig := processAliveFunc
processAliveFunc = func(pid int) bool { return pid == 1 }
defer func() { processAliveFunc = orig }()
got := o.singleRunningInstance()
if got == nil || got.ID != "inst_1" {
t.Fatalf("got %#v, want inst_1", got)
}
}
func TestProxyToURL_UsesAttachedBridgeOriginAndAuth(t *testing.T) {
backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if got := r.Header.Get("Authorization"); got != "Bearer bridge-token" {
t.Fatalf("authorization = %q, want %q", got, "Bearer bridge-token")
}
if r.URL.Path != "/tabs/tab-1/snapshot" {
t.Fatalf("path = %q", r.URL.Path)
}
_, _ = io.WriteString(w, `ok`)
}))
defer backend.Close()
o := NewOrchestrator(t.TempDir())
o.client = backend.Client()
backendURL, err := url.Parse(backend.URL)
if err != nil {
t.Fatalf("parse backend URL: %v", err)
}
allowAttachForTest(o, []string{"http"}, []string{backendURL.Hostname()})
attached, _, err := o.AttachBridge("bridge1", backend.URL, "bridge-token")
if err != nil {
t.Fatalf("AttachBridge failed: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/tabs/tab-1/snapshot", nil)
req.SetPathValue("id", "tab-1")
w := httptest.NewRecorder()
targetURL, err := o.instancePathURLFromBridge(attached, "/tabs/tab-1/snapshot", "")
if err != nil {
t.Fatalf("instancePathURLFromBridge failed: %v", err)
}
o.proxyToURL(w, req, targetURL)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, want 200", w.Code)
}
}
func TestProxyToTarget_InjectsChildAuthAndStripsCookie(t *testing.T) {
backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if got := r.Header.Get("Authorization"); got != "Bearer child-token" {
t.Fatalf("authorization = %q, want %q", got, "Bearer child-token")
}
if got := r.Header.Get("Cookie"); got != "" {
t.Fatalf("cookie = %q, want empty", got)
}
if r.URL.Path != "/action" {
t.Fatalf("path = %q, want /action", r.URL.Path)
}
_, _ = io.WriteString(w, `ok`)
}))
defer backend.Close()
o := NewOrchestrator(t.TempDir())
o.client = backend.Client()
o.ApplyRuntimeConfig(&config.RuntimeConfig{Token: "child-token"})
o.instances["inst_1"] = &InstanceInternal{
Instance: bridge.Instance{ID: "inst_1", Status: "running"},
URL: backend.URL,
cmd: &mockCmd{pid: 1234, isAlive: true},
}
req := httptest.NewRequest(http.MethodPost, "/action", nil)
req.Header.Set("Cookie", "pinchtab_auth_token=session-secret")
w := httptest.NewRecorder()
o.ProxyToTarget(w, req, backend.URL+"/action")
if w.Code != http.StatusOK {
t.Fatalf("status = %d, want 200", w.Code)
}
}