feat: schedule periodic user synchronization

app/main.py

@@ -1,8 +1,16 @@
+from contextlib import asynccontextmanager
+
 from fastapi import FastAPI
 from starlette.middleware.sessions import SessionMiddleware
 
 from app.config import Settings, get_settings
 from app.db.session import create_db_engine, create_session_factory, initialize_schema
+from app.fit.rewriter import convert_fit_device
+from app.garmin.uploader import GarminUploader
+from app.mywhoosh.client import MyWhooshClient
+from app.security.credentials import CredentialCipher
+from app.sync.manager import SyncManager
+from app.sync.scheduler import SyncScheduler
 from app.web.routes import router as web_router
 
 
@@ -12,7 +20,35 @@ def create_app(settings: Settings | None = None) -> FastAPI:
     resolved.tokens_dir.mkdir(parents=True, exist_ok=True)
     resolved.activities_dir.mkdir(parents=True, exist_ok=True)
 
-    app = FastAPI(title="MyWhoosh Garmin Sync")
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        cipher = CredentialCipher(resolved.credential_encryption_key)
+
+        def mywhoosh_factory(token_store):
+            return MyWhooshClient(token_store)
+
+        def garmin_factory(email, password, tokenstore):
+            return GarminUploader(email=email, password=password, tokenstore=tokenstore)
+
+        sync_manager = SyncManager(
+            session_factory=app.state.session_factory,
+            credential_cipher=cipher,
+            settings=resolved,
+            mywhoosh_factory=mywhoosh_factory,
+            garmin_factory=garmin_factory,
+            fit_converter=convert_fit_device,
+        )
+        app.state.sync_manager = sync_manager
+
+        scheduler = SyncScheduler(sync_manager, interval_seconds=resolved.sync_interval_minutes * 60)
+        app.state.scheduler = scheduler
+        await scheduler.start()
+
+        yield
+
+        await scheduler.stop()
+
+    app = FastAPI(title="MyWhoosh Garmin Sync", lifespan=lifespan)
     app.state.settings = resolved
 
     engine = create_db_engine(resolved.database_url)

app/sync/scheduler.py

@@ -0,0 +1,42 @@
+import asyncio
+import logging
+from datetime import datetime, timedelta, timezone
+
+logger = logging.getLogger(__name__)
+
+
+class SyncScheduler:
+    def __init__(self, manager, *, interval_seconds: float) -> None:
+        self.manager = manager
+        self.interval_seconds = interval_seconds
+        self._task: asyncio.Task | None = None
+        self._stop = asyncio.Event()
+        self.last_tick = None
+        self.next_tick = None
+
+    async def run_once(self) -> None:
+        self.last_tick = datetime.now(timezone.utc)
+        try:
+            await self.manager.sync_all_enabled()
+        except Exception:
+            logger.exception("sync_all_enabled failed during scheduled tick")
+        finally:
+            self.next_tick = datetime.now(timezone.utc) + timedelta(seconds=self.interval_seconds)
+
+    async def _run(self) -> None:
+        while not self._stop.is_set():
+            await self.run_once()
+            try:
+                await asyncio.wait_for(self._stop.wait(), timeout=self.interval_seconds)
+            except TimeoutError:
+                pass
+
+    async def start(self) -> None:
+        self._stop.clear()
+        self._task = asyncio.create_task(self._run())
+
+    async def stop(self) -> None:
+        self._stop.set()
+        if self._task is not None:
+            await self._task
+            self._task = None