Skip to content

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

12.4 KB
Raw Blame
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)
	}
}