feat(browser): auto-commit con 60 cambios

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

functions/browser/cdp_handle_dialog.go

@@ -1,35 +1,106 @@
 package browser
 
-import "fmt"
+import (
+	"fmt"
+	"sync"
+)
+
+// DialogLog acumula lo que CdpHandleDialog auto-respondió. El worker lo rellena en
+// cada diálogo; el caller lo lee con Snapshot() de forma segura (mutex interno).
+// Los campos son públicos para inspección directa en tests controlados, pero en
+// concurrencia usa siempre Snapshot() para evitar data races.
+type DialogLog struct {
+	mu          sync.Mutex
+	Count       int    // número de diálogos auto-respondidos
+	LastType    string // tipo del último diálogo: alert|confirm|prompt|beforeunload
+	LastMessage string // mensaje del último diálogo
+}
+
+// record registra un diálogo auto-respondido. Es el núcleo puro (no toca CDP).
+func (l *DialogLog) record(dialogType, message string) {
+	l.mu.Lock()
+	l.Count++
+	l.LastType = dialogType
+	l.LastMessage = message
+	l.mu.Unlock()
+}
+
+// Snapshot devuelve una copia consistente del estado actual del log.
+func (l *DialogLog) Snapshot() (count int, lastType, lastMessage string) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return l.Count, l.LastType, l.LastMessage
+}
+
+// dialogJobBuffer es el tamaño del canal que desacopla el readLoop del worker
+// que responde diálogos. Amplio para absorber ráfagas sin bloquear la lectura
+// del WebSocket.
+const dialogJobBuffer = 64
 
 // CdpHandleDialog instala un auto-handler que responde automaticamente a todos
-// los dialogos JS (alert, confirm, prompt, beforeunload) hasta que se llame
-// la funcion cancel devuelta. Usa el evento Page.javascriptDialogOpening y
+// los dialogos JS (alert, confirm, prompt, beforeunload) hasta que se llame la
+// funcion cancel devuelta. Usa el evento Page.javascriptDialogOpening y
 // Page.handleJavaScriptDialog del protocolo CDP.
 //
-// IMPORTANTE: el handler interno despacha la respuesta en una goroutine nueva
-// para evitar deadlock — el evento llega en la goroutine de lectura del
-// WebSocket, y sendCDP bloquea esperando una respuesta que leeria esa misma
-// goroutine si se llamara de forma sincrona.
-func CdpHandleDialog(c *CDPConn, accept bool, promptText string) (func(), error) {
+// Devuelve, además del cancel, un *DialogLog que el handler rellena en cada
+// diálogo: así el caller sabe cuántos diálogos se auto-respondieron y cuál fue
+// el último (tipo + mensaje).
+//
+// Concurrencia: el handler de evento corre en la goroutine de lectura del
+// WebSocket y NO puede llamar sendCDP de forma síncrona (deadlock). En vez de
+// lanzar una goroutine nueva por diálogo (spawn ilimitado), encola el evento en
+// un canal con buffer que consume UN único worker; el worker serializa las
+// respuestas. cancel() detiene el worker y des-registra el handler; es
+// idempotente (seguro llamarlo varias veces).
+func CdpHandleDialog(c *CDPConn, accept bool, promptText string) (func(), *DialogLog, error) {
 	if c == nil {
-		return nil, fmt.Errorf("cdp handle dialog: conexion nula")
+		return nil, nil, fmt.Errorf("cdp handle dialog: conexion nula")
 	}
 
 	if _, err := c.sendCDP("Page.enable", nil); err != nil {
-		return nil, fmt.Errorf("cdp handle dialog: %w", err)
+		return nil, nil, fmt.Errorf("cdp handle dialog: %w", err)
 	}
 
-	cancel := c.OnEvent("Page.javascriptDialogOpening", func(method string, params map[string]any) {
-		p := map[string]any{"accept": accept}
-		if promptText != "" {
-			p["promptText"] = promptText
+	dlog := &DialogLog{}
+	jobs := make(chan map[string]any, dialogJobBuffer)
+	done := make(chan struct{})
+
+	// Worker único: serializa las respuestas a diálogos. Una sola goroutine para
+	// toda la vida del handler, no una por diálogo.
+	go func() {
+		for {
+			select {
+			case params := <-jobs:
+				dtype, _ := params["type"].(string)
+				msg, _ := params["message"].(string)
+				dlog.record(dtype, msg)
+				p := map[string]any{"accept": accept}
+				if promptText != "" {
+					p["promptText"] = promptText
+				}
+				_, _ = c.sendCDP("Page.handleJavaScriptDialog", p)
+			case <-done:
+				return
+			}
+		}
+	}()
+
+	cancelEvent := c.OnEvent("Page.javascriptDialogOpening", func(_ string, params map[string]any) {
+		// Encolar sin bloquear el readLoop. Si el buffer está lleno (tormenta de
+		// diálogos), descartamos ese evento para no colgar la conexión entera.
+		select {
+		case jobs <- params:
+		default:
 		}
-		// go es OBLIGATORIO: el handler corre en la goroutine de lectura del
-		// WebSocket. Llamar sendCDP aqui directamente provoca deadlock porque
-		// sendCDP espera una respuesta que la misma goroutine deberia leer.
-		go c.sendCDP("Page.handleJavaScriptDialog", p) //nolint:errcheck
 	})
 
-	return cancel, nil
+	var once sync.Once
+	cancel := func() {
+		once.Do(func() {
+			cancelEvent()
+			close(done)
+		})
+	}
+
+	return cancel, dlog, nil
 }