Improve storage controls and API compatibility

Author: Welfordian

docs/arr-setup.md

@@ -58,13 +58,26 @@ Same steps as Sonarr, but use category `movies-radarr` (or your preferred catego
 | Method | Path | Purpose |
 |--------|------|---------|
 | POST | `/api/v2/auth/login` | Cookie-based login |
+| POST | `/api/v2/auth/logout` | Clear session cookie |
 | GET | `/api/v2/app/version` | Client compatibility check |
 | GET | `/api/v2/app/webapiVersion` | API version (`2.11.0`) |
+| GET | `/api/v2/app/buildInfo` | Build information stub |
+| GET | `/api/v2/app/preferences` | qBittorrent preferences stub |
+| GET | `/api/v2/app/defaultSavePath` | Default save path (`/downloads`) |
+| GET | `/api/v2/transfer/info` | Global transfer state |
 | POST | `/api/v2/torrents/add` | Add magnet (`urls` + optional `category`) |
 | GET | `/api/v2/torrents/info` | List torrents |
+| GET | `/api/v2/torrents/properties` | Torrent properties by hash |
+| GET | `/api/v2/torrents/files` | Torrent file list by hash |
+| GET | `/api/v2/torrents/categories` | Category list |
+| POST | `/api/v2/torrents/createCategory` | Create category stub |
+| POST | `/api/v2/torrents/setCategory` | Assign category by hash |
 | POST | `/api/v2/torrents/delete` | Remove by info hash |
+| GET/POST | Additional qBit management probes | Safe stubs for tags, limits, pause/resume, recheck/reannounce |
 | GET | `/api/v2/sync/maindata` | Polling sync (full state stub) |
 
+`GET /api/v2` returns a small compatibility descriptor for browser/manual checks. qBittorrent-compatible clients should still use the grouped endpoints above.
+
 ## curl sanity check
 
 ```bash

internal/api/admin/handlers.go

@@ -104,6 +104,11 @@ func (h *Handler) stats(w http.ResponseWriter, r *http.Request) {
 	resp := map[string]any{
 		"diskUsed":        s.DiskUsed,
 		"diskQuota":       s.DiskQuota,
+		"s3Used":          s.S3Used,
+		"s3Quota":         s.S3Quota,
+		"s3QuotaGb":       h.effectiveS3QuotaGB(),
+		"s3ObjectCount":   s.S3ObjectCount,
+		"s3Enabled":       s.S3Enabled,
 		"torrentCount":    s.TorrentCount,
 		"activeCount":     s.ActiveCount,
 		"downloadSpeed":   s.DownloadSpeed,
@@ -301,14 +306,18 @@ func (h *Handler) maintenanceCleanup(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	h.LogActivity(r.Context(), ActionMaintenance, map[string]any{
-		"ageRemoved":   result.AgeRemoved,
-		"quotaRemoved": result.QuotaRemoved,
+		"ageRemoved":     result.AgeRemoved,
+		"quotaRemoved":   result.QuotaRemoved,
+		"s3QuotaRemoved": result.S3QuotaRemoved,
 	})
 	writeJSON(w, http.StatusOK, map[string]any{
-		"ageRemoved":   result.AgeRemoved,
-		"quotaRemoved": result.QuotaRemoved,
-		"diskUsed":     result.DiskUsed,
-		"diskQuota":    result.DiskQuota,
+		"ageRemoved":     result.AgeRemoved,
+		"quotaRemoved":   result.QuotaRemoved,
+		"s3QuotaRemoved": result.S3QuotaRemoved,
+		"diskUsed":       result.DiskUsed,
+		"diskQuota":      result.DiskQuota,
+		"s3Used":         result.S3Used,
+		"s3Quota":        result.S3Quota,
 	})
 }
 
@@ -367,6 +376,8 @@ func (h *Handler) publicConfig(w http.ResponseWriter, r *http.Request) {
 		"publicUrl":      h.cfg.PublicURL,
 		"retentionDays":  h.effectiveRetentionDays(),
 		"diskQuotaGb":    h.effectiveDiskQuotaGB(),
+		"s3QuotaGb":      h.effectiveS3QuotaGB(),
+		"s3Enabled":      h.effectiveS3Enabled(),
 		"rateLimitMbps":  h.effectiveRateLimitMbps(),
 		"webdavEnabled":  h.cfg.WebDAVEnabled,
 		"metricsEnabled": h.cfg.MetricsEnabled,

internal/api/admin/handlers_test.go

@@ -584,6 +584,63 @@ func TestGetSettingsRedaction(t *testing.T) {
 	_ = db
 }
 
+func TestS3QuotaSettingsConfigAndStats(t *testing.T) {
+	h, _, db := newTestHandler(t)
+	ctx := context.Background()
+
+	patchRec := serve(t, h, http.MethodPatch, "/settings", []byte(`{"s3Enabled":true,"s3QuotaGb":9}`))
+	if patchRec.Code != http.StatusOK {
+		t.Fatalf("patch status = %d, body = %s", patchRec.Code, patchRec.Body.String())
+	}
+	var settingsResp map[string]any
+	if err := json.Unmarshal(patchRec.Body.Bytes(), &settingsResp); err != nil {
+		t.Fatalf("decode settings: %v", err)
+	}
+	if settingsResp["s3QuotaGb"] != float64(9) {
+		t.Fatalf("settings s3QuotaGb = %v", settingsResp["s3QuotaGb"])
+	}
+
+	rec := storage.TorrentRecord{
+		ID:       "S3API",
+		InfoHash: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+		Status:   "downloaded",
+		AddedAt:  time.Now().UTC(),
+		Files: []storage.TorrentFileRecord{
+			{ID: 1, TorrentID: "S3API", Path: "/remote.mkv", Bytes: 2048, Selected: true, ObjectKey: "remote/movie.mkv", RemoteStored: true},
+		},
+	}
+	if err := db.CreateTorrent(ctx, rec); err != nil {
+		t.Fatalf("create torrent: %v", err)
+	}
+
+	configRec := serve(t, h, http.MethodGet, "/config", nil)
+	if configRec.Code != http.StatusOK {
+		t.Fatalf("config status = %d", configRec.Code)
+	}
+	var configResp map[string]any
+	if err := json.Unmarshal(configRec.Body.Bytes(), &configResp); err != nil {
+		t.Fatalf("decode config: %v", err)
+	}
+	if configResp["s3QuotaGb"] != float64(9) || configResp["s3Enabled"] != true {
+		t.Fatalf("config S3 fields = %+v", configResp)
+	}
+
+	statsRec := serve(t, h, http.MethodGet, "/stats", nil)
+	if statsRec.Code != http.StatusOK {
+		t.Fatalf("stats status = %d", statsRec.Code)
+	}
+	var statsResp map[string]any
+	if err := json.Unmarshal(statsRec.Body.Bytes(), &statsResp); err != nil {
+		t.Fatalf("decode stats: %v", err)
+	}
+	if statsResp["s3Used"] != float64(2048) || statsResp["s3ObjectCount"] != float64(1) {
+		t.Fatalf("stats S3 usage = %+v", statsResp)
+	}
+	if statsResp["s3QuotaGb"] != float64(9) || statsResp["s3Quota"] != float64(9*1024*1024*1024) {
+		t.Fatalf("stats S3 quota = %+v", statsResp)
+	}
+}
+
 func TestDeleteSelfRejected(t *testing.T) {
 	cfg := testConfig()
 	cfg.MultiUserEnabled = true

internal/api/admin/settings.go

@@ -56,6 +56,20 @@ func (h *Handler) effectiveDiskQuotaGB() int64 {
 	return h.cfg.DiskQuotaGB
 }
 
+func (h *Handler) effectiveS3QuotaGB() int64 {
+	if h.settings != nil {
+		return h.settings.GetS3QuotaGB()
+	}
+	return objectstore.LoadFromEnv().QuotaGB
+}
+
+func (h *Handler) effectiveS3Enabled() bool {
+	if h.settings != nil {
+		return h.settings.GetS3Enabled()
+	}
+	return objectstore.LoadFromEnv().Enabled
+}
+
 func (h *Handler) effectiveRateLimitMbps() float64 {
 	if h.settings != nil {
 		return h.settings.GetDownloadRateLimitMbps()

internal/api/qbit/auth.go

@@ -50,14 +50,33 @@ func (s *sessionStore) valid(sid string) bool {
 	return true
 }
 
+func (s *sessionStore) delete(sid string) {
+	if sid == "" {
+		return
+	}
+	s.mu.Lock()
+	delete(s.sessions, sid)
+	s.mu.Unlock()
+}
+
 func (h *Handler) authMiddleware(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		cookie, err := r.Cookie(sessionCookie)
-		if err != nil || !h.sessions.valid(cookie.Value) {
-			w.WriteHeader(http.StatusForbidden)
+		if err == nil && h.sessions.valid(cookie.Value) {
+			next.ServeHTTP(w, r)
+			return
+		}
+		if user, password, ok := r.BasicAuth(); ok && h.authenticateLogin(r.Context(), user, password) {
+			next.ServeHTTP(w, r)
 			return
 		}
-		next.ServeHTTP(w, r)
+		if h.auth != nil {
+			if _, ok := h.auth.ValidateToken(r.Context(), r.Header.Get("Authorization")); ok {
+				next.ServeHTTP(w, r)
+				return
+			}
+		}
+		w.WriteHeader(http.StatusForbidden)
 	})
 }
 

internal/api/qbit/convert.go

@@ -133,6 +133,55 @@ func toQBitTorrent(rec *storage.TorrentRecord, category string) map[string]any {
 	}
 }
 
+func torrentProperties(rec *storage.TorrentRecord) map[string]any {
+	size := torrentSize(rec)
+	completed := downloadedBytes(rec)
+	piecesHave := 0
+	if torrentmgr.IsCompletedStatus(rec.Status) || completed >= size && size > 0 {
+		piecesHave = 1
+	}
+	return map[string]any{
+		"save_path":                defaultSave,
+		"creation_date":            rec.AddedAt.Unix(),
+		"piece_size":               size,
+		"comment":                  "",
+		"total_wasted":             int64(0),
+		"total_uploaded":           int64(0),
+		"total_uploaded_session":   int64(0),
+		"total_downloaded":         completed,
+		"total_downloaded_session": completed,
+		"up_limit":                 int64(0),
+		"dl_limit":                 int64(0),
+		"time_elapsed":             timeActive(rec),
+		"seeding_time":             int64(0),
+		"nb_connections":           0,
+		"nb_connections_limit":     -1,
+		"share_ratio":              float64(0),
+		"addition_date":            rec.AddedAt.Unix(),
+		"completion_date":          completionOn(rec),
+		"created_by":               "DebridNest",
+		"dl_speed":                 rec.Speed,
+		"dl_speed_avg":             int64(0),
+		"eta":                      etaSeconds(rec),
+		"last_seen":                int64(-1),
+		"peers":                    0,
+		"peers_total":              0,
+		"pieces_have":              piecesHave,
+		"pieces_num":               1,
+		"reannounce":               int64(-1),
+		"seeds":                    rec.Seeders,
+		"seeds_total":              rec.Seeders,
+		"total_size":               size,
+	}
+}
+
+func qbitFilePriority(f storage.TorrentFileRecord) int {
+	if !f.Selected {
+		return 0
+	}
+	return 1
+}
+
 func completionOn(rec *storage.TorrentRecord) int64 {
 	if rec.EndedAt != nil {
 		return rec.EndedAt.Unix()