Support multiple root directories for monitoring (#80)

Sonarr users often have multiple library root folders, and using a
common parent directory risks processing Radarr (or other) folders
unintentionally. This adds support for configuring multiple root
directories to monitor independently.

## Config changes

`REWRITE_ROOT_DIR` (single path) remains fully backward compatible. New
`REWRITE_ROOT_DIRS` takes priority and accepts a comma-separated list:

```bash
REWRITE_ROOT_DIRS=/tv,/anime
```

The `rewrite_root_dir: Path` field is replaced by `rewrite_root_dirs:
list[Path]`.

## Component updates

- **`file_scanner`** — iterates over all root dirs per scan cycle;
checks `stop_event` before each root dir and `break`s the inner file
loop on signal
- **`file_monitor`** — registers a separate watchdog watch per root dir
- **`file_utils`** — adds `find_root_dir_for_file(file_path, root_dirs)`
to resolve which root dir owns a given file path
- **`backup_utils`** — backups now use the file's full absolute path
(minus the leading `/`) as the storage key, e.g. `/tv/Show A/tvshow.nfo`
→ `<BACKUP_DIR>/tv/Show A/tvshow.nfo`. This guarantees no collision when
files from different root dirs share the same relative path. The
`root_dir` parameter has been removed from all backup functions. An
optional `root_dirs` parameter provides backward-compatible fallback:
when the new-format path is not found, functions automatically search
the legacy root-dir-relative paths so existing backups from older
versions are still found and restored without any migration step. New
backups are always written in the new format.
- **`metadata_processor` / `image_processor`** — pass
`rewrite_root_dirs` to backup calls to enable the legacy fallback
- **`rollback_service`** — reconstructs the original absolute path
directly from the backup path (`Path("/") /
backup_file.relative_to(backup_dir)`); falls back to the legacy
root-dir-relative search for backups created by older versions
- **`main` / `rewrite_service`** — log each monitored directory at
startup

## Documentation

Updated `README.md` with:
- `REWRITE_ROOT_DIRS` configuration option and backward-compat note for
`REWRITE_ROOT_DIR`
- Multi-directory Docker run and Docker Compose examples
- Backup directory structure explanation, including
backward-compatibility note for old-format backups
- Updated startup log, volume mapping, and rollback examples

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: kfstorm <3626358+kfstorm@users.noreply.github.com>

Author: Copilot

README.md

@@ -50,9 +50,10 @@ docker run -d \
   --name sonarr-metadata-rewrite \
   --user $(id -u):$(id -g) \
   -e TMDB_API_KEY=your_api_key_here \
-  -e REWRITE_ROOT_DIR=/media \
+  -e REWRITE_ROOT_DIRS=/tv,/anime \
   -e PREFERRED_LANGUAGES=zh-CN,ja-JP \
-  -v /path/to/your/tv/shows:/media \
+  -v /path/to/tv/shows:/tv \
+  -v /path/to/anime:/anime \
   -v sonarr-metadata-cache:/app/cache \
   -v sonarr-metadata-backups:/app/backups \
   --restart unless-stopped \
@@ -70,12 +71,13 @@ services:
     user: "${UID:-1000}:${GID:-1000}"
     environment:
       - TMDB_API_KEY=your_api_key_here
-      - REWRITE_ROOT_DIR=/media
+      - REWRITE_ROOT_DIRS=/tv,/anime
       - PREFERRED_LANGUAGES=zh-CN,ja-JP
       # Optional: customize cache duration (default: 30 days)
       # - CACHE_DURATION_HOURS=168
     volumes:
-      - /path/to/your/tv/shows:/media
+      - /path/to/tv/shows:/tv
+      - /path/to/anime:/anime
       - sonarr-metadata-cache:/app/cache
       - sonarr-metadata-backups:/app/backups
     restart: unless-stopped
@@ -91,11 +93,15 @@ volumes:
 
 ```bash
 TMDB_API_KEY=your_api_read_access_token_here  # Your TMDB API Read Access Token
-REWRITE_ROOT_DIR=/media              # Path to your TV shows (inside container)
+# One or more media directories (comma-separated) to watch for Sonarr .nfo files
+REWRITE_ROOT_DIRS=/tv,/anime
 # Comma-separated language codes in priority order
 PREFERRED_LANGUAGES=zh-CN,ja-JP
 ```
 
+`REWRITE_ROOT_DIR` (singular, one path) is also accepted for backward
+compatibility. `REWRITE_ROOT_DIRS` takes priority when both are set.
+
 ### Optional Settings (with defaults)
 
 ```bash
@@ -121,6 +127,13 @@ TMDB_MAX_RETRY_DELAY=60.0             # Max retry delay (default: 60.0)
 ORIGINAL_FILES_BACKUP_DIR=./backups   # Backup original files (default: ./backups)
                                       # Applies to both .nfo and images. Set to
                                       # empty string to disable backups.
+                                      # Files are stored under their full absolute
+                                      # path (e.g. /app/backups/tv/Show/tvshow.nfo)
+                                      # so backups from different root dirs never
+                                      # collide.
+                                      # Backups created by older single-root-dir
+                                      # versions are still found and restored
+                                      # automatically (backward compatible).
 
 # Service Mode
 SERVICE_MODE=rewrite                  # Service mode: 'rewrite' or 'rollback'
@@ -198,12 +211,13 @@ id -g  # Shows your group ID (GID)
 
 ### Highly Recommended Volume Mappings
 
-While only the media directory is strictly required, these volumes will
+While only the media directories are strictly required, these volumes will
 improve your experience:
 
 ```bash
-# Media directory (required)
--v /path/to/your/tv/shows:/media
+# Media directories (required - mount each root dir separately)
+-v /path/to/your/tv/shows:/tv
+-v /path/to/your/anime:/anime
 
 # Cache directory (highly recommended - persists translation cache across
 # container restarts)
@@ -229,7 +243,8 @@ You'll see something like:
 ```text
 🚀 Starting Sonarr Metadata Rewrite...
 ✅ TMDB API key loaded (ending in ...xyz)
-📁 Monitoring directory: /media
+📁 Monitoring directory: /tv
+📁 Monitoring directory: /anime
 🌍 Preferred languages: ['zh-CN', 'ja-JP']
 ✅ Service started successfully
 ```
@@ -282,9 +297,10 @@ docker run --rm \
   --user $(id -u):$(id -g) \
   -e SERVICE_MODE=rollback \
   -e TMDB_API_KEY=your_api_key_here \
-  -e REWRITE_ROOT_DIR=/media \
+  -e REWRITE_ROOT_DIRS=/tv,/anime \
   -e PREFERRED_LANGUAGES=zh-CN,ja-JP \
-  -v /path/to/your/tv/shows:/media \
+  -v /path/to/tv/shows:/tv \
+  -v /path/to/anime:/anime \
   -v sonarr-metadata-backups:/app/backups \
   kfstorm/sonarr-metadata-rewrite:latest
 ```

src/sonarr_metadata_rewrite/backup_utils.py

@@ -2,21 +2,71 @@
 
 Provides functions to create backups, retrieve backup paths, and restore files
 from backups, with support for stem-matching across different file extensions.
+
+Backup storage structure
+------------------------
+Each file is stored under the backup directory using its full absolute path
+(with the leading ``/`` stripped).  For example, the file
+``/media/sonarr/Show A/tvshow.nfo`` is backed up as
+``<BACKUP_DIR>/media/sonarr/Show A/tvshow.nfo``.  Using the full absolute path
+as the key guarantees that files from different root directories never collide,
+even when those directories contain identically-named entries.
+
+Legacy format (backward compatibility)
+---------------------------------------
+Versions prior to multi-root-dir support stored backups relative to the single
+configured root directory, e.g. ``<BACKUP_DIR>/Show A/tvshow.nfo`` (with root
+``/media/sonarr``).  The functions below accept an optional ``root_dirs``
+parameter: when the new-format path is not found in the backup directory, they
+fall back to the legacy relative path under each provided root directory.  This
+ensures that users who upgrade retain access to their existing backups.
+
+New backups are always written in the new format; the legacy path is only ever
+*read*, never written.
 """
 
 import shutil
 from pathlib import Path
 
 
+def _legacy_backup_path(
+    file_path: Path, backup_dir: Path, root_dir: Path
+) -> Path | None:
+    """Return the legacy (root-dir-relative) backup path, or None if not applicable.
+
+    This only checks whether ``file_path`` is under ``root_dir``; it does not
+    verify whether the resulting path exists.
+
+    Args:
+        file_path: Absolute path to the file
+        backup_dir: Backup directory root
+        root_dir: Root directory to compute the legacy relative path from
+
+    Returns:
+        The legacy backup path, or None if file_path is not under root_dir
+    """
+    try:
+        relative = file_path.relative_to(root_dir)
+    except ValueError:
+        return None
+    return backup_dir / relative
+
+
 def get_backup_path(
-    file_path: Path, backup_dir: Path | None, root_dir: Path
+    file_path: Path,
+    backup_dir: Path | None,
+    root_dirs: list[Path] | None = None,
 ) -> Path | None:
     """Get backup file path for a given file.
 
+    Checks the new absolute-path format first, then falls back to the legacy
+    root-dir-relative format when ``root_dirs`` is supplied.
+
     Args:
-        file_path: Path to the file to get backup path for
+        file_path: Absolute path to the file to get backup path for
         backup_dir: Backup directory root (None to skip)
-        root_dir: Root directory for calculating relative path
+        root_dirs: Optional list of root directories used as a legacy-format
+            fallback for backups created by earlier versions of this tool.
 
     Returns:
         Path to backup file if backup directory is configured and backup exists,
@@ -26,33 +76,51 @@ def get_backup_path(
     if backup_dir is None:
         return None
 
-    # Calculate backup path using same logic as create_backup()
-    relative_path = file_path.relative_to(root_dir)
-    backup_path = backup_dir / relative_path
+    # --- New format: full absolute path under backup_dir ---
+    backup_path = backup_dir / file_path.relative_to("/")
 
-    # Check for exact path match first
     if backup_path.exists():
         return backup_path
 
-    # For files that might have different extensions (e.g., images),
-    # check if any file with the same stem already exists in backup dir
     if backup_path.parent.exists():
         stem = backup_path.stem
         for existing_file in backup_path.parent.iterdir():
             if existing_file.is_file() and existing_file.stem == stem:
-                # Found backup with same filename stem
                 return existing_file
 
+    # --- Legacy format fallback (backward compat) ---
+    if root_dirs:
+        for root_dir in root_dirs:
+            legacy = _legacy_backup_path(file_path, backup_dir, root_dir)
+            if legacy is None:
+                continue
+            if legacy.exists():
+                return legacy
+            if legacy.parent.exists():
+                stem = legacy.stem
+                for existing_file in legacy.parent.iterdir():
+                    if existing_file.is_file() and existing_file.stem == stem:
+                        return existing_file
+
     return None
 
 
-def create_backup(file_path: Path, backup_dir: Path | None, root_dir: Path) -> bool:
-    """Create backup of a file maintaining directory structure.
+def create_backup(
+    file_path: Path,
+    backup_dir: Path | None,
+    root_dirs: list[Path] | None = None,
+) -> bool:
+    """Create backup of a file maintaining its full absolute path structure.
+
+    Checks the new absolute-path format first and the legacy root-dir-relative
+    format second before creating a new backup, so that existing backups are
+    never overwritten regardless of which format they use.
 
     Args:
-        file_path: Path to file to backup
+        file_path: Absolute path to file to backup
         backup_dir: Backup directory root (None to skip backup)
-        root_dir: Root directory for calculating relative path
+        root_dirs: Optional list of root directories used as a legacy-format
+            fallback for backups created by earlier versions of this tool.
 
     Returns:
         True if backup was created or already exists, False if backup disabled
@@ -63,53 +131,63 @@ def create_backup(file_path: Path, backup_dir: Path | None, root_dir: Path) -> b
     if not file_path.exists():
         return False
 
-    # Calculate backup path maintaining directory structure
-    relative_path = file_path.relative_to(root_dir)
-    backup_path = backup_dir / relative_path
+    # --- New format path ---
+    backup_path = backup_dir / file_path.relative_to("/")
 
-    # Don't overwrite existing backup with exact same path
     if backup_path.exists():
         return True
 
-    # For files that might have different extensions (e.g., images),
-    # check if any file with the same stem already exists in backup dir
     if backup_path.parent.exists():
         stem = backup_path.stem
         for existing_file in backup_path.parent.iterdir():
             if existing_file.is_file() and existing_file.stem == stem:
-                # Backup with same filename stem already exists
                 return True
 
-    # Ensure backup directory exists
+    # --- Legacy format check (backward compat): don't create a new backup if
+    #     an old-format backup already covers this file. ---
+    if root_dirs:
+        for root_dir in root_dirs:
+            legacy = _legacy_backup_path(file_path, backup_dir, root_dir)
+            if legacy is None:
+                continue
+            if legacy.exists():
+                return True  # Legacy backup present; preserve it, don't overwrite
+            if legacy.parent.exists():
+                stem = legacy.stem
+                for existing_file in legacy.parent.iterdir():
+                    if existing_file.is_file() and existing_file.stem == stem:
+                        return True  # Legacy stem-match found
+
+    # --- Create new backup at new-format path ---
     backup_path.parent.mkdir(parents=True, exist_ok=True)
-
-    # Copy file to backup location
     shutil.copy2(file_path, backup_path)
     return True
 
 
 def restore_from_backup(
-    file_path: Path, backup_dir: Path | None, root_dir: Path
+    file_path: Path,
+    backup_dir: Path | None,
+    root_dirs: list[Path] | None = None,
 ) -> bool:
     """Restore file from backup, handling stem-matching and extension changes.
 
     This function handles the case where a backup might have a different extension
     than the current file (e.g., poster.png backup for poster.jpg current).
     It will:
-    1. Find the backup using stem-matching
+    1. Find the backup using stem-matching (new format first, then legacy)
     2. Delete any files with the same stem but different extensions
     3. Copy the backup to the original location
 
     Args:
-        file_path: Path to file to restore
+        file_path: Absolute path to file to restore
         backup_dir: Backup directory root (None to skip)
-        root_dir: Root directory for calculating relative path
+        root_dirs: Optional list of root directories for legacy-format fallback.
 
     Returns:
         True if file was restored from backup, False otherwise
     """
-    # Find backup path
-    backup_path = get_backup_path(file_path, backup_dir, root_dir)
+    # Find backup path (new format first, then legacy)
+    backup_path = get_backup_path(file_path, backup_dir, root_dirs)
     if not backup_path:
         return False
 

src/sonarr_metadata_rewrite/config.py

@@ -16,10 +16,18 @@ class CustomEnvSettings(PydanticBaseSettingsSource):
     """Custom environment settings source that handles comma-separated lists."""
 
     def get_field_value(self, field: Any, field_name: str) -> tuple[Any, str, bool]:
-        """Get field value from environment, handling preferred_languages specially."""
+        """Get field value from environment, handling special fields."""
         env_name = field_name.upper()
         env_val = os.getenv(env_name)
 
+        if field_name == "rewrite_root_dirs":
+            # Support REWRITE_ROOT_DIRS (comma-separated, new) and
+            # REWRITE_ROOT_DIR (single path, backward compatible)
+            env_val = os.getenv("REWRITE_ROOT_DIRS") or os.getenv("REWRITE_ROOT_DIR")
+            if env_val is None:
+                return None, "REWRITE_ROOT_DIRS", False
+            return env_val, "REWRITE_ROOT_DIRS", False
+
         if env_val is None:
             return None, env_name, False
 
@@ -33,8 +41,8 @@ def get_field_value(self, field: Any, field_name: str) -> tuple[Any, str, bool]:
     def prepare_field_value(
         self, field_name: str, field: Any, value: Any, value_is_complex: bool
     ) -> Any:
-        """Prepare field value, skipping JSON parsing for preferred_languages."""
-        if field_name == "preferred_languages":
+        """Prepare field value, skipping JSON parsing for list fields."""
+        if field_name in {"preferred_languages", "rewrite_root_dirs"}:
             return value
         return super().prepare_field_value(field_name, field, value, value_is_complex)
 
@@ -88,8 +96,11 @@ def settings_customise_sources(
     tmdb_api_key: str = Field(description="TMDB API key for translation requests")
 
     # Directory monitoring
-    rewrite_root_dir: Path = Field(
-        description="Root directory to monitor and rewrite .nfo files"
+    rewrite_root_dirs: list[Path] = Field(
+        description=(
+            "Root directories to monitor and rewrite .nfo files "
+            "(comma-separated list)"
+        )
     )
     periodic_scan_interval_seconds: int = Field(
         default=86400, description="How often to scan the directory (seconds)"
@@ -100,6 +111,19 @@ def settings_customise_sources(
         description="Preferred languages in priority order (comma-separated)"
     )
 
+    @field_validator("rewrite_root_dirs", mode="before")
+    @classmethod
+    def parse_rewrite_root_dirs(cls, v: str | list[Any]) -> list[Path]:
+        """Parse root dirs from comma-separated string or list."""
+        if isinstance(v, list):
+            return [Path(p) for p in v]
+        if isinstance(v, str):
+            paths = [Path(p.strip()) for p in v.split(",") if p.strip()]
+            if not paths:
+                raise ValueError("rewrite_root_dirs cannot be empty")
+            return paths
+        raise ValueError("rewrite_root_dirs must be a comma-separated string or list")
+
     @field_validator("preferred_languages", mode="before")
     @classmethod
     def parse_preferred_languages(cls, v: str | list[str]) -> list[str]: