feat(logic): dostawcy LLM i pisanie horoskopu (LOG-31)

Domyslnie model LOKALNY — prompt niesie oryginalne opisy z baz, wiec
domyslnie NIC nie opuszcza sieci. Chmura wlaczana swiadomie (LOG-32).

- app/llm/: LLMProvider (jak EphemerisEngine z LOG-24) + dwie implementacje.
  Lokalny serwer modelu (Ollama/vLLM/llama.cpp) i OpenAI mowia TYM SAMYM
  protokolem /chat/completions, wiec obsluguje je jedna klasa; Anthropic ma
  wlasny /v1/messages. Napisane na samym httpx — bez SDK openai/anthropic:
  mniej zaleznosci i pelna kontrola nad tym, co wychodzi z sieci.
- Kazdy dostawca deklaruje `leaves_lan` — interfejs MUSI jawnie mowic, czy
  tresc baz opuszcza siec; UI na tej podstawie ostrzega.
- Ponawianie z backoffem (429/5xx), timeouty, czytelne bledy zamiast stacktrace.
- Klucz wylacznie z LLM_API_KEY (sekret), nigdy w repo ani w UI.
- POST /chart/horoscope + GET /llm/health.

WAZNE: prompt jest zwracany ZAWSZE — takze gdy model padnie lub brakuje
klucza. Dzieki temu awaria dostawcy nie blokuje pracy: prompt mozna
skopiowac i uzyc recznie.

Prezentacja: wybor modelu (lokalny/Anthropic/OpenAI), przycisk „Napisz
horoskop (AI)", wynik z informacja kto go napisal, czy dane opuscily siec,
ile wskazan weszlo, oraz zastrzezenie ze to nie porada medyczna (PRE-15).

Testy: 13 nowych (transport podstawiony — zaden prawdziwy model nie wolany),
calosc 131 passed / 1 skipped. Zweryfikowane e2e na atrapie serwera modelu:
horoskop napisany, leaves_lan=false, tokeny zliczone; a przy padnietym
modelu / braku klucza / zlym dostawcy — czytelny blad i zachowany prompt.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.gitea/workflows/tests.yml

@@ -51,26 +51,6 @@ jobs:
           EPHEMERIS_DIR: ${{ github.workspace }}/services/logic/.ephemeris
         run: pytest tests -q -rs
 
-  presentation-tests:
-    name: Testy warstwy prezentacji (dostęp do baz)
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-          cache: pip
-          cache-dependency-path: services/presentation/requirements-dev.txt
-      - name: Instalacja zależności
-        run: pip install -r services/presentation/requirements-dev.txt
-      # Bramka chroniąca oryginalne bazy — nietestowany kod ochronny jest gorszy
-      # niż jego brak, bo daje złudzenie zabezpieczenia.
-      - name: Testy (pytest)
-        working-directory: services/presentation
-        env:
-          PYTHONPATH: .
-        run: pytest tests -q -rs
-
   swisseph-image:
     name: Build obrazu silnika B (swisseph)
     runs-on: ubuntu-latest

services/data/app/main.py

@@ -10,7 +10,6 @@ from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
 
-from app import security
 from app.config import settings
 from app.models import HealthInfo, SearchQuery, SearchResult
 from app.providers.factory import build_provider
@@ -25,7 +24,6 @@ async def lifespan(app: FastAPI):
 
 
 app = FastAPI(title="astrololo · warstwa bazodanowa", lifespan=lifespan)
-security.install(app, "danych")       # token międzywarstwowy (LOG-32)
 
 
 @app.post("/search", response_model=SearchResult)

services/data/app/models.py

@@ -18,10 +18,7 @@ class SearchQuery(BaseModel):
     key: str = Field(..., description="Pole/kolumna kanoniczna, po której szukamy, np. 'name'.")
     value: str = Field(..., description="Szukana wartość.")
     exact: bool = Field(False, description="Dopasowanie dokładne vs. zawieranie (contains).")
-    # Górny limit celowo niski: to zapytanie oddaje SUROWE wiersze baz, więc wysoki
-    # pułap zamienia je w narzędzie do masowego pobrania (LOG-32). 5000 = tyle, ile
-    # realnie potrzebuje build_report na jeden obiekt.
-    limit: int = Field(50, ge=1, le=5000)
+    limit: int = Field(50, ge=1, le=50000)
     fields: list[str] | None = Field(
         None, description="Lista pól kanonicznych do zwrócenia; None = wszystkie."
     )

services/data/app/security.py

@@ -1,50 +0,0 @@
-"""Uwierzytelnianie międzywarstwowe (LOG-32).
-
-Warstwa danych oddaje SUROWE wiersze baz — to najbardziej wrażliwy punkt całego
-systemu. Bez tego kontrolera wystarczyłoby uderzyć w nią bezpośrednio, z pominięciem
-i logiki, i logowania w UI. Gdy ustawiono INTERNAL_TOKEN, każde żądanie (poza /health)
-musi go przynieść w nagłówku X-Astrololo-Token.
-
-Bez INTERNAL_TOKEN kontrola jest wyłączona (dev / zgodność wstecz) — wtedy przy
-starcie leci ostrzeżenie.
-"""
-from __future__ import annotations
-
-import logging
-import os
-import secrets
-
-from fastapi import Request
-from fastapi.responses import JSONResponse
-
-log = logging.getLogger("astrololo.security")
-
-HEADER = "X-Astrololo-Token"
-PUBLIC_PATHS = frozenset({"/health"})
-
-
-def token() -> str:
-    """Czytany leniwie — konfiguracja może się zmienić bez importu modułu."""
-    return os.getenv("INTERNAL_TOKEN", "")
-
-
-def enabled() -> bool:
-    return bool(token())
-
-
-def install(app, layer: str) -> None:
-    if not enabled():
-        log.warning(
-            "UWAGA: INTERNAL_TOKEN nie ustawiony — warstwa %s przyjmuje żądania od "
-            "kogokolwiek, kto ma do niej dostęp sieciowy.", layer,
-        )
-
-    @app.middleware("http")
-    async def _guard(request: Request, call_next):
-        if request.url.path in PUBLIC_PATHS or not enabled():
-            return await call_next(request)
-        got = request.headers.get(HEADER, "")
-        if not secrets.compare_digest(got, token()):
-            return JSONResponse({"detail": "Brak lub błędny token międzywarstwowy."},
-                                status_code=401)
-        return await call_next(request)

services/logic/app/clients/data_client.py

@@ -5,7 +5,6 @@ Jedyny punkt styku w dół. Gdyby warstwa bazodanowa zmieniła implementację
 """
 from __future__ import annotations
 
-import os
 from typing import Any
 
 import httpx
@@ -13,12 +12,6 @@ import httpx
 from app.config import settings
 
 
-def _auth_headers() -> dict[str, str]:
-    """Token międzywarstwowy (LOG-32) — pusty, gdy ochrona wyłączona."""
-    token = os.getenv("INTERNAL_TOKEN", "")
-    return {"X-Astrololo-Token": token} if token else {}
-
-
 class DataClient:
     def __init__(self, base_url: str | None = None) -> None:
         self.base_url = (base_url or settings.data_url).rstrip("/")
@@ -33,12 +26,12 @@ class DataClient:
     ) -> dict[str, Any]:
         payload = {"key": key, "value": value, "exact": exact, "limit": limit, "fields": fields}
         with httpx.Client(timeout=max(settings.http_timeout, 30.0)) as client:
-            r = client.post(f"{self.base_url}/search", json=payload, headers=_auth_headers())
+            r = client.post(f"{self.base_url}/search", json=payload)
             r.raise_for_status()
             return r.json()
 
     def health(self) -> dict[str, Any]:
         with httpx.Client(timeout=settings.http_timeout) as client:
-            r = client.get(f"{self.base_url}/health", headers=_auth_headers())
+            r = client.get(f"{self.base_url}/health")
             r.raise_for_status()
             return r.json()

services/logic/app/engine/aspects.py

@@ -27,18 +27,6 @@ LUMINARIES = {"Sun", "Moon"}
 DEFAULT_ORB = 8.0
 LUMINARY_BONUS = 2.0
 
-# Pary sztywno powiązane definicyjnie — kąt między nimi wynika z samej definicji
-# punktu, nie z układu nieba (SN = NN + 180°). Aspekt taki zawsze wychodzi
-# dokładny (orb 0,00°) i nie niesie żadnej informacji astrologicznej, więc
-# wycinamy go z wyników: zaśmieca listę w UI i zjada budżet promptu do LLM.
-RIGID_PAIRS = frozenset({
-    frozenset({"North Node", "South Node"}),
-})
-
-
-def _is_rigid(name_a: str, name_b: str) -> bool:
-    return frozenset({name_a, name_b}) in RIGID_PAIRS
-
 
 def separation(a: float, b: float) -> float:
     """Najmniejsza separacja kątowa [0,180]."""
@@ -68,16 +56,12 @@ def find_aspects(
 
     Zwraca listę aspektów głównych; gdy znane są prędkości, każdy aspekt ma
     applying (bool) i skrót 'as': 'A'/'S' (aplikacyjny/separacyjny).
-
-    Pary z RIGID_PAIRS (np. NN/SN) są pomijane — ich kąt jest definicyjny.
     """
     out: list[dict] = []
     n = len(positions)
     for i in range(n):
         for j in range(i + 1, n):
             a, b = positions[i], positions[j]
-            if _is_rigid(a["name"], b["name"]):
-                continue
             la, lb = a.get("decimal"), b.get("decimal")
             if la is None or lb is None:
                 continue

services/logic/app/llm/factory.py

@@ -4,26 +4,13 @@ Domyślny jest **model lokalny**: prompt niesie oryginalne opisy z baz, więc
 domyślnie nic nie opuszcza naszej sieci (LOG-32). Chmurę włącza się świadomie —
 przez konfigurację albo pojedyncze żądanie.
 
-Konfiguracja jest **per dostawca**, bo UI pozwala przełączać go przy każdym żądaniu.
-Wspólne `LLM_*` nie wystarczy: ustawienie `LLM_BASE_URL` na lokalny model kierowałoby
-tam także żądania do OpenAI, a `LLM_MODEL=llama3.1:8b` kazałoby Anthropic użyć modelu
-llama. Dlatego każdy dostawca ma własny komplet zmiennych.
-
 Zmienne środowiskowe:
-  LLM_PROVIDER      local (domyślnie) | openai | anthropic — dostawca domyślny
+  LLM_PROVIDER   local (domyślnie) | openai | anthropic
+  LLM_MODEL      nazwa modelu (domyślna zależy od dostawcy)
+  LLM_BASE_URL   adres API (domyślnie: lokalny serwer zgodny z OpenAI)
+  LLM_API_KEY    klucz — WYŁĄCZNIE z sekretu; niepotrzebny dla modelu lokalnego
   LLM_TIMEOUT    sekundy (domyślnie 120)
   LLM_MAX_TOKENS limit długości odpowiedzi (domyślnie 2000)
-
-  <DOSTAWCA>_MODEL / _BASE_URL / _API_KEY — konfiguracja konkretnego dostawcy:
-  LOCAL_MODEL, LOCAL_BASE_URL                          (klucz zwykle zbędny)
-  OPENAI_MODEL, OPENAI_BASE_URL, OPENAI_API_KEY
-  ANTHROPIC_MODEL, ANTHROPIC_BASE_URL, ANTHROPIC_API_KEY
-
-  Klucze WYŁĄCZNIE z sekretu — nigdy w repo, w UI ani w logach.
-
-Zgodność wstecz: wspólne `LLM_MODEL` / `LLM_BASE_URL` / `LLM_API_KEY` nadal działają,
-ale stosują się TYLKO do dostawcy domyślnego (LLM_PROVIDER) — czyli konfiguracja
-instalacji jednodostawcowej zostaje nietknięta, a pozostali dostawcy jej nie dziedziczą.
 """
 from __future__ import annotations
 
@@ -62,39 +49,20 @@ def timeout() -> float:
     return float(os.getenv("LLM_TIMEOUT", "120"))
 
 
-def setting(provider: str, suffix: str, fallback: str = "") -> str:
-    """Ustawienie dostawcy: <DOSTAWCA>_<SUFIKS> → LLM_<SUFIKS> → wbudowana domyślna.
-
-    Wspólne `LLM_*` stosuje się WYŁĄCZNIE do dostawcy domyślnego — inaczej adres
-    lokalnego modelu przejąłby żądania do chmury (i odwrotnie).
-    """
-    specific = os.getenv(f"{provider.upper()}_{suffix}")
-    if specific:
-        return specific
-    if provider == default_provider_name():
-        generic = os.getenv(f"LLM_{suffix}")
-        if generic:
-            return generic
-    return fallback
-
-
 def build_provider(name: str | None = None) -> LLMProvider:
     name = (name or default_provider_name()).lower()
     if name not in PROVIDERS:
         raise LLMError(f"Nieznany dostawca LLM: {name!r} (dostępne: {', '.join(PROVIDERS)})")
 
-    model = setting(name, "MODEL", _DEFAULT_MODEL[name])
-    base_url = setting(name, "BASE_URL", _DEFAULT_URL[name])
-    api_key = setting(name, "API_KEY")
+    model = os.getenv("LLM_MODEL") or _DEFAULT_MODEL[name]
+    base_url = os.getenv("LLM_BASE_URL") or _DEFAULT_URL[name]
+    api_key = os.getenv("LLM_API_KEY", "")
 
-    if name in (OPENAI, ANTHROPIC) and not api_key:
-        raise LLMError(
-            f"Brak klucza dla dostawcy {name} — ustaw {name.upper()}_API_KEY "
-            f"(z sekretu). Model lokalny klucza nie wymaga."
-        )
     if name == ANTHROPIC:
         return AnthropicProvider(base_url, model, api_key, timeout())
     if name == OPENAI:
+        if not api_key:
+            raise LLMError("Brak LLM_API_KEY — dostawca openai wymaga klucza.")
         return ChatCompletionsProvider(OPENAI, base_url, model, api_key, timeout(),
                                        leaves_lan=True)
     # lokalny — klucz zwykle zbędny; treść NIE opuszcza sieci

services/logic/app/main.py

@@ -12,14 +12,12 @@ import httpx
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 
-from app import security
 from app.clients.data_client import DataClient
 from app.models import QueryRequest, QueryResponse
 from app.service import QueryService
 
 app = FastAPI(title="astrololo · warstwa logiczna")
 service = QueryService()
-security.install(app, "logiczna")     # token międzywarstwowy (LOG-32)
 
 # --- silnik efemeryd (LOG-24): budowany leniwie, by nie wymagać Skyfielda do startu ---
 _engine = None

services/logic/app/security.py

@@ -1,50 +0,0 @@
-"""Uwierzytelnianie międzywarstwowe (LOG-32).
-
-Warstwa logiczna oddaje treść baz interpretacyjnych, więc samo zalogowanie w
-prezentacji nie wystarczy — bez tego kontrolera wystarczyłoby uderzyć w logikę
-z pominięciem UI. Gdy ustawiono INTERNAL_TOKEN, każde żądanie (poza /health)
-musi go przynieść w nagłówku X-Astrololo-Token.
-
-Bez INTERNAL_TOKEN kontrola jest wyłączona (dev / zgodność wstecz) — wtedy przy
-starcie leci ostrzeżenie.
-"""
-from __future__ import annotations
-
-import logging
-import os
-import secrets
-
-from fastapi import Request
-from fastapi.responses import JSONResponse
-
-log = logging.getLogger("astrololo.security")
-
-HEADER = "X-Astrololo-Token"
-PUBLIC_PATHS = frozenset({"/health"})
-
-
-def token() -> str:
-    """Czytany leniwie — konfiguracja może się zmienić bez importu modułu."""
-    return os.getenv("INTERNAL_TOKEN", "")
-
-
-def enabled() -> bool:
-    return bool(token())
-
-
-def install(app, layer: str) -> None:
-    if not enabled():
-        log.warning(
-            "UWAGA: INTERNAL_TOKEN nie ustawiony — warstwa %s przyjmuje żądania od "
-            "kogokolwiek, kto ma do niej dostęp sieciowy.", layer,
-        )
-
-    @app.middleware("http")
-    async def _guard(request: Request, call_next):
-        if request.url.path in PUBLIC_PATHS or not enabled():
-            return await call_next(request)
-        got = request.headers.get(HEADER, "")
-        if not secrets.compare_digest(got, token()):
-            return JSONResponse({"detail": "Brak lub błędny token międzywarstwowy."},
-                                status_code=401)
-        return await call_next(request)

services/logic/tests/test_aspects.py

@@ -1,5 +1,5 @@
 """Testy aspektów (LOG-06) — czysta matematyka."""
-from app.engine.aspects import RIGID_PAIRS, find_aspects, separation
+from app.engine.aspects import find_aspects, separation
 
 
 def test_separation_wraparound():
@@ -55,28 +55,6 @@ def test_separating_when_moving_apart():
     assert a["applying"] is False and a["as"] == "S"
 
 
-def test_rigid_pair_nodes_not_reported():
-    # SN = NN + 180° z definicji — trywialna opozycja, nie aspekt
-    pos = [
-        {"name": "North Node", "decimal": 42.0, "speed": -0.053},
-        {"name": "South Node", "decimal": 222.0, "speed": -0.053},
-        {"name": "Sun", "decimal": 42.5, "speed": 0.96},
-    ]
-    pairs = {frozenset((a["obj1"], a["obj2"])) for a in find_aspects(pos)}
-    assert frozenset({"North Node", "South Node"}) not in pairs
-    # aspekty węzłów do innych obiektów zostają nietknięte
-    assert frozenset({"Sun", "North Node"}) in pairs
-    assert frozenset({"Sun", "South Node"}) in pairs
-
-
-def test_no_rigid_pairs_in_real_chart(own_engine, reference_moment):
-    from app.engine.chart import build_chart
-
-    chart = build_chart(own_engine, reference_moment)
-    found = [a for a in chart["aspects"] if frozenset((a["obj1"], a["obj2"])) in RIGID_PAIRS]
-    assert not found, f"trywialne aspekty par sztywnych w horoskopie: {found}"
-
-
 def test_no_as_flag_without_speeds():
     pos = [{"name": "Sun", "decimal": 0.0}, {"name": "Moon", "decimal": 2.0}]
     assert "as" not in find_aspects(pos)[0]

services/logic/tests/test_llm.py

@@ -133,9 +133,7 @@ def test_default_provider_is_local(monkeypatch):
 
 def test_openai_requires_key(monkeypatch):
     monkeypatch.delenv("LLM_API_KEY", raising=False)
-    monkeypatch.delenv("OPENAI_API_KEY", raising=False)
-    # komunikat wskazuje ZMIENNĄ DO USTAWIENIA dla tego dostawcy, nie ogólne LLM_API_KEY
-    with pytest.raises(LLMError, match="OPENAI_API_KEY"):
+    with pytest.raises(LLMError, match="LLM_API_KEY"):
         factory.build_provider("openai")
 
 
@@ -149,64 +147,3 @@ def test_env_overrides_model_and_url(monkeypatch):
     monkeypatch.setenv("LLM_BASE_URL", "http://serwer:8000/v1")
     p = factory.build_provider("local")
     assert p.model == "moj-model" and p.base_url == "http://serwer:8000/v1"
-
-
-# ---------------------------------------- konfiguracja per dostawca (regresja LOG-31)
-# UI pozwala przelaczac dostawce przy kazdym zadaniu, wiec ustawienia JEDNEGO nie moga
-# przeciekac na pozostalych. Wczesniej wspolne LLM_BASE_URL/LLM_MODEL kierowaly zadania
-# do OpenAI na adres lokalnej Ollamy i prosily Anthropic o model llama.
-
-def _clear(monkeypatch):
-    for v in ("LLM_PROVIDER", "LLM_MODEL", "LLM_BASE_URL", "LLM_API_KEY",
-              "LOCAL_MODEL", "LOCAL_BASE_URL", "LOCAL_API_KEY",
-              "OPENAI_MODEL", "OPENAI_BASE_URL", "OPENAI_API_KEY",
-              "ANTHROPIC_MODEL", "ANTHROPIC_BASE_URL", "ANTHROPIC_API_KEY"):
-        monkeypatch.delenv(v, raising=False)
-
-
-def test_local_config_does_not_leak_to_cloud(monkeypatch):
-    """Sedno bledu: skonfigurowany model lokalny przejmowal zadania do chmury."""
-    _clear(monkeypatch)
-    monkeypatch.setenv("LLM_PROVIDER", "local")
-    monkeypatch.setenv("LLM_BASE_URL", "http://ollama:11434/v1")   # konfiguracja lokalnego
-    monkeypatch.setenv("LLM_MODEL", "llama3.1:8b")
-    monkeypatch.setenv("OPENAI_API_KEY", "sk-test")
-
-    local = factory.build_provider("local")
-    assert local.base_url == "http://ollama:11434/v1" and local.model == "llama3.1:8b"
-
-    openai = factory.build_provider("openai")
-    assert openai.base_url == "https://api.openai.com/v1", "zadanie do OpenAI poszloby do Ollamy"
-    assert openai.model == "gpt-4o-mini", "OpenAI dostalby nazwe modelu llama"
-
-
-def test_provider_specific_settings_win(monkeypatch):
-    _clear(monkeypatch)
-    monkeypatch.setenv("LLM_PROVIDER", "local")
-    monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-ant")
-    monkeypatch.setenv("ANTHROPIC_MODEL", "claude-opus-4-8")
-    p = factory.build_provider("anthropic")
-    assert p.model == "claude-opus-4-8" and p.api_key == "sk-ant"
-
-
-def test_generic_vars_apply_only_to_default_provider(monkeypatch):
-    """Zgodnosc wstecz: wspolne LLM_* konfiguruja dostawce domyslnego i tylko jego."""
-    _clear(monkeypatch)
-    monkeypatch.setenv("LLM_PROVIDER", "openai")
-    monkeypatch.setenv("LLM_API_KEY", "sk-generic")
-    monkeypatch.setenv("LLM_MODEL", "gpt-4o")
-    assert factory.build_provider("openai").model == "gpt-4o"
-    assert factory.build_provider("local").model == "llama3.1:8b"   # nie dziedziczy
-
-
-def test_cloud_without_key_is_rejected_clearly(monkeypatch):
-    _clear(monkeypatch)
-    monkeypatch.setenv("LLM_PROVIDER", "local")
-    for name in ("openai", "anthropic"):
-        with pytest.raises(LLMError, match=f"{name.upper()}_API_KEY"):
-            factory.build_provider(name)
-
-
-def test_local_needs_no_key(monkeypatch):
-    _clear(monkeypatch)
-    assert factory.build_provider("local").api_key == ""

services/logic/tests/test_security.py

@@ -1,65 +0,0 @@
-"""Token międzywarstwowy (LOG-32).
-
-Warstwa logiczna oddaje treść baz, więc musi odrzucać żądania z pominięciem UI.
-"""
-import pytest
-from fastapi import FastAPI
-from starlette.testclient import TestClient
-
-from app import security
-
-TOKEN = "tajny-token-testowy"
-
-
-def _app() -> FastAPI:
-    app = FastAPI()
-    security.install(app, "testowa")
-
-    @app.get("/health")
-    def health():
-        return {"status": "ok"}
-
-    @app.get("/secret")
-    def secret():
-        return {"rows": ["treść z bazy"]}
-
-    return app
-
-
-@pytest.fixture
-def guarded(monkeypatch):
-    monkeypatch.setenv("INTERNAL_TOKEN", TOKEN)
-    return TestClient(_app())
-
-
-@pytest.fixture
-def open_app(monkeypatch):
-    monkeypatch.delenv("INTERNAL_TOKEN", raising=False)
-    return TestClient(_app())
-
-
-def test_rejects_request_without_token(guarded):
-    assert guarded.get("/secret").status_code == 401
-
-
-def test_rejects_wrong_token(guarded):
-    r = guarded.get("/secret", headers={security.HEADER: "zly"})
-    assert r.status_code == 401
-    assert "treść z bazy" not in r.text
-
-
-def test_accepts_correct_token(guarded):
-    r = guarded.get("/secret", headers={security.HEADER: TOKEN})
-    assert r.status_code == 200
-    assert r.json()["rows"] == ["treść z bazy"]
-
-
-def test_health_stays_public(guarded):
-    """Sonda k8s nie zna tokenu — /health musi działać bez niego."""
-    assert guarded.get("/health").status_code == 200
-
-
-def test_disabled_when_token_unset(open_app):
-    """Brak konfiguracji = zgodność wstecz (dev), nie blokada."""
-    assert not security.enabled()
-    assert open_app.get("/secret").status_code == 200

services/presentation/app/clients/logic_client.py

@@ -5,7 +5,6 @@ opracowane wyniki. Prezentacja nie sięga bezpośrednio do bazy ani do silnika.
 """
 from __future__ import annotations
 
-import os
 from typing import Any
 
 import httpx
@@ -13,12 +12,6 @@ import httpx
 from app.config import settings
 
 
-def _auth_headers() -> dict[str, str]:
-    """Token międzywarstwowy (LOG-32) — pusty, gdy ochrona wyłączona."""
-    token = os.getenv("INTERNAL_TOKEN", "")
-    return {"X-Astrololo-Token": token} if token else {}
-
-
 class LogicClient:
     def __init__(self, base_url: str | None = None) -> None:
         self.base_url = (base_url or settings.logic_url).rstrip("/")
@@ -26,7 +19,7 @@ class LogicClient:
     def query(self, query: str, field: str, exact: bool, limit: int) -> dict[str, Any]:
         payload = {"query": query, "field": field, "exact": exact, "limit": limit}
         with httpx.Client(timeout=settings.http_timeout) as client:
-            r = client.post(f"{self.base_url}/api/query", json=payload, headers=_auth_headers())
+            r = client.post(f"{self.base_url}/api/query", json=payload)
             r.raise_for_status()
             return r.json()
 
@@ -52,7 +45,7 @@ class LogicClient:
         }
         # stacje wymagają root-findów — dłuższy timeout
         with httpx.Client(timeout=max(settings.http_timeout, 60.0) if stations else settings.http_timeout) as client:
-            r = client.post(f"{self.base_url}/chart/positions", json=payload, headers=_auth_headers())
+            r = client.post(f"{self.base_url}/chart/positions", json=payload)
             r.raise_for_status()
             return r.json()
 
@@ -62,7 +55,7 @@ class LogicClient:
         """Sygnifikatory z obliczeń szukane w bazie — woła logic /chart/report."""
         payload = {"when_utc": when_utc_iso, "lat": lat, "lon": lon, "limit": limit, "group": group}
         with httpx.Client(timeout=max(settings.http_timeout, 30.0)) as client:
-            r = client.post(f"{self.base_url}/chart/report", json=payload, headers=_auth_headers())
+            r = client.post(f"{self.base_url}/chart/report", json=payload)
             r.raise_for_status()
             return r.json()
 
@@ -78,7 +71,7 @@ class LogicClient:
         if from_date and to_date:
             payload["from_date"], payload["to_date"] = from_date, to_date
         with httpx.Client(timeout=max(settings.http_timeout, 60.0)) as client:
-            r = client.post(f"{self.base_url}/chart/prompt", json=payload, headers=_auth_headers())
+            r = client.post(f"{self.base_url}/chart/prompt", json=payload)
             r.raise_for_status()
             return r.json()
 
@@ -100,7 +93,7 @@ class LogicClient:
         if from_date and to_date:
             payload["from_date"], payload["to_date"] = from_date, to_date
         with httpx.Client(timeout=max(settings.http_timeout, 300.0)) as client:
-            r = client.post(f"{self.base_url}/chart/horoscope", json=payload, headers=_auth_headers())
+            r = client.post(f"{self.base_url}/chart/horoscope", json=payload)
             r.raise_for_status()
             return r.json()
 
@@ -114,6 +107,6 @@ class LogicClient:
             "from_date": from_date, "to_date": to_date, "interpret": interpret,
         }
         with httpx.Client(timeout=max(settings.http_timeout, 60.0)) as client:
-            r = client.post(f"{self.base_url}/chart/timeline", json=payload, headers=_auth_headers())
+            r = client.post(f"{self.base_url}/chart/timeline", json=payload)
             r.raise_for_status()
             return r.json()

services/presentation/app/main.py

@@ -17,7 +17,7 @@ from fastapi.responses import HTMLResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 
-from app import geocode, security
+from app import geocode
 from app.clients.logic_client import LogicClient
 from app.config import DEFAULT_LOCATION_LABEL, default_form
 
@@ -25,7 +25,6 @@ app = FastAPI(title="astrololo · warstwa prezentacji")
 app.mount("/static", StaticFiles(directory="app/static"), name="static")
 templates = Jinja2Templates(directory="app/templates")
 logic = LogicClient()
-security.install(app)          # logowanie + limit żądań (LOG-32)
 
 
 def _build_utc(date: str, time: str, tz_offset: float) -> tuple[str, str]:

services/presentation/app/security.py

@@ -1,120 +0,0 @@
-"""Ochrona dostępu do aplikacji (LOG-32).
-
-Rdzeniem produktu są oryginalne bazy interpretacyjne. Aplikacja podaje ich treść
-na wielu ścieżkach (`/significators`, `/interpret`, generator promptu), więc BRAK
-uwierzytelnienia oznacza, że każdy w sieci może je wypompować — bez udziału
-jakiegokolwiek modelu językowego. Ten moduł zamyka tę drogę.
-
-Dwa mechanizmy:
-  * **HTTP Basic** — wejście do aplikacji; włącza się, gdy ustawiono APP_PASSWORD.
-  * **limit żądań** — hamuje masowe odpytywanie (eksfiltrację przez pętlę zapytań).
-
-Świadomie NIE logujemy treści żądań ani promptów — logi to kolejny nośnik wycieku.
-
-UWAGA: bez APP_PASSWORD ochrona jest WYŁĄCZONA (zgodność wstecz i wygoda dev).
-Wtedy przy starcie leci głośne ostrzeżenie — żeby nikt nie wdrożył tego w
-przekonaniu, że jest chroniony.
-"""
-from __future__ import annotations
-
-import base64
-import binascii
-import logging
-import os
-import secrets
-import time
-from collections import deque
-
-from fastapi import Request
-from fastapi.responses import HTMLResponse, JSONResponse
-
-log = logging.getLogger("astrololo.security")
-
-MAX_TRACKED_CLIENTS_DEFAULT = 4096
-MAX_TRACKED_CLIENTS = MAX_TRACKED_CLIENTS_DEFAULT   # zabezpieczenie przed puchnięciem pamięci
-
-
-# konfiguracja czytana leniwie — testy i restart mogą ją zmienić bez importu modułu
-def app_user() -> str:
-    return os.getenv("APP_USER", "astrololo")
-
-
-def app_password() -> str:
-    return os.getenv("APP_PASSWORD", "")
-
-
-def rate_limit_per_min() -> int:
-    return int(os.getenv("RATE_LIMIT_PER_MIN", "120"))
-
-PUBLIC_PATHS = frozenset({"/health"})
-PUBLIC_PREFIXES = ("/static/",)
-
-_hits: dict[str, deque[float]] = {}
-
-
-def auth_enabled() -> bool:
-    return bool(app_password())
-
-
-def _is_public(path: str) -> bool:
-    return path in PUBLIC_PATHS or path.startswith(PUBLIC_PREFIXES)
-
-
-def _authorized(header: str | None) -> bool:
-    if not header or not header.lower().startswith("basic "):
-        return False
-    try:
-        raw = base64.b64decode(header.split(" ", 1)[1]).decode("utf-8")
-        user, _, password = raw.partition(":")
-    except (binascii.Error, UnicodeDecodeError, IndexError):
-        return False
-    # porównanie odporne na atak czasowy; oba pola muszą się zgadzać
-    ok_user = secrets.compare_digest(user, app_user())
-    ok_pass = secrets.compare_digest(password, app_password())
-    return ok_user and ok_pass
-
-
-def _rate_limited(client: str) -> bool:
-    cap = rate_limit_per_min()
-    if cap <= 0:
-        return False
-    now = time.monotonic()
-    window = _hits.get(client)
-    if window is None:
-        if len(_hits) >= MAX_TRACKED_CLIENTS:
-            _hits.clear()               # prosty reset zamiast nieograniczonego wzrostu
-        window = _hits[client] = deque()
-    while window and now - window[0] > 60.0:
-        window.popleft()
-    if len(window) >= cap:
-        return True
-    window.append(now)
-    return False
-
-
-def install(app) -> None:
-    """Podpina ochronę pod wszystkie ścieżki poza /health i /static."""
-    if not auth_enabled():
-        log.warning(
-            "UWAGA: APP_PASSWORD nie ustawione — aplikacja jest OTWARTA dla każdego, "
-            "kto ma do niej dostęp sieciowy, wraz z treścią baz interpretacyjnych."
-        )
-
-    @app.middleware("http")
-    async def _guard(request: Request, call_next):
-        if _is_public(request.url.path):
-            return await call_next(request)
-
-        client = request.client.host if request.client else "?"
-        if _rate_limited(client):
-            return JSONResponse(
-                {"detail": "Zbyt wiele żądań — spróbuj za chwilę."},
-                status_code=429, headers={"Retry-After": "60"},
-            )
-
-        if auth_enabled() and not _authorized(request.headers.get("authorization")):
-            return HTMLResponse(
-                "<h1>401 — wymagane logowanie</h1>", status_code=401,
-                headers={"WWW-Authenticate": 'Basic realm="astrololo"'},
-            )
-        return await call_next(request)

services/presentation/requirements-dev.txt

@@ -1,2 +0,0 @@
--r requirements.txt
-pytest>=8.0

services/presentation/tests/test_client_auth.py

@@ -1,62 +0,0 @@
-"""Niezmiennik: KAŻDE wyjście HTTP w dół niesie token międzywarstwowy (LOG-32).
-
-Powód istnienia tego testu: token dodano do klienta na gałęzi, która odbiła się od
-mastera zanim powstały metody `prompt()` i `horoscope()`. Git zmergował obie zmiany
-czysto (różne linie), ale nowe metody wyszły BEZ tokenu — i dostawały 401 dopiero na
-produkcji. Zwykły test jednej metody by tego nie złapał, więc sprawdzamy regułę
-strukturalnie: nie ma wywołania bez `headers=`.
-"""
-import ast
-import pathlib
-
-CLIENT = pathlib.Path(__file__).resolve().parents[1] / "app" / "clients" / "logic_client.py"
-
-
-def _http_calls(path: pathlib.Path) -> list[tuple[str, int, bool]]:
-    """(nazwa_metody_http, linia, czy_ma_headers) dla każdego client.post/get."""
-    tree = ast.parse(path.read_text(encoding="utf-8"))
-    out = []
-    for node in ast.walk(tree):
-        if not isinstance(node, ast.Call) or not isinstance(node.func, ast.Attribute):
-            continue
-        if node.func.attr not in ("post", "get", "put", "patch", "delete"):
-            continue
-        if not (isinstance(node.func.value, ast.Name) and node.func.value.id == "client"):
-            continue
-        has_headers = any(kw.arg == "headers" for kw in node.keywords)
-        out.append((node.func.attr, node.lineno, has_headers))
-    return out
-
-
-def test_client_module_exists():
-    assert CLIENT.is_file()
-
-
-def test_every_outbound_call_sends_auth_header():
-    calls = _http_calls(CLIENT)
-    assert calls, "nie znaleziono żadnego wywołania HTTP — test przestał cokolwiek pilnować"
-    missing = [f"{CLIENT.name}:{line} client.{verb}()" for verb, line, ok in calls if not ok]
-    assert not missing, (
-        "Wywołania w dół bez tokenu międzywarstwowego (dostaną 401 przy włączonej "
-        "ochronie): " + ", ".join(missing)
-    )
-
-
-def test_auth_headers_helper_is_lazy():
-    """Token czytany przy wywołaniu, nie przy imporcie — inaczej pod wystartowałby
-    z pustym tokenem, gdyby zmienna pojawiła się później."""
-    import os
-
-    from app.clients.logic_client import _auth_headers
-
-    old = os.environ.get("INTERNAL_TOKEN")
-    try:
-        os.environ["INTERNAL_TOKEN"] = "abc"
-        assert _auth_headers() == {"X-Astrololo-Token": "abc"}
-        os.environ.pop("INTERNAL_TOKEN")
-        assert _auth_headers() == {}          # ochrona wyłączona = brak nagłówka
-    finally:
-        if old is not None:
-            os.environ["INTERNAL_TOKEN"] = old
-        else:
-            os.environ.pop("INTERNAL_TOKEN", None)

services/presentation/tests/test_security.py

@@ -1,133 +0,0 @@
-"""Logowanie do aplikacji i limit żądań (LOG-32).
-
-To jest brama chroniąca oryginalne bazy interpretacyjne — bez niej każdy w sieci
-mógł je wypompować przez `/significators` czy generator promptu. Testy pilnują,
-że brama faktycznie zamyka, a nie tylko wygląda na zamkniętą.
-"""
-import base64
-
-import pytest
-from fastapi import FastAPI
-from fastapi.responses import HTMLResponse
-from starlette.testclient import TestClient
-
-from app import security
-
-USER, PASSWORD = "astrololo", "haslo-testowe"
-
-
-def _basic(user: str, password: str) -> dict[str, str]:
-    raw = base64.b64encode(f"{user}:{password}".encode()).decode()
-    return {"Authorization": f"Basic {raw}"}
-
-
-def _app() -> FastAPI:
-    app = FastAPI()
-    security.install(app)
-
-    @app.get("/health")
-    def health():
-        return {"status": "ok"}
-
-    @app.get("/significators", response_class=HTMLResponse)
-    def significators():
-        return "<p>treść z bazy interpretacyjnej</p>"
-
-    return app
-
-
-@pytest.fixture(autouse=True)
-def _reset_rate_limit():
-    security._hits.clear()
-    yield
-    security._hits.clear()
-
-
-@pytest.fixture
-def guarded(monkeypatch):
-    monkeypatch.setenv("APP_PASSWORD", PASSWORD)
-    monkeypatch.setenv("RATE_LIMIT_PER_MIN", "120")
-    return TestClient(_app())
-
-
-# ------------------------------------------------------------------ logowanie
-
-def test_blocks_anonymous_access(guarded):
-    r = guarded.get("/significators")
-    assert r.status_code == 401
-    assert "treść z bazy" not in r.text
-
-
-def test_challenges_with_basic_realm(guarded):
-    """Bez nagłówka WWW-Authenticate przeglądarka nie pokaże okna logowania."""
-    assert "Basic" in guarded.get("/significators").headers.get("WWW-Authenticate", "")
-
-
-def test_rejects_wrong_password(guarded):
-    assert guarded.get("/significators", headers=_basic(USER, "zle")).status_code == 401
-
-
-def test_rejects_wrong_user(guarded):
-    assert guarded.get("/significators", headers=_basic("obcy", PASSWORD)).status_code == 401
-
-
-def test_rejects_malformed_header(guarded):
-    for bad in ("Basic !!!niebase64!!!", "Bearer cokolwiek", "", "Basic"):
-        assert guarded.get("/significators", headers={"Authorization": bad}).status_code == 401
-
-
-def test_allows_correct_credentials(guarded):
-    r = guarded.get("/significators", headers=_basic(USER, PASSWORD))
-    assert r.status_code == 200
-    assert "treść z bazy" in r.text
-
-
-def test_health_stays_public(guarded):
-    assert guarded.get("/health").status_code == 200
-
-
-def test_open_when_password_unset(monkeypatch):
-    """Brak hasła = zgodność wstecz; ochrona wyłączona (i ostrzegamy przy starcie)."""
-    monkeypatch.delenv("APP_PASSWORD", raising=False)
-    assert not security.auth_enabled()
-    assert TestClient(_app()).get("/significators").status_code == 200
-
-
-# --------------------------------------------------------------- limit żądań
-
-def test_rate_limit_blocks_flood(monkeypatch):
-    """Masowe odpytywanie to droga eksfiltracji nawet po zalogowaniu."""
-    monkeypatch.setenv("APP_PASSWORD", PASSWORD)
-    monkeypatch.setenv("RATE_LIMIT_PER_MIN", "5")
-    client = TestClient(_app())
-    auth = _basic(USER, PASSWORD)
-    codes = [client.get("/significators", headers=auth).status_code for _ in range(8)]
-    assert codes[:5] == [200] * 5
-    assert 429 in codes[5:]
-
-
-def test_rate_limited_response_has_retry_after(monkeypatch):
-    monkeypatch.setenv("APP_PASSWORD", PASSWORD)
-    monkeypatch.setenv("RATE_LIMIT_PER_MIN", "1")
-    client = TestClient(_app())
-    auth = _basic(USER, PASSWORD)
-    client.get("/significators", headers=auth)
-    r = client.get("/significators", headers=auth)
-    assert r.status_code == 429 and r.headers.get("Retry-After") == "60"
-
-
-def test_rate_limit_precedes_auth(monkeypatch):
-    """Limit musi działać także dla niezalogowanych — inaczej zgadywanie hasła
-    i sondowanie API jest darmowe."""
-    monkeypatch.setenv("APP_PASSWORD", PASSWORD)
-    monkeypatch.setenv("RATE_LIMIT_PER_MIN", "3")
-    client = TestClient(_app())
-    codes = [client.get("/significators").status_code for _ in range(6)]
-    assert 429 in codes
-
-
-def test_rate_limit_disabled_when_zero(monkeypatch):
-    monkeypatch.setenv("RATE_LIMIT_PER_MIN", "0")
-    monkeypatch.delenv("APP_PASSWORD", raising=False)
-    client = TestClient(_app())
-    assert all(client.get("/significators").status_code == 200 for _ in range(30))