293 lines
10 KiB
Go
293 lines
10 KiB
Go
package browser
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"chub/internal/domain"
|
|
)
|
|
|
|
const (
|
|
remoteDebugPortAttempts = 100
|
|
remoteDebugTargetsMaxBytes = 1 << 20
|
|
remoteDebugTargetsMaxCount = 200
|
|
remoteDebugTargetTextMax = 4096
|
|
)
|
|
|
|
var (
|
|
ErrRemoteDebugPortUnavailable = errors.New("remote debugging port is unavailable")
|
|
ErrRemoteDebugEndpointUnavailable = errors.New("remote debugging endpoint is unavailable")
|
|
)
|
|
|
|
type RemoteDebugEndpoint struct {
|
|
Port int
|
|
Browser string
|
|
}
|
|
|
|
// RemoteDebugTarget is a read-only summary of one target returned by CDP
|
|
// /json/list. URL is safe to display but must never be treated as a control
|
|
// endpoint; its userinfo, query, and fragment have been removed.
|
|
type RemoteDebugTarget struct {
|
|
ID string
|
|
Type string
|
|
Title string
|
|
URL string
|
|
}
|
|
|
|
type RemoteDebugEndpointInspector interface {
|
|
InspectRemoteDebugEndpoint(context.Context, domain.BrowserKind, string) (RemoteDebugEndpoint, error)
|
|
WaitForRemoteDebugEndpoint(context.Context, domain.BrowserKind, string) (RemoteDebugEndpoint, error)
|
|
InspectRemoteDebugPort(context.Context, domain.BrowserKind, int) (RemoteDebugEndpoint, error)
|
|
WaitForRemoteDebugPort(context.Context, domain.BrowserKind, int) (RemoteDebugEndpoint, error)
|
|
}
|
|
|
|
type RemoteDebugPortAllocator interface {
|
|
FindAvailableRemoteDebugPort(context.Context, int) (int, error)
|
|
}
|
|
|
|
// RemoteDebugTargetInspector reads CDP targets only from a verified loopback
|
|
// endpoint. It intentionally exposes no WebSocket URL or browser-control API.
|
|
type RemoteDebugTargetInspector interface {
|
|
ListRemoteDebugTargets(context.Context, domain.BrowserKind, int) ([]RemoteDebugTarget, error)
|
|
}
|
|
|
|
type CDPInspector struct {
|
|
readFile func(string) ([]byte, error)
|
|
client *http.Client
|
|
}
|
|
|
|
func NewCDPInspector() *CDPInspector {
|
|
return &CDPInspector{
|
|
readFile: os.ReadFile,
|
|
client: &http.Client{
|
|
Transport: &http.Transport{Proxy: nil},
|
|
CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse },
|
|
},
|
|
}
|
|
}
|
|
|
|
func (i *CDPInspector) InspectRemoteDebugEndpoint(ctx context.Context, kind domain.BrowserKind, userDataDir string) (RemoteDebugEndpoint, error) {
|
|
if err := ctx.Err(); err != nil {
|
|
return RemoteDebugEndpoint{}, err
|
|
}
|
|
if i == nil || i.readFile == nil || i.client == nil || !kind.Valid() {
|
|
return RemoteDebugEndpoint{}, ErrRemoteDebugEndpointUnavailable
|
|
}
|
|
directory := strings.TrimSpace(userDataDir)
|
|
if directory == "" || !filepath.IsAbs(directory) {
|
|
return RemoteDebugEndpoint{}, fmt.Errorf("%w: user data dir must be absolute", domain.ErrInvalidLaunchSpec)
|
|
}
|
|
data, err := i.readFile(filepath.Join(filepath.Clean(directory), "DevToolsActivePort"))
|
|
if err != nil {
|
|
return RemoteDebugEndpoint{}, fmt.Errorf("%w: read active port", ErrRemoteDebugEndpointUnavailable)
|
|
}
|
|
port, err := parseDevToolsActivePort(data)
|
|
if err != nil {
|
|
return RemoteDebugEndpoint{}, err
|
|
}
|
|
return i.InspectRemoteDebugPort(ctx, kind, port)
|
|
}
|
|
|
|
func (i *CDPInspector) InspectRemoteDebugPort(ctx context.Context, kind domain.BrowserKind, port int) (RemoteDebugEndpoint, error) {
|
|
if err := ctx.Err(); err != nil {
|
|
return RemoteDebugEndpoint{}, err
|
|
}
|
|
if i == nil || i.client == nil || !kind.Valid() || !domain.ValidRemoteDebugPort(port) {
|
|
return RemoteDebugEndpoint{}, ErrRemoteDebugEndpointUnavailable
|
|
}
|
|
request, err := http.NewRequestWithContext(ctx, http.MethodGet, "http://127.0.0.1:"+strconv.Itoa(port)+"/json/version", nil)
|
|
if err != nil {
|
|
return RemoteDebugEndpoint{}, fmt.Errorf("%w: build version request", ErrRemoteDebugEndpointUnavailable)
|
|
}
|
|
response, err := i.client.Do(request)
|
|
if err != nil {
|
|
return RemoteDebugEndpoint{}, fmt.Errorf("%w: query version", ErrRemoteDebugEndpointUnavailable)
|
|
}
|
|
defer response.Body.Close()
|
|
if response.StatusCode != http.StatusOK {
|
|
return RemoteDebugEndpoint{}, fmt.Errorf("%w: version status %d", ErrRemoteDebugEndpointUnavailable, response.StatusCode)
|
|
}
|
|
var version struct {
|
|
Browser string `json:"Browser"`
|
|
}
|
|
if err := json.NewDecoder(response.Body).Decode(&version); err != nil {
|
|
return RemoteDebugEndpoint{}, fmt.Errorf("%w: decode version", ErrRemoteDebugEndpointUnavailable)
|
|
}
|
|
if !browserVersionMatchesKind(version.Browser, kind) {
|
|
return RemoteDebugEndpoint{}, fmt.Errorf("%w: browser kind mismatch", ErrRemoteDebugEndpointUnavailable)
|
|
}
|
|
return RemoteDebugEndpoint{Port: port, Browser: version.Browser}, nil
|
|
}
|
|
|
|
func (i *CDPInspector) WaitForRemoteDebugEndpoint(ctx context.Context, kind domain.BrowserKind, userDataDir string) (RemoteDebugEndpoint, error) {
|
|
return waitForRemoteDebugEndpoint(ctx, func(ctx context.Context) (RemoteDebugEndpoint, error) {
|
|
return i.InspectRemoteDebugEndpoint(ctx, kind, userDataDir)
|
|
})
|
|
}
|
|
|
|
func (i *CDPInspector) WaitForRemoteDebugPort(ctx context.Context, kind domain.BrowserKind, port int) (RemoteDebugEndpoint, error) {
|
|
return waitForRemoteDebugEndpoint(ctx, func(ctx context.Context) (RemoteDebugEndpoint, error) {
|
|
return i.InspectRemoteDebugPort(ctx, kind, port)
|
|
})
|
|
}
|
|
|
|
// ListRemoteDebugTargets first validates the browser kind at the supplied
|
|
// loopback port, then reads its bounded /json/list response. It never follows
|
|
// redirects or exposes the response's webSocketDebuggerUrl field.
|
|
func (i *CDPInspector) ListRemoteDebugTargets(ctx context.Context, kind domain.BrowserKind, port int) ([]RemoteDebugTarget, error) {
|
|
if err := ctx.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
if i == nil || i.client == nil || !kind.Valid() || !domain.ValidRemoteDebugPort(port) {
|
|
return nil, ErrRemoteDebugEndpointUnavailable
|
|
}
|
|
if _, err := i.InspectRemoteDebugPort(ctx, kind, port); err != nil {
|
|
return nil, err
|
|
}
|
|
request, err := http.NewRequestWithContext(ctx, http.MethodGet, "http://127.0.0.1:"+strconv.Itoa(port)+"/json/list", nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%w: build target request", ErrRemoteDebugEndpointUnavailable)
|
|
}
|
|
response, err := i.client.Do(request)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%w: query targets", ErrRemoteDebugEndpointUnavailable)
|
|
}
|
|
defer response.Body.Close()
|
|
if response.StatusCode != http.StatusOK {
|
|
return nil, fmt.Errorf("%w: target status %d", ErrRemoteDebugEndpointUnavailable, response.StatusCode)
|
|
}
|
|
data, err := io.ReadAll(io.LimitReader(response.Body, remoteDebugTargetsMaxBytes+1))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%w: read targets", ErrRemoteDebugEndpointUnavailable)
|
|
}
|
|
if len(data) > remoteDebugTargetsMaxBytes {
|
|
return nil, fmt.Errorf("%w: target response exceeds %d bytes", ErrRemoteDebugEndpointUnavailable, remoteDebugTargetsMaxBytes)
|
|
}
|
|
var rawTargets []struct {
|
|
ID string `json:"id"`
|
|
Type string `json:"type"`
|
|
Title string `json:"title"`
|
|
URL string `json:"url"`
|
|
}
|
|
if err := json.Unmarshal(data, &rawTargets); err != nil {
|
|
return nil, fmt.Errorf("%w: decode targets", ErrRemoteDebugEndpointUnavailable)
|
|
}
|
|
if len(rawTargets) > remoteDebugTargetsMaxCount {
|
|
return nil, fmt.Errorf("%w: target count exceeds %d", ErrRemoteDebugEndpointUnavailable, remoteDebugTargetsMaxCount)
|
|
}
|
|
targets := make([]RemoteDebugTarget, 0, len(rawTargets))
|
|
for _, raw := range rawTargets {
|
|
id := strings.TrimSpace(raw.ID)
|
|
if id == "" {
|
|
continue
|
|
}
|
|
targets = append(targets, RemoteDebugTarget{
|
|
ID: truncateRemoteDebugTargetText(id),
|
|
Type: truncateRemoteDebugTargetText(strings.TrimSpace(raw.Type)),
|
|
Title: truncateRemoteDebugTargetText(strings.TrimSpace(raw.Title)),
|
|
URL: sanitizeRemoteDebugTargetURL(raw.URL),
|
|
})
|
|
}
|
|
return targets, nil
|
|
}
|
|
|
|
func waitForRemoteDebugEndpoint(ctx context.Context, inspect func(context.Context) (RemoteDebugEndpoint, error)) (RemoteDebugEndpoint, error) {
|
|
const pollInterval = 50 * time.Millisecond
|
|
for {
|
|
endpoint, err := inspect(ctx)
|
|
if err == nil {
|
|
return endpoint, nil
|
|
}
|
|
if !errors.Is(err, ErrRemoteDebugEndpointUnavailable) {
|
|
return RemoteDebugEndpoint{}, err
|
|
}
|
|
timer := time.NewTimer(pollInterval)
|
|
select {
|
|
case <-ctx.Done():
|
|
timer.Stop()
|
|
return RemoteDebugEndpoint{}, fmt.Errorf("%w: %v", ErrRemoteDebugEndpointUnavailable, ctx.Err())
|
|
case <-timer.C:
|
|
}
|
|
}
|
|
}
|
|
|
|
func (i *CDPInspector) FindAvailableRemoteDebugPort(ctx context.Context, start int) (int, error) {
|
|
if i == nil || !domain.ValidRemoteDebugPort(start) {
|
|
return 0, fmt.Errorf("%w: start port must be between %d and %d", ErrRemoteDebugPortUnavailable, domain.MinRemoteDebugPort, domain.MaxRemoteDebugPort)
|
|
}
|
|
for offset := 0; offset < remoteDebugPortAttempts && start+offset <= domain.MaxRemoteDebugPort; offset++ {
|
|
if err := ctx.Err(); err != nil {
|
|
return 0, err
|
|
}
|
|
port := start + offset
|
|
listener, err := net.Listen("tcp4", net.JoinHostPort("127.0.0.1", strconv.Itoa(port)))
|
|
if err != nil {
|
|
continue
|
|
}
|
|
_ = listener.Close()
|
|
return port, nil
|
|
}
|
|
return 0, fmt.Errorf("%w: no free port in %d candidates starting at %d", ErrRemoteDebugPortUnavailable, remoteDebugPortAttempts, start)
|
|
}
|
|
|
|
func parseDevToolsActivePort(data []byte) (int, error) {
|
|
lines := strings.Split(strings.ReplaceAll(string(data), "\r\n", "\n"), "\n")
|
|
if len(lines) < 2 {
|
|
return 0, fmt.Errorf("%w: malformed active port file", ErrRemoteDebugEndpointUnavailable)
|
|
}
|
|
port, err := strconv.Atoi(strings.TrimSpace(lines[0]))
|
|
if err != nil || !domain.ValidRemoteDebugPort(port) {
|
|
return 0, fmt.Errorf("%w: malformed active port", ErrRemoteDebugEndpointUnavailable)
|
|
}
|
|
if strings.TrimSpace(lines[1]) == "" {
|
|
return 0, fmt.Errorf("%w: missing browser endpoint", ErrRemoteDebugEndpointUnavailable)
|
|
}
|
|
return port, nil
|
|
}
|
|
|
|
func browserVersionMatchesKind(browser string, kind domain.BrowserKind) bool {
|
|
switch kind {
|
|
case domain.BrowserChrome:
|
|
return strings.HasPrefix(browser, "Chrome/") || strings.HasPrefix(browser, "HeadlessChrome/")
|
|
case domain.BrowserEdge:
|
|
return strings.HasPrefix(browser, "Edg/") || strings.HasPrefix(browser, "HeadlessEdg/")
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func sanitizeRemoteDebugTargetURL(value string) string {
|
|
parsed, err := url.Parse(strings.TrimSpace(value))
|
|
if err != nil || parsed == nil {
|
|
return ""
|
|
}
|
|
parsed.User = nil
|
|
parsed.RawQuery = ""
|
|
parsed.ForceQuery = false
|
|
parsed.Fragment = ""
|
|
return truncateRemoteDebugTargetText(parsed.String())
|
|
}
|
|
|
|
func truncateRemoteDebugTargetText(value string) string {
|
|
if len(value) <= remoteDebugTargetTextMax {
|
|
return value
|
|
}
|
|
cut := remoteDebugTargetTextMax
|
|
for cut > 0 && !utf8.RuneStart(value[cut]) {
|
|
cut--
|
|
}
|
|
return value[:cut]
|
|
}
|