sync: 194 file da Baida98/AI@4c1d2f92 (2026-08-30 07:22 UTC)

api/public_snapshot.py

@@ -8,49 +8,9 @@ from __future__ import annotations
 
 import asyncio
 import logging
-import os
 from typing import Any
 
-from .state import _agent_tasks, _loop_registry
-
-try:
-    from supabase import create_client
-except ImportError:  # pragma: no cover - deployment dependency guard
-    create_client = None
-
-_snapshot_client: Any | None = None
-_snapshot_client_initialized = False
-
-
-def get_snapshot_client() -> Any | None:
-    """Return one stable Supabase client for the canonical snapshot project.
-
-    Unlike the general round-robin pool, this client never changes project
-    between a write and a read. Dedicated variables can be used when the
-    snapshot lives in a separate project; otherwise project A is canonical.
-    """
-    global _snapshot_client, _snapshot_client_initialized
-    if _snapshot_client_initialized:
-        return _snapshot_client
-    _snapshot_client_initialized = True
-    if create_client is None:
-        _logger.warning("BOOT: public snapshot skipped — supabase package unavailable")
-        return None
-    url = os.getenv("PUBLIC_SNAPSHOT_SUPABASE_URL") or os.getenv("SUPABASE_URL")
-    key = (
-        os.getenv("PUBLIC_SNAPSHOT_SUPABASE_SERVICE_ROLE_KEY")
-        or os.getenv("SUPABASE_SERVICE_ROLE_KEY")
-        or os.getenv("SUPABASE_KEY")
-    )
-    if not url or not key:
-        _logger.warning("BOOT: public snapshot skipped — canonical Supabase URL/key unavailable")
-        return None
-    try:
-        _snapshot_client = create_client(url, key)
-        _logger.info("BOOT: canonical Supabase snapshot client initialized")
-    except Exception as exc:
-        _logger.warning("BOOT: canonical Supabase snapshot client init failed type=%s", type(exc).__name__)
-    return _snapshot_client
+from .state import _agent_tasks, _loop_registry, sb
 from .version import RUNTIME_VERSION
 
 _logger = logging.getLogger("agente_ai.public_snapshot")
@@ -77,7 +37,7 @@ async def write_public_dashboard_snapshot() -> bool:
     public status route remains available with its degraded response while the
     service continues booting; the exact exception is kept in backend logs.
     """
-    client = get_snapshot_client()
+    client = sb()
     if client is None:
         _logger.warning("BOOT: public snapshot skipped — Supabase client unavailable")
         return False

api/public_snapshot_diagnostics.py

@@ -12,7 +12,7 @@ from typing import Any, Optional
 from fastapi import APIRouter, Depends
 
 from .auth_guard import AuthRole, require_role
-from .public_snapshot import get_snapshot_client
+from .state import sb
 
 router = APIRouter(
     prefix="/api/diagnostics/public-snapshot",
@@ -40,7 +40,7 @@ def _safe_error(exc: Exception) -> dict[str, Optional[str]]:
 @router.get("")
 async def public_snapshot_diagnostics() -> dict[str, Any]:
     """Return snapshot presence and a sanitized exact Supabase error, if any."""
-    client = get_snapshot_client()
+    client = sb()
     if client is None:
         return {
             "ok": False,

api/public_status.py

@@ -12,7 +12,7 @@ from typing import Any
 
 from fastapi import APIRouter
 
-from .public_snapshot import get_snapshot_client
+from .state import sb
 
 _logger = logging.getLogger("agente_ai.api.public_status")
 router = APIRouter(prefix="/api/public", tags=["public"])
@@ -26,7 +26,7 @@ _PUBLIC_FIELDS = (
 @router.get("/status")
 async def public_status() -> dict[str, Any]:
     """Restituisce esclusivamente lo snapshot deliberatamente pubblico."""
-    client = get_snapshot_client()
+    client = sb()
     if client is None:
         return _degraded_snapshot("database_unavailable")
 

main.py

@@ -253,9 +253,7 @@ async def startup_event():
         _logger.info("✅ BOOT: apply_rls_fix_sync() eseguito con successo.")
     except Exception as e:
         _logger.warning(f"⚠️ BOOT: apply_rls_fix_sync() fallito (non bloccante): {e}")
-    # Schema e RLS sono gestiti dalle migrazioni versionate Supabase.
-    # Non avviare auto-migrazioni in background: il boot deve restare
-    # deterministico e non può dichiarare successo prima della migrazione.
+    asyncio.create_task(_run_auto_migration())
     try:
         from api.public_snapshot import write_public_dashboard_snapshot
         snapshot_ok = await asyncio.wait_for(write_public_dashboard_snapshot(), timeout=12.0)

scripts/lib/report-engine.mjs

@@ -0,0 +1,36 @@
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+const DEFAULT_REPORT_DIRECTORY = "/tmp/agente-ai";
+
+function safeSegment(value) {
+  return String(value ?? "benchmark")
+    .trim()
+    .replace(/[^a-zA-Z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 96) || "benchmark";
+}
+
+/**
+ * Persiste un artefatto diagnostico del runner senza incidere sui calcoli.
+ * Il write-then-rename evita file JSON parziali in caso di interruzione.
+ */
+export function saveBenchmarkReport(reportName, payload) {
+  const reportDirectory = resolve(process.env.BENCHMARK_REPORT_DIR || DEFAULT_REPORT_DIRECTORY);
+  mkdirSync(reportDirectory, { recursive: true });
+
+  const safeName = safeSegment(reportName);
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const finalPath = join(reportDirectory, `${safeName}-${stamp}.json`);
+  const temporaryPath = `${finalPath}.${process.pid}.tmp`;
+  const document = {
+    schemaVersion: "benchmark-report-v1",
+    generatedAt: new Date().toISOString(),
+    reportName: safeName,
+    ...payload,
+  };
+
+  writeFileSync(temporaryPath, `${JSON.stringify(document, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+  renameSync(temporaryPath, finalPath);
+  return finalPath;
+}

tests/test_public_snapshot_writer.py

@@ -4,14 +4,10 @@ from api import public_snapshot
 
 
 class _FakeTable:
-    def __init__(self, calls, failures=0):
+    def __init__(self, calls):
         self.calls = calls
-        self.failures = failures
 
     def upsert(self, row, on_conflict=None):
-        if self.failures:
-            self.failures -= 1
-            raise RuntimeError("temporary Supabase failure")
         self.calls.append((row, on_conflict))
         return self
 
@@ -20,22 +16,17 @@ class _FakeTable:
 
 
 class _FakeClient:
-    def __init__(self, failures=0):
+    def __init__(self):
         self.calls = []
-        self.failures = failures
 
     def table(self, name):
         assert name == "public_dashboard_snapshot"
-        return _FakeTable(self.calls, self.failures)
-
-
-def _run(coro):
-    return asyncio.run(coro)
+        return _FakeTable(self.calls)
 
 
 def test_snapshot_writer_is_idempotent_and_counts_runtime_state(monkeypatch):
     fake = _FakeClient()
-    monkeypatch.setattr(public_snapshot, "get_snapshot_client", lambda: fake)
+    monkeypatch.setattr(public_snapshot, "sb", lambda: fake)
     monkeypatch.setattr(
         public_snapshot,
         "_agent_tasks",
@@ -47,8 +38,8 @@ def test_snapshot_writer_is_idempotent_and_counts_runtime_state(monkeypatch):
     )
     monkeypatch.setattr(public_snapshot, "_loop_registry", {"session-1": object()})
 
-    assert _run(public_snapshot.write_public_dashboard_snapshot()) is True
-    assert _run(public_snapshot.write_public_dashboard_snapshot()) is True
+    assert asyncio.run(public_snapshot.write_public_dashboard_snapshot()) is True
+    assert asyncio.run(public_snapshot.write_public_dashboard_snapshot()) is True
 
     assert len(fake.calls) == 2
     first, second = fake.calls
@@ -62,34 +53,6 @@ def test_snapshot_writer_is_idempotent_and_counts_runtime_state(monkeypatch):
     assert first[0]["service_status"] == "operational"
 
 
-def test_snapshot_writer_retries_transient_failure(monkeypatch):
-    calls = []
-
-    class _RetryTable:
-        def upsert(self, row, on_conflict=None):
-            calls.append((row, on_conflict))
-            if len(calls) < 3:
-                raise RuntimeError("temporary Supabase failure")
-            return self
-
-        def execute(self):
-            return object()
-
-    class _RetryClient:
-        def table(self, name):
-            assert name == "public_dashboard_snapshot"
-            return _RetryTable()
-
-    monkeypatch.setattr(public_snapshot, "get_snapshot_client", lambda: _RetryClient())
-    async def _no_sleep(_seconds):
-        return None
-
-    monkeypatch.setattr(public_snapshot.asyncio, "sleep", _no_sleep)
-
-    assert _run(public_snapshot.write_public_dashboard_snapshot()) is True
-    assert len(calls) == 3
-
-
-def test_snapshot_writer_returns_false_when_supabase_is_unavailable(monkeypatch):
-    monkeypatch.setattr(public_snapshot, "get_snapshot_client", lambda: None)
-    assert _run(public_snapshot.write_public_dashboard_snapshot()) is False
+def test_snapshot_writer_is_non_blocking_when_supabase_is_unavailable(monkeypatch):
+    monkeypatch.setattr(public_snapshot, "sb", lambda: None)
+    assert asyncio.run(public_snapshot.write_public_dashboard_snapshot()) is False