Repository Public
1// Exploitation (pur, sans DOM) : lecture défensive de /api/admin/{health,alerts,devices,trends,security-events}, présentation des2// contrôles et des alertes, séries de tendances et projection linéaire, diagnostics tirés des codes SMTP, filtres des appareils.34const isRecord = (v: unknown): v is Record<string, unknown> => typeof v === "object" && v !== null && !Array.isArray(v)5const str = (v: unknown): string | null => (typeof v === "string" && v.trim() ? v : null)6const num = (v: unknown): number | null => (typeof v === "number" && Number.isFinite(v) ? v : typeof v === "string" && /^-?\d+(\.\d+)?$/.test(v.trim()) ? Number(v) : null)7const list = (v: unknown): Record<string, unknown>[] => (Array.isArray(v) ? v.filter(isRecord) : [])89// ================================================================ santé10export type CheckStatus = "ok" | "warn" | "fail" | "unknown"11export const CHECK_NAMES = ["mail_server", "queue", "disk", "certificates", "backups", "dns", "push", "workers", "webhooks", "database"] as const12export type CheckName = (typeof CHECK_NAMES)[number]13export interface HealthCheck {14 name: string15 status: CheckStatus16 /** phrase brute du serveur (en anglais) : montrée comme détail technique, jamais comme seul texte */17 detail: string18 checkedAt: string | null19 data: Record<string, unknown>20}21export interface Health {22 status: CheckStatus23 generatedAt: string | null24 checks: HealthCheck[]25}26const STATUSES = new Set<string>(["ok", "warn", "fail", "unknown"])27export const asStatus = (v: unknown): CheckStatus => (typeof v === "string" && STATUSES.has(v) ? (v as CheckStatus) : "unknown")2829/** Le pire état d'une liste ; « inconnu » n'aggrave jamais (il ne vaut que si rien d'autre n'est connu). */30export function worstStatus(statuses: readonly CheckStatus[]): CheckStatus {31 return statuses.includes("fail") ? "fail" : statuses.includes("warn") ? "warn" : statuses.includes("ok") ? "ok" : "unknown"32}3334/** Réponse de GET /api/admin/health : contrôles dans l'ordre de la console, puis ceux que cette version ne connaît pas. */35export function parseHealth(raw: unknown): Health {36 const o = isRecord(raw) ? raw : {}37 const checks = isRecord(o.checks) ? o.checks : {}38 const one = (name: string): HealthCheck | null => {39 const c = checks[name]40 if (!isRecord(c)) return null41 return { name, status: asStatus(c.status), detail: str(c.detail) ?? "", checkedAt: str(c.checked_at), data: isRecord(c.data) ? c.data : {} }42 }43 const known = CHECK_NAMES.map(one).filter((c): c is HealthCheck => c !== null)44 const extra = Object.keys(checks).filter((k) => !(CHECK_NAMES as readonly string[]).includes(k)).sort().map(one).filter((c): c is HealthCheck => c !== null)45 const all = [...known, ...extra]46 return { status: typeof o.status === "string" && STATUSES.has(o.status) ? (o.status as CheckStatus) : worstStatus(all.map((c) => c.status)), generatedAt: str(o.generated_at), checks: all }47}4849export type Tone = "ok" | "warn" | "danger" | ""50/** Pastille d'un état : ton (couleur), icône et clé de libellé — l'état n'est jamais porté par la couleur seule. */51export function statusChip(s: CheckStatus): { tone: Tone; icon: "check" | "warn" | "close" | "help"; label: "adm.ops.status.ok" | "adm.ops.status.warn" | "adm.ops.status.fail" | "adm.ops.status.unknown" } {52 switch (s) {53 case "ok":54 return { tone: "ok", icon: "check", label: "adm.ops.status.ok" }55 case "warn":56 return { tone: "warn", icon: "warn", label: "adm.ops.status.warn" }57 case "fail":58 return { tone: "danger", icon: "close", label: "adm.ops.status.fail" }59 default:60 return { tone: "", icon: "help", label: "adm.ops.status.unknown" }61 }62}63export function countByStatus(checks: readonly { status: CheckStatus }[]): Record<CheckStatus, number> {64 const out: Record<CheckStatus, number> = { ok: 0, warn: 0, fail: 0, unknown: 0 }65 for (const c of checks) out[c.status]++66 return out67}6869export interface Certificate {70 name: string71 /** web | smtp | stalwart */72 kind: string73 subject: string74 status: CheckStatus75 days: number | null76 expiresAt: string | null77 detail: string | null78}79/** Certificats du contrôle « certificates », du plus proche de l'expiration au plus lointain (inconnus en dernier). */80export function certificatesOf(check: HealthCheck | undefined): Certificate[] {81 return list(check?.data.certificates)82 .flatMap((c): Certificate[] => {83 const name = str(c.name)84 if (!name) return []85 const at = name.indexOf(":")86 return [{ name, kind: at > 0 ? name.slice(0, at) : "other", subject: at > 0 ? name.slice(at + 1) : name, status: asStatus(c.status), days: num(c.days), expiresAt: str(c.expires_at), detail: str(c.detail) }]87 })88 .sort((a, b) => (a.days ?? Infinity) - (b.days ?? Infinity) || a.name.localeCompare(b.name))89}9091export interface WorkerBeat {92 name: string93 lastRunAt: string | null94 ageMs: number | null95 stale: boolean96}97export interface WorkersView {98 enabled: boolean99 workers: WorkerBeat[]100 queues: { ruleJobs: number | null; ruleOldestSeconds: number | null; semanticQueue: number | null; stuckOutbound: number | null; watcherIdleSeconds: number | null }101 stalled: { address: string; failures: number; since: string | null; error: string | null }[]102}103export function workersOf(check: HealthCheck | undefined): WorkersView {104 const d = check?.data ?? {}105 const q = isRecord(d.queues) ? d.queues : {}106 return {107 enabled: d.enabled !== false,108 workers: list(d.workers).flatMap((w) => (str(w.name) ? [{ name: str(w.name)!, lastRunAt: str(w.last_run_at), ageMs: num(w.age_ms), stale: w.stale === true }] : [])),109 queues: { ruleJobs: num(q.rule_jobs), ruleOldestSeconds: num(q.rule_oldest_s), semanticQueue: num(q.semantic_queue), stuckOutbound: num(q.stuck_outbound), watcherIdleSeconds: num(q.watcher_idle_s) },110 stalled: list(d.watcher_stalled).flatMap((s) => (str(s.address) ? [{ address: str(s.address)!, failures: num(s.failures) ?? 0, since: str(s.since), error: str(s.error) }] : [])),111 }112}113114/** Durée lisible sans locale : « 45 s », « 12 min », « 5 h », « 3 j » (unités communes au français et à l'anglais sauf « j/d »). */115export function compactDuration(ms: number, dayUnit = "j"): string {116 const s = Math.max(0, Math.round(ms / 1000))117 if (s < 90) return `${s} s`118 const m = Math.round(s / 60)119 if (m < 90) return `${m} min`120 const h = Math.round(m / 60)121 if (h < 48) return `${h} h`122 return `${Math.round(h / 24)} ${dayUnit}`123}124125// ================================================================ alertes126export type AlertState = "open" | "acked" | "resolved"127export type AlertKind = "mail_server" | "queue" | "disk" | "cert" | "backup" | "auth_anomaly" | "delivery" | "webhooks" | "watcher" | "other"128export interface Alert {129 id: string130 key: string131 kind: AlertKind132 /** sujet d'une alerte de certificat (« web:mail.example.org ») */133 subject: string | null134 severity: "warn" | "fail"135 title: string136 detail: string137 state: AlertState138 firstSeen: string | null139 lastSeen: string | null140 count: number141 ackedBy: string | null142 ackedAt: string | null143 resolvedAt: string | null144}145const ALERT_KINDS = new Set<string>(["mail_server", "queue", "disk", "backup", "auth_anomaly", "delivery", "webhooks", "watcher"])146/** Famille d'une alerte d'après sa clé de condition (`cert:<nom>` → cert). */147export function alertKind(key: string): AlertKind {148 if (key.startsWith("cert:")) return "cert"149 return ALERT_KINDS.has(key) ? (key as AlertKind) : "other"150}151export function parseAlerts(raw: unknown): Alert[] {152 return list(isRecord(raw) ? raw.data : raw).flatMap((a): Alert[] => {153 const id = str(a.id)154 const key = str(a.key)155 if (!id || !key) return []156 const state: AlertState = a.state === "acked" || a.state === "resolved" ? a.state : "open"157 return [{158 id, key, kind: alertKind(key), subject: key.startsWith("cert:") ? key.slice(5) : null, severity: a.severity === "fail" ? "fail" : "warn", title: str(a.title) ?? key, detail: str(a.detail) ?? "", state,159 firstSeen: str(a.first_seen), lastSeen: str(a.last_seen), count: Math.max(1, num(a.count) ?? 1), ackedBy: str(a.acked_by_handle), ackedAt: str(a.acked_at), resolvedAt: str(a.resolved_at),160 }]161 })162}163const STATE_RANK: Record<AlertState, number> = { open: 0, acked: 1, resolved: 2 }164/** Ouvertes d'abord, puis acquittées, puis résolues ; les pannes avant les avertissements ; les plus récentes en tête. */165export function sortAlerts(alerts: readonly Alert[]): Alert[] {166 return [...alerts].sort((a, b) => STATE_RANK[a.state] - STATE_RANK[b.state] || Number(b.severity === "fail") - Number(a.severity === "fail") || (b.lastSeen ?? "").localeCompare(a.lastSeen ?? ""))167}168/** Pastille de l'entrée « Administration » : alertes encore ouvertes (non acquittées). */169export const openAlertCount = (alerts: readonly Pick<Alert, "state">[]): number => alerts.filter((a) => a.state === "open").length170export function alertTone(a: Pick<Alert, "state" | "severity">): Tone {171 return a.state === "resolved" ? "ok" : a.severity === "fail" ? "danger" : "warn"172}173174// ================================================================ tendances175export interface Point {176 /** AAAA-MM-JJ (UTC) */177 day: string178 value: number179}180const DAY_MS = 86_400_000181const DAY_RE = /^\d{4}-\d{2}-\d{2}$/182const dayIndex = (day: string): number => Math.round(Date.parse(`${day}T00:00:00Z`) / DAY_MS)183export const dayOf = (index: number): string => new Date(index * DAY_MS).toISOString().slice(0, 10)184185export interface StorageTrend {186 total: Point[]187 mailboxes: { mailboxId: string; address: string; points: Point[] }[]188}189/** Réponse `metric=storage` : série du total et une série par boîte (jours sans relevé simplement absents). */190export function parseStorageTrend(raw: unknown): StorageTrend {191 const rows = list(isRecord(raw) ? raw.data : null).filter((r) => typeof r.day === "string" && DAY_RE.test(r.day)).sort((a, b) => String(a.day).localeCompare(String(b.day)))192 const boxes = new Map<string, { mailboxId: string; address: string; points: Point[] }>()193 const total: Point[] = []194 for (const r of rows) {195 const day = r.day as string196 total.push({ day, value: Math.max(0, num(r.used_bytes) ?? 0) })197 for (const m of list(r.mailboxes)) {198 const id = str(m.mailbox_id)199 const used = num(m.used_bytes)200 if (!id || used === null) continue201 const box = boxes.get(id) ?? { mailboxId: id, address: str(m.address) ?? id, points: [] }202 box.points.push({ day, value: Math.max(0, used) })203 boxes.set(id, box)204 }205 }206 return { total, mailboxes: [...boxes.values()].sort((a, b) => (b.points.at(-1)?.value ?? 0) - (a.points.at(-1)?.value ?? 0) || a.address.localeCompare(b.address)) }207}208209export const DELIVERY_SERIES = ["delivered", "deferred", "bounced", "failed"] as const210export type DeliverySeries = (typeof DELIVERY_SERIES)[number]211export interface DeliveryDay {212 day: string213 received: number214 sent: number215 delivered: number216 /** déduit : envois soumis ni livrés, ni rebondis, ni échoués ce jour-là (encore en cours ou différés) */217 deferred: number218 bounced: number219 failed: number220}221/** Réponse `metric=deliveries`. Le relevé ne compte pas les différés : ils sont déduits (soumis − livrés − rebondis − échoués, ≥ 0). */222export function parseDeliveryTrend(raw: unknown): DeliveryDay[] {223 return list(isRecord(raw) ? raw.data : null)224 .filter((r) => typeof r.day === "string" && DAY_RE.test(r.day))225 .map((r) => {226 const n = (k: string) => Math.max(0, Math.floor(num(r[k]) ?? 0))227 const sent = n("sent")228 const delivered = n("delivered")229 const bounced = n("bounced")230 const failed = n("failed")231 return { day: r.day as string, received: n("received"), sent, delivered, bounced, failed, deferred: Math.max(0, sent - delivered - bounced - failed) }232 })233 .sort((a, b) => a.day.localeCompare(b.day))234}235236export interface ApiDay {237 day: string238 requests: number239 errors: number240 rateLimited: number241 avgMs: number242}243export function parseApiTrend(raw: unknown): ApiDay[] {244 return list(isRecord(raw) ? raw.data : null)245 .filter((r) => typeof r.day === "string" && DAY_RE.test(r.day))246 .map((r) => ({ day: r.day as string, requests: Math.max(0, num(r.requests) ?? 0), errors: Math.max(0, num(r.errors) ?? 0), rateLimited: Math.max(0, num(r.rate_limited) ?? 0), avgMs: Math.max(0, num(r.avg_ms) ?? 0) }))247 .sort((a, b) => a.day.localeCompare(b.day))248}249250/** Série continue des `days` derniers jours (UTC, aujourd'hui compris) : un jour sans ligne reçoit `zero(day)`. */251export function fillDaily<T extends { day: string }>(rows: readonly T[], days: number, today: Date, zero: (day: string) => T): T[] {252 const known = new Map(rows.map((r) => [r.day, r]))253 const end = Math.floor(Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate()) / DAY_MS)254 const out: T[] = []255 for (let i = Math.max(1, days) - 1; i >= 0; i--) {256 const day = dayOf(end - i)257 out.push(known.get(day) ?? zero(day))258 }259 return out260}261262export interface Projection {263 /** pente de la droite des moindres carrés, en unités par jour */264 perDay: number265 /** valeur attendue dans `horizonDays` jours (jamais négative) */266 projected: number267 horizonDays: number268 /** jours avant d'atteindre `capacity` au rythme actuel ; null si la série ne croît pas ou s'il n'y a pas de plafond */269 daysToCapacity: number | null270 /** nombre de relevés utilisés */271 samples: number272}273/**274 * Projection simple : droite des moindres carrés sur les relevés (abscisse = jour réel, les trous comptent), prolongée de275 * `horizonDays`. Moins de deux relevés sur des jours distincts : aucune projection (null) plutôt qu'un chiffre inventé.276 */277export function projectLinear(points: readonly Point[], horizonDays = 30, capacity: number | null = null): Projection | null {278 const pts = points.filter((p) => DAY_RE.test(p.day) && Number.isFinite(p.value)).map((p) => ({ x: dayIndex(p.day), y: p.value }))279 if (new Set(pts.map((p) => p.x)).size < 2) return null280 const n = pts.length281 const mx = pts.reduce((s, p) => s + p.x, 0) / n282 const my = pts.reduce((s, p) => s + p.y, 0) / n283 const sxx = pts.reduce((s, p) => s + (p.x - mx) ** 2, 0)284 const sxy = pts.reduce((s, p) => s + (p.x - mx) * (p.y - my), 0)285 const perDay = sxx > 0 ? sxy / sxx : 0286 const lastX = Math.max(...pts.map((p) => p.x))287 const last = pts.filter((p) => p.x === lastX).at(-1)!.y288 // la projection part du dernier relevé (valeur réelle), avec la pente de la tendance289 const projected = Math.max(0, last + perDay * horizonDays)290 const daysToCapacity = capacity !== null && capacity > 0 && perDay > 0 ? (last >= capacity ? 0 : Math.ceil((capacity - last) / perDay)) : null291 return { perDay, projected, horizonDays, daysToCapacity, samples: n }292}293294export interface LineLayout {295 max: number296 ticks: { value: number; y: number }[]297 points: { day: string; value: number; x: number; y: number }[]298 /** tracé de la ligne (attribut `d`) */299 path: string300 /** surface sous la ligne */301 area: string302 /** segment pointillé de la projection, s'il y en a une */303 projection: { x1: number; y1: number; x2: number; y2: number } | null304}305const r2 = (n: number): number => Math.round(n * 100) / 100306/** Graduations « rondes » de 0 à ≥ max, en puissances de 10 × {1, 2, 5} ou, pour des octets, en puissances de 1024. */307export function niceScale(max: number, target = 4, binary = false): number[] {308 const top = Math.max(1, Number.isFinite(max) ? max : 0)309 const rough = top / Math.max(1, target)310 let step: number311 if (binary) {312 // octets : l'unité (o, Ko, Mo…) puis un multiple en puissance de deux, pour des graduations qui tombent juste313 const base = 1024 ** Math.floor(Math.log(Math.max(1, rough)) / Math.log(1024))314 step = 2 ** Math.ceil(Math.log2(Math.max(1, rough / base))) * base315 } else {316 const pow = 10 ** Math.floor(Math.log10(Math.max(rough, 1e-9)))317 const frac = rough / pow318 // jamais de pas inférieur à l'unité : on compte des messages ou des requêtes319 step = Math.max(1, (frac <= 1 ? 1 : frac <= 2 ? 2 : frac <= 5 ? 5 : 10) * pow)320 }321 const ticks: number[] = []322 for (let v = 0; v < top + step - 1e-9 && ticks.length < 12; v += step) ticks.push(v)323 return ticks324}325/** Géométrie d'une courbe : abscisse proportionnelle au temps réel (un jour sans relevé laisse un écart, pas un zéro). */326export function lineLayout(points: readonly Point[], box: { width: number; height: number; top: number; right: number; bottom: number; left: number }, opts: { binary?: boolean; projected?: { days: number; value: number } | null } = {}): LineLayout {327 const w = Math.max(0, box.width - box.left - box.right)328 const h = Math.max(0, box.height - box.top - box.bottom)329 const tk = niceScale(Math.max(0, ...points.map((p) => p.value), opts.projected?.value ?? 0), 4, opts.binary)330 const max = tk[tk.length - 1]331 const base = box.top + h332 const y = (v: number) => r2(base - (max > 0 ? (v / max) * h : 0))333 const xs = points.map((p) => dayIndex(p.day))334 const x0 = xs.length ? Math.min(...xs) : 0335 const x1 = (xs.length ? Math.max(...xs) : 0) + (opts.projected?.days ?? 0)336 const span = Math.max(1, x1 - x0)337 const x = (i: number) => r2(box.left + ((i - x0) / span) * w)338 const pts = points.map((p, i) => ({ day: p.day, value: p.value, x: xs.length === 1 && !opts.projected ? r2(box.left + w / 2) : x(xs[i]), y: y(p.value) }))339 const path = pts.length ? `M${pts.map((p) => `${p.x},${p.y}`).join("L")}` : ""340 const area = pts.length ? `${path}L${pts[pts.length - 1].x},${r2(base)}L${pts[0].x},${r2(base)}Z` : ""341 const last = pts[pts.length - 1]342 return { max, ticks: tk.map((value) => ({ value, y: y(value) })), points: pts, path, area, projection: last && opts.projected ? { x1: last.x, y1: last.y, x2: x(x1), y2: y(opts.projected.value) } : null }343}344345// ================================================================ diagnostics SMTP346export type SmtpHintKind = "mailbox_full" | "unknown_user" | "greylisted" | "rate_limited" | "blocked" | "auth_dns" | "tls" | "too_large" | "relay_denied" | "connect" | "dns" | "content" | "temporary" | "permanent" | "unknown"347export interface SmtpHint {348 kind: SmtpHintKind349 /** code de réponse à trois chiffres, s'il a été trouvé */350 code: string | null351 /** code étendu (RFC 3463), ex. « 5.1.1 » */352 enhanced: string | null353 /** vrai : un nouvel essai peut réussir (4xx, connexion) ; faux : définitif tant que rien ne change */354 transient: boolean355}356const has = (text: string, re: RegExp) => re.test(text)357/**358 * Pourquoi cette remise est-elle bloquée ? Lecture du code SMTP (et du code étendu) d'une réponse du serveur distant, avec359 * repli sur des mots-clés. Le texte d'origine reste affiché à côté : ceci est une aide, pas un verdict.360 */361export function smtpHint(text: string | null | undefined): SmtpHint {362 const s = (text ?? "").trim()363 if (!s) return { kind: "unknown", code: null, enhanced: null, transient: true }364 const enhanced = s.match(/(?<![\d.])([245])\.(\d{1,3})\.(\d{1,3})(?!\.?\d)/)365 const code = s.match(/(?:^|[^\d.])([245][0-5]\d)(?![\d.])/)?.[1] ?? null366 const cls = code?.[0] ?? enhanced?.[1] ?? null367 const low = s.toLowerCase()368 const e = enhanced ? `${enhanced[1]}.${enhanced[2]}.${enhanced[3]}` : null369 const sub = enhanced ? `${enhanced[2]}.${enhanced[3]}` : ""370 const timeout = has(low, /timed? ?out|connection (refused|reset|closed)|could not connect|unreachable|no route|network/)371 let kind: SmtpHintKind372 if (sub === "2.2" || code === "552" && has(low, /quota|full|storage/) || has(low, /mailbox (is )?full|over ?quota|quota exceeded|insufficient storage/)) kind = "mailbox_full"373 else if (sub === "1.1" || sub === "1.10" || sub === "1.0" && code === "550" || has(low, /user unknown|no such user|unknown user|does not exist|recipient (address )?rejected|invalid recipient|unknown recipient|no mailbox/)) kind = "unknown_user"374 else if (has(low, /greylist|graylist|try again later/) && cls === "4") kind = "greylisted"375 else if (sub === "7.26" || sub === "7.23" || sub === "7.20" || sub === "7.25" || has(low, /\b(spf|dkim|dmarc)\b|reverse dns|ptr record|not authenticated|unauthenticated/)) kind = "auth_dns"376 else if (sub === "4.5" || sub === "3.2" && cls === "4" || has(low, /rate limit|too many (connections|messages|recipients)|throttl|sending limit|try again in/)) kind = "rate_limited"377 else if (has(low, /relay(ing)? (access )?(denied|not permitted)|not permitted to relay/)) kind = "relay_denied"378 else if (sub === "7.1" || has(low, /blocked|blacklist|blocklist|denylist|spamhaus|reputation|listed (at|by|in)|policy (reasons|violation)|\bspam\b/)) kind = "blocked"379 else if (sub === "7.10" || sub === "7.11" || has(low, /\btls\b|starttls|certificate|handshake|encryption required/)) kind = "tls"380 else if (sub === "3.4" || sub === "2.3" || code === "552" || has(low, /message (size|too (large|big))|size limit|exceeds .*size/)) kind = "too_large"381 else if (sub === "4.3" || sub === "4.4" && has(low, /dns|resolve/) || sub === "1.2" || has(low, /dns|nxdomain|domain not found|no mx|host not found|name or service not known|could not resolve/)) kind = "dns"382 else if (sub === "4.1" || sub === "4.2" || sub === "4.7" || code === "421" || timeout) kind = "connect"383 else if (sub.startsWith("6.") || has(low, /content rejected|virus|malware|attachment (type|rejected)/)) kind = "content"384 else if (cls === "4") kind = "temporary"385 else if (cls === "5") kind = "permanent"386 else kind = "unknown"387 const transient = kind === "greylisted" || kind === "rate_limited" || kind === "connect" || kind === "temporary" || kind === "unknown" || (cls === "4" && kind !== "unknown_user")388 return { kind, code, enhanced: e, transient: cls === "5" ? false : transient }389}390391export interface ProblemDelivery {392 id: string393 from: string394 status: "deferred" | "bounced" | "failed"395 attempts: number396 lastError: string | null397 external: boolean398 createdAt: string | null399 updatedAt: string | null400 recipients: { address: string; status: string | null; smtpReply: string | null }[]401}402export function parseProblems(raw: unknown): ProblemDelivery[] {403 return list(isRecord(raw) ? raw.data : null).flatMap((o): ProblemDelivery[] => {404 const id = str(o.id)405 if (!id || (o.status !== "deferred" && o.status !== "bounced" && o.status !== "failed")) return []406 return [{407 id, from: str(o.from) ?? "", status: o.status, attempts: num(o.attempts) ?? 0, lastError: str(o.last_error), external: o.external === true, createdAt: str(o.created_at), updatedAt: str(o.updated_at),408 recipients: list(o.recipients).flatMap((r) => (str(r.address) ? [{ address: str(r.address)!, status: str(r.status), smtpReply: str(r.smtp_reply) }] : [])),409 }]410 })411}412/** Réponse la plus parlante d'une remise à problème : celle d'un destinataire non livré, sinon la dernière erreur. */413export function problemReply(p: Pick<ProblemDelivery, "recipients" | "lastError">): string | null {414 return p.recipients.find((r) => r.smtpReply && r.status !== "delivered")?.smtpReply ?? p.recipients.find((r) => r.smtpReply)?.smtpReply ?? p.lastError415}416417// ================================================================ appareils418export interface DeviceSession {419 id: string420 userId: string421 handle: string422 kind: string423 deviceName: string | null424 platform: string | null425 ip: string | null426 userAgent: string | null427 createdAt: string | null428 lastSeenAt: string | null429 expiresAt: string | null430 current: boolean431}432export interface PushDevice {433 id: string434 userId: string435 handle: string436 sessionId: string | null437 bundleId: string | null438 environment: string | null439 deviceName: string | null440 platform: string | null441 /** six derniers caractères du jeton : le jeton entier n'est jamais transmis à la console */442 tokenTail: string | null443 createdAt: string | null444 lastSeenAt: string | null445}446export interface Devices {447 sessions: DeviceSession[]448 push: PushDevice[]449}450export function parseDevices(raw: unknown): Devices {451 const o = isRecord(raw) ? raw : {}452 return {453 sessions: list(o.sessions).flatMap((s): DeviceSession[] => {454 const id = str(s.id)455 if (!id) return []456 return [{ id, userId: str(s.user_id) ?? "", handle: str(s.handle) ?? "", kind: str(s.kind) ?? "web", deviceName: str(s.device_name), platform: str(s.platform), ip: str(s.ip), userAgent: str(s.user_agent), createdAt: str(s.created_at), lastSeenAt: str(s.last_seen_at), expiresAt: str(s.expires_at), current: s.current === true }]457 }),458 push: list(o.push_devices).flatMap((d): PushDevice[] => {459 const id = str(d.id)460 if (!id) return []461 return [{ id, userId: str(d.user_id) ?? "", handle: str(d.handle) ?? "", sessionId: str(d.session_id), bundleId: str(d.bundle_id), environment: str(d.environment), deviceName: str(d.device_name) ?? str(d.name), platform: str(d.platform) ?? str(d.device_model), tokenTail: str(d.token_tail), createdAt: str(d.created_at), lastSeenAt: str(d.last_seen_at) ?? str(d.updated_at) }]462 }),463 }464}465/** Famille de plateforme pour le filtre : web, mac, ios, android, autre. */466export function platformFamily(d: { kind?: string; platform: string | null; userAgent?: string | null; bundleId?: string | null }): "web" | "mac" | "ios" | "android" | "other" {467 const p = `${d.platform ?? ""} ${d.bundleId ?? ""}`.toLowerCase()468 if (d.kind === "web") return "web"469 if (/iphone|ipad|ios/.test(p)) return "ios"470 if (/mac/.test(p)) return "mac"471 if (/android/.test(p)) return "android"472 if (d.kind === "native" || d.bundleId) return /ios|iphone|ipad/.test(p) ? "ios" : "other"473 return "other"474}475export interface DeviceFilter {476 user: string477 platform: string478}479export function filterDevices<T extends { handle: string; platform: string | null; kind?: string; bundleId?: string | null }>(items: readonly T[], f: DeviceFilter): T[] {480 const user = f.user.trim().toLowerCase()481 return items.filter((d) => (!user || d.handle.toLowerCase() === user || d.handle.toLowerCase().includes(user)) && (!f.platform || platformFamily(d) === f.platform))482}483export const handlesOf = (d: Devices): string[] => [...new Set([...d.sessions, ...d.push].map((x) => x.handle).filter(Boolean))].sort((a, b) => a.localeCompare(b))484485// ================================================================ événements de sécurité486export interface SecurityEvent {487 id: number488 at: string | null489 action: string490 actor: string | null491 target: string | null492 ip: string | null493 meta: Record<string, unknown>494}495export interface SecurityPage {496 events: SecurityEvent[]497 nextBefore: number | null498 failed24h: { login: number; reauth: number }499}500export function parseSecurity(raw: unknown): SecurityPage {501 const o = isRecord(raw) ? raw : {}502 const f = isRecord(o.failed_24h) ? o.failed_24h : {}503 return {504 events: list(o.data).flatMap((e): SecurityEvent[] => {505 const id = num(e.id)506 const action = str(e.action)507 if (id === null || !action) return []508 return [{ id, at: str(e.at), action, actor: str(e.actor), target: str(e.target), ip: str(e.ip), meta: isRecord(e.meta) ? e.meta : {} }]509 }),510 nextBefore: num(o.next_before),511 failed24h: { login: num(f.login_failed) ?? 0, reauth: num(f.reauth_failed) ?? 0 },512 }513}514/** Filtres de la console → préfixe d'action de l'API (`action=` est un filtre par préfixe). */515export const SECURITY_FILTERS = [516 { id: "all", prefix: "" },517 { id: "failures", prefix: "" },518 { id: "login", prefix: "login" },519 { id: "reauth", prefix: "reauth" },520 { id: "apikey", prefix: "apikey" },521 { id: "session", prefix: "session" },522 { id: "admin", prefix: "admin" },523 { id: "passkey", prefix: "passkey" },524 { id: "consent", prefix: "ai" },525 { id: "approval", prefix: "approval" },526 { id: "alert", prefix: "alert" },527] as const528export type SecurityFilterId = (typeof SECURITY_FILTERS)[number]["id"]529export const isFailure = (action: string): boolean => /\.failed$|\.denied$|\.rejected$/.test(action)530/** Ton d'un événement : échec, action sensible (révocation, suppression, rotation), ou neutre. */531export function eventTone(action: string): Tone {532 if (isFailure(action)) return "danger"533 if (/revoke|remove|delete|purge|rotate|detach|allowlist|consent|provider|alert\.notified/.test(action)) return "warn"534 if (action === "alert.resolved") return "ok"535 return ""536}537/** Métadonnées d'un événement, sans rien qui ressemble à un secret (jeton, clé, empreinte) : clé : valeur courte. */538export function safeMeta(meta: Record<string, unknown>, max = 6): { key: string; value: string }[] {539 const out: { key: string; value: string }[] = []540 for (const [key, v] of Object.entries(meta)) {541 if (/token|secret|password|hash|private|credential|cookie|authorization/i.test(key)) continue542 const value = typeof v === "string" ? v : typeof v === "number" || typeof v === "boolean" ? String(v) : v === null || v === undefined ? "" : JSON.stringify(v)543 if (!value || /\bspm_[A-Za-z0-9_-]{8,}/.test(value)) continue544 out.push({ key, value: value.length > 80 ? `${value.slice(0, 79)}…` : value })545 if (out.length >= max) break546 }547 return out548}549550// ================================================================ boîtes : état d'exploitation551export interface MailboxStatus {552 mailboxId: string553 address: string554 handle: string555 usedBytes: number | null556 lastReceivedAt: string | null557 lastSentAt: string | null558 ownerSessions: number559 watcher: { state: "ok" | "failing" | "stalled" | "off" | "unknown"; updatedAt: string | null; failures: number; error: string | null }560}561export function parseMailboxStatus(raw: unknown): Map<string, MailboxStatus> {562 const out = new Map<string, MailboxStatus>()563 for (const r of list(isRecord(raw) ? raw.data : null)) {564 const id = str(r.mailbox_id)565 if (!id) continue566 const w = isRecord(r.watcher) ? r.watcher : {}567 const state = w.state === "ok" || w.state === "failing" || w.state === "stalled" || w.state === "off" ? w.state : "unknown"568 out.set(id, { mailboxId: id, address: str(r.address) ?? "", handle: str(r.handle) ?? "", usedBytes: num(r.used_bytes), lastReceivedAt: str(r.last_received_at), lastSentAt: str(r.last_sent_at), ownerSessions: num(r.owner_sessions) ?? 0, watcher: { state, updatedAt: str(w.updated_at), failures: num(w.failures) ?? 0, error: str(w.error) } })569 }570 return out571}572/** La dernière remise d'une boîte : le plus récent de la dernière réception et du dernier envoi. */573export function lastDelivery(s: Pick<MailboxStatus, "lastReceivedAt" | "lastSentAt">): { at: string; direction: "in" | "out" } | null {574 const i = s.lastReceivedAt ? Date.parse(s.lastReceivedAt) : NaN575 const o = s.lastSentAt ? Date.parse(s.lastSentAt) : NaN576 if (Number.isNaN(i) && Number.isNaN(o)) return null577 return Number.isNaN(o) || i >= o ? { at: s.lastReceivedAt!, direction: "in" } : { at: s.lastSentAt!, direction: "out" }578}579