No activity recorded yet.
{activityEnabled && (
diff --git a/web/src/components/instances/preferences/TrackerRulesPanel.tsx b/web/src/components/instances/preferences/TrackerRulesPanel.tsx
new file mode 100644
index 000000000..d930bf4ce
--- /dev/null
+++ b/web/src/components/instances/preferences/TrackerRulesPanel.tsx
@@ -0,0 +1,530 @@
+/*
+ * Copyright (c) 2025, s0up and the autobrr contributors.
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+import { Badge } from "@/components/ui/badge"
+import { Button } from "@/components/ui/button"
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
+import {
+ Dialog,
+ DialogContent,
+ DialogDescription,
+ DialogFooter,
+ DialogHeader,
+ DialogTitle
+} from "@/components/ui/dialog"
+import { Input } from "@/components/ui/input"
+import { Label } from "@/components/ui/label"
+import { MultiSelect, type Option } from "@/components/ui/multi-select"
+import { Switch } from "@/components/ui/switch"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { useInstanceTrackers } from "@/hooks/useInstanceTrackers"
+import { api } from "@/lib/api"
+import { cn } from "@/lib/utils"
+import type { TrackerRule, TrackerRuleInput } from "@/types"
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
+import { ArrowDown, ArrowUp, Clock, Loader2, Pencil, Plus, RefreshCw, Scale, Trash2 } from "lucide-react"
+import { useMemo, useState } from "react"
+import { toast } from "sonner"
+
+interface TrackerRulesPanelProps {
+ instanceId: number
+}
+
+type FormState = TrackerRuleInput & { trackerDomains: string[] }
+
+const emptyFormState: FormState = {
+ name: "",
+ trackerPattern: "",
+ trackerDomains: [],
+ category: "",
+ tag: "",
+ uploadLimitKiB: undefined,
+ downloadLimitKiB: undefined,
+ ratioLimit: undefined,
+ seedingTimeLimitMinutes: undefined,
+ enabled: true,
+}
+
+export function TrackerRulesPanel({ instanceId }: TrackerRulesPanelProps) {
+ const queryClient = useQueryClient()
+ const [dialogOpen, setDialogOpen] = useState(false)
+ const [editingRule, setEditingRule] = useState(null)
+ const [formState, setFormState] = useState(emptyFormState)
+
+ const trackersQuery = useInstanceTrackers(instanceId, { enabled: true })
+ const trackerOptions: Option[] = useMemo(() => {
+ if (!trackersQuery.data) return []
+ return Object.keys(trackersQuery.data)
+ .map((domain) => ({ label: domain, value: domain }))
+ .sort((a, b) => a.label.localeCompare(b.label))
+ }, [trackersQuery.data])
+
+ const rulesQuery = useQuery({
+ queryKey: ["tracker-rules", instanceId],
+ queryFn: () => api.listTrackerRules(instanceId),
+ })
+
+ const createOrUpdate = useMutation({
+ mutationFn: async (input: FormState) => {
+ if (editingRule) {
+ return api.updateTrackerRule(instanceId, editingRule.id, input)
+ }
+ return api.createTrackerRule(instanceId, input)
+ },
+ onSuccess: () => {
+ toast.success(`Tracker rule ${editingRule ? "updated" : "created"}`)
+ setDialogOpen(false)
+ setEditingRule(null)
+ setFormState(emptyFormState)
+ void queryClient.invalidateQueries({ queryKey: ["tracker-rules", instanceId] })
+ },
+ onError: (error) => {
+ toast.error(error instanceof Error ? error.message : "Failed to save tracker rule")
+ },
+ })
+
+ const deleteRule = useMutation({
+ mutationFn: (ruleId: number) => api.deleteTrackerRule(instanceId, ruleId),
+ onSuccess: () => {
+ toast.success("Tracker rule deleted")
+ void queryClient.invalidateQueries({ queryKey: ["tracker-rules", instanceId] })
+ },
+ onError: (error) => {
+ toast.error(error instanceof Error ? error.message : "Failed to delete tracker rule")
+ },
+ })
+
+ const reorderRules = useMutation({
+ mutationFn: (orderedIds: number[]) => api.reorderTrackerRules(instanceId, orderedIds),
+ onSuccess: () => {
+ void queryClient.invalidateQueries({ queryKey: ["tracker-rules", instanceId] })
+ },
+ })
+
+ const toggleEnabled = useMutation({
+ mutationFn: (rule: TrackerRule) => api.updateTrackerRule(instanceId, rule.id, { ...rule, enabled: !rule.enabled }),
+ onSuccess: () => {
+ void queryClient.invalidateQueries({ queryKey: ["tracker-rules", instanceId] })
+ },
+ onError: (error) => {
+ toast.error(error instanceof Error ? error.message : "Failed to toggle rule")
+ },
+ })
+
+ const applyRules = useMutation({
+ mutationFn: () => api.applyTrackerRules(instanceId),
+ onSuccess: () => {
+ toast.success("Tracker rules applied")
+ },
+ onError: (error) => {
+ toast.error(error instanceof Error ? error.message : "Failed to apply tracker rules")
+ },
+ })
+
+ const sortedRules = useMemo(() => {
+ const rules = rulesQuery.data ?? []
+ return [...rules].sort((a, b) => a.sortOrder - b.sortOrder || a.id - b.id)
+ }, [rulesQuery.data])
+
+ const openForCreate = () => {
+ setEditingRule(null)
+ setFormState(emptyFormState)
+ setDialogOpen(true)
+ }
+
+ const openForEdit = (rule: TrackerRule) => {
+ const domains = parseTrackerDomains(rule)
+ setEditingRule(rule)
+ setFormState({
+ name: rule.name,
+ trackerPattern: rule.trackerPattern,
+ trackerDomains: domains,
+ category: rule.category,
+ tag: rule.tag,
+ uploadLimitKiB: rule.uploadLimitKiB,
+ downloadLimitKiB: rule.downloadLimitKiB,
+ ratioLimit: rule.ratioLimit,
+ seedingTimeLimitMinutes: rule.seedingTimeLimitMinutes,
+ enabled: rule.enabled,
+ sortOrder: rule.sortOrder,
+ })
+ setDialogOpen(true)
+ }
+
+ const handleMove = (ruleId: number, direction: -1 | 1) => {
+ if (!sortedRules) return
+ const index = sortedRules.findIndex(r => r.id === ruleId)
+ const target = index + direction
+ if (index === -1 || target < 0 || target >= sortedRules.length) {
+ return
+ }
+ const nextOrder = sortedRules.map(r => r.id)
+ const [removed] = nextOrder.splice(index, 1)
+ nextOrder.splice(target, 0, removed)
+ reorderRules.mutate(nextOrder)
+ }
+
+ const handleSubmit = (event: React.FormEvent) => {
+ event.preventDefault()
+ if (!formState.name) {
+ toast.error("Name is required")
+ return
+ }
+ const selectedTrackers = formState.trackerDomains.filter(Boolean)
+ if (selectedTrackers.length === 0) {
+ toast.error("Select at least one tracker")
+ return
+ }
+ const payload: FormState = {
+ ...formState,
+ trackerDomains: selectedTrackers,
+ trackerPattern: selectedTrackers.join(","),
+ category: formState.category || undefined,
+ tag: formState.tag || undefined,
+ }
+ createOrUpdate.mutate(payload)
+ }
+
+ return (
+
+
+
+
+ Tracker Rules
+ Apply speed and ratio caps per tracker domain.
+
+
+
+
+
+
+ Loading rules...
+
+ ) : (sortedRules?.length ?? 0) === 0 ? (
+ No tracker rules yet. Add one to start enforcing per-tracker limits.
+ ) : (
+
+ {sortedRules.map((rule) => {
+ const actions = (
+ <>
+
+
+
+
+
+ )
+
+ return (
+
+
+
+
+ toggleEnabled.mutate(rule)}
+ disabled={toggleEnabled.isPending}
+ className="shrink-0"
+ />
+ {rule.name}
+ {!rule.enabled && (
+
+ Disabled
+
+ )}
+
+
+ {actions}
+
+
+
+
+
+
+ {actions}
+
+
+ )
+ })}
+
+
+
+
+ {trackers.length > 0 && (
+
+
+
+ {trackers[0]}
+ {trackers.length > 1 && (
+
+ +{trackers.length - 1}
+
+ )}
+
+
+
+ {trackers.join(", ")}
+
+
+ )}
+
+ {rule.category && (
+
+ Cat: {rule.category}
+
+ )}
+
+ {rule.tag && (
+
+ Tag: {rule.tag}
+
+ )}
+
+ {rule.uploadLimitKiB !== undefined && (
+
+
+ UL {rule.uploadLimitKiB} KiB/s
+
+ )}
+
+ {rule.downloadLimitKiB !== undefined && (
+
+
+ DL {rule.downloadLimitKiB} KiB/s
+
+ )}
+
+ {rule.ratioLimit !== undefined && (
+
+
+ Ratio {rule.ratioLimit}
+
+ )}
+
+ {rule.seedingTimeLimitMinutes !== undefined && (
+
+
+ {rule.seedingTimeLimitMinutes}m
+
+ )}
+
+
+
+
Services
+
+ Instance-level automation and helper services managed by qui.
+
+
+
+
+ {instances && instances.length > 0 && (
+
+ )}
+
+
+
+ {instances && instances.length === 0 && (
+
+ No instances configured yet. Add one in Settings to use services.
+
+ )}
+
+ {!selectedInstance && instances && instances.length > 0 && (
+
+ Select an active instance to configure services.
+
+ )}
+
+ {selectedInstance && (
+
+
+
+
+
+ )}
+