@cachly-dev/mcp-server 0.10.48 → 0.10.49

package/apps/travel-chaos-organizer/backend/alembic/versions/0002_telegram_chat_id.py

@@ -0,0 +1,24 @@
+"""add telegram_chat_id to users
+
+Revision ID: 0002
+Revises: 0001
+Create Date: 2025-01-02 00:00:00.000000
+"""
+from typing import Sequence, Union
+from alembic import op
+import sqlalchemy as sa
+
+revision: str = '0002'
+down_revision: Union[str, None] = '0001'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column('users', sa.Column('telegram_chat_id', sa.Text(), nullable=True))
+    op.create_index('ix_users_telegram_chat_id', 'users', ['telegram_chat_id'], unique=True)
+
+
+def downgrade() -> None:
+    op.drop_index('ix_users_telegram_chat_id', 'users')
+    op.drop_column('users', 'telegram_chat_id')

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

@@ -0,0 +1,39 @@
+[alembic]
+script_location = alembic
+prepend_sys_path = .
+version_path_separator = os
+sqlalchemy.url = postgresql+asyncpg://tco:tco@localhost:5432/tco
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

package/apps/travel-chaos-organizer/backend/app/auth/keycloak.py

@@ -0,0 +1,81 @@
+from datetime import datetime, timedelta, timezone
+from typing import Annotated
+import httpx
+from fastapi import Depends, HTTPException, Request, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from jose import JWTError, jwt
+from app.config import get_settings
+from app.db.database import get_db
+from sqlalchemy.ext.asyncio import AsyncSession
+
+settings = get_settings()
+bearer_scheme = HTTPBearer()
+
+_jwks_cache: dict | None = None
+_jwks_cached_at: datetime | None = None
+_JWKS_TTL = timedelta(hours=1)  # refresh every hour to pick up key rotations
+
+
+async def _get_jwks() -> dict:
+    global _jwks_cache, _jwks_cached_at
+    now = datetime.now(timezone.utc)
+    if _jwks_cache and _jwks_cached_at and (now - _jwks_cached_at) < _JWKS_TTL:
+        return _jwks_cache
+    url = f"{settings.keycloak_url}/realms/{settings.keycloak_realm}/protocol/openid-connect/certs"
+    async with httpx.AsyncClient() as client:
+        resp = await client.get(url, timeout=10)
+        resp.raise_for_status()
+        _jwks_cache = resp.json()
+        _jwks_cached_at = now
+        return _jwks_cache
+
+
+async def get_current_user(
+    credentials: Annotated[HTTPAuthorizationCredentials, Depends(bearer_scheme)],
+) -> dict:
+    token = credentials.credentials
+    try:
+        jwks = await _get_jwks()
+        unverified_header = jwt.get_unverified_header(token)
+        key = next(
+            (k for k in jwks["keys"] if k["kid"] == unverified_header.get("kid")),
+            None,
+        )
+        if key is None:
+            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Unknown signing key")
+
+        payload = jwt.decode(
+            token,
+            key,
+            algorithms=["RS256"],
+            audience=settings.keycloak_client_id,
+            options={"verify_exp": True},
+        )
+        return payload
+    except JWTError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=f"Invalid token: {exc}",
+        ) from exc
+
+
+def user_id(user: Annotated[dict, Depends(get_current_user)]) -> str:
+    return user["sub"]
+
+
+async def user_id_or_bot(request: Request, db: AsyncSession = Depends(get_db)) -> str:
+    """Accept either JWT auth or X-User-Id header (when X-Bot-Token matches)."""
+    s = get_settings()
+    bot_token = request.headers.get("X-Bot-Token", "")
+    if bot_token and s.telegram_bot_token and bot_token == s.telegram_bot_token:
+        uid = request.headers.get("X-User-Id")
+        if uid:
+            return uid
+    # Fall back to normal JWT auth — extract bearer token from request directly
+    auth_header = request.headers.get("Authorization", "")
+    if not auth_header.startswith("Bearer "):
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Not authenticated")
+    from fastapi.security import HTTPAuthorizationCredentials
+    credentials = HTTPAuthorizationCredentials(scheme="Bearer", credentials=auth_header[7:])
+    user = await get_current_user(credentials)
+    return user["sub"]

package/apps/travel-chaos-organizer/backend/app/config.py

@@ -0,0 +1,66 @@
+from pydantic_settings import BaseSettings
+from functools import lru_cache
+
+
+class Settings(BaseSettings):
+    # App
+    app_name: str = "Travel Chaos Organizer API"
+    debug: bool = False
+    upload_dir: str = "/data/uploads"
+    app_url: str = "https://tco.app"
+
+    # Database
+    database_url: str = "postgresql+asyncpg://tco:tco@localhost:5432/tco"
+
+    # Keycloak
+    keycloak_url: str = "http://localhost:8080"
+    keycloak_realm: str = "travel-chaos"
+    keycloak_client_id: str = "tco-backend"
+
+    # Ollama
+    ollama_url: str = "http://localhost:11434"
+    ollama_model: str = "llama3.2-vision"
+    ollama_timeout: int = 120
+
+    # Cachly Redis (optional) — caches Ollama parse results by content hash.
+    # Set to your Cachly Redis connection string to enable deduplication.
+    # Format: redis://:<password>@<host>:<port>/0  or  rediss:// for TLS
+    cachly_redis_url: str = ""
+
+    # CORS
+    cors_origins: str = "*"  # Set to your domain in production: https://yourapp.com
+
+    # Telegram notifier (optional)
+    telegram_bot_token: str = ""
+    telegram_chat_id: str = ""       # default chat; per-app override below
+    tco_telegram_chat_id: str = ""   # if set, overrides telegram_chat_id for TCO events
+
+    # Email (Resend)
+    resend_api_key: str = ""
+    resend_from: str = "noreply@tco.app"
+
+    # Admin
+    admin_user: str = "admin"
+    admin_password: str = "changeme"
+
+    # Sentry (optional)
+    sentry_dsn: str = ""
+    environment: str = "production"
+
+    # Upload
+    max_upload_bytes: int = 20 * 1024 * 1024  # 20 MB
+
+    # Stripe
+    stripe_secret_key: str = ""
+    stripe_webhook_secret: str = ""
+    stripe_pro_price_id: str = "price_YOUR_PRICE_ID"
+    stripe_success_url: str = "tco://upgrade/success"
+    stripe_cancel_url: str = "tco://upgrade/cancel"
+
+    class Config:
+        env_file = ".env"
+
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()

package/apps/travel-chaos-organizer/backend/app/db/database.py

@@ -0,0 +1,20 @@
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
+from sqlalchemy.orm import DeclarativeBase
+from app.config import get_settings
+
+settings = get_settings()
+
+engine = create_async_engine(settings.database_url, echo=settings.debug)
+AsyncSessionLocal = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+async def get_db() -> AsyncSession:
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+        finally:
+            await session.close()

package/apps/travel-chaos-organizer/backend/app/db/migrations/001_init.sql

@@ -0,0 +1,71 @@
+-- Travel Chaos Organizer — Initial Schema
+
+CREATE EXTENSION IF NOT EXISTS "pgcrypto";
+
+CREATE TABLE IF NOT EXISTS trips (
+    id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id     TEXT NOT NULL,
+    name        TEXT NOT NULL,
+    description TEXT,
+    start_date  DATE,
+    end_date    DATE,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX idx_trips_user_id ON trips(user_id);
+
+CREATE TYPE item_type AS ENUM (
+    'flight', 'train', 'bus', 'hotel', 'rental_car',
+    'activity', 'transfer', 'document', 'other'
+);
+
+CREATE TABLE IF NOT EXISTS trip_items (
+    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    trip_id       UUID NOT NULL REFERENCES trips(id) ON DELETE CASCADE,
+    user_id       TEXT NOT NULL,
+    type          item_type NOT NULL DEFAULT 'other',
+    title         TEXT NOT NULL,
+    raw_text      TEXT,
+    parsed_data   JSONB,
+    event_at      TIMESTAMPTZ,
+    event_end_at  TIMESTAMPTZ,
+    booking_ref   TEXT,
+    provider      TEXT,
+    created_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at    TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX idx_trip_items_trip_id ON trip_items(trip_id);
+CREATE INDEX idx_trip_items_event_at ON trip_items(event_at);
+CREATE INDEX idx_trip_items_parsed_data ON trip_items USING gin(parsed_data);
+
+CREATE TABLE IF NOT EXISTS attachments (
+    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    trip_item_id  UUID REFERENCES trip_items(id) ON DELETE CASCADE,
+    inbox_id      UUID,
+    user_id       TEXT NOT NULL,
+    file_path     TEXT NOT NULL,
+    file_name     TEXT NOT NULL,
+    mime_type     TEXT NOT NULL,
+    size_bytes    BIGINT,
+    created_at    TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX idx_attachments_trip_item_id ON attachments(trip_item_id);
+
+CREATE TYPE inbox_status AS ENUM ('pending', 'processed', 'rejected', 'assigned');
+
+CREATE TABLE IF NOT EXISTS chaos_inbox (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id      TEXT NOT NULL,
+    raw_content  TEXT,
+    source       TEXT,
+    status       inbox_status NOT NULL DEFAULT 'pending',
+    parsed_data  JSONB,
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX idx_chaos_inbox_user_id ON chaos_inbox(user_id);
+CREATE INDEX idx_chaos_inbox_status ON chaos_inbox(status);

package/apps/travel-chaos-organizer/backend/app/db/migrations/002_telemetry_freemium.sql

@@ -0,0 +1,31 @@
+-- users table: freemium plan tracking. id = Keycloak sub.
+CREATE TABLE IF NOT EXISTS users (
+    id              TEXT PRIMARY KEY,
+    email           TEXT,
+    plan            TEXT NOT NULL DEFAULT 'free',
+    plan_expires_at TIMESTAMPTZ,
+    created_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at      TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+-- events table: telemetry. user_id nullable for anonymous/server events.
+CREATE TABLE IF NOT EXISTS events (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id      TEXT,
+    event_name   TEXT NOT NULL,
+    properties   JSONB,
+    platform     TEXT,
+    app_version  TEXT,
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_events_user_id  ON events(user_id);
+CREATE INDEX idx_events_name     ON events(event_name);
+CREATE INDEX idx_events_created  ON events(created_at DESC);
+
+-- waitlist: email capture from landing page (no auth required)
+CREATE TABLE IF NOT EXISTS waitlist (
+    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    email      TEXT NOT NULL UNIQUE,
+    source     TEXT DEFAULT 'landing',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);

package/apps/travel-chaos-organizer/backend/app/db/migrations/003_telegram_chat_id.sql

@@ -0,0 +1,4 @@
+-- Add telegram_chat_id column to users table.
+-- This column was referenced in the application but missing from the initial schema.
+ALTER TABLE users ADD COLUMN IF NOT EXISTS telegram_chat_id TEXT;
+CREATE INDEX IF NOT EXISTS idx_users_telegram_chat_id ON users(telegram_chat_id) WHERE telegram_chat_id IS NOT NULL;

package/apps/travel-chaos-organizer/backend/app/db/migrations/004_stripe_and_email.sql

@@ -0,0 +1,5 @@
+-- Add stripe_customer_id to users table.
+-- Used by payments.py to link Stripe customer to user in webhook handlers.
+-- Missing column causes crash on every Stripe webhook (checkout, subscription cancel, renewal, payment failed).
+ALTER TABLE users ADD COLUMN IF NOT EXISTS stripe_customer_id TEXT;
+CREATE INDEX IF NOT EXISTS idx_users_stripe_customer_id ON users(stripe_customer_id) WHERE stripe_customer_id IS NOT NULL;

package/apps/travel-chaos-organizer/backend/app/limiter.py

@@ -0,0 +1,4 @@
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+limiter = Limiter(key_func=get_remote_address)

package/apps/travel-chaos-organizer/backend/app/logging_config.py

@@ -0,0 +1,25 @@
+import logging
+import sys
+import json
+from datetime import datetime, timezone
+
+
+class JsonFormatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:
+        return json.dumps({
+            "ts": datetime.now(timezone.utc).isoformat(),
+            "level": record.levelname,
+            "logger": record.name,
+            "msg": record.getMessage(),
+            **({"exc": self.formatException(record.exc_info)} if record.exc_info else {}),
+        })
+
+
+def setup_logging(debug: bool = False) -> None:
+    level = logging.DEBUG if debug else logging.INFO
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(JsonFormatter())
+    logging.basicConfig(level=level, handlers=[handler], force=True)
+    # Silence noisy libraries
+    for name in ("uvicorn.access", "sqlalchemy.engine", "asyncio"):
+        logging.getLogger(name).setLevel(logging.WARNING)

package/apps/travel-chaos-organizer/backend/app/main.py

@@ -0,0 +1,77 @@
+from contextlib import asynccontextmanager
+import os
+from pathlib import Path
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.config import get_settings
+from app.routers import trips, items, parse, inbox, mail, events as events_router, waitlist as waitlist_router
+from app.routers import admin as admin_router
+from app.routers import users as users_router
+from app.routers import payments as payments_router
+from app.routers import export as export_router
+from app.routers import cache as cache_router
+from app.services.cache import cachly_configured
+from app.limiter import limiter
+from slowapi import _rate_limit_exceeded_handler
+from slowapi.errors import RateLimitExceeded
+from slowapi.middleware import SlowAPIMiddleware
+
+settings = get_settings()
+
+APP_VERSION = "0.1.0"
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    from app.logging_config import setup_logging
+    setup_logging(debug=settings.debug)
+    from app.services import sentry as sentry_svc
+    sentry_svc.init(settings.sentry_dsn, settings.environment, release=APP_VERSION)
+    Path(settings.upload_dir).mkdir(parents=True, exist_ok=True)
+    import sys
+    if settings.admin_password == "changeme":
+        print("⚠️  WARNING: ADMIN_PASSWORD is still 'changeme'. Change it before going live!", file=sys.stderr)
+    yield
+
+
+app = FastAPI(
+    title=settings.app_name,
+    version=APP_VERSION,
+    lifespan=lifespan,
+    docs_url="/docs" if settings.debug else None,
+    redoc_url="/redoc" if settings.debug else None,
+    openapi_url="/openapi.json" if settings.debug else None,
+)
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+app.add_middleware(SlowAPIMiddleware)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.cors_origins.split(",") if settings.cors_origins != "*" else ["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(trips.router, prefix="/api/v1")
+app.include_router(items.router, prefix="/api/v1")
+app.include_router(parse.router, prefix="/api/v1")
+app.include_router(inbox.router, prefix="/api/v1")
+app.include_router(mail.router, prefix="/api/v1")
+app.include_router(events_router.router, prefix="/api/v1")
+app.include_router(waitlist_router.router, prefix="/api/v1")
+app.include_router(admin_router.router)   # no /api/v1 prefix — admin is at /admin
+app.include_router(users_router.router, prefix="/api/v1")
+app.include_router(payments_router.router, prefix="/api/v1")
+app.include_router(export_router.router, prefix="/api/v1")
+app.include_router(cache_router.router, prefix="/api/v1")
+
+
+@app.get("/health")
+async def health():
+    return {
+        "status": "ok",
+        "version": APP_VERSION,
+        "cachly_cache": "enabled" if cachly_configured() else "disabled",
+    }

package/apps/travel-chaos-organizer/backend/app/models/schemas.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+from datetime import date, datetime
+from typing import Any, Literal
+from uuid import UUID
+from pydantic import BaseModel, Field
+
+
+ItemType = Literal[
+    "flight", "train", "bus", "hotel", "rental_car",
+    "activity", "transfer", "document", "other"
+]
+
+InboxStatus = Literal["pending", "processed", "rejected", "assigned"]
+
+
+# ── Trips ──────────────────────────────────────────────────────────────────
+
+class TripCreate(BaseModel):
+    name: str = Field(..., min_length=1, max_length=200)
+    description: str | None = None
+    start_date: date | None = None
+    end_date: date | None = None
+
+
+class TripUpdate(BaseModel):
+    name: str | None = Field(None, min_length=1, max_length=200)
+    description: str | None = None
+    start_date: date | None = None
+    end_date: date | None = None
+
+
+class TripOut(BaseModel):
+    id: UUID
+    user_id: str
+    name: str
+    description: str | None
+    start_date: date | None
+    end_date: date | None
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = {"from_attributes": True}
+
+
+# ── Trip Items ─────────────────────────────────────────────────────────────
+
+class TripItemCreate(BaseModel):
+    type: ItemType = "other"
+    title: str = Field(..., min_length=1, max_length=300)
+    raw_text: str | None = None
+    parsed_data: dict[str, Any] | None = None
+    event_at: datetime | None = None
+    event_end_at: datetime | None = None
+    booking_ref: str | None = None
+    provider: str | None = None
+
+
+class TripItemUpdate(BaseModel):
+    type: ItemType | None = None
+    title: str | None = Field(None, min_length=1, max_length=300)
+    raw_text: str | None = None
+    parsed_data: dict[str, Any] | None = None
+    event_at: datetime | None = None
+    event_end_at: datetime | None = None
+    booking_ref: str | None = None
+    provider: str | None = None
+
+
+class TripItemOut(BaseModel):
+    id: UUID
+    trip_id: UUID
+    user_id: str
+    type: str
+    title: str
+    raw_text: str | None
+    parsed_data: dict[str, Any] | None
+    event_at: datetime | None
+    event_end_at: datetime | None
+    booking_ref: str | None
+    provider: str | None
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = {"from_attributes": True}
+
+
+# ── Attachments ────────────────────────────────────────────────────────────
+
+class AttachmentOut(BaseModel):
+    id: UUID
+    trip_item_id: UUID | None
+    inbox_id: UUID | None
+    file_name: str
+    mime_type: str
+    size_bytes: int | None
+    created_at: datetime
+
+    model_config = {"from_attributes": True}
+
+
+# ── Chaos Inbox ────────────────────────────────────────────────────────────
+
+class InboxItemOut(BaseModel):
+    id: UUID
+    user_id: str
+    raw_content: str | None
+    source: str | None
+    status: str
+    parsed_data: dict[str, Any] | None
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = {"from_attributes": True}
+
+
+class InboxAssign(BaseModel):
+    trip_id: UUID
+    type: ItemType = "other"
+
+
+# ── Parsing ────────────────────────────────────────────────────────────────
+
+class ParsedTravelData(BaseModel):
+    type: ItemType = "other"
+    title: str = "Unnamed Item"
+    booking_ref: str | None = None
+    provider: str | None = None
+    event_at: str | None = None
+    event_end_at: str | None = None
+    origin: str | None = None
+    destination: str | None = None
+    passengers: list[str] | None = None
+    confirmation_number: str | None = None
+    price: str | None = None
+    raw_summary: str | None = None
+    confidence: float = 0.0
+
+
+class ParseResponse(BaseModel):
+    parsed: ParsedTravelData
+    raw_text: str | None = None
+    model_used: str