feat: Google Photos provider backend + API hardening

- Add Google Photos provider: client, models, change detector, capabilities
- Add notification templates (en/ru) for all GP event slots
- Add command templates (en/ru) for GP bot commands
- Register GP in slot/command loaders, capabilities, and seeds
- Harden provider API: validate OAuth credentials on create/update
- Add internal URL rewriting for asset fetches (LAN optimization)
- Fix template renderer to handle missing variables gracefully
- Improve webhook command routing for multi-provider support
- Add provider health check endpoint and watcher improvements

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

@@ -4,6 +4,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 notify_bridge_core.providers.nut import NutServiceProvider
+from notify_bridge_core.providers.google_photos import GooglePhotosServiceProvider
 
 from ..database.models import ServiceProvider
 
@@ -52,3 +53,15 @@ def make_nut_provider(provider: ServiceProvider) -> NutServiceProvider:
         password=config.get("password"),
         name=provider.name,
     )
+
+
+def make_google_photos_provider(http_session, provider: ServiceProvider) -> GooglePhotosServiceProvider:
+    """Create a GooglePhotosServiceProvider from a DB provider model."""
+    config = provider.config or {}
+    return GooglePhotosServiceProvider(
+        http_session,
+        config.get("client_id", ""),
+        config.get("client_secret", ""),
+        config.get("refresh_token", ""),
+        provider.name,
+    )

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

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import logging
 from typing import Any
 
@@ -28,6 +29,7 @@ _LOGGER = logging.getLogger(__name__)
 # Module-level Telegram file caches — shared across dispatches for reuse
 _url_cache: TelegramFileCache | None = None
 _asset_cache: TelegramFileCache | None = None
+_cache_lock = asyncio.Lock()
 
 
 async def _get_telegram_caches() -> tuple[TelegramFileCache | None, TelegramFileCache | None]:
@@ -35,18 +37,24 @@ async def _get_telegram_caches() -> tuple[TelegramFileCache | None, TelegramFile
     global _url_cache, _asset_cache
     if _url_cache is not None:
         return _url_cache, _asset_cache
-    import os
-    from pathlib import Path
-    data_dir = os.environ.get("NOTIFY_BRIDGE_DATA_DIR")
-    if not data_dir:
-        return None, None
-    cache_dir = Path(data_dir) / "cache"
-    _url_cache = TelegramFileCache(JsonFileBackend(cache_dir / "telegram_url_cache.json"))
-    _asset_cache = TelegramFileCache(JsonFileBackend(cache_dir / "telegram_asset_cache.json"))
-    await _url_cache.async_load()
-    await _asset_cache.async_load()
-    _LOGGER.info("Initialized Telegram file caches in %s", cache_dir)
-    return _url_cache, _asset_cache
+    async with _cache_lock:
+        # Double-check after acquiring lock
+        if _url_cache is not None:
+            return _url_cache, _asset_cache
+        import os
+        from pathlib import Path
+        data_dir = os.environ.get("NOTIFY_BRIDGE_DATA_DIR")
+        if not data_dir:
+            return None, None
+        cache_dir = Path(data_dir) / "cache"
+        url_cache = TelegramFileCache(JsonFileBackend(cache_dir / "telegram_url_cache.json"))
+        asset_cache = TelegramFileCache(JsonFileBackend(cache_dir / "telegram_asset_cache.json"))
+        await url_cache.async_load()
+        await asset_cache.async_load()
+        _url_cache = url_cache
+        _asset_cache = asset_cache
+        _LOGGER.info("Initialized Telegram file caches in %s", cache_dir)
+        return _url_cache, _asset_cache
 
 
 async def check_tracker(tracker_id: int) -> dict[str, Any]:
@@ -133,6 +141,20 @@ async def check_tracker(tracker_id: int) -> dict[str, Any]:
             name=provider_name,
         )
         events, new_state = await nut.poll(collection_ids, state_dict)
+    elif provider_type == "google_photos":
+        from notify_bridge_core.providers.google_photos import GooglePhotosServiceProvider
+        async with aiohttp.ClientSession() as http_session:
+            gp = GooglePhotosServiceProvider(
+                http_session,
+                provider_config.get("client_id", ""),
+                provider_config.get("client_secret", ""),
+                provider_config.get("refresh_token", ""),
+                provider_name,
+            )
+            connected = await gp.connect()
+            if not connected:
+                return {"status": "error", "reason": "failed to connect to Google Photos"}
+            events, new_state = await gp.poll(collection_ids, state_dict)
     else:
         return {"status": "error", "reason": f"unsupported provider type: {provider_type}"}