fix: pipe selection, CDP debugger stability, and E2E tests (#9)

- Pipe selection: try every discovered pipe with getInfo health check
- CDP stability: detach-before-attach with auto-retry on detach errors
- Debug logging: optional BRIDGE_DEBUG_LOG env var for MCP debugging
- Tests: client and MCP E2E tests for session lifecycle and retry paths
- CI: migrate golangci-lint config to v2 format

Author: DeliciousBuding

.golangci.yml

@@ -1,66 +1,63 @@
+version: "2"
+
 run:
-  timeout: 3m
   tests: true
-  # Pin the analysis target below the latest released golangci-lint
-  # toolchain (currently 1.24). The project's go.mod declares 1.26 for
-  # the runtime toolchain, but no 1.25+ syntax is used; this just stops
-  # golangci-lint from refusing to load the config.
-  go: "1.24"
 
 linters:
-  disable-all: true
+  default: none
   enable:
     - errcheck
-    - gosimple
     - govet
     - ineffassign
     - staticcheck
     - unused
     - misspell
     - unconvert
     - revive
+  settings:
+    errcheck:
+      check-type-assertions: false
+      exclude-functions:
+        - encoding/json.Unmarshal
+        - encoding/json.Marshal
+        - (*encoding/json.Encoder).Encode
+        - fmt.Fprintln
+        - fmt.Fprintf
+        - fmt.Println
+        - fmt.Printf
+    revive:
+      rules:
+        - name: blank-imports
+        - name: context-as-argument
+        - name: error-return
+        - name: error-strings
+        - name: error-naming
+        - name: exported
+          arguments: ["disableStutteringCheck"]
+        - name: increment-decrement
+        - name: var-declaration
+        - name: range
+        - name: receiver-naming
+        - name: time-naming
+        - name: unexported-return
+        - name: indent-error-flow
+        - name: errorf
+        - name: empty-block
+        - name: superfluous-else
+        - name: unused-parameter
+  exclusions:
+    rules:
+      - path: _test\.go
+        linters:
+          - errcheck
+          - revive
+          - unused
+
+formatters:
+  enable:
     - gofmt
     - goimports
 
-linters-settings:
-  errcheck:
-    check-type-assertions: false
-    exclude-functions:
-      - encoding/json.Unmarshal
-      - encoding/json.Marshal
-      - (*encoding/json.Encoder).Encode
-      - fmt.Fprintln
-      - fmt.Fprintf
-      - fmt.Println
-      - fmt.Printf
-
-  revive:
-    rules:
-      - name: blank-imports
-      - name: context-as-argument
-      - name: error-return
-      - name: error-strings
-      - name: error-naming
-      - name: exported
-        arguments: ["disableStutteringCheck"]
-      - name: increment-decrement
-      - name: var-declaration
-      - name: range
-      - name: receiver-naming
-      - name: time-naming
-      - name: unexported-return
-      - name: indent-error-flow
-      - name: errorf
-      - name: empty-block
-      - name: superfluous-else
-      - name: unused-parameter
-
 issues:
-  exclude-rules:
-    - path: _test\.go
-      linters:
-        - errcheck
-        - revive
-        - unused
   max-issues-per-linter: 0
   max-same-issues: 0

cmd/bridge/main.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"flag"
 	"fmt"
+	"io"
 	"log"
 	"os"
 
@@ -27,6 +28,14 @@ func main() {
 
 	logger := log.New(os.Stderr, "[codex-bridge] ", log.LstdFlags)
 
+	// If BRIDGE_DEBUG_LOG is set, also tee logs to that file
+	if debugPath := os.Getenv("BRIDGE_DEBUG_LOG"); debugPath != "" {
+		if f, err := os.OpenFile(debugPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644); err == nil {
+			logger = log.New(io.MultiWriter(os.Stderr, f), "[codex-bridge] ", log.LstdFlags)
+			defer func() { _ = f.Close() }()
+		}
+	}
+
 	switch *mode {
 	case "discover":
 		runDiscover()
@@ -55,21 +64,25 @@ func runDiscover() {
 }
 
 func runMCP(pipeName string, logger *log.Logger) {
+	logger.Println("runMCP starting, discovering pipes...")
 	c, err := client.Connect(pipeName, logger)
 	if err != nil {
+		logger.Printf("Failed to connect: %v", err)
 		fmt.Fprintf(os.Stderr, "Failed to connect: %v\n", err)
 		os.Exit(1)
 	}
-	defer c.Close()
+	defer func() { _ = c.Close() }()
 
-	logger.Println("Connected to Codex browser pipe")
+	logger.Println("Connected to Codex browser pipe, starting MCP server...")
 
 	srv := mcp.NewMCPServer(c)
 	srv.SetVersion(version)
 	if err := srv.Run(); err != nil {
+		logger.Printf("MCP server error: %v", err)
 		fmt.Fprintf(os.Stderr, "MCP server error: %v\n", err)
 		os.Exit(1)
 	}
+	logger.Println("MCP server exited normally")
 }
 
 func runCLI(pipeName string, logger *log.Logger) {
@@ -78,7 +91,7 @@ func runCLI(pipeName string, logger *log.Logger) {
 		fmt.Fprintf(os.Stderr, "Failed to connect: %v\n", err)
 		os.Exit(1)
 	}
-	defer c.Close()
+	defer func() { _ = c.Close() }()
 
 	fmt.Println("Connected to Codex browser pipe")
 	fmt.Println("Commands: tabs, create, close <id>, user-tabs, claim <id>, nav <id> <url>,")

internal/client/browser.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strconv"
+	"strings"
 	"time"
 )
 
@@ -219,12 +220,40 @@ func (c *Client) attachTab(tabID int) error {
 	return err
 }
 
-// cdpWithAttach attaches the debugger and then executes a CDP command.
+// detachTab detaches the debugger from a tab.
+func (c *Client) detachTab(tabID int) error {
+	_, err := c.SendRequest("detach", map[string]interface{}{
+		"tabId": tabID,
+	})
+	return err
+}
+
+// cdpWithAttach ensures the debugger is attached and then executes a CDP command.
+// It first tries to detach (to clear any stale attachment state), then attach
+// fresh, then execute. If execute fails with "not attached", it retries once.
 func (c *Client) cdpWithAttach(tabID int, method string, params map[string]interface{}) (json.RawMessage, error) {
+	// Detach first to clear any stale debugger state from Chrome
+	_ = c.detachTab(tabID)
 	if err := c.attachTab(tabID); err != nil {
 		return nil, fmt.Errorf("attach failed for tab %d: %w", tabID, err)
 	}
-	return c.executeCdp(tabID, method, params)
+	raw, err := c.executeCdp(tabID, method, params)
+	if err != nil {
+		// If attach didn't take, try one more detach+attach+retry cycle
+		if isDebuggerError(err) {
+			_ = c.detachTab(tabID)
+			if err2 := c.attachTab(tabID); err2 != nil {
+				return nil, fmt.Errorf("retry attach failed for tab %d: %w", tabID, err2)
+			}
+			return c.executeCdp(tabID, method, params)
+		}
+		return nil, err
+	}
+	return raw, nil
+}
+
+func isDebuggerError(err error) bool {
+	return err != nil && strings.Contains(err.Error(), "not attached")
 }
 
 // --- Playwright API (via CDP) ---

internal/client/browser_rpc_test.go

@@ -72,26 +72,29 @@ func TestNavigateSendsCDPNavigate(t *testing.T) {
 	}
 
 	calls := rec.snapshot()
-	if len(calls) < 2 {
-		t.Fatalf("expected attach + executeCdp, got %d calls", len(calls))
+	if len(calls) < 3 {
+		t.Fatalf("expected detach + attach + executeCdp, got %d calls: %v", len(calls), calls)
 	}
-	if calls[0].method != "attach" {
-		t.Errorf("first call %q, want attach", calls[0].method)
+	if calls[0].method != "detach" {
+		t.Errorf("first call %q, want detach", calls[0].method)
 	}
-	if calls[1].method != "executeCdp" {
-		t.Errorf("second call %q, want executeCdp", calls[1].method)
+	if calls[1].method != "attach" {
+		t.Errorf("second call %q, want attach", calls[1].method)
 	}
-	target, _ := calls[1].params["target"].(map[string]interface{})
+	if calls[2].method != "executeCdp" {
+		t.Errorf("third call %q, want executeCdp", calls[2].method)
+	}
+	target, _ := calls[2].params["target"].(map[string]interface{})
 	if target == nil {
-		t.Fatalf("executeCdp missing nested target: %+v", calls[1].params)
+		t.Fatalf("executeCdp missing nested target: %+v", calls[2].params)
 	}
 	if got, ok := target["tabId"].(float64); !ok || int(got) != 17 {
 		t.Errorf("target.tabId = %v, want 17", target["tabId"])
 	}
-	if calls[1].params["method"] != "Page.navigate" {
-		t.Errorf("CDP method = %v, want Page.navigate", calls[1].params["method"])
+	if calls[2].params["method"] != "Page.navigate" {
+		t.Errorf("CDP method = %v, want Page.navigate", calls[2].params["method"])
 	}
-	cmd, _ := calls[1].params["commandParams"].(map[string]interface{})
+	cmd, _ := calls[2].params["commandParams"].(map[string]interface{})
 	if cmd["url"] != "https://example.com" {
 		t.Errorf("commandParams.url = %v", cmd["url"])
 	}

internal/client/client.go

@@ -33,7 +33,8 @@ type Client struct {
 }
 
 // Connect dials a named pipe and returns a ready-to-use Client.
-// If pipeName is empty, auto-discovers the first codex-browser-use-* pipe.
+// If pipeName is empty, auto-discovers codex-browser-use-* pipes and tries each
+// one until a successful connection is made.
 func Connect(pipeName string, logger *log.Logger) (*Client, error) {
 	if pipeName == "" {
 		pipes, err := discovery.DiscoverCodexPipes()
@@ -48,18 +49,46 @@ func Connect(pipeName string, logger *log.Logger) (*Client, error) {
 				"  3. Codex Chrome Extension is installed and enabled\n" +
 				"  4. The extension has connected to Codex Desktop (open a Codex chat once to trigger initialization)")
 		}
-		pipeName = pipes[0].Name
-		if logger != nil {
-			logger.Printf("auto-discovered pipe: %s", pipeName)
+
+		// Try each pipe until one connects AND passes health check
+		var lastErr error
+		for _, p := range pipes {
+			path := discovery.PipePath(p.Name)
+			conn, err := dialNamedPipe(path)
+			if err != nil {
+				lastErr = err
+				if logger != nil {
+					logger.Printf("pipe %s failed: %v, trying next...", p.UUID, err)
+				}
+				continue
+			}
+			c := NewFromConn(conn, logger)
+			// Health check: send a quick getInfo to verify the pipe is usable
+			result, err := c.SendRequest("getInfo", nil)
+			if err != nil {
+				_ = c.Close()
+				lastErr = err
+				if logger != nil {
+					logger.Printf("pipe %s health check failed: %v, trying next...", p.UUID, err)
+				}
+				continue
+			}
+			if logger != nil {
+				logger.Printf("auto-discovered pipe: %s (verified, info=%s)", p.Name, truncate(string(result), 120))
+			}
+			return c, nil
 		}
+		return nil, fmt.Errorf("all %d pipes failed; last error: %w. "+
+			"Try: restart Codex Desktop, then re-open the Codex Chrome Extension",
+			len(pipes), lastErr)
 	}
 
 	path := discovery.PipePath(pipeName)
 	conn, err := dialNamedPipe(path)
 	if err != nil {
-		return nil, fmt.Errorf("dial pipe %s: %w\n"+
-			"This usually means the pipe is stale (Codex Desktop restarted) or the extension lost its host.\n"+
-			"Try: restart Codex Desktop, then re-open the Codex Chrome Extension.", path, err)
+		return nil, fmt.Errorf("dial pipe %s: %w. "+
+			"This usually means the pipe is stale (Codex Desktop restarted) or the extension lost its host. "+
+			"Try: restart Codex Desktop, then re-open the Codex Chrome Extension", path, err)
 	}
 
 	return NewFromConn(conn, logger), nil