cloudwright-ai-web 1.2.2__tar.gz → 1.4.0__tar.gz

{cloudwright_ai_web-1.2.2 → cloudwright_ai_web-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudwright-ai-web
-Version: 1.2.2
+Version: 1.4.0
 Summary: Web UI for Cloudwright architecture intelligence
 Project-URL: Homepage, https://github.com/xmpuspus/cloudwright
 Project-URL: Repository, https://github.com/xmpuspus/cloudwright

{cloudwright_ai_web-1.2.2 → cloudwright_ai_web-1.4.0}/cloudwright_web/__init__.py

@@ -1,6 +1,6 @@
 """Cloudwright Web — FastAPI backend for architecture intelligence."""
 
-__version__ = "1.2.2"
+__version__ = "1.4.0"
 
 
 def __getattr__(name: str):

{cloudwright_ai_web-1.2.2 → cloudwright_ai_web-1.4.0}/cloudwright_web/app.py

@@ -14,6 +14,7 @@ from starlette.middleware.base import BaseHTTPMiddleware
 from cloudwright_web import __version__
 from cloudwright_web.middleware import (  # noqa: F401
     PathTraversalMiddleware,
+    RequestIdMiddleware,
     _rate_limiter,
     _RateLimiter,
     add_cors,
@@ -44,16 +45,37 @@ class SecurityHeadersMiddleware(BaseHTTPMiddleware):
         return response
 
 
+def _docs_enabled() -> bool:
+    """Whether to expose /docs, /redoc, and /openapi.json.
+
+    Disabled by default in production (CLOUDWRIGHT_ENV=production) to reduce
+    reconnaissance surface. Override with CLOUDWRIGHT_DOCS_ENABLED=true.
+    """
+    explicit = os.environ.get("CLOUDWRIGHT_DOCS_ENABLED")
+    if explicit is not None:
+        return explicit.lower() == "true"
+    env = os.environ.get("CLOUDWRIGHT_ENV", "").lower()
+    return env != "production"
+
+
 def create_app() -> FastAPI:
+    docs_on = _docs_enabled()
     application = FastAPI(
         title="Cloudwright",
         version=__version__,
         description="Architecture intelligence for cloud engineers",
+        docs_url="/docs" if docs_on else None,
+        redoc_url="/redoc" if docs_on else None,
+        openapi_url="/openapi.json" if docs_on else None,
     )
 
+    # RequestIdMiddleware MUST be added LAST so Starlette dispatches it FIRST
+    # (Starlette runs middleware in reverse-add order). This way every later
+    # middleware's log lines carry the request_id.
     application.add_middleware(SecurityHeadersMiddleware)
     application.add_middleware(PathTraversalMiddleware)
     add_cors(application)
+    application.add_middleware(RequestIdMiddleware)
 
     application.include_router(health_router, prefix="/api")
     application.include_router(design_router, prefix="/api")

{cloudwright_ai_web-1.2.2 → cloudwright_ai_web-1.4.0}/cloudwright_web/middleware.py

@@ -2,12 +2,15 @@
 
 from __future__ import annotations
 
+import hmac
 import os
 import threading
 import time
+import uuid
 from collections import deque
 from urllib.parse import unquote
 
+import structlog
 from fastapi import HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
@@ -22,6 +25,32 @@ class PathTraversalMiddleware(BaseHTTPMiddleware):
         return await call_next(request)
 
 
+class RequestIdMiddleware(BaseHTTPMiddleware):
+    """Attach a request correlation ID to every request.
+
+    - Reads X-Request-Id from incoming headers, otherwise mints a UUID4 hex.
+    - Binds the value into structlog's contextvars for the duration of the
+      request so every log line carries it.
+    - Echoes the same value back as the X-Request-Id response header.
+    """
+
+    async def dispatch(self, request: Request, call_next):
+        incoming = request.headers.get("x-request-id", "").strip()
+        request_id = incoming or uuid.uuid4().hex
+
+        # Stash on request.state so handlers can read it if they need to.
+        request.state.request_id = request_id
+
+        structlog.contextvars.bind_contextvars(request_id=request_id)
+        try:
+            response = await call_next(request)
+        finally:
+            structlog.contextvars.unbind_contextvars("request_id")
+
+        response.headers["X-Request-Id"] = request_id
+        return response
+
+
 def add_cors(app):
     origins = os.environ.get("CLOUDWRIGHT_CORS_ORIGINS", "http://localhost:5173,http://localhost:3000").split(",")
     app.add_middleware(
@@ -38,10 +67,21 @@ _API_KEY = os.environ.get("CLOUDWRIGHT_API_KEY")
 
 
 def check_api_key(request: Request):
+    """Validate the X-API-Key header in constant time.
+
+    Using ``hmac.compare_digest`` prevents timing-based recovery of the
+    configured key. Both sides are encoded to bytes (utf-8); mismatched
+    lengths are rejected by ``compare_digest`` itself but we short-circuit
+    empty input first to avoid leaking even a length signal.
+    """
     if not _API_KEY:
         return None
     provided = request.headers.get("x-api-key", "")
-    if provided != _API_KEY:
+    if not provided:
+        raise HTTPException(status_code=401, detail="Invalid or missing API key")
+    expected_bytes = _API_KEY.encode("utf-8")
+    provided_bytes = provided.encode("utf-8")
+    if not hmac.compare_digest(provided_bytes, expected_bytes):
         raise HTTPException(status_code=401, detail="Invalid or missing API key")
     return None
 

{cloudwright_ai_web-1.2.2 → cloudwright_ai_web-1.4.0}/cloudwright_web/routers/chat.py

@@ -4,8 +4,6 @@ from __future__ import annotations
 
 import asyncio
 import logging
-import threading
-import time
 from typing import Literal
 
 from cloudwright.session import ConversationSession
@@ -20,6 +18,19 @@ from cloudwright_web.streaming import sse_event
 log = logging.getLogger(__name__)
 router = APIRouter()
 
+# Per-call SDK timeout passed into the async LLM client. Matches the previous
+# route-level ``asyncio.wait_for(..., timeout=120)`` budget but pushes the
+# enforcement down into the SDK so cancellation actually short-circuits the
+# upstream LLM call (sync paths used to keep billing tokens after the route
+# timed out).
+_LLM_STREAM_TIMEOUT_S = 120.0
+
+# Headers attached to every SSE response. ``X-Accel-Buffering: no`` disables
+# nginx (and most reverse-proxy) buffering so token chunks reach the browser
+# as soon as we yield them — without it, first-token latency observed by the
+# user can balloon to 2-4s waiting for the proxy buffer to fill.
+_SSE_HEADERS = {"X-Accel-Buffering": "no", "Cache-Control": "no-cache"}
+
 
 class ChatMessage(BaseModel):
     role: Literal["user", "assistant"]
@@ -91,51 +102,55 @@ async def chat_stream(req: ChatRequest, request: Request):
                 continue  # only accept user-role messages from client history
             session.history.append({"role": msg.role, "content": msg.content})
 
+        # Push the stream timeout into the SDK call; on the async path this
+        # cancels the upstream httpx connection, so we stop billing tokens the
+        # moment the deadline passes (the old thread-bridge could not).
         try:
-            queue: asyncio.Queue = asyncio.Queue(maxsize=256)
-            loop = asyncio.get_running_loop()
-
-            def _run_stream():
-                try:
-                    for chunk in session.send_stream(req.message):
-                        loop.call_soon_threadsafe(queue.put_nowait, ("token", chunk))
-                    loop.call_soon_threadsafe(queue.put_nowait, ("done", None))
-                except Exception as exc:
-                    loop.call_soon_threadsafe(queue.put_nowait, ("error", str(exc)))
-
-            thread = threading.Thread(target=_run_stream, daemon=True)
-            thread.start()
-
-            deadline = time.time() + 120
-            while True:
-                remaining = deadline - time.time()
-                if remaining <= 0:
-                    yield sse_event(
-                        "error",
-                        code="llm_timeout",
-                        message="Request timed out",
-                        suggestion="Try a simpler architecture description",
-                    )
-                    return
-                try:
-                    kind, payload = await asyncio.wait_for(queue.get(), timeout=min(remaining, 5))
-                except asyncio.TimeoutError:
-                    continue
-
-                if kind == "token":
-                    yield sse_event("token", data=payload)
-                elif kind == "error":
-                    yield sse_event("error", message=payload)
-                    return
-                else:  # done
-                    spec = session.current_spec
-                    done_kwargs: dict = {"usage": session.last_usage}
-                    if spec:
-                        done_kwargs["data"] = spec.model_dump(exclude_none=True)
-                        done_kwargs["yaml"] = spec.to_yaml()
-                    yield sse_event("done", **done_kwargs)
-                    return
+            session.llm.timeout = _LLM_STREAM_TIMEOUT_S  # best-effort hint for legacy adapters
+        except Exception:
+            pass
+
+        try:
+            agen = session.send_stream_async(req.message)
+            try:
+                while True:
+                    try:
+                        chunk = await asyncio.wait_for(agen.__anext__(), timeout=_LLM_STREAM_TIMEOUT_S)
+                    except StopAsyncIteration:
+                        break
+                    except asyncio.TimeoutError:
+                        # ``aclose`` cancels the inner ``async for`` and the
+                        # SDK's ``async with`` tears down the upstream connection,
+                        # so we do not orphan a coroutine billing tokens.
+                        await agen.aclose()
+                        yield sse_event(
+                            "error",
+                            code="llm_timeout",
+                            message="Request timed out",
+                            suggestion="Try a simpler architecture description",
+                        )
+                        return
+                    yield sse_event("token", data=chunk)
+            finally:
+                # If the consumer disconnects (or anything else aborts the
+                # generator), explicitly close the inner async-gen so the
+                # SDK's ``async with`` cleanup runs synchronously here rather
+                # than at GC time.
+                await agen.aclose()
+
+            spec = session.current_spec
+            done_kwargs: dict = {"usage": session.last_usage}
+            if spec:
+                done_kwargs["data"] = spec.model_dump(exclude_none=True)
+                done_kwargs["yaml"] = spec.to_yaml()
+            yield sse_event("done", **done_kwargs)
+        except asyncio.CancelledError:
+            # Re-raised so Starlette can finish the request unwind. We do NOT
+            # emit an SSE error event here — the consumer is gone, nobody is
+            # listening, and yielding into a closed connection raises again.
+            raise
         except Exception as e:
+            log.exception("Chat stream failed")
             yield sse_event("error", message=str(e))
 
-    return StreamingResponse(event_generator(), media_type="text/event-stream")
+    return StreamingResponse(event_generator(), media_type="text/event-stream", headers=_SSE_HEADERS)

{cloudwright_ai_web-1.2.2 → cloudwright_ai_web-1.4.0}/cloudwright_web/routers/design.py

@@ -17,6 +17,12 @@ from cloudwright_web.streaming import sse_event
 log = logging.getLogger(__name__)
 router = APIRouter()
 
+# Mirrors the chat router. Push timeouts into ``asyncio.wait_for`` so a
+# cancelled request actually unwinds the SDK call instead of leaving a worker
+# thread to keep billing tokens.
+_LLM_DESIGN_TIMEOUT_S = 120.0
+_SSE_HEADERS = {"X-Accel-Buffering": "no", "Cache-Control": "no-cache"}
+
 
 class DesignRequest(BaseModel):
     description: str = Field(..., min_length=5, max_length=2000)
@@ -52,7 +58,8 @@ async def design(req: DesignRequest, request: Request):
             spec = spec.model_copy(update={"cost_estimate": cost_estimate})
         except Exception:
             log.warning("Cost estimation failed in design endpoint", exc_info=True)
-        return {"spec": spec.model_dump(exclude_none=True), "yaml": spec.to_yaml()}
+        usage = getattr(architect, "last_usage", None) or {}
+        return {"spec": spec.model_dump(exclude_none=True), "yaml": spec.to_yaml(), "usage": usage}
     except RuntimeError as e:
         if "No LLM provider" in str(e):
             return error_response("missing_api_key", str(e), "Set an LLM provider API key in your environment", 503)
@@ -78,12 +85,30 @@ async def design_stream(req: DesignRequest, request: Request):
         yield sse_event("generating", message="Generating architecture...")
 
         try:
-            spec = await asyncio.to_thread(architect.design, req.description, constraints)
+            # ``asyncio.wait_for`` cancels the awaitable on timeout, which
+            # propagates ``CancelledError`` into the ``to_thread`` shim. The
+            # underlying ``architect.design`` is still a sync SDK call, so it
+            # may finish anyway, but the route no longer blocks forever
+            # waiting on it. Once ``Architect`` exposes an async path this
+            # becomes truly cancel-safe.
+            spec = await asyncio.wait_for(
+                asyncio.to_thread(architect.design, req.description, constraints),
+                timeout=_LLM_DESIGN_TIMEOUT_S,
+            )
+        except asyncio.TimeoutError:
+            yield sse_event(
+                "error",
+                code="llm_timeout",
+                message="Request timed out",
+                suggestion="Try a simpler architecture description",
+            )
+            return
         except Exception as e:
             yield sse_event("error", message=str(e))
             return
 
-        yield sse_event("generated", spec=spec.model_dump(exclude_none=True), yaml=spec.to_yaml())
+        usage = getattr(architect, "last_usage", None) or {}
+        yield sse_event("generated", spec=spec.model_dump(exclude_none=True), yaml=spec.to_yaml(), usage=usage)
 
         yield sse_event("costing", message="Estimating cost...")
         try:
@@ -107,9 +132,9 @@ async def design_stream(req: DesignRequest, request: Request):
             log.warning("Validation failed in design stream", exc_info=True)
             yield sse_event("validated", passed=None, total=None)
 
-        yield sse_event("done", spec=spec.model_dump(exclude_none=True), yaml=spec.to_yaml())
+        yield sse_event("done", spec=spec.model_dump(exclude_none=True), yaml=spec.to_yaml(), usage=usage)
 
-    return StreamingResponse(event_generator(), media_type="text/event-stream")
+    return StreamingResponse(event_generator(), media_type="text/event-stream", headers=_SSE_HEADERS)
 
 
 @router.post("/modify")
@@ -124,7 +149,8 @@ async def modify(req: ModifyRequest, request: Request):
             updated = await asyncio.wait_for(asyncio.to_thread(architect.modify, spec, req.instruction), timeout=120)
         except asyncio.TimeoutError:
             return error_response("llm_timeout", "Request timed out", "Try a simpler architecture description", 504)
-        return {"spec": updated.model_dump(exclude_none=True), "yaml": updated.to_yaml()}
+        usage = getattr(architect, "last_usage", None) or {}
+        return {"spec": updated.model_dump(exclude_none=True), "yaml": updated.to_yaml(), "usage": usage}
     except Exception:
         log.exception("Modify endpoint failed")
         return error_response("internal_error", "Internal server error", "Check server logs for details", 500)
@@ -143,12 +169,24 @@ async def modify_stream(req: ModifyRequest, request: Request):
         yield sse_event("modifying", message="Applying modifications...")
 
         try:
-            updated = await asyncio.to_thread(architect.modify, spec, req.instruction)
+            updated = await asyncio.wait_for(
+                asyncio.to_thread(architect.modify, spec, req.instruction),
+                timeout=_LLM_DESIGN_TIMEOUT_S,
+            )
+        except asyncio.TimeoutError:
+            yield sse_event(
+                "error",
+                code="llm_timeout",
+                message="Request timed out",
+                suggestion="Try a simpler modification",
+            )
+            return
         except Exception as e:
             yield sse_event("error", message=str(e))
             return
 
-        yield sse_event("modified", spec=updated.model_dump(exclude_none=True), yaml=updated.to_yaml())
+        usage = getattr(architect, "last_usage", None) or {}
+        yield sse_event("modified", spec=updated.model_dump(exclude_none=True), yaml=updated.to_yaml(), usage=usage)
 
         yield sse_event("costing", message="Estimating cost...")
         try:
@@ -159,6 +197,6 @@ async def modify_stream(req: ModifyRequest, request: Request):
             log.warning("Cost estimation failed in modify stream", exc_info=True)
             yield sse_event("costed", cost_estimate=None)
 
-        yield sse_event("done", spec=updated.model_dump(exclude_none=True), yaml=updated.to_yaml())
+        yield sse_event("done", spec=updated.model_dump(exclude_none=True), yaml=updated.to_yaml(), usage=usage)
 
-    return StreamingResponse(event_generator(), media_type="text/event-stream")
+    return StreamingResponse(event_generator(), media_type="text/event-stream", headers=_SSE_HEADERS)

cloudwright_ai_web-1.4.0/cloudwright_web/routers/health.py

@@ -0,0 +1,102 @@
+"""GET /api/health, /api/version, and static icon serving."""
+
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse, JSONResponse
+
+import cloudwright_web.singletons as _singletons
+
+router = APIRouter()
+
+# Captured at module import for uptime reporting.
+_START_MONOTONIC = time.monotonic()
+
+
+def _llm_provider_and_model() -> tuple[str | None, str | None]:
+    """Return (provider, model_name) based on env, without instantiating clients."""
+    if os.environ.get("ANTHROPIC_API_KEY"):
+        from cloudwright.llm.anthropic import GENERATE_MODEL as ANTHROPIC_MODEL
+
+        return "anthropic", ANTHROPIC_MODEL
+    if os.environ.get("OPENAI_API_KEY"):
+        from cloudwright.llm.openai import GENERATE_MODEL as OPENAI_MODEL
+
+        return "openai", OPENAI_MODEL
+    return None, None
+
+
+def _version_payload() -> dict:
+    from cloudwright import __version__
+
+    provider, model = _llm_provider_and_model()
+    return {
+        "version": __version__,
+        "build_sha": os.environ.get("CLOUDWRIGHT_BUILD_SHA"),
+        "llm_provider": provider,
+        "llm_model": model,
+    }
+
+
+@router.get("/health")
+def health():
+    has_llm_key = bool(os.environ.get("ANTHROPIC_API_KEY") or os.environ.get("OPENAI_API_KEY"))
+    if not has_llm_key:
+        return JSONResponse(
+            status_code=503,
+            content={
+                "status": "degraded",
+                "reason": "No LLM API key configured (ANTHROPIC_API_KEY or OPENAI_API_KEY)",
+                **_version_payload(),
+                "catalog_loaded": False,
+                "catalog_size": 0,
+                "uptime_s": round(time.monotonic() - _START_MONOTONIC, 3),
+            },
+        )
+
+    catalog_loaded = False
+    catalog_size = 0
+    try:
+        catalog = _singletons.get_catalog()
+        # Try to size the catalog; fall back to a sample search if no len.
+        try:
+            catalog_size = len(catalog)  # type: ignore[arg-type]
+        except TypeError:
+            catalog_size = len(catalog.search(query="m5", limit=1))
+        catalog_loaded = True
+    except Exception:
+        catalog_loaded = False
+
+    body = {
+        "status": "ok" if catalog_loaded else "degraded",
+        **_version_payload(),
+        "catalog_loaded": catalog_loaded,
+        "catalog_size": catalog_size,
+        "uptime_s": round(time.monotonic() - _START_MONOTONIC, 3),
+    }
+    if not catalog_loaded:
+        # Readiness probes (Kubernetes) should treat catalog-load failure as Not Ready.
+        return JSONResponse(status_code=503, content=body)
+    return body
+
+
+@router.get("/version")
+def version():
+    return _version_payload()
+
+
+@router.get("/icons/{provider}/{service}.svg")
+def get_icon(provider: str, service: str):
+    import cloudwright
+
+    icons_dir = Path(cloudwright.__file__).parent / "data" / "icons"
+    icon_path = icons_dir / provider / f"{service}.svg"
+    if not icon_path.exists():
+        raise HTTPException(status_code=404, detail=f"Icon not found: {provider}/{service}")
+    if not icon_path.resolve().is_relative_to(icons_dir.resolve()):
+        raise HTTPException(status_code=404, detail="Invalid path")
+    return FileResponse(str(icon_path), media_type="image/svg+xml")

cloudwright_ai_web-1.4.0/tests/test_api_key_auth.py

@@ -0,0 +1,98 @@
+"""Tests for the constant-time API key check.
+
+The pre-v1.3 ``check_api_key`` used ``provided != _API_KEY`` which leaks the
+key length and (under some interpreters) prefix-match timing. v1.3 switches
+to ``hmac.compare_digest`` on bytes, plus an explicit empty-input short-circuit.
+
+Tests patch the module-level ``_API_KEY`` directly via monkeypatch and restore
+it on teardown — we avoid ``importlib.reload`` because reloading the
+middleware module wipes the singleton ``_rate_limiter`` and breaks
+unrelated tests that rely on the same instance.
+"""
+
+from __future__ import annotations
+
+import cloudwright_web.middleware as middleware
+import pytest
+from fastapi import HTTPException
+
+
+class _StubRequest:
+    """Just enough of starlette.Request to drive ``check_api_key``."""
+
+    def __init__(self, header_value: str | None):
+        self.headers = {"x-api-key": header_value} if header_value is not None else {}
+
+
+@pytest.fixture
+def with_key(monkeypatch):
+    """Set the configured API key for the duration of one test."""
+
+    def _set(value: str | None):
+        monkeypatch.setattr(middleware, "_API_KEY", value)
+
+    return _set
+
+
+def test_returns_none_when_no_api_key_configured(with_key):
+    with_key(None)
+    # Even an explicitly garbage header is allowed when no key is set.
+    assert middleware.check_api_key(_StubRequest("anything")) is None
+
+
+def test_correct_key_passes(with_key):
+    with_key("secret-token-abc123")
+    assert middleware.check_api_key(_StubRequest("secret-token-abc123")) is None
+
+
+def test_wrong_key_same_length_raises_401(with_key):
+    """Two equal-length keys must compare via hmac.compare_digest."""
+    with_key("secret-token-abc123")
+    with pytest.raises(HTTPException) as exc:
+        middleware.check_api_key(_StubRequest("secret-token-XYZ999"))
+    assert exc.value.status_code == 401
+
+
+def test_wrong_key_different_length_raises_401(with_key):
+    with_key("secret-token-abc123")
+    with pytest.raises(HTTPException) as exc:
+        middleware.check_api_key(_StubRequest("short"))
+    assert exc.value.status_code == 401
+
+
+def test_missing_header_raises_401(with_key):
+    with_key("secret-token-abc123")
+    with pytest.raises(HTTPException) as exc:
+        middleware.check_api_key(_StubRequest(None))
+    assert exc.value.status_code == 401
+
+
+def test_empty_header_raises_401(with_key):
+    with_key("secret-token-abc123")
+    with pytest.raises(HTTPException) as exc:
+        middleware.check_api_key(_StubRequest(""))
+    assert exc.value.status_code == 401
+
+
+def test_uses_hmac_compare_digest(with_key, monkeypatch):
+    """Sanity check: the implementation actually calls hmac.compare_digest.
+
+    We monkeypatch ``hmac.compare_digest`` and assert it is invoked with the
+    UTF-8 encoded bytes of both sides — this pins the constant-time semantic.
+    """
+    with_key("abc")
+    calls: list[tuple[bytes, bytes]] = []
+    real = middleware.hmac.compare_digest
+
+    def spy(a, b):
+        calls.append((a, b))
+        return real(a, b)
+
+    monkeypatch.setattr(middleware.hmac, "compare_digest", spy)
+    with pytest.raises(HTTPException):
+        middleware.check_api_key(_StubRequest("xyz"))
+    assert calls, "hmac.compare_digest should have been called"
+    a, b = calls[0]
+    assert isinstance(a, bytes) and isinstance(b, bytes)
+    assert a == b"xyz"
+    assert b == b"abc"