feat(crossseed): add indexerName to webhook apply + fix category mode defaults (#916)

Author: s0up4200

README.md

@@ -564,15 +564,15 @@ In your autobrr filter, go to **External** tab → **Add new**:
 **Data (JSON):**
 ```json
 {
-  "torrentName": "{{ .TorrentName }}",
+  "torrentName": {{ toRawJson .TorrentName }},
   "instanceIds": [1]
 }
 ```
 
 To search all instances, omit `instanceIds`:
 ```json
 {
-  "torrentName": "{{ .TorrentName }}"
+  "torrentName": {{ toRawJson .TorrentName }}
 }
 ```
 
@@ -605,14 +605,16 @@ When `/check` returns `200 OK`, send the torrent to `/api/cross-seed/apply`:
 ```json
 {
   "torrentData": "{{ .TorrentDataRawBytes | toString | b64enc }}",
-  "instanceIds": [1]
+  "instanceIds": [1],
+  "indexerName": {{ toRawJson .IndexerName }}
 }
 ```
 
 - `torrentData` - Base64-encoded torrent file bytes
 - `instanceIds` - Target instances (omit to apply to any matching instance)
+- `indexerName` (optional) - Indexer display name (e.g., "TorrentDB"). Only used when "Use indexer name as category" mode is enabled; ignored otherwise
 - `tags` (optional) - Override webhook tags from settings
-- `category` (optional) - Override category (defaults to matched torrent's category)
+- `category` (optional) - Override category. Takes precedence over `indexerName`
 
 Cross-seeded torrents are added paused with `skip_checking=true`. qui polls the torrent state and auto-resumes if progress meets the size tolerance threshold. If progress is too low, it remains paused for manual review.
 

docs/CROSS_SEEDING.md

@@ -207,6 +207,15 @@ The `.cross` category is created automatically with the same save path as the ba
 
 Uses the indexer name (from the search source) as the category. Useful for organizing cross-seeds by tracker.
 
+**Note for webhook applies:** When using the `/api/cross-seed/apply` endpoint (autobrr webhook), the indexer name cannot be derived from the torrent file. To use this mode with webhook applies, include the `indexerName` field in your payload (ignored if this mode is not enabled):
+
+```json
+{
+  "torrentData": "{{ .TorrentDataRawBytes | toString | b64enc }}",
+  "indexerName": {{ toRawJson .IndexerName }}
+}
+```
+
 ### 3. Custom Category
 
 Uses a user-specified static category name for all cross-seeds. No suffix is applied—the exact category name you enter is used.
@@ -293,6 +302,33 @@ The incoming torrent has files not present in your matched torrent, and those fi
 - Verify the "Size mismatch tolerance" setting in Rules
 - Torrents below the auto-resume threshold stay paused for manual review
 
+### Webhook returns HTTP 400 "invalid character" error
+
+This typically means the torrent name contains special characters (like double quotes `"`) that break JSON encoding. The error often looks like:
+
+```json
+{"level":"error","error":"invalid character 'V' after object key:value pair","time":"...","message":"Failed to decode webhook check request"}
+```
+
+**Solution:** In your autobrr webhook configuration, use `toRawJson` instead of quoting the template variable directly:
+
+```json
+{
+  "torrentName": {{ toRawJson .TorrentName }},
+  "instanceIds": [1]
+}
+```
+
+**Not:**
+```json
+{
+  "torrentName": "{{ .TorrentName }}",
+  "instanceIds": [1]
+}
+```
+
+The `toRawJson` function (from Sprig) properly escapes special characters and outputs a valid JSON string including the quotes.
+
 ### Cross-seed in wrong category
 
 - Check your cross-seed settings in qui

internal/api/handlers/crossseed.go

@@ -5,6 +5,7 @@ package handlers
 
 import (
 	"context"
+	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -520,6 +521,29 @@ func (h *CrossSeedHandler) AutobrrApply(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
+	// Parse torrent for logging (cheap operation, also done in service)
+	var torrentName, torrentHash string
+	var totalSize int64
+	var fileCount int
+	if torrentBytes, err := base64.StdEncoding.DecodeString(req.TorrentData); err == nil {
+		if name, hash, files, info, err := crossseed.ParseTorrentMetadataWithInfo(torrentBytes); err == nil {
+			torrentName, torrentHash = name, hash
+			totalSize = info.TotalLength()
+			fileCount = len(files)
+		}
+	}
+
+	log.Debug().
+		Str("source", "cross-seed.webhook").
+		Str("torrentName", torrentName).
+		Str("torrentHash", torrentHash).
+		Int64("size", totalSize).
+		Int("fileCount", fileCount).
+		Ints("instanceIds", req.InstanceIDs).
+		Str("indexerName", req.IndexerName).
+		Str("category", req.Category).
+		Msg("Webhook apply: received request")
+
 	response, err := h.service.AutobrrApply(context.WithoutCancel(r.Context()), &req)
 	if err != nil {
 		status := mapCrossSeedErrorStatus(err)

internal/services/crossseed/autobrr_apply_test.go

@@ -137,6 +137,56 @@ func TestAutobrrApplyTargetInstanceIDs(t *testing.T) {
 	}
 }
 
+// TestAutobrrApply_IndexerNamePassthrough verifies that IndexerName from the request
+// is passed through to the CrossSeedRequest, enabling "Use indexer name as category" mode
+// for webhook applies where the indexer cannot be derived from the torrent file.
+func TestAutobrrApply_IndexerNamePassthrough(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+
+	tests := []struct {
+		name              string
+		indexerName       string
+		expectIndexerName string
+	}{
+		{
+			name:              "indexer name passed through",
+			indexerName:       "TorrentDB",
+			expectIndexerName: "TorrentDB",
+		},
+		{
+			name:              "empty indexer name remains empty",
+			indexerName:       "",
+			expectIndexerName: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			service := &Service{}
+			var captured *CrossSeedRequest
+			service.crossSeedInvoker = func(ctx context.Context, req *CrossSeedRequest) (*CrossSeedResponse, error) {
+				captured = req
+				return &CrossSeedResponse{Success: true}, nil
+			}
+
+			req := &AutobrrApplyRequest{
+				TorrentData: "ZGF0YQ==",
+				InstanceIDs: []int{1},
+				IndexerName: tt.indexerName,
+			}
+
+			_, err := service.AutobrrApply(ctx, req)
+			require.NoError(t, err)
+			require.NotNil(t, captured, "CrossSeedRequest should have been captured")
+			require.Equal(t, tt.expectIndexerName, captured.IndexerName, "IndexerName mismatch")
+		})
+	}
+}
+
 // TestAutobrrApply_RespectsWebhookSourceFilters verifies that AutobrrApply passes
 // webhook source filters through to the CrossSeedRequest. This is an integration test
 // that catches the bug where filters worked in isolation but weren't passed through the flow.
@@ -146,52 +196,52 @@ func TestAutobrrApply_RespectsWebhookSourceFilters(t *testing.T) {
 	ctx := context.Background()
 
 	tests := []struct {
-		name                     string
-		settings                 *models.CrossSeedAutomationSettings
-		expectCategories         []string
-		expectTags               []string
-		expectExcludeCategories  []string
-		expectExcludeTags        []string
+		name                    string
+		settings                *models.CrossSeedAutomationSettings
+		expectCategories        []string
+		expectTags              []string
+		expectExcludeCategories []string
+		expectExcludeTags       []string
 	}{
 		{
 			name: "include categories passed through",
 			settings: &models.CrossSeedAutomationSettings{
 				WebhookSourceCategories: []string{"movies", "tv"},
 			},
-			expectCategories:         []string{"movies", "tv"},
-			expectTags:               nil,
-			expectExcludeCategories:  nil,
-			expectExcludeTags:        nil,
+			expectCategories:        []string{"movies", "tv"},
+			expectTags:              nil,
+			expectExcludeCategories: nil,
+			expectExcludeTags:       nil,
 		},
 		{
 			name: "include tags passed through",
 			settings: &models.CrossSeedAutomationSettings{
 				WebhookSourceTags: []string{"cross-seed", "priority"},
 			},
-			expectCategories:         nil,
-			expectTags:               []string{"cross-seed", "priority"},
-			expectExcludeCategories:  nil,
-			expectExcludeTags:        nil,
+			expectCategories:        nil,
+			expectTags:              []string{"cross-seed", "priority"},
+			expectExcludeCategories: nil,
+			expectExcludeTags:       nil,
 		},
 		{
 			name: "exclude categories passed through",
 			settings: &models.CrossSeedAutomationSettings{
 				WebhookSourceExcludeCategories: []string{"cross-seed-link", "temp"},
 			},
-			expectCategories:         nil,
-			expectTags:               nil,
-			expectExcludeCategories:  []string{"cross-seed-link", "temp"},
-			expectExcludeTags:        nil,
+			expectCategories:        nil,
+			expectTags:              nil,
+			expectExcludeCategories: []string{"cross-seed-link", "temp"},
+			expectExcludeTags:       nil,
 		},
 		{
 			name: "exclude tags passed through",
 			settings: &models.CrossSeedAutomationSettings{
 				WebhookSourceExcludeTags: []string{"no-cross-seed", "blocked"},
 			},
-			expectCategories:         nil,
-			expectTags:               nil,
-			expectExcludeCategories:  nil,
-			expectExcludeTags:        []string{"no-cross-seed", "blocked"},
+			expectCategories:        nil,
+			expectTags:              nil,
+			expectExcludeCategories: nil,
+			expectExcludeTags:       []string{"no-cross-seed", "blocked"},
 		},
 		{
 			name: "all filters passed through together",
@@ -201,26 +251,26 @@ func TestAutobrrApply_RespectsWebhookSourceFilters(t *testing.T) {
 				WebhookSourceExcludeCategories: []string{"movies-Race"},
 				WebhookSourceExcludeTags:       []string{"temporary"},
 			},
-			expectCategories:         []string{"movies-LTS"},
-			expectTags:               []string{"important"},
-			expectExcludeCategories:  []string{"movies-Race"},
-			expectExcludeTags:        []string{"temporary"},
+			expectCategories:        []string{"movies-LTS"},
+			expectTags:              []string{"important"},
+			expectExcludeCategories: []string{"movies-Race"},
+			expectExcludeTags:       []string{"temporary"},
 		},
 		{
-			name:                     "nil settings results in empty filters",
-			settings:                 nil,
-			expectCategories:         nil,
-			expectTags:               nil,
-			expectExcludeCategories:  nil,
-			expectExcludeTags:        nil,
+			name:                    "nil settings results in empty filters",
+			settings:                nil,
+			expectCategories:        nil,
+			expectTags:              nil,
+			expectExcludeCategories: nil,
+			expectExcludeTags:       nil,
 		},
 		{
-			name:                     "empty settings results in empty filters",
-			settings:                 &models.CrossSeedAutomationSettings{},
-			expectCategories:         nil,
-			expectTags:               nil,
-			expectExcludeCategories:  nil,
-			expectExcludeTags:        nil,
+			name:                    "empty settings results in empty filters",
+			settings:                &models.CrossSeedAutomationSettings{},
+			expectCategories:        nil,
+			expectTags:              nil,
+			expectExcludeCategories: nil,
+			expectExcludeTags:       nil,
 		},
 	}
 

internal/services/crossseed/models.go

@@ -384,4 +384,8 @@ type AutobrrApplyRequest struct {
 	SkipIfExists   *bool    `json:"skipIfExists,omitempty"`
 	// FindIndividualEpisodes overrides the automation-level episode matching behavior when set.
 	FindIndividualEpisodes *bool `json:"findIndividualEpisodes,omitempty"`
+	// IndexerName is the display name of the indexer (e.g., "TorrentDB") used when
+	// "Use indexer name as category" mode is enabled. Without this field, webhook applies
+	// cannot derive the indexer from the torrent file itself.
+	IndexerName string `json:"indexerName,omitempty"`
 }

internal/services/crossseed/service.go

@@ -2542,6 +2542,7 @@ func (s *Service) AutobrrApply(ctx context.Context, req *AutobrrApplyRequest) (*
 		SkipAutoResume:               skipAutoResume,
 		SkipRecheck:                  skipRecheck,
 		SkipPieceBoundarySafetyCheck: skipPieceBoundarySafetyCheck,
+		IndexerName:                  req.IndexerName,
 	}
 	// Pass webhook source filters so CrossSeed respects them when finding candidates
 	if settings != nil {
@@ -3115,9 +3116,10 @@ func (s *Service) processCrossSeedCandidate(
 		} else {
 			result.Message = fmt.Sprintf("Added torrent with recheck (match: %s, category: %s)", matchType, crossCategory)
 		}
-		log.Debug().
+		log.Info().
 			Int("instanceID", candidate.InstanceID).
 			Str("instanceName", candidate.InstanceName).
+			Str("torrentName", torrentName).
 			Msg("Successfully added cross-seed torrent with recheck")
 	} else {
 		if categoryCreationFailed {
@@ -3215,9 +3217,10 @@ func (s *Service) processCrossSeedCandidate(
 	// Execute external program if configured (async, non-blocking)
 	s.executeExternalProgram(ctx, candidate.InstanceID, torrentHash)
 
-	logEvent := log.Debug().
+	logEvent := log.Info().
 		Int("instanceID", candidate.InstanceID).
 		Str("instanceName", candidate.InstanceName).
+		Str("torrentName", torrentName).
 		Str("torrentHash", torrentHash).
 		Str("matchedHash", matchedTorrent.Hash).
 		Str("matchType", matchType).

internal/web/swagger/openapi.yaml

@@ -3032,6 +3032,9 @@ paths:
                   type: boolean
                 findIndividualEpisodes:
                   type: boolean
+                indexerName:
+                  type: string
+                  description: Indexer display name (e.g., "TorrentDB"). Only used when "Use indexer name as category" mode is enabled; ignored otherwise. Webhook applies cannot derive the indexer from the torrent file, so this field is required for that mode.
       responses:
         '200':
           description: Torrent processed

web/src/pages/CrossSeedPage.tsx

@@ -721,11 +721,16 @@ export function CrossSeedPage({ activeTab, onTabChange }: CrossSeedPageProps) {
 
   useEffect(() => {
     if (settings && !globalSettingsInitialized) {
+      // If all three category modes are false, default to suffix mode
+      // This handles legacy databases where none were explicitly set
+      const hasCategoryMode = settings.useCrossCategorySuffix || settings.useCategoryFromIndexer || settings.useCustomCategory
+      const useCrossCategorySuffix = hasCategoryMode ? (settings.useCrossCategorySuffix ?? false) : true
+
       setGlobalSettings({
         findIndividualEpisodes: settings.findIndividualEpisodes,
         sizeMismatchTolerancePercent: settings.sizeMismatchTolerancePercent ?? 5.0,
         useCategoryFromIndexer: settings.useCategoryFromIndexer ?? false,
-        useCrossCategorySuffix: settings.useCrossCategorySuffix ?? true,
+        useCrossCategorySuffix,
         useCustomCategory: settings.useCustomCategory ?? false,
         customCategory: settings.customCategory ?? "",
         runExternalProgramId: settings.runExternalProgramId ?? null,
@@ -823,13 +828,17 @@ export function CrossSeedPage({ activeTab, onTabChange }: CrossSeedPageProps) {
 
     const ignorePatterns = Array.isArray(settings.ignorePatterns) ? settings.ignorePatterns : []
 
+    // If all three category modes are false, default to suffix mode
+    const hasCategoryMode = settings.useCrossCategorySuffix || settings.useCategoryFromIndexer || settings.useCustomCategory
+    const defaultCrossCategorySuffix = hasCategoryMode ? (settings.useCrossCategorySuffix ?? false) : true
+
     const globalSource = globalSettingsInitialized
       ? globalSettings
       : {
         findIndividualEpisodes: settings.findIndividualEpisodes,
         sizeMismatchTolerancePercent: settings.sizeMismatchTolerancePercent,
         useCategoryFromIndexer: settings.useCategoryFromIndexer,
-        useCrossCategorySuffix: settings.useCrossCategorySuffix ?? true,
+        useCrossCategorySuffix: defaultCrossCategorySuffix,
         useCustomCategory: settings.useCustomCategory ?? false,
         customCategory: settings.customCategory ?? "",
         runExternalProgramId: settings.runExternalProgramId ?? null,