fix(login): don't abort browser login when a single poll request stalls (#26)

A single poll of /cli-session/<nonce>/key that outlived the 5s
per-request http.Client timeout escaped the retry loop as fatal:
since Go 1.16 the client's timeout error matches
errors.Is(err, context.DeadlineExceeded), so it was indistinguishable
from the overall login deadline and rendered as "login timed out"
after ~5 seconds instead of the advertised 90.

Classify the terminal condition via ctx.Err() (the outer deadline or
a cancel) instead of the error sentinel; per-request stalls now fold
into pollTransient and the loop keeps polling. The client timeout
moves to a package-level var so the regression test can shrink it —
the test stalls the first response past the client timeout, serves
the key on the second, and asserts the poll survives (fails before
the fix, passes after).

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: anujhydrabadi

cmd/login.go

@@ -28,6 +28,11 @@ import (
 // 5-minute server-side TTL.
 const pollInterval = 1500 * time.Millisecond
 
+// pollRequestTimeout bounds a SINGLE poll attempt. A request that
+// outlives it is a transient failure (retry), never the overall login
+// deadline. Var rather than const so tests can shrink it.
+var pollRequestTimeout = 5 * time.Second
+
 var (
 	loginProfile string
 	loginURL     string
@@ -240,7 +245,7 @@ func browserSessionPollLogin(out io.Writer, asJSON bool, profileName, baseURL st
 func pollSessionKey(ctx context.Context, baseURL, nonce string, interval time.Duration) (string, error) {
 	endpoint := fmt.Sprintf("%s/ai-api/v1/cli-session/%s/key",
 		strings.TrimRight(baseURL, "/"), nonce)
-	client := &http.Client{Timeout: 5 * time.Second}
+	client := &http.Client{Timeout: pollRequestTimeout}
 
 	for {
 		key, status, err := pollSessionOnce(ctx, client, endpoint)
@@ -278,9 +283,15 @@ func pollSessionOnce(ctx context.Context, client *http.Client, endpoint string)
 	}
 	resp, err := client.Do(req)
 	if err != nil {
-		if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
-			return "", pollPending, err
+		if ctx.Err() != nil {
+			// The OVERALL login deadline (or a cancel) fired — stop.
+			return "", pollPending, ctx.Err()
 		}
+		// Everything else is transient and must keep the loop polling.
+		// That includes the client's own per-request timeout, whose
+		// error matches errors.Is(err, context.DeadlineExceeded) since
+		// Go 1.16 — checking the error instead of ctx.Err() here used
+		// to abort the whole login as "timed out" after one slow poll.
 		return "", pollTransient, nil
 	}
 	defer resp.Body.Close()

cmd/login_test.go

@@ -171,6 +171,42 @@ func TestPollSessionKey_FatalOn400(t *testing.T) {
 	}
 }
 
+func TestPollSessionKey_SlowRequestIsTransientNotTimeout(t *testing.T) {
+	// Regression: a single poll request that outlived the per-request
+	// http.Client timeout used to be reported as context.DeadlineExceeded
+	// (the client wraps its timeout error to match that sentinel since
+	// Go 1.16), which the login flow renders as "login timed out" — long
+	// before the overall 90s deadline. A stalled request must instead be
+	// treated as transient and the loop must keep polling.
+	prev := pollRequestTimeout
+	pollRequestTimeout = 50 * time.Millisecond
+	defer func() { pollRequestTimeout = prev }()
+
+	var calls atomic.Int32
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if calls.Add(1) == 1 {
+			time.Sleep(250 * time.Millisecond) // outlive the client timeout
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{"plaintext_key":"sk_live_AFTER_STALL"}`))
+	}))
+	defer srv.Close()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+	got, err := pollSessionKey(ctx, srv.URL, "n", fastPoll)
+	if err != nil {
+		t.Fatalf("a single stalled request should be transient, got err = %v", err)
+	}
+	if got != "sk_live_AFTER_STALL" {
+		t.Errorf("got %q, want sk_live_AFTER_STALL", got)
+	}
+	if calls.Load() < 2 {
+		t.Errorf("expected a retry after the stalled request, got %d calls", calls.Load())
+	}
+}
+
 func TestPollSessionKey_TimeoutReturnsDeadlineExceeded(t *testing.T) {
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusNoContent) // always pending