feat: add Planka service provider with full notification and command support

Webhook-based provider for Planka (self-hosted Kanban board) with:
- 15 event types (cards, boards, lists, comments, tasks, attachments, labels)
- Bearer token webhook authentication
- Async API client for boards/cards/lists
- 30 notification templates (en/ru) + 26 command templates (en/ru)
- Bot commands: /status, /boards, /cards, /lists
- Default tracking config, template config, command config seeded on startup
- DB migration for 15 new tracking_config columns
- Frontend: provider config UI with auto-name, Planka-specific hints
- Frontend: tracking config event toggles for all 15 Planka events

packages/server/src/notify_bridge_server/api/providers.py

@@ -13,7 +13,7 @@ import aiohttp
 from ..auth.dependencies import get_current_user
 from ..database.engine import get_session
 from ..database.models import ServiceProvider, User
-from ..services import make_immich_provider, make_gitea_provider
+from ..services import make_immich_provider, make_gitea_provider, make_planka_provider
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -57,6 +57,12 @@ class GiteaProviderConfig(BaseModel):
     api_token: str | None = None
 
 
+class PlankaProviderConfig(BaseModel):
+    url: str
+    webhook_secret: str
+    api_key: str | None = None
+
+
 class SchedulerProviderConfig(BaseModel):
     """Scheduler is a virtual provider — no required fields."""
 
@@ -66,6 +72,7 @@ class SchedulerProviderConfig(BaseModel):
 _PROVIDER_CONFIG_MODELS: dict[str, type[BaseModel]] = {
     "immich": ImmichProviderConfig,
     "gitea": GiteaProviderConfig,
+    "planka": PlankaProviderConfig,
     "scheduler": SchedulerProviderConfig,
 }
 
@@ -141,6 +148,21 @@ async def create_provider(
                         detail=test_result.get("message", "Cannot connect to Gitea"),
                     )
 
+    elif body.type == "planka":
+        config = body.config
+        if config.get("api_key"):
+            async with aiohttp.ClientSession() as http_session:
+                from notify_bridge_core.providers.planka import PlankaServiceProvider
+                planka = PlankaServiceProvider(
+                    http_session, config.get("url", ""), config.get("api_key", ""), body.name,
+                )
+                test_result = await planka.test_connection()
+                if not test_result.get("ok"):
+                    raise HTTPException(
+                        status_code=status.HTTP_400_BAD_REQUEST,
+                        detail=test_result.get("message", "Cannot connect to Planka"),
+                    )
+
     # Scheduler: no validation needed (virtual provider)
 
     provider = ServiceProvider(
@@ -258,6 +280,22 @@ async def update_provider(
                     status_code=status.HTTP_400_BAD_REQUEST,
                     detail=f"Connection error: {err}",
                 )
+    elif config_changed and provider.type == "planka":
+        if provider.config.get("api_key"):
+            try:
+                async with aiohttp.ClientSession() as http_session:
+                    planka = make_planka_provider(http_session, provider)
+                    test_result = await planka.test_connection()
+                    if not test_result.get("ok"):
+                        raise HTTPException(
+                            status_code=status.HTTP_400_BAD_REQUEST,
+                            detail=test_result.get("message", "Cannot connect to Planka"),
+                        )
+            except aiohttp.ClientError as err:
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=f"Connection error: {err}",
+                )
 
     session.add(provider)
     await session.commit()
@@ -300,6 +338,13 @@ async def test_provider(
             gitea = make_gitea_provider(http_session, provider)
             return await gitea.test_connection()
 
+    if provider.type == "planka":
+        if not provider.config.get("api_key"):
+            return {"ok": True, "message": "Planka webhook-only mode (no API key for testing)"}
+        async with aiohttp.ClientSession() as http_session:
+            planka = make_planka_provider(http_session, provider)
+            return await planka.test_connection()
+
     if provider.type == "scheduler":
         return {"ok": True, "message": "Virtual provider — always available"}
 
@@ -327,6 +372,13 @@ async def list_collections(
             gitea = make_gitea_provider(http_session, provider)
             return await gitea.list_collections()
 
+    if provider.type == "planka":
+        if not provider.config.get("api_key"):
+            return []
+        async with aiohttp.ClientSession() as http_session:
+            planka = make_planka_provider(http_session, provider)
+            return await planka.list_collections()
+
     return []
 
 

packages/server/src/notify_bridge_server/api/webhooks.py

@@ -14,6 +14,7 @@ from sqlmodel.ext.asyncio.session import AsyncSession
 from notify_bridge_core.models.events import ServiceEvent
 from notify_bridge_core.notifications.dispatcher import NotificationDispatcher, TargetConfig
 from notify_bridge_core.providers.gitea.event_parser import parse_webhook as parse_gitea_webhook
+from notify_bridge_core.providers.planka.event_parser import parse_webhook as parse_planka_webhook
 
 from ..database.engine import get_engine
 from ..database.models import (
@@ -174,6 +175,118 @@ async def gitea_webhook(provider_id: int, request: Request):
     return {"ok": True, "dispatched": dispatched}
 
 
+# ---------------------------------------------------------------------------
+# Planka webhook endpoint
+# ---------------------------------------------------------------------------
+
+def _verify_planka_token(expected_token: str, request: Request) -> bool:
+    """Verify Planka webhook Bearer token."""
+    auth_header = request.headers.get("Authorization", "")
+    if auth_header.startswith("Bearer "):
+        token = auth_header[7:]
+        return hmac.compare_digest(token, expected_token)
+    return False
+
+
+@router.post("/planka/{provider_id}")
+async def planka_webhook(provider_id: int, request: Request):
+    """Receive a Planka webhook, parse it, filter, and dispatch notifications."""
+    engine = get_engine()
+
+    # --- Load provider and validate token ---
+    async with AsyncSession(engine) as session:
+        provider = await session.get(ServiceProvider, provider_id)
+        if not provider or provider.type != "planka":
+            raise HTTPException(status_code=404, detail="Provider not found")
+
+        webhook_secret = (provider.config or {}).get("webhook_secret", "")
+
+    if not webhook_secret:
+        raise HTTPException(
+            status_code=403,
+            detail="Webhook secret not configured on this provider",
+        )
+
+    if not _verify_planka_token(webhook_secret, request):
+        raise HTTPException(status_code=403, detail="Invalid token")
+
+    # Parse payload
+    try:
+        payload = await request.json()
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid JSON")
+
+    event_type = payload.get("type", "")
+    if not event_type:
+        return {"ok": True, "skipped": "no event type"}
+
+    base_url = (provider.config or {}).get("url", "")
+    event = parse_planka_webhook(event_type, payload, provider.name, base_url=base_url)
+    if event is None:
+        return {"ok": True, "skipped": "unmapped event"}
+
+    # --- Find trackers for this provider and dispatch ---
+    dispatched = 0
+    async with AsyncSession(engine) as session:
+        tracker_result = await session.exec(
+            select(NotificationTracker).where(
+                NotificationTracker.provider_id == provider_id,
+                NotificationTracker.enabled == True,
+            )
+        )
+        trackers = tracker_result.all()
+
+        for tracker in trackers:
+            filters = tracker.filters or {}
+            if not _passes_filters(event, filters):
+                _LOGGER.debug(
+                    "Event filtered out for tracker %d (%s)", tracker.id, tracker.name
+                )
+                continue
+
+            link_data = await load_link_data(session, tracker.id)
+            if not link_data:
+                continue
+
+            # Log event
+            session.add(EventLog(
+                tracker_id=tracker.id,
+                tracker_name=tracker.name,
+                provider_id=provider_id,
+                provider_name=provider.name,
+                event_type=event.event_type.value,
+                collection_id=event.collection_id,
+                collection_name=event.collection_name,
+                assets_count=0,
+                details={
+                    "provider_type": event.provider_type.value,
+                    **{k: v for k, v in event.extra.items() if k in (
+                        "sender", "card_name", "board_name",
+                        "list_name", "old_list_name", "new_list_name",
+                        "comment_text", "task_name", "attachment_name",
+                        "label_name",
+                    )},
+                },
+            ))
+            await session.commit()
+
+            # Dispatch to targets
+            dispatcher = NotificationDispatcher()
+            target_configs = _build_target_configs(event, link_data, provider.config or {})
+            if target_configs:
+                results = await dispatcher.dispatch(event, target_configs)
+                for r in results:
+                    if r.get("success"):
+                        dispatched += 1
+                    else:
+                        _LOGGER.error(
+                            "Notification failed for tracker %d: %s",
+                            tracker.id, r.get("error", "unknown"),
+                        )
+
+    return {"ok": True, "dispatched": dispatched}
+
+
 def _build_target_configs(
     event: ServiceEvent,
     link_data: list[dict[str, Any]],

packages/server/src/notify_bridge_server/commands/dispatch.py

@@ -31,9 +31,11 @@ def _auto_register() -> None:
     """Auto-register all built-in handlers."""
     from .immich import ImmichCommandHandler
     from .gitea_handler import GiteaCommandHandler
+    from .planka_handler import PlankaCommandHandler
 
     register_handler(ImmichCommandHandler())
     register_handler(GiteaCommandHandler())
+    register_handler(PlankaCommandHandler())
 
 
 # Auto-register on import

packages/server/src/notify_bridge_server/commands/planka_handler.py

@@ -0,0 +1,193 @@
+"""Planka-specific bot command handler."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import aiohttp
+from sqlmodel import select
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from ..database.engine import get_engine
+from ..database.models import (
+    CommandConfig, CommandTracker, EventLog,
+    NotificationTracker, ServiceProvider, TelegramBot,
+)
+from ..services import make_planka_provider
+from .base import ProviderCommandHandler
+from .handler import _render_cmd_template, _get_notification_trackers_for_providers
+
+_LOGGER = logging.getLogger(__name__)
+
+_PLANKA_COMMANDS = {"status", "boards", "cards", "lists"}
+
+
+class PlankaCommandHandler(ProviderCommandHandler):
+    """Handles Planka-specific bot commands."""
+
+    provider_type = "planka"
+
+    def get_provider_commands(self) -> set[str]:
+        return _PLANKA_COMMANDS
+
+    def get_rate_categories(self) -> dict[str, str]:
+        return {
+            "boards": "api", "cards": "api", "lists": "api",
+        }
+
+    async def handle(
+        self,
+        cmd: str,
+        args: str,
+        count: int,
+        locale: str,
+        response_mode: str,
+        providers_map: dict[int, ServiceProvider],
+        cmd_templates: dict[str, dict[str, str]],
+        bot: TelegramBot,
+        ctx_tuples: list[tuple[CommandTracker, CommandConfig, ServiceProvider]],
+    ) -> str | list[dict[str, Any]] | None:
+        if cmd == "status":
+            ctx = await _cmd_status(providers_map)
+            return _render_cmd_template(cmd_templates, "status", locale, ctx)
+        if cmd == "boards":
+            ctx = await _cmd_boards(providers_map)
+            return _render_cmd_template(cmd_templates, "boards", locale, ctx)
+        if cmd == "cards":
+            ctx = await _cmd_cards(providers_map, count)
+            return _render_cmd_template(cmd_templates, "cards", locale, ctx)
+        if cmd == "lists":
+            ctx = await _cmd_lists(providers_map)
+            return _render_cmd_template(cmd_templates, "lists", locale, ctx)
+        return None
+
+
+def _get_tracked_board_ids(
+    providers_map: dict[int, ServiceProvider],
+    trackers: list[NotificationTracker],
+) -> list[tuple[ServiceProvider, str]]:
+    """Get (provider, board_id) tuples from tracked collection_ids."""
+    boards: list[tuple[ServiceProvider, str]] = []
+    for tracker in trackers:
+        provider = providers_map.get(tracker.provider_id)
+        if not provider or provider.type != "planka":
+            continue
+        if not provider.config.get("api_key"):
+            continue
+        for board_id in (tracker.collection_ids or []):
+            entry = (provider, board_id)
+            if entry not in boards:
+                boards.append(entry)
+        # Also check filters.collections
+        for board_id in (tracker.filters or {}).get("collections", []):
+            entry = (provider, board_id)
+            if entry not in boards:
+                boards.append(entry)
+    return boards[:20]
+
+
+async def _cmd_status(providers_map: dict[int, ServiceProvider]) -> dict[str, Any]:
+    provider_ids = set(providers_map.keys())
+    trackers = await _get_notification_trackers_for_providers(provider_ids)
+    tracked_boards = _get_tracked_board_ids(providers_map, trackers)
+
+    # Last event
+    engine = get_engine()
+    async with AsyncSession(engine) as session:
+        tracker_ids = [t.id for t in trackers]
+        if tracker_ids:
+            result = await session.exec(
+                select(EventLog)
+                .where(EventLog.tracker_id.in_(tracker_ids))
+                .order_by(EventLog.created_at.desc()).limit(1)
+            )
+            last_event = result.first()
+        else:
+            last_event = None
+    last_str = last_event.created_at.strftime("%Y-%m-%d %H:%M") if last_event else "-"
+
+    return {
+        "boards_count": len(tracked_boards),
+        "last_event": last_str,
+    }
+
+
+async def _cmd_boards(providers_map: dict[int, ServiceProvider]) -> dict[str, Any]:
+    provider_ids = set(providers_map.keys())
+    trackers = await _get_notification_trackers_for_providers(provider_ids)
+    tracked_boards = _get_tracked_board_ids(providers_map, trackers)
+
+    boards_data: list[dict[str, Any]] = []
+    async with aiohttp.ClientSession() as http:
+        for provider, board_id in tracked_boards:
+            planka = make_planka_provider(http, provider)
+            all_boards = await planka.client.get_boards()
+            for b in all_boards:
+                if str(b.get("id", "")) == board_id:
+                    boards_data.append({"name": b.get("name", board_id)})
+                    break
+            else:
+                boards_data.append({"name": board_id})
+
+    return {"boards": boards_data}
+
+
+async def _cmd_cards(
+    providers_map: dict[int, ServiceProvider], count: int,
+) -> dict[str, Any]:
+    provider_ids = set(providers_map.keys())
+    trackers = await _get_notification_trackers_for_providers(provider_ids)
+    tracked_boards = _get_tracked_board_ids(providers_map, trackers)
+
+    all_cards: list[dict[str, Any]] = []
+    async with aiohttp.ClientSession() as http:
+        for provider, board_id in tracked_boards:
+            planka = make_planka_provider(http, provider)
+            cards = await planka.client.get_board_cards(board_id, limit=count)
+            lists = await planka.client.get_board_lists(board_id)
+            lists_by_id = {str(lst.get("id", "")): lst.get("name", "") for lst in lists}
+
+            boards = await planka.client.get_boards()
+            board_name = board_id
+            for b in boards:
+                if str(b.get("id", "")) == board_id:
+                    board_name = b.get("name", board_id)
+                    break
+
+            for card in cards:
+                list_id = str(card.get("listId", ""))
+                all_cards.append({
+                    "name": card.get("name", ""),
+                    "list_name": lists_by_id.get(list_id, ""),
+                    "board_name": board_name,
+                })
+
+    return {"cards": all_cards[:count]}
+
+
+async def _cmd_lists(providers_map: dict[int, ServiceProvider]) -> dict[str, Any]:
+    provider_ids = set(providers_map.keys())
+    trackers = await _get_notification_trackers_for_providers(provider_ids)
+    tracked_boards = _get_tracked_board_ids(providers_map, trackers)
+
+    all_lists: list[dict[str, Any]] = []
+    async with aiohttp.ClientSession() as http:
+        for provider, board_id in tracked_boards:
+            planka = make_planka_provider(http, provider)
+            lists = await planka.client.get_board_lists(board_id)
+
+            boards = await planka.client.get_boards()
+            board_name = board_id
+            for b in boards:
+                if str(b.get("id", "")) == board_id:
+                    board_name = b.get("name", board_id)
+                    break
+
+            for lst in lists:
+                all_lists.append({
+                    "name": lst.get("name", ""),
+                    "board_name": board_name,
+                })
+
+    return {"lists": all_lists}

packages/server/src/notify_bridge_server/commands/registry.py

@@ -9,6 +9,8 @@ _RATE_CATEGORY: dict[str, str] = {
     "place": "search", "favorites": "search", "people": "search",
     # Gitea (API calls share a category)
     "repos": "api", "issues": "api", "prs": "api", "commits": "api",
+    # Planka (API calls share a category)
+    "boards": "api", "cards": "api", "lists": "api",
 }
 
 

packages/server/src/notify_bridge_server/database/migrations.py

@@ -159,6 +159,32 @@ async def migrate_schema(engine: AsyncEngine) -> None:
                     )
                     logger.info("Added %s column to tracking_config table", col_name)
 
+        # Add Planka tracking flags to tracking_config if missing
+        if await _has_table(conn, "tracking_config"):
+            planka_flags = [
+                ("track_card_created", "INTEGER DEFAULT 1"),
+                ("track_card_updated", "INTEGER DEFAULT 0"),
+                ("track_card_moved", "INTEGER DEFAULT 1"),
+                ("track_card_deleted", "INTEGER DEFAULT 0"),
+                ("track_card_commented", "INTEGER DEFAULT 1"),
+                ("track_comment_updated", "INTEGER DEFAULT 0"),
+                ("track_board_created", "INTEGER DEFAULT 1"),
+                ("track_board_updated", "INTEGER DEFAULT 0"),
+                ("track_board_deleted", "INTEGER DEFAULT 1"),
+                ("track_list_created", "INTEGER DEFAULT 0"),
+                ("track_list_updated", "INTEGER DEFAULT 0"),
+                ("track_list_deleted", "INTEGER DEFAULT 0"),
+                ("track_attachment_created", "INTEGER DEFAULT 1"),
+                ("track_card_label_added", "INTEGER DEFAULT 0"),
+                ("track_task_completed", "INTEGER DEFAULT 1"),
+            ]
+            for col_name, col_type in planka_flags:
+                if not await _has_column(conn, "tracking_config", col_name):
+                    await conn.execute(
+                        text(f"ALTER TABLE tracking_config ADD COLUMN {col_name} {col_type}")
+                    )
+                    logger.info("Added %s column to tracking_config table", col_name)
+
         # Add collection_name and shared to tracker_state if missing
         state_table = "notification_tracker_state" if await _has_table(conn, "notification_tracker_state") else "tracker_state"
         if await _has_table(conn, state_table):

packages/server/src/notify_bridge_server/database/models.py

@@ -128,6 +128,23 @@ class TrackingConfig(SQLModel, table=True):
     track_pr_commented: bool = Field(default=False)
     track_release_published: bool = Field(default=True)
 
+    # Planka event tracking
+    track_card_created: bool = Field(default=True)
+    track_card_updated: bool = Field(default=False)
+    track_card_moved: bool = Field(default=True)
+    track_card_deleted: bool = Field(default=False)
+    track_card_commented: bool = Field(default=True)
+    track_comment_updated: bool = Field(default=False)
+    track_board_created: bool = Field(default=True)
+    track_board_updated: bool = Field(default=False)
+    track_board_deleted: bool = Field(default=True)
+    track_list_created: bool = Field(default=False)
+    track_list_updated: bool = Field(default=False)
+    track_list_deleted: bool = Field(default=False)
+    track_attachment_created: bool = Field(default=True)
+    track_card_label_added: bool = Field(default=False)
+    track_task_completed: bool = Field(default=True)
+
     # Scheduler event tracking
     track_scheduled_message: bool = Field(default=True)
 

packages/server/src/notify_bridge_server/database/seeds.py

@@ -183,6 +183,7 @@ async def _seed_default_templates() -> None:
     async with AsyncSession(engine) as session:
         await _seed_provider_template(session, "immich", "Immich")
         await _seed_provider_template(session, "gitea", "Gitea")
+        await _seed_provider_template(session, "planka", "Planka")
         await _seed_provider_template(session, "scheduler", "Scheduler")
         await session.commit()
 
@@ -201,6 +202,9 @@ async def _seed_default_command_templates() -> None:
         await _seed_provider_command_template(
             session, "gitea", "Default Gitea Commands", "Default Gitea command templates",
         )
+        await _seed_provider_command_template(
+            session, "planka", "Default Planka Commands", "Default Planka command templates",
+        )
         await session.commit()
 
 
@@ -227,6 +231,25 @@ async def _seed_default_tracking_configs() -> None:
                 "track_pr_commented": False,
                 "track_release_published": True,
             },
+            {
+                "provider_type": "planka",
+                "name": "Default Planka",
+                "track_card_created": True,
+                "track_card_updated": False,
+                "track_card_moved": True,
+                "track_card_deleted": False,
+                "track_card_commented": True,
+                "track_comment_updated": False,
+                "track_board_created": True,
+                "track_board_updated": False,
+                "track_board_deleted": True,
+                "track_list_created": False,
+                "track_list_updated": False,
+                "track_list_deleted": False,
+                "track_attachment_created": True,
+                "track_card_label_added": False,
+                "track_task_completed": True,
+            },
             {
                 "provider_type": "scheduler",
                 "name": "Default Scheduler",
@@ -280,6 +303,16 @@ async def _seed_default_command_configs() -> None:
                 "default_count": 10,
                 "rate_limits": {"api": 15, "default": 10},
             },
+            {
+                "provider_type": "planka",
+                "name": "Default Planka",
+                "enabled_commands": [
+                    "help", "status", "boards", "cards", "lists",
+                ],
+                "response_mode": "text",
+                "default_count": 10,
+                "rate_limits": {"api": 15, "default": 10},
+            },
         ]
 
         for cfg in defaults:

packages/server/src/notify_bridge_server/services/__init__.py

@@ -2,6 +2,7 @@
 
 from notify_bridge_core.providers.immich import ImmichServiceProvider
 from notify_bridge_core.providers.gitea import GiteaServiceProvider
+from notify_bridge_core.providers.planka import PlankaServiceProvider
 
 from ..database.models import ServiceProvider
 
@@ -27,3 +28,14 @@ def make_gitea_provider(http_session, provider: ServiceProvider) -> GiteaService
         config.get("api_token", ""),
         provider.name,
     )
+
+
+def make_planka_provider(http_session, provider: ServiceProvider) -> PlankaServiceProvider:
+    """Create a PlankaServiceProvider from a DB provider model."""
+    config = provider.config or {}
+    return PlankaServiceProvider(
+        http_session,
+        config.get("url", ""),
+        config.get("api_key", ""),
+        provider.name,
+    )

packages/server/src/notify_bridge_server/services/dispatch_helpers.py

@@ -62,6 +62,22 @@ def event_allowed_by_config(event: ServiceEvent, tc: TrackingConfig) -> bool:
         "pr_merged": tc.track_pr_merged,
         "pr_commented": tc.track_pr_commented,
         "release_published": tc.track_release_published,
+        # Planka events
+        "card_created": tc.track_card_created,
+        "card_updated": tc.track_card_updated,
+        "card_moved": tc.track_card_moved,
+        "card_deleted": tc.track_card_deleted,
+        "card_commented": tc.track_card_commented,
+        "comment_updated": tc.track_comment_updated,
+        "board_created": tc.track_board_created,
+        "board_updated": tc.track_board_updated,
+        "board_deleted": tc.track_board_deleted,
+        "list_created": tc.track_list_created,
+        "list_updated": tc.track_list_updated,
+        "list_deleted": tc.track_list_deleted,
+        "attachment_created": tc.track_attachment_created,
+        "card_label_added": tc.track_card_label_added,
+        "task_completed": tc.track_task_completed,
         # Scheduler events
         "scheduled_message": tc.track_scheduled_message,
     }

packages/server/src/notify_bridge_server/services/sample_context.py

@@ -142,6 +142,30 @@ _SAMPLE_CONTEXT = {
     "release_body": "Initial release",
     "release_draft": False,
     "release_prerelease": False,
+    # Planka variables (for planka provider templates)
+    "board_name": "My Project",
+    "board_id": "123456",
+    "board_url": "https://planka.example.com/boards/123456",
+    "card_name": "Fix login bug",
+    "card_id": "789012",
+    "card_url": "https://planka.example.com/cards/789012",
+    "card_description": "Users cannot log in with SSO",
+    "card_due_date": "2026-04-01T00:00:00.000Z",
+    "list_name": "In Progress",
+    "list_id": "list-1",
+    "old_list_name": "To Do",
+    "new_list_name": "In Progress",
+    "old_list_id": "list-0",
+    "new_list_id": "list-1",
+    "comment_text": "Looks good, ready for review!",
+    "comment_id": "comment-1",
+    "task_name": "Write unit tests",
+    "task_id": "task-1",
+    "task_completed": True,
+    "attachment_name": "screenshot.png",
+    "attachment_id": "att-1",
+    "label_name": "bug",
+    "label_color": "berry-red",
     # Scheduler variables (for scheduler provider templates)
     "schedule_name": "Daily Reminder",
     "fire_count": 42,

packages/server/src/notify_bridge_server/services/watcher.py

@@ -111,6 +111,9 @@ async def check_tracker(tracker_id: int) -> dict[str, Any]:
         # Gitea is webhook-based — events arrive via /api/webhooks/gitea endpoint.
         # The scheduler still calls check_tracker but there's nothing to poll.
         return {"status": "ok", "events_detected": 0, "collections_checked": 0}
+    elif provider_type == "planka":
+        # Planka is webhook-based — events arrive via /api/webhooks/planka endpoint.
+        return {"status": "ok", "events_detected": 0, "collections_checked": 0}
     elif provider_type == "scheduler":
         from notify_bridge_core.providers.scheduler import SchedulerServiceProvider
         custom_vars = tracker_filters.get("custom_variables", {})