fix(allanime): keep fast4speed direct source fallback

Author: Vittuu

docs/SCRAPING_INTEGRATION.md

@@ -84,6 +84,26 @@ type UnifiedScraper interface {
 5. **Error Handling with Fallbacks**
 6. **Metadata Extraction**
 
+### AllAnime Provider Notes
+
+The AllAnime implementation follows the current `ani-cli` provider behavior for
+source resolution:
+
+- GraphQL requests use `https://api.allanime.day/api`.
+- Provider and playback requests use `https://allmanga.to` as the referer.
+- Encoded `/clock` source URLs are decoded with the ani-cli hex substitution
+  table and normalized to `/clock.json`.
+- `tools.fast4speed.rsvp` entries are treated as direct playable URLs. Some
+  shows expose this provider while the `/apivtwo/clock.json` providers return
+  server errors, so the resolver keeps the direct URL as a fallback instead of
+  requiring it to return a secondary JSON link list.
+
+Regression coverage:
+
+```bash
+go test ./internal/scraper -run TestProcessSourceURLsConcurrentFallsBackToFast4SpeedDirectSource -count=1
+```
+
 
 
 ### Command Equivalents

internal/api/allanime_enhanced.go

@@ -106,6 +106,9 @@ func GetAllAnimeEpisodeURLDirect(anime *models.Anime, episodeNumber string, qual
 	if err != nil {
 		return "", nil, fmt.Errorf("failed to get episode URL: %w", err)
 	}
+	if referer, ok := metadata["referer"]; ok && referer != "" {
+		util.SetGlobalReferer(referer)
+	}
 
 	// Add additional metadata
 	metadata["navigator"] = "allanime"

internal/scraper/allanime.go

@@ -676,6 +676,16 @@ func (c *AllAnimeClient) processSourceURLsConcurrent(sourceURLs []string, qualit
 
 	for i, sourceURL := range sourceURLs {
 		go func(idx int, url string) {
+			if c.isDirectProviderURL(url) {
+				results <- result{
+					index:     idx,
+					sourceURL: url,
+					links: map[string]string{
+						"direct": url,
+					},
+				}
+				return
+			}
 
 			links, err := c.getLinks(url)
 			if err != nil {
@@ -778,6 +788,10 @@ func (c *AllAnimeClient) getPriorityScore(url string) int {
 	return 0
 }
 
+func (c *AllAnimeClient) isDirectProviderURL(sourceURL string) bool {
+	return strings.Contains(sourceURL, "tools.fast4speed.rsvp")
+}
+
 // extractSourceURLs extracts source URLs from the API response
 func (c *AllAnimeClient) extractSourceURLs(response string) []string {
 	// Check if the response contains a "tobeparsed" blob (AES-encrypted source URLs).
@@ -905,8 +919,8 @@ func (c *AllAnimeClient) getLinks(sourceURL string) (map[string]string, error) {
 		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
 
-	// Use the same headers as Curd for better compatibility
-	req.Header.Set("Referer", "https://allanime.to")
+	// Match ani-cli: AllAnime's current providers expect the allmanga referer.
+	req.Header.Set("Referer", c.referer)
 	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/121.0")
 
 	resp, err := c.client.Do(req) // #nosec G704
@@ -1079,6 +1093,13 @@ func (c *AllAnimeClient) selectQuality(links map[string]string, requestedQuality
 		return url, metadata
 	}
 
+	if url, exists := links["direct"]; exists {
+		metadata["quality"] = "direct"
+		metadata["type"] = "direct"
+		metadata["referer"] = c.referer
+		return url, metadata
+	}
+
 	// Return first priority link available
 	for quality, url := range links {
 		if before, ok := strings.CutSuffix(quality, "_priority"); ok {

internal/scraper/allanime_test.go

@@ -1369,7 +1369,7 @@ func TestGetLinksVerifiesRefererHeader(t *testing.T) {
 	defer server.Close()
 
 	_, _ = newTestClient(server.URL).getLinks(server.URL)
-	assert.Equal(t, "https://allanime.to", capturedReferer)
+	assert.Equal(t, AllAnimeReferer, capturedReferer)
 }
 
 // ---------------------------------------------------------------------------
@@ -1518,6 +1518,31 @@ func TestProcessSourceURLsConcurrentPartialFailure(t *testing.T) {
 	assert.Less(t, time.Since(startedAt), 2*time.Second, "successful fallback should not wait for the global timeout")
 }
 
+func TestProcessSourceURLsConcurrentFallsBackToFast4SpeedDirectSource(t *testing.T) {
+	t.Parallel()
+
+	failServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+	}))
+	defer failServer.Close()
+
+	client := newTestClient(failServer.URL)
+	directURL := "https://tools.fast4speed.rsvp//media9/videos/gHQe2eBBh57QdC9hZ/sub/1"
+
+	url, meta, err := client.processSourceURLsConcurrent(
+		[]string{failServer.URL + "/clock.json", directURL},
+		"worst", "gHQe2eBBh57QdC9hZ", "1",
+	)
+
+	require.NoError(t, err)
+	assert.Equal(t, directURL, url)
+	assert.Equal(t, "direct", meta["quality"])
+	assert.Equal(t, "direct", meta["type"])
+	assert.Equal(t, AllAnimeReferer, meta["referer"])
+	assert.Equal(t, "gHQe2eBBh57QdC9hZ", meta["anime_id"])
+	assert.Equal(t, "1", meta["episode"])
+}
+
 func TestProcessSourceURLsConcurrentHighPriorityWins(t *testing.T) {
 	t.Parallel()