feat: add Scheduler provider + multi-provider UX fixes

Scheduler provider:
- Virtual provider (no external service) that emits SCHEDULED_MESSAGE
  events on user-defined intervals or cron expressions
- Custom variables stored in tracker filters, flattened into template context
- fire_count persists across triggers via tracker state
- APScheduler CronTrigger support for cron-mode schedules
- Default templates (EN+RU), seeded on startup

Multi-provider UX fixes:
- Tracking config hides Immich-specific sections (periodic, scheduled,
  memory, asset display) for non-Immich providers
- Command config driven by provider capabilities — hides commands/settings
  for providers without bot commands
- Template config hides empty "Scheduled Messages" group
- Test menu on tracker targets is provider-aware (Immich shows all 4 test
  types, others show only basic)
- Removed redundant Test button from tracker card
- System-owned tracking configs (user_id=0) seeded for Gitea + Scheduler
- Fixed ownership checks to allow system configs in tracker-target links
- Capabilities cache shared across template-configs and command-configs
- Command tracker bot selector uses EntitySelect instead of raw select
- Sample context includes Gitea + Scheduler variables for template preview

packages/server/src/notify_bridge_server/main.py

@@ -52,6 +52,7 @@ async def lifespan(app: FastAPI):
     await migrate_command_slot_locale(engine)
     await _seed_default_templates()
     await _seed_default_command_templates()
+    await _seed_default_tracking_configs()
     # Configure webhook secret from DB setting (falls back to env var)
     from sqlmodel.ext.asyncio.session import AsyncSession as _AS
     from .api.app_settings import get_setting as _get_setting
@@ -275,6 +276,85 @@ async def _seed_default_templates():
                             template=template_text,
                         ))
 
+        # --- Seed Scheduler default templates ---
+        sched_result = await session.exec(
+            select(TemplateConfig).where(
+                TemplateConfig.user_id == 0,
+                TemplateConfig.provider_type == "scheduler",
+            )
+        )
+        sched_configs = sched_result.all()
+        sched_existing_locales = {
+            (c.locale if c.locale else "en"): c for c in sched_configs
+        }
+
+        for locale in ("en", "ru"):
+            sched_slots = load_default_templates(locale, provider_type="scheduler")
+            if not sched_slots:
+                continue
+
+            if locale not in sched_existing_locales:
+                from datetime import datetime as _dt2, timezone as _tz2
+                now2 = _dt2.now(_tz2.utc).isoformat()
+                name2 = f"Default Scheduler ({locale.upper()})"
+                desc2 = f"Default Scheduler templates ({locale.upper()})"
+                col_info2 = (await session.execute(
+                    text("PRAGMA table_info(template_config)")
+                )).fetchall()
+                col_names2 = [c[1] for c in col_info2 if c[1] != "id"]
+                values2 = {}
+                for col in col_names2:
+                    if col == "user_id":
+                        values2[col] = 0
+                    elif col == "provider_type":
+                        values2[col] = "scheduler"
+                    elif col == "name":
+                        values2[col] = name2
+                    elif col == "description":
+                        values2[col] = desc2
+                    elif col == "created_at":
+                        values2[col] = now2
+                    elif col == "date_format":
+                        values2[col] = "%d.%m.%Y, %H:%M UTC"
+                    elif col == "date_only_format":
+                        values2[col] = "%d.%m.%Y"
+                    elif col == "locale":
+                        values2[col] = locale
+                    else:
+                        values2[col] = ""
+                cols_str2 = ", ".join(values2.keys())
+                placeholders2 = ", ".join(f":{k}" for k in values2.keys())
+                await session.execute(
+                    text(f"INSERT INTO template_config ({cols_str2}) VALUES ({placeholders2})"),
+                    values2,
+                )
+                row2 = (await session.execute(text("SELECT last_insert_rowid()"))).scalar()
+                for slot_name, template_text in sched_slots.items():
+                    session.add(TemplateSlot(
+                        config_id=row2,
+                        slot_name=slot_name,
+                        template=template_text,
+                    ))
+            else:
+                config = sched_existing_locales[locale]
+                for slot_name, template_text in sched_slots.items():
+                    slot_result = await session.exec(
+                        select(TemplateSlot).where(
+                            TemplateSlot.config_id == config.id,
+                            TemplateSlot.slot_name == slot_name,
+                        )
+                    )
+                    existing = slot_result.first()
+                    if existing:
+                        existing.template = template_text
+                        session.add(existing)
+                    else:
+                        session.add(TemplateSlot(
+                            config_id=config.id,
+                            slot_name=slot_name,
+                            template=template_text,
+                        ))
+
         await session.commit()
 
 
@@ -339,6 +419,51 @@ async def _seed_default_command_templates():
         await session.commit()
 
 
+async def _seed_default_tracking_configs():
+    """Seed system-owned default tracking configs for each provider type."""
+    from sqlmodel import select
+    from sqlmodel.ext.asyncio.session import AsyncSession
+    from .database.engine import get_engine
+    from .database.models import TrackingConfig
+
+    engine = get_engine()
+    async with AsyncSession(engine) as session:
+        # Find existing system-owned tracking configs
+        result = await session.exec(
+            select(TrackingConfig).where(TrackingConfig.user_id == 0)
+        )
+        existing = {c.provider_type: c for c in result.all()}
+
+        defaults = [
+            {
+                "provider_type": "gitea",
+                "name": "Default Gitea",
+                "track_push": True,
+                "track_issue_opened": True,
+                "track_issue_closed": True,
+                "track_issue_commented": False,
+                "track_pr_opened": True,
+                "track_pr_closed": True,
+                "track_pr_merged": True,
+                "track_pr_commented": False,
+                "track_release_published": True,
+            },
+            {
+                "provider_type": "scheduler",
+                "name": "Default Scheduler",
+                "track_scheduled_message": True,
+            },
+        ]
+
+        for cfg in defaults:
+            ptype = cfg["provider_type"]
+            if ptype in existing:
+                continue
+            session.add(TrackingConfig(user_id=0, **cfg))
+
+        await session.commit()
+
+
 def run():
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8420)