Skip to content

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

7.8 KB
Raw Blame
package staticfetch

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"io"
	"net/http"
	"strings"
	"sync"
	"time"

	"github.com/gost-dom/browser/dom"
	"github.com/gost-dom/browser/html"
	gosturl "github.com/gost-dom/browser/url"
	"github.com/pinchtab/pinchtab/internal/browserops"
	"github.com/pinchtab/pinchtab/internal/urls"
	nethtml "golang.org/x/net/html"
)

var ErrStaticNotSupported = errors.New("operation not supported by static browser")

type liteTab struct {
	window html.Window
	url    string
	// refMap resolves a ref back to its element and refByEl gives an element its
	// stable ref. Both persist for the tab's life and grow across snapshots so a
	// ref denotes an element rather than a row index: the same element keeps its
	// ref across a change of filter, and refs are sparse in a filtered view. The
	// static DOM never mutates, so entries never go stale; a new page is a new
	// tab with fresh maps.
	refMap  map[string]dom.Element
	refByEl map[dom.Element]string
	refNext int
}

func (t *liteTab) assignRef(el dom.Element) string {
	if ref, ok := t.refByEl[el]; ok {
		return ref
	}
	ref := fmt.Sprintf("e%d", t.refNext)
	t.refNext++
	t.refByEl[el] = ref
	t.refMap[ref] = el
	return ref
}

type Browser struct {
	client  *http.Client
	tabs    map[string]*liteTab
	current string // active tab ID
	seq     int    // tab ID sequence counter
	mu      sync.Mutex
}

func NewBrowser() *Browser {
	return &Browser{
		client: &http.Client{Timeout: 30 * time.Second},
		tabs:   make(map[string]*liteTab),
	}
}

func (l *Browser) Name() string { return "static" }

func (l *Browser) Capabilities() []browserops.Capability {
	return []browserops.Capability{browserops.CapNavigate, browserops.CapSnapshot, browserops.CapText, browserops.CapClick, browserops.CapType}
}

func (l *Browser) Navigate(ctx context.Context, url string) (*browserops.NavigateResult, error) {
	l.mu.Lock()
	defer l.mu.Unlock()

	// SSRF is enforced before this call (handler) and again at dial/redirect
	// time, so an inline nav guard here is intentionally omitted.
	safeURL, err := urls.Sanitize(url)
	if err != nil {
		return nil, fmt.Errorf("lite navigate: %w", err)
	}

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, safeURL, nil)
	if err != nil {
		return nil, fmt.Errorf("lite navigate: %w", err)
	}
	req.Header.Set("User-Agent", "Mozilla/5.0 (compatible; PinchTab-StaticFetch/1.0)")
	req.Header.Set("Accept", "text/html,application/xhtml+xml,*/*")

	resp, err := l.clientForNavigate(ctx).Do(req)
	if err != nil {
		return nil, fmt.Errorf("lite navigate fetch: %w", err)
	}
	defer func() { _ = resp.Body.Close() }()

	if resp.StatusCode >= 400 {
		return nil, fmt.Errorf("lite navigate: HTTP %d from %s", resp.StatusCode, url)
	}

	ct := resp.Header.Get("Content-Type")
	if ct != "" && !strings.Contains(ct, "html") && !strings.Contains(ct, "xml") {
		return nil, fmt.Errorf("lite navigate: unsupported content type %q", ct)
	}

	// Strip <script> elements to prevent gost-dom panics (no JS runtime).
	cleanBody, err := stripScripts(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("lite navigate strip scripts: %w", err)
	}

	parsedURL := gosturl.ParseURL(url)
	win, err := html.NewWindowReader(cleanBody, parsedURL)
	if err != nil {
		return nil, fmt.Errorf("lite navigate open: %w", err)
	}

	l.seq++
	tabID := fmt.Sprintf("lite-%d", l.seq)
	l.tabs[tabID] = &liteTab{
		window:  win,
		url:     url,
		refMap:  make(map[string]dom.Element),
		refByEl: make(map[dom.Element]string),
	}
	l.current = tabID

	title := l.getTitle(win)

	return &browserops.NavigateResult{
		TabID: tabID,
		URL:   url,
		Title: title,
	}, nil
}

func (l *Browser) Snapshot(_ context.Context, tabID, filter string) (*browserops.SnapshotResult, error) {
	l.mu.Lock()
	defer l.mu.Unlock()

	tab, err := l.resolveTab(tabID)
	if err != nil {
		return nil, err
	}

	doc := tab.window.Document()
	if doc == nil {
		return nil, errors.New("no document")
	}

	body := doc.Body()
	if body == nil {
		return nil, errors.New("no body element")
	}

	nodes := l.walkDOM(tab, body, filter, 0)

	title := l.getTitle(tab.window)

	return &browserops.SnapshotResult{
		Nodes: nodes,
		URL:   tab.url,
		Title: title,
	}, nil
}

func (l *Browser) Text(_ context.Context, tabID string) (*browserops.TextResult, error) {
	l.mu.Lock()
	defer l.mu.Unlock()

	tab, err := l.resolveTab(tabID)
	if err != nil {
		return nil, err
	}

	doc := tab.window.Document()
	if doc == nil {
		return nil, errors.New("no document")
	}

	body := doc.Body()
	if body == nil {
		return nil, errors.New("no body element")
	}

	raw := body.TextContent()
	title := l.getTitle(tab.window)

	return &browserops.TextResult{
		Text:  normalizeWhitespace(raw),
		URL:   tab.url,
		Title: title,
	}, nil
}

func (l *Browser) Click(ctx context.Context, tabID, ref string) (retErr error) {
	l.mu.Lock()
	defer l.mu.Unlock()

	tab, err := l.resolveTab(tabID)
	if err != nil {
		return err
	}

	el, ok := tab.refMap[ref]
	if !ok {
		return fmt.Errorf("ref %q not found (take a snapshot first)", ref)
	}

	// Recover from gost-dom panics (e.g., anchor click triggers navigation
	// to a page with scripts, but no JS runtime is configured).
	defer func() {
		if r := recover(); r != nil {
			retErr = fmt.Errorf("click recovered from panic: %v", r)
		}
	}()

	if htmlEl, ok := el.(html.HTMLElement); ok {
		htmlEl.Click()
		return nil
	}
	return errors.New("element does not support click")
}

func (l *Browser) Type(_ context.Context, tabID, ref, text string) error {
	l.mu.Lock()
	defer l.mu.Unlock()

	tab, err := l.resolveTab(tabID)
	if err != nil {
		return err
	}

	el, ok := tab.refMap[ref]
	if !ok {
		return fmt.Errorf("ref %q not found (take a snapshot first)", ref)
	}

	if input, ok := el.(html.HTMLInputElement); ok {
		input.SetValue(text)
		return nil
	}

	return el.SetAttribute("value", text)
}

func (l *Browser) TabURL(tabID string) (string, bool) {
	l.mu.Lock()
	defer l.mu.Unlock()
	tab := l.tabs[tabID]
	if tab == nil {
		return "", false
	}
	return tab.url, true
}

// CloseTab releases a single tab's window and bookkeeping. Unknown IDs are a
// no-op so callers can close defensively; reports whether a tab was removed.
func (l *Browser) CloseTab(tabID string) bool {
	l.mu.Lock()
	defer l.mu.Unlock()

	tab := l.tabs[tabID]
	if tab == nil {
		return false
	}
	if tab.window != nil {
		tab.window.Close()
	}
	delete(l.tabs, tabID)
	if l.current == tabID {
		l.current = ""
	}
	return true
}

func (l *Browser) Close() error {
	l.mu.Lock()
	defer l.mu.Unlock()

	for _, tab := range l.tabs {
		if tab.window != nil {
			tab.window.Close()
		}
	}
	l.tabs = make(map[string]*liteTab)
	return nil
}

func (l *Browser) resolveTab(tabID string) (*liteTab, error) {
	if tabID == "" {
		tabID = l.current
	}
	if tabID == "" {
		return nil, errors.New("no page loaded")
	}
	tab := l.tabs[tabID]
	if tab == nil || tab.window == nil {
		return nil, fmt.Errorf("tab %q not found", tabID)
	}
	l.current = tabID
	return tab, nil
}

// stripScripts removes <script> elements from HTML to prevent gost-dom
// from panicking when no JavaScript runtime is configured.
func stripScripts(r io.Reader) (io.Reader, error) {
	z := nethtml.NewTokenizer(r)
	var buf bytes.Buffer
	inScript := false
	for {
		tt := z.Next()
		switch tt {
		case nethtml.ErrorToken:
			if z.Err() == io.EOF {
				return &buf, nil
			}
			return nil, z.Err()
		case nethtml.StartTagToken:
			tn, _ := z.TagName()
			if string(tn) == "script" {
				inScript = true
				continue
			}
			buf.Write(z.Raw())
		case nethtml.EndTagToken:
			tn, _ := z.TagName()
			if string(tn) == "script" {
				inScript = false
				continue
			}
			buf.Write(z.Raw())
		case nethtml.SelfClosingTagToken:
			// `<script src="x"/>`: browsers don't honor self-closing script,
			// but gost-dom's reader may — skip it so no script element can
			// reach the JS-less DOM.
			tn, _ := z.TagName()
			if string(tn) == "script" {
				continue
			}
			buf.Write(z.Raw())
		default:
			if !inScript {
				buf.Write(z.Raw())
			}
		}
	}
}