Shelfmark

Shelfmark can execute a custom script after a download task completes successfully (e.g., after transferring to a folder or uploading to Booklore).

Setup Steps

1. Place your script on the machine running Shelfmark.
2. Make the script executable (e.g., chmod +x /path/to/script.sh).
3. In the Shelfmark UI, navigate to Settings -> Advanced -> Custom Script Path and provide the path to your executable.

Docker Configuration

If running Shelfmark in Docker, the script must exist inside the container. It is recommended to mount a local directory containing your scripts as a volume:

services:
  shelfmark:
    image: ghcr.io/calibrain/shelfmark:latest
    volumes:
      - /path/to/your/scripts:/scripts:ro

Then, set the Custom Script Path in the UI to the container path (e.g., /scripts/post_process.sh).

Alternatively, you can configure this via environment variables:

services:
  shelfmark:
    environment:
      - CUSTOM_SCRIPT=/scripts/post_process.sh
      - CUSTOM_SCRIPT_PATH_MODE=absolute
      - CUSTOM_SCRIPT_JSON_PAYLOAD=true

chmod +x /path/to/your/scripts/post_process.sh

To create a release source, extend the ReleaseSource class and use @register_source to register it. If the source requires specific download logic, implement a DownloadHandler and register it using @register_handler.

Use @register_settings to define the UI for the source. You can use the show_when parameter on fields to implement conditional visibility (e.g., only showing a URL field if an 'Enabled' checkbox is checked).

from shelfmark.release_sources.base import ReleaseSource, DownloadHandler, register_source, register_handler
from shelfmark.core.settings_registry import register_settings, CheckboxField, TextField, SelectField
from shelfmark.core.config import config

@register_settings(
    name="my_source",
    display_name="My Source",
    group="direct_download",
)
def my_source_settings():
    return [
        CheckboxField(key="MY_SOURCE_ENABLED", label="Enable", default=True),
        TextField(
            key="MY_SOURCE_URL", 
            label="URL",
            show_when={"field": "MY_SOURCE_ENABLED", "value": True}
        ),
        SelectField(
            key="MY_SOURCE_PRIORITY",
            label="Priority",
            options=[{"value": "high", "label": "High"}, {"value": "normal", "label": "Normal"}],
            show_when={"field": "MY_SOURCE_ENABLED", "value": True}
        ),
    ]

@register_source("my_source")
class MySource(ReleaseSource):
    name = "my_source"
    def __init__(self):
        self.enabled = config.get("MY_SOURCE_ENABLED", True)

@register_handler("my_source")
class MySourceHandler(DownloadHandler):
    name = "my_source"
    def download(self, release, output_path):
        pass

To route all external egress through a WireGuard VPN tunnel with a fail-closed kill-switch, use the WireGuard compose file.

Requirements:

• Requires root startup.
• Requires NET_ADMIN and NET_RAW capabilities.
• Configuration: Mount a standard wg-quick config at the WIREGUARD_CONFIG path (default is /config/wg0.conf).
• Kill-switch: All non-LAN egress is forced through the tunnel. If the tunnel drops, external traffic fails closed, but LAN ranges (WebUI, Prowlarr, etc.) remain reachable via LAN_NETWORK.
• DNS: Use WIREGUARD_DNS to pin a trusted resolver. If using Docker's embedded resolver, you must pin its upstream via the compose dns: list.
• IPv6: If your kernel lacks ip6tables, you may need to disable IPv6 via sysctls to prevent leaks.

curl -O https://raw.githubusercontent.com/calibrain/shelfmark/main/compose/docker-compose.wireguard.yml
# place your wg-quick config where the compose mounts /config, as wg0.conf
docker compose -f docker-compose.wireguard.yml up -d