@cachly-dev/mcp-server 0.10.48 → 0.10.49

package/apps/travel-chaos-organizer/backend/app/services/errors.py

@@ -0,0 +1,44 @@
+"""
+Actionable error helpers — mirrors cachly's handleApiError pattern.
+All user-facing messages include a concrete next step.
+"""
+
+from fastapi import HTTPException, status
+
+
+def ollama_unavailable(url: str) -> HTTPException:
+    return HTTPException(
+        status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+        detail=(
+            f"Ollama nicht erreichbar unter {url}. "
+            "Stelle sicher, dass Ollama läuft und OLLAMA_URL korrekt gesetzt ist."
+        ),
+    )
+
+
+def ollama_model_not_found(model: str) -> HTTPException:
+    return HTTPException(
+        status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+        detail=(
+            f"Ollama-Modell '{model}' nicht gefunden. "
+            f"Führe 'ollama pull {model}' auf deinem Server aus."
+        ),
+    )
+
+
+def unsupported_file_type(mime: str) -> HTTPException:
+    return HTTPException(
+        status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+        detail=(
+            f"Dateityp '{mime}' wird nicht unterstützt. "
+            "Unterstützt: application/pdf, image/*, text/*"
+        ),
+    )
+
+
+def low_confidence_warning(confidence: float) -> dict:
+    return {
+        "warning": f"Niedrige Erkennungssicherheit ({confidence:.0%}). "
+                   "Bitte parsed_data manuell prüfen.",
+        "confidence": confidence,
+    }

package/apps/travel-chaos-organizer/backend/app/services/notifier.py

@@ -0,0 +1,10 @@
+"""
+Re-exports from the shared telegram-notify package.
+Canonical implementation: packages/telegram-notify/telegram_notify/client.py
+
+Install locally: pip install -e ../../../../packages/telegram-notify
+Docker build: COPY packages/telegram-notify /tmp/telegram-notify && pip install /tmp/telegram-notify
+"""
+from telegram_notify import notify, notify_user, format_message
+
+__all__ = ["notify", "notify_user", "format_message"]

package/apps/travel-chaos-organizer/backend/app/services/ollama.py

@@ -0,0 +1,101 @@
+import base64
+import json
+import re
+import httpx
+from app.config import get_settings
+from app.services.errors import ollama_unavailable, ollama_model_not_found
+from app.services import cache as cache_svc
+
+settings = get_settings()
+
+PARSE_PROMPT = """You are a travel document parser. Extract structured travel information from the following content.
+
+Return ONLY valid JSON matching this exact schema:
+{
+  "type": "flight|train|bus|hotel|rental_car|activity|transfer|document|other",
+  "title": "short human-readable title",
+  "booking_ref": "booking/confirmation number or null",
+  "provider": "airline/hotel/company name or null",
+  "event_at": "ISO 8601 datetime or null",
+  "event_end_at": "ISO 8601 datetime or null",
+  "origin": "departure city/airport or null",
+  "destination": "arrival city/hotel address or null",
+  "passengers": ["name1", "name2"] or null,
+  "confirmation_number": "separate confirmation if different from booking_ref or null",
+  "price": "total price with currency or null",
+  "raw_summary": "one sentence summary of this travel item",
+  "confidence": 0.0 to 1.0
+}
+
+Content to parse:
+"""
+
+
+async def parse_text(raw_text: str) -> tuple[dict, bool]:
+    """Returns (parsed_dict, was_cached). Cachly cache hit skips Ollama entirely."""
+    cached = await cache_svc.cache_get(raw_text)
+    if cached is not None:
+        return cached, True
+
+    payload = {
+        "model": settings.ollama_model,
+        "prompt": PARSE_PROMPT + raw_text,
+        "stream": False,
+        "format": "json",
+    }
+    try:
+        async with httpx.AsyncClient(timeout=settings.ollama_timeout) as client:
+            resp = await client.post(f"{settings.ollama_url}/api/generate", json=payload)
+            if resp.status_code == 404:
+                raise ollama_model_not_found(settings.ollama_model)
+            resp.raise_for_status()
+            response_text = resp.json().get("response", "{}")
+            result = _safe_parse(response_text)
+            await cache_svc.cache_set(raw_text, result)
+            return result, False
+    except httpx.ConnectError:
+        raise ollama_unavailable(settings.ollama_url)
+
+
+async def parse_image(image_bytes: bytes, mime_type: str) -> tuple[dict, str, bool]:
+    """Returns (parsed_dict, raw_text, was_cached)."""
+    cached = await cache_svc.cache_get(image_bytes)
+    if cached is not None:
+        return cached, "", True
+
+    b64 = base64.b64encode(image_bytes).decode()
+    payload = {
+        "model": settings.ollama_model,
+        "prompt": PARSE_PROMPT + "Extract all visible travel information from this image.",
+        "images": [b64],
+        "stream": False,
+        "format": "json",
+    }
+    try:
+        async with httpx.AsyncClient(timeout=settings.ollama_timeout) as client:
+            resp = await client.post(f"{settings.ollama_url}/api/generate", json=payload)
+            if resp.status_code == 404:
+                raise ollama_model_not_found(settings.ollama_model)
+            resp.raise_for_status()
+            response_text = resp.json().get("response", "{}")
+            result = _safe_parse(response_text)
+            await cache_svc.cache_set(image_bytes, result)
+            # For images, Ollama returns structured JSON directly — there is no
+            # separate OCR text output. Store the human-readable raw_summary
+            # (from the parsed result) as raw_text instead of the JSON blob.
+            return result, result.get("raw_summary") or None, False
+    except httpx.ConnectError:
+        raise ollama_unavailable(settings.ollama_url)
+
+
+def _safe_parse(text: str) -> dict:
+    try:
+        cleaned = re.sub(r"```(?:json)?\s*|\s*```", "", text).strip()
+        return json.loads(cleaned)
+    except json.JSONDecodeError:
+        return {
+            "type": "other",
+            "title": "Unrecognized document",
+            "raw_summary": text[:300],
+            "confidence": 0.0,
+        }

package/apps/travel-chaos-organizer/backend/app/services/parser.py

@@ -0,0 +1,22 @@
+"""Extracts raw text from various file types before sending to Ollama."""
+import io
+from pathlib import Path
+import fitz  # PyMuPDF
+
+
+def extract_text_from_pdf(content: bytes) -> str:
+    doc = fitz.open(stream=content, filetype="pdf")
+    pages = [page.get_text() for page in doc]
+    return "\n".join(pages).strip()
+
+
+def is_image(mime_type: str) -> bool:
+    return mime_type.startswith("image/")
+
+
+def is_pdf(mime_type: str) -> bool:
+    return mime_type == "application/pdf"
+
+
+def is_text(mime_type: str) -> bool:
+    return mime_type.startswith("text/")

package/apps/travel-chaos-organizer/backend/app/services/quota.py

@@ -0,0 +1,85 @@
+"""
+Freemium quota enforcement.
+
+Plans:
+  free  — 50 AI parses / day, 3 active trips
+  pro   — unlimited parses, unlimited trips
+
+Usage:
+    await quota.check_parse(db, uid)   # raises HTTP 429 if over limit
+    await quota.check_trips(db, uid)   # raises HTTP 402 if over limit
+    await quota.get_plan(db, uid)      # returns "free" | "pro"
+"""
+from datetime import datetime, timedelta, timezone
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import text
+from fastapi import HTTPException
+
+FREE_DAILY_PARSES = 50
+FREE_MAX_TRIPS = 3
+
+
+def _now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+async def get_plan(db: AsyncSession, uid: str) -> str:
+    row = await db.execute(
+        text("""
+            SELECT plan FROM users
+            WHERE id = :uid
+              AND (plan_expires_at IS NULL OR plan_expires_at > :now)
+        """),
+        {"uid": uid, "now": _now()},
+    )
+    r = row.fetchone()
+    return r[0] if r else "free"
+
+
+async def _ensure_user(db: AsyncSession, uid: str) -> None:
+    await db.execute(
+        text("INSERT INTO users (id) VALUES (:uid) ON CONFLICT (id) DO NOTHING"),
+        {"uid": uid},
+    )
+
+
+async def check_parse(db: AsyncSession, uid: str) -> None:
+    await _ensure_user(db, uid)
+    plan = await get_plan(db, uid)
+    if plan != "free":
+        return
+
+    cutoff = _now() - timedelta(days=1)
+    row = await db.execute(
+        text("""
+            SELECT COUNT(*) FROM events
+            WHERE user_id = :uid
+              AND event_name IN ('parse_file', 'parse_text', 'parse_url')
+              AND created_at >= :cutoff
+        """),
+        {"uid": uid, "cutoff": cutoff},
+    )
+    count = row.scalar() or 0
+    if count >= FREE_DAILY_PARSES:
+        raise HTTPException(
+            status_code=429,
+            detail=f"Free plan: {FREE_DAILY_PARSES} AI parses per day. Upgrade to Pro for unlimited access.",
+        )
+
+
+async def check_trips(db: AsyncSession, uid: str) -> None:
+    await _ensure_user(db, uid)
+    plan = await get_plan(db, uid)
+    if plan != "free":
+        return
+
+    row = await db.execute(
+        text("SELECT COUNT(*) FROM trips WHERE user_id = :uid"),
+        {"uid": uid},
+    )
+    count = row.scalar() or 0
+    if count >= FREE_MAX_TRIPS:
+        raise HTTPException(
+            status_code=402,
+            detail=f"Free plan: max {FREE_MAX_TRIPS} trips. Upgrade to Pro for unlimited trips.",
+        )

package/apps/travel-chaos-organizer/backend/app/services/sentry.py

@@ -0,0 +1,11 @@
+def init(dsn: str = "", environment: str = "production", release: str = "0.1.0") -> None:
+    if not dsn:
+        return
+    import sentry_sdk
+    sentry_sdk.init(
+        dsn=dsn,
+        environment=environment,
+        release=release,
+        traces_sample_rate=0.05,
+        profiles_sample_rate=0.01,
+    )

package/apps/travel-chaos-organizer/backend/app/services/telemetry.py

@@ -0,0 +1,35 @@
+"""
+Fire-and-forget event tracking.
+Never raises — telemetry must never break the request.
+"""
+import json
+from typing import Any
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import text
+
+
+async def track(
+    db: AsyncSession,
+    user_id: str | None,
+    event_name: str,
+    properties: dict[str, Any] | None = None,
+    platform: str | None = None,
+    app_version: str | None = None,
+) -> None:
+    try:
+        await db.execute(
+            text("""
+                INSERT INTO events (user_id, event_name, properties, platform, app_version)
+                VALUES (:uid, :name, :props, :platform, :version)
+            """),
+            {
+                "uid": user_id,
+                "name": event_name,
+                "props": json.dumps(properties or {}),
+                "platform": platform,
+                "version": app_version,
+            },
+        )
+        await db.commit()
+    except Exception:
+        pass

package/apps/travel-chaos-organizer/backend/pytest.ini

@@ -0,0 +1,4 @@
+[pytest]
+asyncio_mode = auto
+testpaths = tests
+addopts = -v --tb=short

package/apps/travel-chaos-organizer/backend/requirements-dev.txt

@@ -0,0 +1,6 @@
+-r requirements.txt
+pytest==8.3.4
+pytest-asyncio==0.24.0
+pytest-cov==6.0.0
+httpx==0.28.0
+aiosqlite==0.20.0

package/apps/travel-chaos-organizer/backend/requirements.txt

@@ -0,0 +1,25 @@
+# shared monorepo package — installed from /packages/telegram-notify in Docker
+# local dev: pip install -e ../../../../packages/telegram-notify
+telegram-notify @ file:///packages/telegram-notify
+fastapi==0.115.5
+uvicorn[standard]==0.32.1
+python-jose[cryptography]==3.3.0
+python-multipart==0.0.12
+httpx==0.28.0
+asyncpg==0.30.0
+sqlalchemy[asyncio]==2.0.36
+alembic==1.14.0
+python-dotenv==1.0.1
+pydantic[email]==2.10.3
+email-validator>=2.0
+pydantic-settings==2.6.1
+Pillow==11.0.0
+PyMuPDF==1.24.14
+aiofiles==24.1.0
+python-magic==0.4.27
+redis[asyncio]==5.2.1
+slowapi>=0.1.9
+limits>=3.6.0
+sentry-sdk[fastapi]>=2.0
+stripe>=8.0
+reportlab>=4.0

package/apps/travel-chaos-organizer/backend/tests/conftest.py

@@ -0,0 +1,223 @@
+"""
+Shared fixtures for Travel Chaos Organizer backend tests.
+
+Patterns from cachly-mcp:
+- In-memory mocks instead of real services (no Docker required for unit tests)
+- Deterministic fake data via factory helpers
+- Auth always injectable / bypassable in unit scope
+"""
+
+import json
+import uuid
+from collections.abc import AsyncGenerator
+from datetime import date
+from typing import Any
+from unittest.mock import AsyncMock, patch
+
+import pytest
+import pytest_asyncio
+from fastapi import FastAPI
+from httpx import ASGITransport, AsyncClient
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+
+from app.db.database import Base, get_db
+from app.main import app
+from app.models.schemas import ParsedTravelData
+
+# ── In-memory SQLite DB (mirrors cachly MockRedis pattern) ────────────────────
+
+TEST_DB_URL = "sqlite+aiosqlite:///:memory:"
+
+
+@pytest_asyncio.fixture(scope="function")
+async def db_engine():
+    import sqlalchemy
+    engine = create_async_engine(TEST_DB_URL, echo=False)
+    async with engine.begin() as conn:
+        # Execute each DDL statement separately — SQLite doesn't support
+        # multi-statement execute() calls.
+        for stmt in SQLITE_SCHEMA.strip().split(";"):
+            stmt = stmt.strip()
+            if stmt:
+                await conn.execute(sqlalchemy.text(stmt))
+    yield engine
+    await engine.dispose()
+
+
+@pytest_asyncio.fixture
+async def db_session(db_engine) -> AsyncGenerator[AsyncSession, None]:
+    SessionLocal = async_sessionmaker(db_engine, expire_on_commit=False)
+    async with SessionLocal() as session:
+        yield session
+        await session.rollback()
+
+
+# ── Auth bypass (like cachly's checkJwt mock) ─────────────────────────────────
+
+FAKE_USER_ID = "user-test-123"
+FAKE_USER_PAYLOAD = {"sub": FAKE_USER_ID, "email": "test@example.com"}
+
+
+@pytest_asyncio.fixture
+async def client(db_session: AsyncSession) -> AsyncGenerator[AsyncClient, None]:
+    """HTTP client with auth bypassed and real in-memory DB."""
+    from app.auth.keycloak import get_current_user
+    from app.db.database import get_db
+
+    from app.auth.keycloak import user_id_or_bot
+
+    async def override_auth():
+        return FAKE_USER_PAYLOAD
+
+    async def override_user_id_or_bot():
+        return FAKE_USER_ID
+
+    async def override_db():
+        yield db_session
+
+    app.dependency_overrides[get_current_user] = override_auth
+    app.dependency_overrides[user_id_or_bot] = override_user_id_or_bot
+    app.dependency_overrides[get_db] = override_db
+
+    async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as c:
+        yield c
+
+    app.dependency_overrides.clear()
+
+
+# ── Ollama mock (no real LLM needed) ──────────────────────────────────────────
+
+PARSED_FLIGHT = ParsedTravelData(
+    type="flight",
+    title="LH 400 Frankfurt → New York",
+    booking_ref="ABC123",
+    provider="Lufthansa",
+    event_at="2024-08-15T10:30:00",
+    origin="FRA",
+    destination="JFK",
+    passengers=["Max Mustermann"],
+    price="€ 850",
+    confidence=0.92,
+)
+
+
+@pytest.fixture
+def mock_ollama_flight():
+    with patch("app.services.ollama.parse_text", new_callable=AsyncMock) as m:
+        m.return_value = (PARSED_FLIGHT.model_dump(), False)
+        yield m
+
+
+@pytest.fixture
+def mock_ollama_low_confidence():
+    with patch("app.services.ollama.parse_text", new_callable=AsyncMock) as m:
+        m.return_value = (
+            {"type": "other", "title": "Unrecognized document", "confidence": 0.1},
+            False,
+        )
+        yield m
+
+
+# ── Factory helpers ────────────────────────────────────────────────────────────
+
+def make_trip(name: str = "Sommerurlaub 2024", **kwargs) -> dict[str, Any]:
+    return {"name": name, "description": "Test trip", "start_date": "2024-08-01",
+            "end_date": "2024-08-15", **kwargs}
+
+
+def make_item(**kwargs) -> dict[str, Any]:
+    return {"type": "flight", "title": "LH 400 FRA→JFK", "event_at": "2024-08-15T10:30:00",
+            "booking_ref": "ABC123", "provider": "Lufthansa", **kwargs}
+
+
+# ── SQLite-compatible schema (no PostgreSQL ENUMs / pgcrypto) ─────────────────
+
+def _uuid_default() -> str:
+    """SQLite UUID expression: generates xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx format."""
+    return (
+        "lower(hex(randomblob(4))) || '-' || lower(hex(randomblob(2))) || '-' || "
+        "lower(hex(randomblob(2))) || '-' || lower(hex(randomblob(2))) || '-' || "
+        "lower(hex(randomblob(6)))"
+    )
+
+_UD = _uuid_default()
+
+SQLITE_SCHEMA = f"""
+CREATE TABLE IF NOT EXISTS trips (
+    id          TEXT PRIMARY KEY DEFAULT ({_UD}),
+    user_id     TEXT NOT NULL,
+    name        TEXT NOT NULL,
+    description TEXT,
+    start_date  TEXT,
+    end_date    TEXT,
+    created_at  TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at  TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS trip_items (
+    id            TEXT PRIMARY KEY DEFAULT ({_UD}),
+    trip_id       TEXT NOT NULL,
+    user_id       TEXT NOT NULL,
+    type          TEXT NOT NULL DEFAULT 'other',
+    title         TEXT NOT NULL,
+    raw_text      TEXT,
+    parsed_data   TEXT,
+    event_at      TEXT,
+    event_end_at  TEXT,
+    booking_ref   TEXT,
+    provider      TEXT,
+    created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at    TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS attachments (
+    id            TEXT PRIMARY KEY DEFAULT ({_UD}),
+    trip_item_id  TEXT,
+    inbox_id      TEXT,
+    user_id       TEXT NOT NULL,
+    file_path     TEXT NOT NULL,
+    file_name     TEXT NOT NULL,
+    mime_type     TEXT NOT NULL,
+    size_bytes    INTEGER,
+    created_at    TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS chaos_inbox (
+    id           TEXT PRIMARY KEY DEFAULT ({_UD}),
+    user_id      TEXT NOT NULL,
+    raw_content  TEXT,
+    source       TEXT,
+    status       TEXT NOT NULL DEFAULT 'pending',
+    parsed_data  TEXT,
+    created_at   TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at   TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS users (
+    id                 TEXT PRIMARY KEY,
+    email              TEXT,
+    plan               TEXT NOT NULL DEFAULT 'free',
+    plan_expires_at    TEXT,
+    stripe_customer_id TEXT,
+    telegram_chat_id   TEXT UNIQUE,
+    created_at         TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at         TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS events (
+    id          TEXT PRIMARY KEY DEFAULT ({_UD}),
+    user_id     TEXT,
+    event_name  TEXT NOT NULL,
+    properties  TEXT,
+    platform    TEXT,
+    app_version TEXT,
+    created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS waitlist (
+    id         TEXT PRIMARY KEY DEFAULT ({_UD}),
+    email      TEXT NOT NULL UNIQUE,
+    source     TEXT DEFAULT 'landing',
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+"""

package/apps/travel-chaos-organizer/backend/tests/test_admin.py

@@ -0,0 +1,99 @@
+"""Tests for admin endpoints."""
+import base64
+
+import pytest
+from httpx import AsyncClient
+
+pytestmark = pytest.mark.asyncio
+
+
+def admin_headers(user: str = "admin", password: str = "changeme") -> dict:
+    token = base64.b64encode(f"{user}:{password}".encode()).decode()
+    return {"Authorization": f"Basic {token}"}
+
+
+async def test_admin_health_requires_auth(client: AsyncClient):
+    r = await client.get("/admin/health")
+    assert r.status_code == 401
+
+
+async def test_admin_health_ok(client: AsyncClient):
+    r = await client.get("/admin/health", headers=admin_headers())
+    assert r.status_code == 200
+    data = r.json()
+    assert "events_total" in data
+    assert "waitlist_total" in data
+
+
+async def test_admin_dashboard_requires_auth(client: AsyncClient):
+    r = await client.get("/admin")
+    assert r.status_code == 401
+
+
+async def test_admin_dashboard_returns_html(client: AsyncClient):
+    r = await client.get("/admin", headers=admin_headers())
+    assert r.status_code == 200
+    assert "text/html" in r.headers["content-type"]
+    assert "TCO Admin" in r.text
+
+
+async def test_admin_wrong_password(client: AsyncClient):
+    r = await client.get("/admin/health", headers=admin_headers(password="wrongpassword"))
+    assert r.status_code == 401
+
+
+async def test_admin_events_summary(client: AsyncClient):
+    r = await client.get("/admin/events/summary", headers=admin_headers())
+    assert r.status_code == 200
+    assert "events" in r.json()
+
+
+async def test_admin_waitlist(client: AsyncClient):
+    r = await client.get("/admin/waitlist", headers=admin_headers())
+    assert r.status_code == 200
+    assert "signups" in r.json()
+
+
+async def test_admin_set_user_plan(client: AsyncClient, db_session):
+    from sqlalchemy import text
+
+    # First create the user by calling /me
+    await client.get("/api/v1/users/me")
+
+    r = await client.patch(
+        "/admin/users/user-test-123/plan?plan=pro", headers=admin_headers()
+    )
+    assert r.status_code == 200
+    assert r.json()["plan"] == "pro"
+
+    # Verify in DB
+    row = await db_session.execute(
+        text("SELECT plan FROM users WHERE id = 'user-test-123'")
+    )
+    assert row.fetchone()[0] == "pro"
+
+
+async def test_admin_set_invalid_plan(client: AsyncClient):
+    """Setting an invalid plan returns 400."""
+    # Create user first
+    await client.get("/api/v1/users/me")
+
+    r = await client.patch(
+        "/admin/users/user-test-123/plan?plan=enterprise", headers=admin_headers()
+    )
+    assert r.status_code == 400
+
+
+async def test_admin_users_list(client: AsyncClient):
+    r = await client.get("/admin/users", headers=admin_headers())
+    assert r.status_code == 200
+    assert "users" in r.json()
+
+
+async def test_admin_health_counts(client: AsyncClient):
+    """Health endpoint returns all expected count fields."""
+    r = await client.get("/admin/health", headers=admin_headers())
+    assert r.status_code == 200
+    data = r.json()
+    assert "users_total" in data
+    assert "pro_users" in data