feat: add local cdp startup and external association

2026-07-25 15:53:31 +08:00
parent 972c637716
commit 4063b851eb
17 changed files with 845 additions and 158 deletions
@@ -0,0 +1,182 @@
+package browser
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"chub/internal/domain"
+)
+
+const remoteDebugPortAttempts = 100
+
+var (
+	ErrRemoteDebugPortUnavailable     = errors.New("remote debugging port is unavailable")
+	ErrRemoteDebugEndpointUnavailable = errors.New("remote debugging endpoint is unavailable")
+)
+
+type RemoteDebugEndpoint struct {
+	Port    int
+	Browser 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)
+}
+
+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}},
+	}
+}
+
+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)
+	})
+}
+
+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
+	}
+}