sync: 172 file da Baida98/AI@841e91e3 (2026-08-23 10:54 UTC) [deploy-all]

api/public_status.py

@@ -10,7 +10,7 @@ import asyncio
 import logging
 from typing import Any
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter
 
 from .state import sb
 
@@ -28,7 +28,7 @@ async def public_status() -> dict[str, Any]:
     """Restituisce esclusivamente lo snapshot deliberatamente pubblico."""
     client = sb()
     if client is None:
-        raise HTTPException(status_code=503, detail="Public status non configurato")
+        return _degraded_snapshot("database_unavailable")
 
     def operation():
         return client.table("public_dashboard_snapshot").select(_PUBLIC_FIELDS).eq("singleton", True).limit(1).execute()
@@ -37,11 +37,11 @@ async def public_status() -> dict[str, Any]:
         result = await asyncio.to_thread(operation)
     except Exception as exc:
         _logger.warning("public status snapshot unavailable: %s", type(exc).__name__)
-        raise HTTPException(status_code=503, detail="Public status temporaneamente non disponibile") from exc
+        return _degraded_snapshot("snapshot_unavailable")
 
     row = (result.data or [None])[0]
     if not row:
-        raise HTTPException(status_code=503, detail="Public status snapshot non inizializzato")
+        return _degraded_snapshot("snapshot_not_initialized")
 
     return {
         "service_status": str(row.get("service_status") or "unknown"),
@@ -51,3 +51,22 @@ async def public_status() -> dict[str, Any]:
         "app_version": row.get("app_version"),
         "updated_at": row.get("updated_at"),
     }
+
+
+def _degraded_snapshot(reason: str) -> dict[str, Any]:
+    """Safe public response while the operational snapshot is unavailable.
+
+    The public endpoint is used by lightweight status surfaces. Returning a
+    deliberate degraded state keeps those surfaces functional without
+    exposing database errors, internal topology, or operational records.
+    """
+    return {
+        "service_status": "degraded",
+        "active_sessions": 0,
+        "queued_tasks": 0,
+        "in_progress_tasks": 0,
+        "app_version": None,
+        "updated_at": None,
+        "degraded": True,
+        "reason": reason,
+    }

api/terminal.py

@@ -1,5 +1,6 @@
 """backend/api/terminal.py — WebSocket PTY terminal (S354 + S754-B + S755)."""
 import os, asyncio, pty, fcntl, struct, termios, json, shlex, time, logging
+from collections import defaultdict, deque
 from pathlib import Path
 from fastapi import APIRouter, WebSocket, WebSocketDisconnect
 from fastapi import Depends
@@ -8,6 +9,31 @@ from .auth_guard import require_role, AuthRole
 router  = APIRouter()
 _logger = logging.getLogger("terminal")
 
+# Recent PTY output used by the authenticated auto-repair diagnostic.
+# Buffers are intentionally process-local and bounded: they are diagnostics,
+# not a second persistence channel for terminal sessions.
+_BUFFER_MAX_CHUNKS = 200
+_BUFFER_MAX_CHARS = 20_000
+_terminal_buffers: dict[str, deque[str]] = defaultdict(
+    lambda: deque(maxlen=_BUFFER_MAX_CHUNKS)
+)
+_terminal_active: set[str] = set()
+
+
+def _session_id(value: str | None) -> str:
+    """Normalize the client-provided diagnostic key without trusting it."""
+    value = (value or "default").strip()
+    return value[:128] or "default"
+
+
+def _append_buffer(session_id: str, data: bytes) -> None:
+    text = data.decode("utf-8", errors="replace")
+    if text:
+        _terminal_buffers[session_id].append(text)
+        # Keep the joined diagnostic bounded even when chunks are large.
+        while sum(len(chunk) for chunk in _terminal_buffers[session_id]) > _BUFFER_MAX_CHARS:
+            _terminal_buffers[session_id].popleft()
+
 # ── Startup script (S755) ─────────────────────────────────────────────────────
 # Scritto in /data/.bashrc_agente e sourciate da bash via --rcfile.
 # Configura venv Python + npm persistenti, Playwright, workspace, aliases, prompt.
@@ -239,6 +265,25 @@ async def terminal_packages(role: AuthRole = Depends(require_role(AuthRole.MACHI
         'generated_at': int(time.time()),
     }
 
+
+@router.get('/api/terminal/buffer/{session_id}')
+async def terminal_buffer(
+    session_id: str,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+):
+    """Return a bounded recent PTY diagnostic buffer.
+
+    The route is machine-authenticated because terminal output can contain
+    project data. It deliberately exposes no tmux metadata or environment.
+    """
+    sid = _session_id(session_id)
+    return {
+        "buffer": "".join(_terminal_buffers.get(sid, ())),
+        "active": sid in _terminal_active,
+        "session_id": sid,
+    }
+
+
 @router.websocket('/ws/terminal')
 async def terminal_ws(ws: WebSocket):
     """
@@ -263,6 +308,8 @@ async def terminal_ws(ws: WebSocket):
         await ws.close(code=4403)
         return
     await ws.accept()
+    _sid = _session_id(ws.query_params.get("session_id"))
+    _terminal_active.add(_sid)
     loop = asyncio.get_event_loop()
 
     # S755: assicura che /data/.bashrc_agente esista e sia aggiornato
@@ -327,6 +374,7 @@ async def terminal_ws(ws: WebSocket):
                 try:
                     data = await loop.run_in_executor(None, lambda: os.read(master_fd, 4096))
                     if data:
+                        _append_buffer(_sid, data)
                         await ws.send_bytes(data)
                         # S754-B: salvataggio periodico ogni 60s durante attività
                         _now = time.monotonic()
@@ -361,6 +409,7 @@ async def terminal_ws(ws: WebSocket):
     try:
         await asyncio.gather(_reader(), _writer())
     finally:
+        _terminal_active.discard(_sid)
         closed.set()
         # S754-B: salva lo stato prima di terminare il processo.
         # La sessione tmux è ancora viva qui (proc è il CLIENT tmux, non il SERVER).