Fix cross-app fly-replay: remove timeout/fallback that caused PDF 503s

When fly-replaying to a different app (e.g., smooth-pdf for PDF generation),
the timeout and fallback fields were causing Fly to cut off requests after
30s and return them to Navigator as failures, which served 503 maintenance
pages. This was a regression from adding timeout/fallback for same-app
cross-region replays.

Cross-app replays should let Fly handle the connection natively - the target
app (smooth-pdf) needs time to cold start and generate PDFs. Without timeout
and fallback, Fly waits for the target to respond without artificial cutoff.

Also removes transform headers from cross-app replays since they're
unnecessary (no loop detection needed) and their presence causes Fly to
drop the original Authorization header.

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

Author: rubys

internal/server/fly_replay.go

@@ -109,32 +109,25 @@ func HandleFlyReplay(w http.ResponseWriter, r *http.Request, target string, stat
 			responseMap = map[string]interface{}{
 				"app":      appName,
 				"instance": machineID,
-				"timeout":  DefaultFlyReplayTimeout,
-				"fallback": DefaultFlyReplayFallback,
 			}
 
-			// Only add transform if staying within the same app
+			// Only add timeout/fallback/transform for same-app replays
 			if currentAppName == appName {
+				responseMap["timeout"] = DefaultFlyReplayTimeout
+				responseMap["fallback"] = DefaultFlyReplayFallback
 				responseMap["transform"] = map[string]interface{}{
 					"set_headers": buildTransformHeaders(),
 				}
 			}
 		}
 	} else if strings.HasPrefix(target, "app=") {
-		// App-based fly-replay
+		// App-based fly-replay to a different app (e.g., smooth-pdf)
+		// No timeout/fallback - let Fly handle the connection natively,
+		// allowing cold starts to complete without artificial cutoff
 		appName := strings.TrimPrefix(target, "app=")
 
 		responseMap = map[string]interface{}{
-			"app":      appName,
-			"timeout":  DefaultFlyReplayTimeout,
-			"fallback": DefaultFlyReplayFallback,
-		}
-
-		// Only add transform if staying within the same app
-		if currentAppName == appName {
-			responseMap["transform"] = map[string]interface{}{
-				"set_headers": buildTransformHeaders(),
-			}
+			"app": appName,
 		}
 	} else {
 		// Region-based fly-replay (same app, different region)

internal/server/fly_replay_integration_test.go

@@ -135,12 +135,22 @@ func TestFlyReplayIntegration_EndToEnd(t *testing.T) {
 					}
 				}
 
-				// Verify timeout and fallback are present
-				if _, ok := response["timeout"]; !ok {
-					t.Error("Response should contain 'timeout' field")
-				}
-				if _, ok := response["fallback"]; !ok {
-					t.Error("Response should contain 'fallback' field")
+				// Cross-app replays should NOT have timeout/fallback
+				// Same-app (region) replays SHOULD have timeout/fallback
+				if tt.expectedApp != "" {
+					if _, ok := response["timeout"]; ok {
+						t.Error("Cross-app replay should not contain 'timeout' field")
+					}
+					if _, ok := response["fallback"]; ok {
+						t.Error("Cross-app replay should not contain 'fallback' field")
+					}
+				} else {
+					if _, ok := response["timeout"]; !ok {
+						t.Error("Response should contain 'timeout' field")
+					}
+					if _, ok := response["fallback"]; !ok {
+						t.Error("Response should contain 'fallback' field")
+					}
 				}
 
 			} else {

internal/server/fly_replay_test.go

@@ -199,51 +199,39 @@ func TestHandleFlyReplay(t *testing.T) {
 				}
 			}
 
-			// Verify timeout and fallback fields are present
-			if _, ok := response["timeout"]; !ok {
-				t.Error("Response should contain 'timeout' field")
-			}
-			if _, ok := response["fallback"]; !ok {
-				t.Error("Response should contain 'fallback' field")
-			}
-			if response["timeout"] != DefaultFlyReplayTimeout {
-				t.Errorf("timeout = %v, expected %v", response["timeout"], DefaultFlyReplayTimeout)
-			}
-			if response["fallback"] != DefaultFlyReplayFallback {
-				t.Errorf("fallback = %v, expected %v", response["fallback"], DefaultFlyReplayFallback)
-			}
-
-			// Check for transform headers
-			// Same-app and region replays should have transform with X-Navigator-Retry
-			// Different-app replays should not have transform
-			if strings.HasPrefix(tt.target, "machine=") {
+			// Cross-app replays should NOT have timeout/fallback (let Fly handle natively)
+			// Same-app (machine/region) replays SHOULD have timeout/fallback
+			// Determine if this is a cross-app replay
+			isCrossApp := false
+			if strings.HasPrefix(tt.target, "app=") {
+				isCrossApp = strings.TrimPrefix(tt.target, "app=") != tt.currentApp
+			} else if strings.HasPrefix(tt.target, "machine=") {
 				parts := strings.Split(strings.TrimPrefix(tt.target, "machine="), ":")
 				if len(parts) == 2 {
-					if parts[1] == tt.currentApp {
-						if _, ok := response["transform"]; !ok {
-							t.Error("Same-app replay should contain transform with retry header")
-						}
-					} else {
-						if _, ok := response["transform"]; ok {
-							t.Error("Different-app replay should not contain transform")
-						}
-					}
+					isCrossApp = parts[1] != tt.currentApp
 				}
-			} else if strings.HasPrefix(tt.target, "app=") {
-				appName := strings.TrimPrefix(tt.target, "app=")
-				if appName == tt.currentApp {
-					if _, ok := response["transform"]; !ok {
-						t.Error("Same-app replay should contain transform with retry header")
-					}
-				} else {
-					if _, ok := response["transform"]; ok {
-						t.Error("Different-app replay should not contain transform")
-					}
+			}
+			if isCrossApp {
+				if _, ok := response["timeout"]; ok {
+					t.Error("Cross-app replay should not contain 'timeout' field")
+				}
+				if _, ok := response["fallback"]; ok {
+					t.Error("Cross-app replay should not contain 'fallback' field")
+				}
+				if _, ok := response["transform"]; ok {
+					t.Error("Cross-app replay should not contain transform")
 				}
 			} else {
-				// Region-based always has transform
+				if response["timeout"] != DefaultFlyReplayTimeout {
+					t.Errorf("timeout = %v, expected %v", response["timeout"], DefaultFlyReplayTimeout)
+				}
+				if response["fallback"] != DefaultFlyReplayFallback {
+					t.Errorf("fallback = %v, expected %v", response["fallback"], DefaultFlyReplayFallback)
+				}
+
+				// Same-app and region replays should have transform with X-Navigator-Retry
 				if _, ok := response["transform"]; !ok {
-					t.Error("Region-based replay should contain transform with retry header")
+					t.Error("Same-app/region replay should contain transform with retry header")
 				}
 			}
 		})