Merge branch 'feature/arch-refactoring' into dev

.dockerignore

@@ -12,7 +12,8 @@ scratch/
 .claude/
 *.local.*
 node_modules/
-docker-compose-dev.yml
+frontend/node_modules/
+deploy/compose/docker-compose-dev.yml
 data/*
 !data/tariffs.example.json
 
@@ -24,15 +25,14 @@ data/*
 
 # Docker
 docker-compose.yml
-Dockerfile
-.docker
+deploy/compose/*.yml
 .dockerignore
 tmp/
 
 # WebApp build artifacts (regenerated inside Docker)
-bot/app/web/templates/subscription_webapp.css
-bot/app/web/templates/subscription_webapp.js
-bot/app/web/templates/subscription_webapp.min.*.js
+backend/bot/app/web/templates/subscription_webapp.css
+backend/bot/app/web/templates/subscription_webapp.js
+backend/bot/app/web/templates/subscription_webapp.min.*.js
 
 # Byte-compiled / optimized / DLL files
 **/__pycache__/

.env.example

@@ -8,6 +8,21 @@ POSTGRES_PASSWORD=                                                           # R
 POSTGRES_HOST=remnawave-minishop-db                                           # Database container name
 POSTGRES_PORT=5432                                                            # Port
 POSTGRES_DB=postgres                                                          # Database name
+DB_POOL_SIZE=20                                                               # SQLAlchemy async pool size per backend/worker process
+DB_MAX_OVERFLOW=10                                                            # Extra transient DB connections above pool size
+DB_POOL_TIMEOUT_SECONDS=30                                                     # Seconds to wait for a DB pool connection
+DB_POOL_RECYCLE_SECONDS=1800                                                   # Recycle DB connections to avoid stale sockets
+
+REDIS_URL=redis://redis:6379/0                                                 # Shared Redis for FSM, rate limits, cache, locks and queues
+REDIS_KEY_PREFIX=remnawave-tg-shop                                             # Prefix for Redis keys
+WEBAPP_ME_CACHE_TTL_SECONDS=15                                                 # Short TTL for /api/me payload cache
+WEBAPP_RATE_LIMIT_TTL_SECONDS=60                                               # Redis rate-limit window
+WEBAPP_RATE_LIMIT_MAX_REQUESTS=30                                              # Requests per window/action/user/IP
+WEBHOOK_QUEUE_NAME=webhook-events                                              # Redis queue for heavy webhook processing
+WEBHOOK_QUEUE_CONCURRENCY=4                                                    # Worker webhook consumers
+WORKER_PANEL_SYNC_INTERVAL_SECONDS=900                                         # Worker panel sync interval
+TARIFF_WORKER_LOCK_TTL_SECONDS=240                                             # Redis lock TTL for tariff tick
+TARIFF_WORKER_TICK_SECONDS=300                                                 # Tariff worker tick interval
 
 # Localization and Display
 DEFAULT_LANGUAGE="ru"                                                         # or "en"
@@ -146,8 +161,6 @@ STARS_PRICE_12_MONTHS=0
 TRAFFIC_PACKAGES=10:199,50:799                                                # Format: "<GB>:<price>", comma-separated
 STARS_TRAFFIC_PACKAGES=10:2500                                                # Optional: traffic packages priced in Stars
 TARIFFS_CONFIG_PATH=data/tariffs.json                                         # Optional Tariffs 2.0 JSON config. If missing, legacy .env pricing is used.
-NEWT_ID=                                                                      # Optional: local docker-compose-dev.yml Newt tunnel id
-NEWT_SECRET=                                                                  # Optional: local docker-compose-dev.yml Newt tunnel secret
 TARIFF_TRAFFIC_WARNING_LEVELS=85,90,95                                        # Tariffs 2.0 traffic warning levels, percent used
 
 # Subscription Notifications

.gitignore

@@ -5,6 +5,7 @@ bot_database.sqlite3
 .env
 .env.*
 !.env.example
+docker-compose-dev.yml
 scratch_*.py
 *.local.*
 node_modules/
@@ -14,6 +15,9 @@ node_modules/
 bot/app/web/templates/subscription_webapp.css
 bot/app/web/templates/subscription_webapp.js
 bot/app/web/templates/subscription_webapp.min.*.js
+backend/bot/app/web/templates/subscription_webapp.css
+backend/bot/app/web/templates/subscription_webapp.js
+backend/bot/app/web/templates/subscription_webapp.min.*.js
 tmp
 .claude
 
@@ -32,4 +36,3 @@ locales/en_backup.json
 db/models_old.py
 data/*
 !data/tariffs.example.json
-docker-compose-dev.yml

Caddyfile

@@ -1,10 +0,0 @@
-# Replace the example domains below with your real webhook and Mini App hostnames.
-webhook.domain.com {
-	encode zstd gzip
-	reverse_proxy remnawave-minishop:{$WEB_SERVER_PORT:8080}
-}
-
-app.domain.com {
-	encode zstd gzip
-	reverse_proxy remnawave-minishop:{$WEBAPP_SERVER_PORT:8081}
-}

Dockerfile

@@ -1,96 +0,0 @@
-FROM python:3.12-slim AS python-builder
-
-WORKDIR /app
-
-COPY requirements.txt .
-
-RUN --mount=type=cache,target=/root/.cache/pip \
-    pip install --no-cache-dir -r requirements.txt
-
-
-FROM node:22-slim AS webapp-builder
-
-WORKDIR /webapp
-
-COPY package.json package-lock.json* ./
-RUN --mount=type=cache,target=/root/.npm \
-    if [ -f package-lock.json ]; then npm ci; else npm install; fi
-
-COPY bot/app/web/frontend ./bot/app/web/frontend
-COPY bot/app/web/templates ./bot/app/web/templates
-COPY scripts/build_subscription_webapp_js.mjs ./scripts/build_subscription_webapp_js.mjs
-
-RUN npm run build:webapp
-
-
-FROM python:3.12-slim
-
-WORKDIR /app
-
-ARG APP_VERSION=""
-ARG APP_REVISION=""
-
-LABEL org.opencontainers.image.source="https://github.com/3252a8/remnawave-minishop" \
-      org.opencontainers.image.version="${APP_VERSION}" \
-      org.opencontainers.image.revision="${APP_REVISION}"
-
-RUN useradd -u 10001 -m appuser
-
-COPY --from=python-builder /usr/local/lib/python3.12/site-packages /usr/local/lib/python3.12/site-packages
-
-RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
-    --mount=type=cache,target=/var/lib/apt,sharing=locked \
-    apt-get update && \
-    apt-get install -y --no-install-recommends git
-
-COPY . .
-
-# Replace template assets with freshly built ones
-RUN rm -f bot/app/web/templates/subscription_webapp.css \
-          bot/app/web/templates/subscription_webapp.js \
-          bot/app/web/templates/subscription_webapp.min.*.js
-COPY --from=webapp-builder /webapp/bot/app/web/templates/subscription_webapp.css \
-                           bot/app/web/templates/subscription_webapp.css
-COPY --from=webapp-builder /webapp/bot/app/web/templates/subscription_webapp.js \
-                           bot/app/web/templates/subscription_webapp.js
-COPY --from=webapp-builder /webapp/bot/app/web/templates/subscription_webapp.min.*.js \
-                           bot/app/web/templates/
-
-RUN set -eux; \
-    if [ -n "$APP_VERSION" ]; then \
-      printf '%s\n' "$APP_VERSION" > .build-version; \
-    elif [ -d .git ]; then \
-      tag="$(git describe --tags --abbrev=0 2>/dev/null || true)"; \
-      sha="$(git rev-parse --short HEAD 2>/dev/null || true)"; \
-      dirty=""; \
-      if ! git diff --quiet --ignore-submodules HEAD 2>/dev/null; then dirty="-dirty"; fi; \
-      if [ -n "$tag" ] && [ -n "$sha" ]; then \
-        count="$(git rev-list "${tag}..HEAD" --count 2>/dev/null || true)"; \
-        if [ -n "$count" ] && [ "$count" != "0" ]; then \
-          printf '%s+%s.g%s%s\n' "$tag" "$count" "$sha" "$dirty" > .build-version; \
-        else \
-          printf '%s%s\n' "$tag" "$dirty" > .build-version; \
-        fi; \
-      elif [ -n "$sha" ]; then \
-        printf 'dev+g%s%s\n' "$sha" "$dirty" > .build-version; \
-      else \
-        printf 'dev+container\n' > .build-version; \
-      fi; \
-    else \
-      printf 'dev+container\n' > .build-version; \
-    fi; \
-    if [ -n "$APP_REVISION" ]; then \
-      printf '%s\n' "$APP_REVISION" > .build-revision; \
-    elif [ -d .git ]; then \
-      git rev-parse HEAD > .build-revision 2>/dev/null || printf 'unknown\n' > .build-revision; \
-    else \
-      printf 'unknown\n' > .build-revision; \
-    fi; \
-    apt-get purge -y --auto-remove git; \
-    rm -rf .git /root/.cache
-
-RUN mkdir -p /app/logs /app/data && chown -R appuser:appuser /app/logs /app/data
-
-USER appuser
-
-CMD ["python", "main.py"]

README.md

@@ -43,13 +43,13 @@ Remnawave Minishop - Telegram-бот и Web App (Mini App) для продажи
 
 ## Стек
 
-Сборка и runtime задаются **Dockerfile** и **docker-compose.yml**; точные версии пакетов — в **requirements.txt** и **package.json**.
+Сборка и runtime задаются **deploy/docker/Dockerfile** и **docker-compose.yml**; точные версии пакетов — в **backend/requirements.txt** и **frontend/package.json**.
 
 | Слой | Технологии |
 | --- | --- |
 | Backend | Python **3.12**, [aiogram](https://docs.aiogram.dev/) 3.x (Telegram), **aiohttp** (HTTP и Web App), **SQLAlchemy** 2 async, **asyncpg**, **Pydantic** / pydantic-settings, **httpx**, платёжные SDK (в т.ч. YooKassa, aiocryptopay), **PyJWT** |
-| Данные | **PostgreSQL** **17** (сервис `remnawave-minishop-db` в Compose) |
-| Сборка Web App | **Node.js** **22**, **Svelte** **5**, **Vite**, **Tailwind CSS** 4; артефакты попадают в шаблоны `bot/app/web/templates/` |
+| Данные | **PostgreSQL** **17** (сервис `postgres` в Compose) и **Redis** **7** (сервис `redis`) |
+| Сборка Web App | **Node.js** **22**, **Svelte** **5**, **Vite**, **Tailwind CSS** 4; артефакты попадают в шаблоны `backend/bot/app/web/templates/` |
 
 Локальная разработка без Docker возможна при установленных Python 3.12, PostgreSQL и (для пересборки фронта) Node 22; типичный сценарий — всё через Compose.
 
@@ -68,7 +68,7 @@ cd remnawave-minishop
 cp .env.example .env
 nano .env
 docker compose up -d --build
-docker compose logs -f remnawave-minishop
+docker compose logs -f backend worker frontend
 ```
 
 Минимально заполните в `.env`:
@@ -98,15 +98,21 @@ chmod -R u+rwX data
 docker compose up -d --build
 
 # Логи приложения
-docker compose logs -f remnawave-minishop
+docker compose logs -f backend worker frontend
 
 # Запуск с Caddy
-docker compose -f docker-compose-caddy.yml up -d --build
+docker compose -f deploy/compose/docker-compose-caddy.yml up -d
 
 # Запуск из готового образа
-IMAGE_TAG=3.1.0 docker compose -f docker-compose-remote-server.yml up -d
+IMAGE_TAG=3.1.0 docker compose -f deploy/compose/docker-compose-remote-server.yml up -d
 ```
 
+GHCR image names for releases:
+
+- `ghcr.io/3252a8/remnawave-minishop-backend`
+- `ghcr.io/3252a8/remnawave-minishop-worker`
+- `ghcr.io/3252a8/remnawave-minishop-frontend`
+
 ## Поддержка
 
 - Crypto: `USDT/Other ERC-20 0xeD506D44aae634fEc0E01C8835744fBedb7B2a44 (Ethereum/Polygon/Gnosis)`

backend/app_logging.py

@@ -0,0 +1,12 @@
+import logging
+import os
+import sys
+
+
+def configure_logging() -> None:
+    level = getattr(logging, os.getenv("LOG_LEVEL", "INFO").upper(), logging.INFO)
+    logging.basicConfig(
+        level=level,
+        stream=sys.stdout,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    )

backend/bot/app/controllers/dispatcher_controller.py

@@ -6,6 +6,11 @@ from aiogram.enums import ParseMode
 from aiogram.fsm.storage.memory import MemoryStorage
 from sqlalchemy.orm import sessionmaker
 
+try:
+    from aiogram.fsm.storage.redis import RedisStorage
+except ModuleNotFoundError:  # pragma: no cover - dependency is installed in Docker image
+    RedisStorage = None  # type: ignore[assignment]
+
 from bot.middlewares.action_logger_middleware import ActionLoggerMiddleware
 from bot.middlewares.ban_check_middleware import BanCheckMiddleware
 from bot.middlewares.channel_subscription import ChannelSubscriptionMiddleware
@@ -18,7 +23,11 @@ from config.settings import Settings
 def build_dispatcher(
     settings: Settings, async_session_factory: sessionmaker
 ) -> tuple[Dispatcher, Bot, Dict]:
-    storage = MemoryStorage()
+    storage = (
+        RedisStorage.from_url(settings.REDIS_URL)
+        if settings.REDIS_URL and RedisStorage is not None
+        else MemoryStorage()
+    )
     default_props = DefaultBotProperties(parse_mode=ParseMode.HTML)
     bot = Bot(token=settings.BOT_TOKEN, default=default_props)
 

backend/bot/app/factories/build_services.py

@@ -81,14 +81,12 @@ def build_core_services(
         api_url=settings.LKNPD_API_URL,
     )
 
-    # Wire services that depend on each other
-    try:
-        # Attach YooKassa to subscription service for auto-renew charges
-        setattr(subscription_service, "yookassa_service", yookassa_service)
-        # Allow panel webhook to trigger renewals through subscription service
-        setattr(panel_webhook_service, "subscription_service", subscription_service)
-    except Exception:
-        pass
+    # Wire services that depend on each other. These attachments are critical
+    # for auto-renew (subscription_service.yookassa_service) and for the panel
+    # webhook handler's 24h pre-expiry renewal trigger; do NOT swallow errors —
+    # silent wiring failures previously caused auto-renew to disappear.
+    subscription_service.yookassa_service = yookassa_service
+    panel_webhook_service.subscription_service = subscription_service
 
     return {
         "panel_service": panel_service,

backend/bot/app/web/admin_api_impl/_runtime.py

@@ -28,6 +28,7 @@ from sqlalchemy.orm import sessionmaker
 from bot.app.web.admin_settings_manifest import (
     manifest_payload,
 )
+from bot.infra.webhook_queue import enqueue_webhook_event
 from bot.services.referral_service import ReferralService
 from bot.services.settings_override_service import (
     current_value,

backend/bot/app/web/admin_api_impl/settings.py

@@ -83,5 +83,8 @@ async def admin_settings_patch_route(request: web.Request) -> web.Response:
         or "WEBAPP_LOGO_FAVICON_URL" in deletes
     ):
         request.app["webapp_logo_cache"] = None
+        from bot.app.web.admin_api_impl.themes import prune_unused_appearance_assets
+
+        prune_unused_appearance_assets(settings)
 
     return _ok({"applied": result.get("applied", 0), "reverted": result.get("reverted", 0)})

backend/bot/app/web/admin_api_impl/sync.py

@@ -0,0 +1,16 @@
+# ruff: noqa: F401,F403,F405,I001
+from ._runtime import *  # noqa: F403,F405
+
+
+async def admin_sync_route(request: web.Request) -> web.Response:
+    _require_admin_user_id(request)
+    settings: Settings = request.app["settings"]
+    queued = await enqueue_webhook_event(
+        settings,
+        "panel_sync",
+        {"requested_by": _require_admin_user_id(request)},
+        event_id=None,
+    )
+    if queued:
+        return _ok({"result": {"status": "queued"}})
+    return _error(503, "queue_unavailable")

backend/bot/app/web/admin_api_impl/themes.py

@@ -4,6 +4,7 @@ from ._runtime import *  # noqa: F403,F405
 import asyncio
 import hashlib
 import ipaddress
+import shutil
 import re
 import socket
 
@@ -19,10 +20,11 @@ from config.webapp_themes_config import (
 
 
 WEBAPP_LOGO_MAX_BYTES = 2 * 1024 * 1024
-WEBAPP_UPLOADED_LOGO_DIR = Path(__file__).resolve().parents[4] / "data" / "webapp-logo" / "uploads"
+WEBAPP_UPLOADED_LOGO_DIR = Path(__file__).resolve().parents[5] / "data" / "webapp-logo" / "uploads"
 WEBAPP_UPLOADED_LOGO_PATH = "/webapp-uploaded-logo"
-WEBAPP_FAVICON_DIR = Path(__file__).resolve().parents[4] / "data" / "webapp-logo" / "favicons"
+WEBAPP_FAVICON_DIR = Path(__file__).resolve().parents[5] / "data" / "webapp-logo" / "favicons"
 WEBAPP_FAVICON_PATH = "/webapp-favicon"
+WEBAPP_EMOJI_CACHE_DIR = Path(__file__).resolve().parents[5] / "data" / "webapp-emoji"
 WEBAPP_FAVICON_SIZES = (16, 32, 48, 180, 192, 512)
 WEBAPP_LOGO_UPLOAD_CONTENT_TYPES = {
     ".gif": "image/gif",
@@ -73,6 +75,113 @@ def _write_uploaded_logo(body: bytes, content_type: str = "", filename: str = ""
     return f"{WEBAPP_UPLOADED_LOGO_PATH}/{safe_name}"
 
 
+def _uploaded_logo_filename(url: str) -> Optional[str]:
+    parsed = urlsplit(str(url or ""))
+    path = parsed.path if parsed.scheme or parsed.netloc else str(url or "")
+    prefix = f"{WEBAPP_UPLOADED_LOGO_PATH}/"
+    if not path.startswith(prefix):
+        return None
+    filename = path.removeprefix(prefix)
+    if re.fullmatch(r"logo-[0-9a-f]{16}\.(?:gif|ico|jpe?g|png|svg|webp)", filename):
+        return filename
+    return None
+
+
+def _favicon_digest(url: str) -> Optional[str]:
+    parsed = urlsplit(str(url or ""))
+    path = parsed.path if parsed.scheme or parsed.netloc else str(url or "")
+    match = re.fullmatch(
+        rf"{re.escape(WEBAPP_FAVICON_PATH)}/([0-9a-f]{{16}})/(?:[A-Za-z0-9_.-]+)",
+        path,
+    )
+    return match.group(1) if match else None
+
+
+def _emoji_to_codepoints(value: str) -> str:
+    return "_".join(f"{ord(char):x}" for char in str(value or "").strip())
+
+
+def prune_unused_appearance_assets(settings: Settings) -> None:
+    keep_logos = {
+        filename
+        for filename in [
+            _uploaded_logo_filename(getattr(settings, "WEBAPP_LOGO_URL", "")),
+        ]
+        if filename
+    }
+    keep_favicons = {
+        digest
+        for digest in [
+            _favicon_digest(getattr(settings, "WEBAPP_FAVICON_URL", "")),
+            _favicon_digest(getattr(settings, "WEBAPP_LOGO_FAVICON_URL", "")),
+        ]
+        if digest
+    }
+    keep_emoji_prefixes = set()
+    if (
+        getattr(settings, "WEBAPP_LOGO_USE_EMOJI", False)
+        and str(getattr(settings, "WEBAPP_LOGO_EMOJI_FONT", "") or "").strip()
+        == "noto-color-animated"
+    ):
+        codepoints = _emoji_to_codepoints(getattr(settings, "WEBAPP_LOGO_EMOJI", ""))
+        if codepoints:
+            keep_emoji_prefixes.add(f"{codepoints}.512.")
+
+    for path in WEBAPP_UPLOADED_LOGO_DIR.glob("logo-*"):
+        if path.is_file() and path.name not in keep_logos:
+            try:
+                path.unlink()
+            except OSError:
+                logger.warning("Failed to remove unused webapp logo %s", path, exc_info=True)
+
+    for path in WEBAPP_FAVICON_DIR.glob("*"):
+        if (
+            path.is_dir()
+            and re.fullmatch(r"[0-9a-f]{16}", path.name)
+            and path.name not in keep_favicons
+        ):
+            try:
+                shutil.rmtree(path)
+            except OSError:
+                logger.warning("Failed to remove unused webapp favicon set %s", path, exc_info=True)
+
+    for path in WEBAPP_EMOJI_CACHE_DIR.glob("*.512.*"):
+        if path.is_file() and not any(
+            path.name.startswith(prefix) for prefix in keep_emoji_prefixes
+        ):
+            try:
+                path.unlink()
+            except OSError:
+                logger.warning("Failed to remove unused webapp emoji asset %s", path, exc_info=True)
+
+
+async def _persist_appearance_upload(
+    request: web.Request,
+    updates: Dict[str, Any],
+    actor_id: int,
+) -> bool:
+    settings: Settings = request.app["settings"]
+    async_session_factory: sessionmaker = request.app["async_session_factory"]
+    result = await update_overrides(
+        settings,
+        async_session_factory,
+        updates=updates,
+        deletes=[],
+        actor_id=actor_id,
+    )
+    if not result.get("ok"):
+        logger.warning("Failed to persist uploaded appearance asset settings: %s", result)
+        return False
+
+    cache = request.app.get("webapp_settings_cache")
+    if isinstance(cache, dict):
+        cache["ts"] = 0.0
+        cache["data"] = {}
+    request.app["webapp_logo_cache"] = None
+    prune_unused_appearance_assets(settings)
+    return True
+
+
 def _image_to_square_icon(source: Image.Image, size: int) -> Image.Image:
     fitted = source.copy()
     fitted.thumbnail((size, size), Image.Resampling.LANCZOS)
@@ -221,7 +330,7 @@ async def _fetch_logo_from_url(url: str) -> tuple[bytes, str, str]:
 
 
 async def admin_appearance_logo_upload_route(request: web.Request) -> web.Response:
-    _require_admin_user_id(request)
+    actor_id = _require_admin_user_id(request)
     content_type = (request.headers.get("Content-Type") or "").lower()
     try:
         if content_type.startswith("multipart/form-data"):
@@ -242,12 +351,25 @@ async def admin_appearance_logo_upload_route(request: web.Request) -> web.Respon
     except OSError as exc:
         logger.exception("Failed to save uploaded webapp logo")
         return _error(500, "write_failed", str(exc))
+    persisted = await _persist_appearance_upload(
+        request,
+        {
+            "WEBAPP_LOGO_URL": logo_url,
+            "WEBAPP_LOGO_USE_EMOJI": False,
+            **(
+                {"WEBAPP_LOGO_FAVICON_URL": favicon_payload["favicon_url"]}
+                if favicon_payload.get("favicon_url")
+                else {}
+            ),
+        },
+        actor_id,
+    )
 
-    return _ok({"logo_url": logo_url, **favicon_payload})
+    return _ok({"logo_url": logo_url, "persisted": persisted, **favicon_payload})
 
 
 async def admin_appearance_favicon_upload_route(request: web.Request) -> web.Response:
-    _require_admin_user_id(request)
+    actor_id = _require_admin_user_id(request)
     content_type = (request.headers.get("Content-Type") or "").lower()
     try:
         if content_type.startswith("multipart/form-data"):
@@ -264,8 +386,16 @@ async def admin_appearance_favicon_upload_route(request: web.Request) -> web.Res
     except OSError as exc:
         logger.exception("Failed to save uploaded webapp favicon")
         return _error(500, "write_failed", str(exc))
+    persisted = await _persist_appearance_upload(
+        request,
+        {
+            "WEBAPP_FAVICON_URL": favicon_payload["favicon_url"],
+            "WEBAPP_FAVICON_USE_CUSTOM": True,
+        },
+        actor_id,
+    )
 
-    return _ok(favicon_payload)
+    return _ok({"persisted": persisted, **favicon_payload})
 
 
 async def admin_themes_get_route(request: web.Request) -> web.Response:

backend/bot/app/web/admin_settings_manifest.py

@@ -100,7 +100,12 @@ SETTINGS_MANIFEST: List[SettingField] = [
             ("noto-local", "Noto Emoji (local)"),
         ),
     ),
-    SettingField("WEBAPP_FAVICON_USE_CUSTOM", "bool", "appearance", "Использовать отдельную favicon"),
+    SettingField(
+        "WEBAPP_FAVICON_USE_CUSTOM",
+        "bool",
+        "appearance",
+        "Использовать отдельную favicon",
+    ),
     SettingField("WEBAPP_FAVICON_URL", "url", "appearance", "URL отдельной favicon"),
     SettingField("WEBAPP_LOGO_FAVICON_URL", "url", "appearance", "Favicon из логотипа"),
     SettingField("WEBAPP_ENABLED", "bool", "appearance", "Web App включён"),

backend/bot/app/web/templates/subscription_webapp.html

@@ -9,7 +9,6 @@
   <link id="app-favicon" rel="icon" href="data:," sizes="any">
   <title>/minishop</title>
   <link rel="stylesheet" href="/subscription_webapp.css">
-  <link rel="preload" id="logo-preload" href="" as="image" fetchpriority="high">
 </head>
 
 <body>

backend/bot/app/web/web_server.py

@@ -56,9 +56,24 @@ async def build_and_start_web_app(
     _inject_shared_instances(app, dp, bot, settings, async_session_factory)
 
     async def _healthcheck(request: web.Request) -> web.Response:
-        return web.json_response({"status": "ok"})
+        payload = {"status": "ok"}
+        try:
+            from db.database_setup import async_engine
+
+            pool = async_engine.pool if async_engine is not None else None
+            if pool is not None:
+                payload["db_pool"] = {
+                    "checked_in": pool.checkedin(),
+                    "checked_out": pool.checkedout(),
+                    "size": pool.size(),
+                    "overflow": pool.overflow(),
+                }
+        except Exception:
+            logging.exception("Failed to collect DB pool health metrics")
+        return web.json_response(payload)
 
     app.router.add_get("/healthz", _healthcheck)
+    app.router.add_get("/health", _healthcheck)
 
     setup_application(app, dp, bot=bot)
 

backend/bot/app/web/webapp/_runtime.py

@@ -42,6 +42,7 @@ from bot.app.web.webapp_auth import (
     verify_telegram_oauth_nonce,
     verify_webapp_session_token,
 )
+from bot.infra.redis import cache_get_json, cache_set_json, get_redis, redis_key
 from bot.services.crypto_pay_service import CryptoPayService
 from bot.services.email_auth_service import EmailAuthService, normalize_email
 from bot.services.email_templates import render_account_merged
@@ -64,13 +65,14 @@ logger = logging.getLogger(__name__)
 
 TEMPLATE_PATH = Path(__file__).resolve().parents[1] / "templates" / "subscription_webapp.html"
 ASSET_DIR = TEMPLATE_PATH.parent
+APP_ROOT = Path(__file__).resolve().parents[5]
 WEBAPP_LOGO_PROXY_PATH = "/webapp-logo"
-WEBAPP_LOGO_CACHE_DIR = Path(__file__).resolve().parents[4] / "data" / "webapp-logo"
+WEBAPP_LOGO_CACHE_DIR = APP_ROOT / "data" / "webapp-logo"
 WEBAPP_UPLOADED_LOGO_DIR = WEBAPP_LOGO_CACHE_DIR / "uploads"
 WEBAPP_UPLOADED_LOGO_PATH = "/webapp-uploaded-logo"
 WEBAPP_FAVICON_DIR = WEBAPP_LOGO_CACHE_DIR / "favicons"
 WEBAPP_FAVICON_PATH = "/webapp-favicon"
-WEBAPP_EMOJI_CACHE_DIR = Path(__file__).resolve().parents[4] / "data" / "webapp-emoji"
+WEBAPP_EMOJI_CACHE_DIR = APP_ROOT / "data" / "webapp-emoji"
 WEBAPP_CONFIG_PLACEHOLDER = "<!-- WEBAPP_CONFIG_SCRIPT -->"
 WEBAPP_I18N_PLACEHOLDER = "<!-- WEBAPP_I18N_SCRIPT -->"
 WEBAPP_JS_PLACEHOLDER = "<!-- WEBAPP_JS_SCRIPT -->"

backend/bot/app/web/webapp/account.py

@@ -350,7 +350,13 @@ async def account_telegram_link_route(request: web.Request) -> web.Response:
 
 async def me_route(request: web.Request) -> web.Response:
     user_id = _require_user_id(request)
+    settings: Settings = request.app["settings"]
+    cache_key = redis_key(settings, "cache", "webapp", "me", user_id)
+    cached = await cache_get_json(settings, cache_key)
+    if cached:
+        return web.json_response({"ok": True, **cached})
     data = await _build_user_payload(request, user_id)
+    await cache_set_json(settings, cache_key, data, settings.WEBAPP_ME_CACHE_TTL_SECONDS)
     return web.json_response({"ok": True, **data})
 
 

backend/bot/app/web/webapp/application.py

@@ -52,8 +52,7 @@ def create_subscription_webapp_application(
         if hasattr(dp, "workflow_data") and key in dp.workflow_data:  # type: ignore[attr-defined]
             app[key] = dp.workflow_data[key]  # type: ignore[index]
 
-    # type: ignore[attr-defined]
-    if hasattr(dp, "workflow_data") and "bot_username" in dp.workflow_data:
+    if hasattr(dp, "workflow_data") and "bot_username" in dp.workflow_data:  # type: ignore[attr-defined]
         app["bot_username"] = dp.workflow_data["bot_username"]  # type: ignore[index]
 
     setup_subscription_webapp_routes(app)

backend/bot/app/web/webapp/assets.py

@@ -182,6 +182,48 @@ def _is_proxyable_webapp_logo_url(logo_url: str) -> bool:
     return parsed_logo_url.scheme == "https" and bool(parsed_logo_url.hostname)
 
 
+def _uploaded_webapp_logo_filename(logo_url: str) -> Optional[str]:
+    parsed_logo_url = urlsplit(str(logo_url or ""))
+    path = parsed_logo_url.path if parsed_logo_url.scheme or parsed_logo_url.netloc else logo_url
+    prefix = f"{WEBAPP_UPLOADED_LOGO_PATH}/"
+    if not path.startswith(prefix):
+        return None
+    filename = path.removeprefix(prefix)
+    if re.fullmatch(r"logo-[0-9a-f]{16}\.(?:gif|ico|jpe?g|png|svg|webp)", filename):
+        return filename
+    return None
+
+
+def _uploaded_webapp_logo_response(filename: str) -> web.Response:
+    if not re.fullmatch(r"logo-[0-9a-f]{16}\.(?:gif|ico|jpe?g|png|svg|webp)", filename):
+        raise web.HTTPNotFound(text="webapp_logo_not_found")
+
+    root = WEBAPP_UPLOADED_LOGO_DIR.expanduser().resolve()
+    path = (root / filename).resolve()
+    try:
+        path.relative_to(root)
+    except ValueError:
+        raise web.HTTPNotFound(text="webapp_logo_not_found") from None
+
+    content_type = WEBAPP_THEME_ASSET_CONTENT_TYPES.get(path.suffix.lower())
+    if not content_type:
+        raise web.HTTPNotFound(text="webapp_logo_not_found")
+
+    try:
+        if path.stat().st_size > WEBAPP_LOGO_MAX_BYTES:
+            raise web.HTTPNotFound(text="webapp_logo_too_large")
+        body = path.read_bytes()
+    except OSError:
+        raise web.HTTPNotFound(text="webapp_logo_not_found") from None
+
+    if not body:
+        raise web.HTTPNotFound(text="webapp_logo_not_found")
+
+    response = web.Response(body=body, content_type=content_type)
+    response.headers["Cache-Control"] = "public, max-age=31536000, immutable"
+    return response
+
+
 def _emoji_to_codepoints(value: str) -> str:
     return "_".join(f"{ord(char):x}" for char in str(value or "").strip())
 
@@ -209,6 +251,10 @@ async def webapp_logo_route(request: web.Request) -> web.Response:
     if not raw_logo_url:
         raise web.HTTPNotFound(text="webapp_logo_not_configured")
 
+    uploaded_filename = _uploaded_webapp_logo_filename(raw_logo_url)
+    if uploaded_filename:
+        return _uploaded_webapp_logo_response(uploaded_filename)
+
     if not _is_proxyable_webapp_logo_url(raw_logo_url):
         raise web.HTTPNotFound(text="webapp_logo_not_proxied")
 
@@ -244,33 +290,7 @@ async def webapp_uploaded_logo_route(request: web.Request) -> web.Response:
         raise web.HTTPNotFound(text="webapp_disabled")
 
     filename = str(request.match_info.get("filename") or "").strip()
-    if not re.fullmatch(r"logo-[0-9a-f]{16}\.(?:gif|ico|jpe?g|png|svg|webp)", filename):
-        raise web.HTTPNotFound(text="webapp_logo_not_found")
-
-    root = WEBAPP_UPLOADED_LOGO_DIR.expanduser().resolve()
-    path = (root / filename).resolve()
-    try:
-        path.relative_to(root)
-    except ValueError:
-        raise web.HTTPNotFound(text="webapp_logo_not_found") from None
-
-    content_type = WEBAPP_THEME_ASSET_CONTENT_TYPES.get(path.suffix.lower())
-    if not content_type:
-        raise web.HTTPNotFound(text="webapp_logo_not_found")
-
-    try:
-        if path.stat().st_size > WEBAPP_LOGO_MAX_BYTES:
-            raise web.HTTPNotFound(text="webapp_logo_too_large")
-        body = path.read_bytes()
-    except OSError:
-        raise web.HTTPNotFound(text="webapp_logo_not_found") from None
-
-    if not body:
-        raise web.HTTPNotFound(text="webapp_logo_not_found")
-
-    response = web.Response(body=body, content_type=content_type)
-    response.headers["Cache-Control"] = "public, max-age=31536000, immutable"
-    return response
+    return _uploaded_webapp_logo_response(filename)
 
 
 async def webapp_favicon_route(request: web.Request) -> web.Response:
@@ -727,7 +747,7 @@ def _get_cached_webapp_settings(request: web.Request) -> Dict[str, Any]:
 
 
 def _run_git_command(*args: str) -> str:
-    repo_root = Path(__file__).resolve().parents[3]
+    repo_root = APP_ROOT
     try:
         result = subprocess.run(
             ["git", *args],
@@ -752,7 +772,7 @@ def _resolve_app_version() -> str:
         _APP_VERSION_CACHE = env_version
         return env_version
 
-    build_version_path = Path(__file__).resolve().parents[3] / ".build-version"
+    build_version_path = APP_ROOT / ".build-version"
     try:
         build_version = build_version_path.read_text(encoding="utf-8").strip()
     except OSError:
@@ -796,6 +816,26 @@ async def _enforce_webapp_rate_limit(
         or "unknown"
     )
     key = f"{action}:{ip_address}:{int(user_id)}"
+    redis = await get_redis(settings)
+    if redis is not None:
+        redis_rate_key = redis_key(settings, "rate-limit", "webapp", key)
+        current = await redis.incr(redis_rate_key)
+        if current == 1:
+            await redis.expire(redis_rate_key, settings.WEBAPP_RATE_LIMIT_TTL_SECONDS)
+        if current > settings.WEBAPP_RATE_LIMIT_MAX_REQUESTS:
+            ttl = await redis.ttl(redis_rate_key)
+            retry_after = max(1, int(ttl if ttl and ttl > 0 else WEBAPP_RATE_LIMIT_WINDOW_SECONDS))
+            return web.json_response(
+                {
+                    "ok": False,
+                    "error": "rate_limited",
+                    "retry_after": retry_after,
+                },
+                status=429,
+                headers={"Retry-After": str(retry_after)},
+            )
+        return None
+
     buckets: Dict[str, deque[float]] = request.app["webapp_rate_limit_buckets"]
     lock: asyncio.Lock = request.app["webapp_rate_limit_lock"]
     now = time.monotonic()
@@ -847,6 +887,56 @@ async def js_asset_route(request: web.Request) -> web.Response:
     return response
 
 
+def _build_webapp_bootstrap_payload(request: web.Request) -> Dict[str, Any]:
+    settings: Settings = request.app["settings"]
+    cached = _get_cached_webapp_settings(request)
+    themes_catalog = settings.webapp_themes_catalog
+    primary_color = settings.WEBAPP_PRIMARY_COLOR or "#00fe7a"
+    preview_key = str(request.query.get("theme_preview") or "").strip()
+    preview_theme = themes_catalog.theme_by_key(preview_key) if preview_key else None
+    if preview_theme is None or not preview_theme.enabled:
+        preview_key = ""
+    i18n_instance: Optional[object] = request.app.get("i18n")
+    return {
+        "config": {
+            "title": settings.WEBAPP_TITLE,
+            "primaryColor": settings.WEBAPP_PRIMARY_COLOR,
+            "themesCatalog": public_themes_catalog_payload(
+                themes_catalog,
+                primary_color,
+                enabled_only=True,
+            ),
+            "themesDir": settings.WEBAPP_THEMES_DIR,
+            "themePreviewKey": preview_key,
+            "logoUrl": cached["logo_url"],
+            "logoUseEmoji": bool(settings.WEBAPP_LOGO_USE_EMOJI),
+            "logoEmoji": settings.WEBAPP_LOGO_EMOJI,
+            "logoEmojiFont": settings.WEBAPP_LOGO_EMOJI_FONT,
+            "faviconUrl": cached["favicon_url"],
+            "faviconUseCustom": bool(settings.WEBAPP_FAVICON_USE_CUSTOM),
+            "apiBase": "/api",
+            "telegramLoginBotUsername": request.app.get("bot_username") or "",
+            "telegramLoginBotId": _resolve_telegram_bot_id(settings.BOT_TOKEN) or 0,
+            "telegramOAuthClientId": _resolve_telegram_oauth_client_id(settings) or 0,
+            "telegramOAuthRequestAccess": _resolve_telegram_oauth_request_access(settings),
+            "supportUrl": cached["support_url"],
+            "termsUrl": cached["terms_url"],
+            "privacyPolicyUrl": cached["privacy_policy_url"],
+            "userAgreementUrl": cached["user_agreement_url"],
+            "currency": cached["currency"],
+            "language": cached["language"],
+            "emailAuthEnabled": cached["email_auth_enabled"],
+            "appVersion": _resolve_app_version(),
+            "appRepositoryUrl": APP_REPOSITORY_URL,
+        },
+        "i18n": getattr(i18n_instance, "locales_data", {}) if i18n_instance else {},
+    }
+
+
+async def bootstrap_route(request: web.Request) -> web.Response:
+    return web.json_response({"ok": True, **_build_webapp_bootstrap_payload(request)})
+
+
 async def index_route(request: web.Request) -> web.Response:
     settings: Settings = request.app["settings"]
     if not settings.WEBAPP_ENABLED:
@@ -857,47 +947,13 @@ async def index_route(request: web.Request) -> web.Response:
     themes_catalog = settings.webapp_themes_catalog
     primary_color = settings.WEBAPP_PRIMARY_COLOR or "#00fe7a"
     initial_theme = _initial_theme_for_request(request, themes_catalog)
-    preview_key = str(request.query.get("theme_preview") or "").strip()
-    preview_theme = themes_catalog.theme_by_key(preview_key) if preview_key else None
-    if preview_theme is None or not preview_theme.enabled:
-        preview_key = ""
-    config = {
-        "title": settings.WEBAPP_TITLE,
-        "primaryColor": settings.WEBAPP_PRIMARY_COLOR,
-        "themesCatalog": public_themes_catalog_payload(
-            themes_catalog,
-            primary_color,
-            enabled_only=True,
-        ),
-        "themesDir": settings.WEBAPP_THEMES_DIR,
-        "themePreviewKey": preview_key,
-        "logoUrl": cached["logo_url"],
-        "logoUseEmoji": bool(settings.WEBAPP_LOGO_USE_EMOJI),
-        "logoEmoji": settings.WEBAPP_LOGO_EMOJI,
-        "logoEmojiFont": settings.WEBAPP_LOGO_EMOJI_FONT,
-        "faviconUrl": cached["favicon_url"],
-        "faviconUseCustom": bool(settings.WEBAPP_FAVICON_USE_CUSTOM),
-        "apiBase": "/api",
-        "telegramLoginBotUsername": request.app.get("bot_username") or "",
-        "telegramLoginBotId": _resolve_telegram_bot_id(settings.BOT_TOKEN) or 0,
-        "telegramOAuthClientId": _resolve_telegram_oauth_client_id(settings) or 0,
-        "telegramOAuthRequestAccess": _resolve_telegram_oauth_request_access(settings),
-        "supportUrl": cached["support_url"],
-        "termsUrl": cached["terms_url"],
-        "privacyPolicyUrl": cached["privacy_policy_url"],
-        "userAgreementUrl": cached["user_agreement_url"],
-        "currency": cached["currency"],
-        "language": cached["language"],
-        "emailAuthEnabled": cached["email_auth_enabled"],
-        "appVersion": _resolve_app_version(),
-        "appRepositoryUrl": APP_REPOSITORY_URL,
-    }
+    bootstrap = _build_webapp_bootstrap_payload(request)
+    config = bootstrap["config"]
     html = _strip_marked_block(html, DEV_MOCK_START_MARKER, DEV_MOCK_END_MARKER)
     initial_theme_markup = _initial_theme_head_markup(request, initial_theme, primary_color)
     if initial_theme_markup:
         html = html.replace("</head>", f"{initial_theme_markup}\n</head>", 1)
-    i18n_instance: Optional[object] = request.app.get("i18n")
-    i18n_payload = getattr(i18n_instance, "locales_data", {}) if i18n_instance else {}
+    i18n_payload = bootstrap["i18n"]
     nonce = request.get("csp_nonce", "")
     html = html.replace(
         WEBAPP_CONFIG_PLACEHOLDER,
@@ -934,13 +990,12 @@ async def index_route(request: web.Request) -> web.Response:
         brand_asset_url = _webapp_animated_emoji_asset_path(settings.WEBAPP_LOGO_EMOJI)
     if brand_asset_url:
         html = html.replace(
-            '<link rel="preload" id="logo-preload" href="" as="image" fetchpriority="high">',
-            f'<link rel="preload" href="{brand_asset_url}" as="image" fetchpriority="high">',
-        )
-    else:
-        html = html.replace(
-            '<link rel="preload" id="logo-preload" href="" as="image" fetchpriority="high">',
-            "",
+            "</head>",
+            (
+                f'<link rel="preload" href="{brand_asset_url}" '
+                'as="image" fetchpriority="high">\n</head>'
+            ),
+            1,
         )
     return web.Response(text=html, content_type="text/html", charset="utf-8")
 

backend/bot/app/web/webapp/routes.py

@@ -44,6 +44,7 @@ def setup_subscription_webapp_routes(app: web.Application) -> None:
     app.router.add_post("/api/auth/email/verify", email_auth_verify_route)
     app.router.add_post("/api/auth/email/magic", email_auth_magic_route)
     app.router.add_post("/api/auth/logout", logout_route)
+    app.router.add_get("/api/bootstrap", bootstrap_route)
     app.router.add_get("/api/me", me_route)
     app.router.add_get("/api/account/avatar", account_avatar_route)
     app.router.add_post("/api/account/language", account_language_route)

backend/bot/app/web/webapp/serializers.py

@@ -193,6 +193,7 @@ def _serialize_subscription(
     can_topup_regular_traffic = False
     can_topup_premium_traffic = False
     can_topup_traffic = False
+    can_topup_devices = False
     if settings.tariffs_config and active.get("tariff_key"):
         try:
             tariff = settings.tariffs_config.require(str(active.get("tariff_key")))
@@ -204,10 +205,16 @@ def _serialize_subscription(
                 and tariff.premium_topup_packages.has_any()
             )
             can_topup_traffic = bool(can_topup_regular_traffic or can_topup_premium_traffic)
+            # max_devices == 0 means unlimited — top-up is pointless in that case.
+            can_topup_devices = bool(
+                tariff.has_hwid_device_packages()
+                and _coerce_int_or_none(active.get("max_devices")) != 0
+            )
         except Exception:
             can_topup_regular_traffic = False
             can_topup_premium_traffic = False
             can_topup_traffic = False
+            can_topup_devices = False
 
     return {
         "active": seconds_left > 0,
@@ -249,6 +256,7 @@ def _serialize_subscription(
         "can_topup_traffic": can_topup_traffic,
         "can_topup_regular_traffic": can_topup_regular_traffic,
         "can_topup_premium_traffic": can_topup_premium_traffic,
+        "can_topup_devices": can_topup_devices,
         "period_start_at": active.get("period_start_at").isoformat()
         if active.get("period_start_at")
         else None,