Temps réel

// Client temps réel Aicscan (Node.js 18+, paquet « ws » : npm install ws).
import WebSocket from 'ws';

const URL = 'wss://aicscan.io/api/ws/alertes';
const DELAYS = [1, 2, 5, 10, 30]; // secondes entre deux reconnexions
let lastId = null; // à enregistrer durablement pour reprendre après un redémarrage
let failures = 0;
let stop = false; // clé refusée : inutile de réessayer

function connect() {
  const url = lastId == null ? URL : `${URL}?last_id=${lastId}`;
  const ws = new WebSocket(url, {
    headers: { Authorization: `Bearer ${process.env.AICSCAN_API_KEY}` },
  });

  ws.on('message', (data) => {
    const msg = JSON.parse(data.toString());
    if (msg.type === 'hello') {
      failures = 0;
      lastId ??= msg.last_id;
    } else if (msg.type === 'alert') {
      if (lastId != null && msg.id <= lastId) return; // déjà reçue
      lastId = msg.id;
      const a = msg.alert;
      console.log(a.severity, a.stage, a.title);
    } else if (msg.type === 'gap') {
      console.warn(`alertes ${msg.from + 1} à ${msg.to} non rejouées : voir GET /v1/matches`);
    }
  });

  // Refus à l'ouverture : 401, 403, 429… avec un corps JSON.
  ws.on('unexpected-response', (_req, res) => {
    let body = '';
    res.on('data', (c) => (body += c));
    res.on('end', () => console.error('connexion refusée', res.statusCode, body));
    stop = res.statusCode === 401 || res.statusCode === 403;
  });

  ws.on('close', (code) => {
    if (stop) return;
    if (code === 4401) return console.error('accès révoqué ou expiré : reconnexion abandonnée');
    const delay = DELAYS[Math.min(failures++, DELAYS.length - 1)];
    setTimeout(connect, delay * 1000);
  });
  ws.on('error', () => {}); // l'événement « close » suit toujours
}

connect();

# Client temps réel Aicscan (Python 3.9+, paquet « websockets » 14 ou plus récent).
import asyncio
import json
import os

import websockets

URL = "wss://aicscan.io/api/ws/alertes"
DELAYS = [1, 2, 5, 10, 30]  # secondes entre deux reconnexions


async def main():
    last_id = None  # à enregistrer durablement pour reprendre après un redémarrage
    failures = 0
    headers = {"Authorization": f"Bearer {os.environ['AICSCAN_API_KEY']}"}
    while True:
        url = URL if last_id is None else f"{URL}?last_id={last_id}"
        try:
            async with websockets.connect(url, additional_headers=headers) as ws:
                async for raw in ws:
                    msg = json.loads(raw)
                    if msg["type"] == "hello":
                        failures = 0
                        if last_id is None:
                            last_id = msg["last_id"]
                    elif msg["type"] == "alert":
                        if last_id is not None and msg["id"] <= last_id:
                            continue  # déjà reçue
                        last_id = msg["id"]
                        alert = msg["alert"]
                        print(alert["severity"], alert["stage"], alert["title"])
                    elif msg["type"] == "gap":
                        print(f"alertes {msg['from'] + 1} à {msg['to']} non rejouées : voir GET /v1/matches")
        except websockets.InvalidStatus as e:  # refus à l'ouverture (401, 403, 429…)
            print("connexion refusée", e.response.status_code, e.response.body.decode(errors="replace"))
            if e.response.status_code in (401, 403):
                return
        except websockets.ConnectionClosed as e:
            if e.rcvd is not None and e.rcvd.code == 4401:
                print("accès révoqué ou expiré : reconnexion abandonnée")
                return
        except OSError:
            pass  # réseau indisponible
        await asyncio.sleep(DELAYS[min(failures, len(DELAYS) - 1)])
        failures += 1


asyncio.run(main())