feat: add the dashboard

Current state at the top, the panel as it stands beside what is known
about the device, the next seven days resolved with their exceptions,
and alerts when something needs attention.

There is no "push now" button, because in BYOS there is nothing to push:
the panel sleeps on battery and fetches when it wakes. Pretending
otherwise would be the most misleading control on the page. It says so
in plain words instead, and shows when the device is next due back.

Everything about the device is inference from one timestamp and one
interval, so it lives in a tested module rather than in a template. A
panel is only called overdue once it has missed its slot by half its
interval again: firmware wake-ups drift, and an alert that cries wolf
every cycle is an alert nobody reads. Battery falls back to a voltage
estimate, labelled as an estimate, because "about a third left" is the
only thing anyone acts on.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012cSY9pVhZmJUKNN7wf1Myd

app/admin/page.tsx

@@ -1,70 +1,198 @@
+import Link from 'next/link';
+
 import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/db';
+import { deviceHealth, humaniseSeconds } from '@/lib/device/health';
+import { toCivilDate } from '@/lib/schedule/civil';
+import { loadScheduleContext, loadSettings } from '@/lib/schedule/context';
+import { formatDateFr, formatHoursText, formatNextChangeFr } from '@/lib/schedule/format';
+import { getCurrentStatus, resolveWeek } from '@/lib/schedule/resolver';
+
+import ScreenPreview from './ScreenPreview';
 
 export const metadata = { title: 'Tableau de bord — ITA ITO' };
 
 export default async function AdminHome() {
-  const session = await auth();
+  const now = new Date();
-  const user = session?.user;
+  const [session, settings] = await Promise.all([auth(), loadSettings()]);
-  const isAdmin = user?.role === 'admin';
+  const context = await loadScheduleContext(now, settings);
+
+  const status = getCurrentStatus(now, context);
+  const week = resolveWeek(now, context);
+  const today = toCivilDate(now, settings.timezone);
+
+  const [device, failedTranslations, holidaySync] = await Promise.all([
+    prisma.device.findFirst({ where: { isActive: true }, orderBy: { lastSeenAt: 'desc' } }),
+    prisma.message.count({ where: { translationStatus: 'ERROR' } }),
+    prisma.syncState.findUnique({ where: { key: 'holidays' } }),
+  ]);
+
+  const health = device ? deviceHealth(device, now) : null;
+  const isOpen = status.status === 'OPEN' || status.status === 'CLOSING_SOON';
+
+  const alerts: { text: string; href?: string }[] = [];
+  if (!device) {
+    alerts.push({ text: 'Aucun écran appairé. Suivez la procédure d’appairage du README.' });
+  } else if (health?.neverSeen) {
+    alerts.push({ text: 'L’écran est enregistré mais ne s’est jamais manifesté.' });
+  } else if (health?.isOverdue) {
+    const silentFor = humaniseSeconds(secondsSince(device.lastSeenAt, now));
+    alerts.push({
+      text: `L’écran n’a pas donné signe de vie ${silentFor}. Vérifiez la batterie et le Wi-Fi.`,
+    });
+  }
+  if (failedTranslations > 0) {
+    alerts.push({
+      text: `${failedTranslations} message${failedTranslations > 1 ? 's' : ''} sans traduction anglaise.`,
+      href: '/admin/messages',
+    });
+  }
+  if (holidaySync?.lastErrorAt) {
+    alerts.push({
+      text: `La synchronisation des jours fériés a échoué : ${holidaySync.lastError ?? 'raison inconnue'}.`,
+      href: '/admin/feries',
+    });
+  }
 
   return (
-    <main className="mx-auto max-w-5xl px-4 py-10">
+    <main className="mx-auto max-w-4xl px-4 py-10">
       <h1 className="text-2xl">Tableau de bord</h1>
-      <p className="mt-2 text-[var(--ink-muted)]">
-        Connecté en tant que {user?.email} ({isAdmin ? 'administrateur' : 'lecture seule'}).
-      </p>
 
-      {!isAdmin ? <ReadOnlyExplanation groups={user?.groups ?? []} expected={user?.adminGroup ?? ''} /> : null}
+      {alerts.length > 0 ? (
+        <ul className="mt-4 space-y-2">
+          {alerts.map((alert) => (
+            <li
+              key={alert.text}
+              className="rounded-[var(--radius-md)] border border-[var(--danger)] bg-[var(--danger-tint)] px-4 py-3 text-sm text-[var(--danger)]"
+            >
+              {alert.href ? (
+                <Link href={alert.href} className="underline-offset-2 hover:underline">
+                  {alert.text}
+                </Link>
+              ) : (
+                alert.text
+              )}
+            </li>
+          ))}
+        </ul>
+      ) : null}
+
+      <section className="mt-6 rounded-[var(--radius-md)] border border-[var(--line)] bg-[var(--surface)] p-5">
+        <div className="flex flex-wrap items-baseline gap-x-4 gap-y-2">
+          <span
+            className={`rounded-[var(--radius-sm)] px-3 py-1 text-lg font-medium ${
+              isOpen
+                ? 'bg-[var(--success-tint)] text-[var(--success)]'
+                : 'bg-[var(--surface-muted)] text-[var(--ink-muted)]'
+            }`}
+          >
+            {isOpen ? 'Ouvert' : 'Fermé'}
+          </span>
+          <span className="text-lg">
+            {status.today.slots.length > 0 ? formatHoursText(status.today.slots) : 'Fermé aujourd’hui'}
+          </span>
+          <span className="text-[var(--ink-muted)]">
+            {formatNextChangeFr(
+              status.nextChangeAt
+                ? { kind: isOpen ? 'CLOSES' : 'OPENS', ...status.nextChangeAt }
+                : null,
+              today,
+            ) || 'Aucune réouverture programmée'}
+          </span>
+        </div>
+        <p className="mt-2 text-sm text-[var(--ink-muted)]">{formatDateFr(today)}</p>
+      </section>
+
+      <div className="mt-8 grid gap-8 lg:grid-cols-[1.2fr_1fr]">
+        <section>
+          <h2 className="text-lg">L’écran en ce moment</h2>
+          <ScreenPreview className="mt-3" />
+        </section>
+
+        <section>
+          <h2 className="text-lg">Appareil</h2>
+          {device && health ? (
+            <dl className="mt-3 space-y-2 text-sm">
+              <Row label="Identifiant">{device.friendlyId}</Row>
+              <Row label="Dernier contact">
+                {device.lastSeenAt ? humaniseSeconds(secondsSince(device.lastSeenAt, now)) : 'jamais'}
+              </Row>
+              <Row label="Prochain réveil">
+                {health.secondsUntilWake === null
+                  ? 'inconnu'
+                  : health.secondsUntilWake >= 0
+                    ? humaniseSeconds(health.secondsUntilWake)
+                    : 'attendu, en retard'}
+              </Row>
+              <Row label="Batterie">
+                {health.batteryPercent === null
+                  ? 'inconnue'
+                  : `environ ${health.batteryPercent}%${device.percentCharged === null ? ' (estimée)' : ''}`}
+              </Row>
+              <Row label="Wi-Fi">
+                {health.signal === null
+                  ? 'inconnu'
+                  : { good: 'bon', fair: 'moyen', poor: 'faible' }[health.signal]}
+              </Row>
+              <Row label="Firmware">{device.fwVersion ?? 'inconnu'}</Row>
+            </dl>
+          ) : (
+            <p className="mt-3 text-sm text-[var(--ink-muted)]">Aucun écran appairé.</p>
+          )}
+
+          <p className="mt-4 rounded-[var(--radius-md)] bg-[var(--surface-muted)] px-3 py-2 text-sm text-[var(--ink-muted)]">
+            L’écran fonctionne sur batterie et dort entre deux réveils&nbsp;: une modification
+            n’apparaît qu’au réveil suivant. Rien ne peut lui être poussé.
+          </p>
+        </section>
+      </div>
+
+      <section className="mt-10">
+        <h2 className="text-lg">Les sept prochains jours</h2>
+        <ul className="mt-3 divide-y divide-[var(--line)] overflow-hidden rounded-[var(--radius-md)] border border-[var(--line)] bg-[var(--surface)]">
+          {week.map((day, index) => (
+            <li key={day.date} className="flex flex-wrap items-center gap-x-3 gap-y-1 px-4 py-2.5">
+              <span className={`min-w-44 ${index === 0 ? 'font-medium' : ''}`}>
+                {formatDateFr(day.date)}
+                {index === 0 ? ' (aujourd’hui)' : ''}
+              </span>
+              <span className={day.isOpen ? '' : 'text-[var(--ink-muted)]'}>
+                {day.slots.length > 0 ? formatHoursText(day.slots) : 'Fermé'}
+              </span>
+              {day.isException ? (
+                <span className="rounded-[var(--radius-sm)] bg-[var(--accent-tint)] px-2 py-0.5 text-xs text-[var(--accent-ink)]">
+                  {day.noteFr ?? 'exception'}
+                </span>
+              ) : null}
+            </li>
+          ))}
+        </ul>
+        <p className="mt-2 text-sm text-[var(--ink-muted)]">
+          <Link href="/admin/exceptions" className="underline-offset-2 hover:underline">
+            Modifier les horaires d’aujourd’hui
+          </Link>
+        </p>
+      </section>
+
+      {session?.user?.role !== 'admin' ? (
+        <p className="mt-8 text-sm text-[var(--ink-muted)]">
+          Compte en lecture seule&nbsp;: aucune modification n’est possible.
+        </p>
+      ) : null}
     </main>
   );
 }
 
-/**
+/** Negative, so `humaniseSeconds` phrases it as "il y a …". */
- * A read-only account has exactly two causes, fixed in completely different
+function secondsSince(moment: Date | null, now: Date): number {
- * places: either the identity provider sent no groups at all, or it sent
+  return moment ? Math.round((moment.getTime() - now.getTime()) / 1000) : 0;
- * groups that do not include the one that grants write access. Saying which
+}
- * turns a support conversation into a thirty-second fix.
- */
-function ReadOnlyExplanation({ groups, expected }: { groups: string[]; expected: string }) {
-  const claimMissing = groups.length === 0;
 
+function Row({ label, children }: { label: string; children: React.ReactNode }) {
   return (
-    <section className="mt-8 max-w-2xl rounded-[var(--radius-md)] border border-[var(--line-strong)] bg-[var(--surface)] p-5">
+    <div className="flex justify-between gap-4 border-b border-[var(--line)] pb-2">
-      <h2 className="text-base">Pourquoi ce compte est-il en lecture seule&nbsp;?</h2>
+      <dt className="text-[var(--ink-muted)]">{label}</dt>
-
+      <dd className="text-right">{children}</dd>
-      <dl className="mt-4 space-y-3 text-sm">
+    </div>
-        <div>
-          <dt className="text-[var(--ink-muted)]">Groupe donnant l’accès en écriture</dt>
-          <dd className="mt-0.5 font-mono">{expected || '(non configuré)'}</dd>
-        </div>
-        <div>
-          <dt className="text-[var(--ink-muted)]">Groupes reçus d’Authentik</dt>
-          <dd className="mt-0.5 font-mono">
-            {claimMissing ? 'aucun — le claim « groups » est absent' : groups.join(', ')}
-          </dd>
-        </div>
-      </dl>
-
-      <p className="mt-4 text-sm text-[var(--ink-muted)]">
-        {claimMissing ? (
-          <>
-            Authentik n’envoie aucun groupe. Dans le provider OAuth2/OpenID, vérifiez que le scope{' '}
-            <span className="font-mono">profile</span> est bien sélectionné et que{' '}
-            <em>Include claims in id_token</em> est activé.
-          </>
-        ) : (
-          <>
-            Authentik envoie bien des groupes, mais pas celui attendu. Ajoutez ce compte au groupe{' '}
-            <span className="font-mono">{expected}</span>, ou corrigez{' '}
-            <span className="font-mono">AUTHENTIK_ADMIN_GROUP</span> pour qu’il corresponde à l’un
-            des groupes ci-dessus.
-          </>
-        )}
-      </p>
-
-      <p className="mt-3 text-sm text-[var(--ink-muted)]">
-        Le rôle est fixé à la connexion&nbsp;: après correction, déconnectez-vous et reconnectez-vous.
-      </p>
-    </section>
   );
 }

lib/device/health.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, it } from 'vitest';
+
+import { deviceHealth, humaniseSeconds, OVERDUE_FACTOR, type DeviceSnapshot } from './health';
+
+const NOW = new Date('2026-09-22T12:00:00Z');
+
+function snapshot(overrides: Partial<DeviceSnapshot> = {}): DeviceSnapshot {
+  return {
+    lastSeenAt: new Date('2026-09-22T11:50:00Z'),
+    lastRefreshRate: 600,
+    batteryVoltage: null,
+    percentCharged: null,
+    rssi: null,
+    ...overrides,
+  };
+}
+
+describe('deviceHealth', () => {
+  it('reports a device that has never called', () => {
+    const health = deviceHealth(snapshot({ lastSeenAt: null }), NOW);
+    expect(health.neverSeen).toBe(true);
+    expect(health.nextWakeAt).toBeNull();
+    expect(health.isOverdue).toBe(false);
+  });
+
+  it('predicts the next wake from the interval the device was given', () => {
+    const health = deviceHealth(snapshot(), NOW);
+    expect(health.nextWakeAt?.toISOString()).toBe('2026-09-22T12:00:00.000Z');
+    expect(health.secondsUntilWake).toBe(0);
+  });
+
+  it('counts down to the next wake', () => {
+    const health = deviceHealth(snapshot({ lastSeenAt: new Date('2026-09-22T11:55:00Z') }), NOW);
+    expect(health.secondsUntilWake).toBe(300);
+    expect(health.isOverdue).toBe(false);
+  });
+
+  it('tolerates a late wake before calling it overdue', () => {
+    // Firmware wake-ups drift; an alert that cries wolf every cycle is unread.
+    const justLate = new Date(NOW.getTime() - 600 * 1.2 * 1000);
+    expect(deviceHealth(snapshot({ lastSeenAt: justLate }), NOW).isOverdue).toBe(false);
+  });
+
+  it('calls a device overdue once it misses by half its interval again', () => {
+    const wellLate = new Date(NOW.getTime() - 600 * (OVERDUE_FACTOR + 0.1) * 1000);
+    const health = deviceHealth(snapshot({ lastSeenAt: wellLate }), NOW);
+    expect(health.isOverdue).toBe(true);
+    expect(health.secondsUntilWake).toBeLessThan(0);
+  });
+
+  it('says nothing about lateness with no interval to go on', () => {
+    const health = deviceHealth(snapshot({ lastRefreshRate: null }), NOW);
+    expect(health.nextWakeAt).toBeNull();
+    expect(health.isOverdue).toBe(false);
+  });
+
+  it('ignores a nonsensical interval', () => {
+    expect(deviceHealth(snapshot({ lastRefreshRate: 0 }), NOW).nextWakeAt).toBeNull();
+  });
+
+  it('prefers the reported battery percentage to the voltage', () => {
+    const health = deviceHealth(snapshot({ percentCharged: 42, batteryVoltage: 4.1 }), NOW);
+    expect(health.batteryPercent).toBe(42);
+  });
+
+  it('derives a rough percentage from the voltage when that is all there is', () => {
+    expect(deviceHealth(snapshot({ batteryVoltage: 4.1 }), NOW).batteryPercent).toBe(100);
+    expect(deviceHealth(snapshot({ batteryVoltage: 3.3 }), NOW).batteryPercent).toBe(0);
+    expect(deviceHealth(snapshot({ batteryVoltage: 3.7 }), NOW).batteryPercent).toBe(50);
+  });
+
+  it('clamps a voltage outside the usable range', () => {
+    expect(deviceHealth(snapshot({ batteryVoltage: 4.5 }), NOW).batteryPercent).toBe(100);
+    expect(deviceHealth(snapshot({ batteryVoltage: 2.9 }), NOW).batteryPercent).toBe(0);
+  });
+
+  it('reports nothing about a battery it was never told about', () => {
+    expect(deviceHealth(snapshot(), NOW).batteryPercent).toBeNull();
+  });
+
+  it('grades the wifi signal', () => {
+    expect(deviceHealth(snapshot({ rssi: -55 }), NOW).signal).toBe('good');
+    expect(deviceHealth(snapshot({ rssi: -72 }), NOW).signal).toBe('fair');
+    expect(deviceHealth(snapshot({ rssi: -88 }), NOW).signal).toBe('poor');
+    expect(deviceHealth(snapshot(), NOW).signal).toBeNull();
+  });
+});
+
+describe('humaniseSeconds', () => {
+  it('looks forward and backward', () => {
+    expect(humaniseSeconds(300)).toBe('dans 5 minutes');
+    expect(humaniseSeconds(-300)).toBe('il y a 5 minutes');
+  });
+
+  it('shortens anything under a minute', () => {
+    expect(humaniseSeconds(30)).toBe('dans moins d’une minute');
+    expect(humaniseSeconds(0)).toBe('dans moins d’une minute');
+  });
+
+  it('switches unit as the distance grows', () => {
+    expect(humaniseSeconds(3600)).toBe('dans 1 heure');
+    expect(humaniseSeconds(7200)).toBe('dans 2 heures');
+    expect(humaniseSeconds(172_800)).toBe('dans 2 jours');
+  });
+
+  it('keeps the singular', () => {
+    expect(humaniseSeconds(60)).toBe('dans 1 minute');
+  });
+});

lib/device/health.ts

@@ -0,0 +1,118 @@
+/**
+ * What can be said about a panel from its last visit.
+ *
+ * In BYOS nothing can be pushed and nothing can be asked: the device wakes,
+ * fetches, and sleeps. Everything below is therefore inference from one
+ * timestamp and one interval — which is exactly why it is worth writing down
+ * and testing, rather than improvising in a template.
+ */
+
+export type DeviceSnapshot = {
+  lastSeenAt: Date | null;
+  lastRefreshRate: number | null;
+  batteryVoltage: number | null;
+  percentCharged: number | null;
+  rssi: number | null;
+};
+
+export type DeviceHealth = {
+  /** Never contacted us at all. */
+  neverSeen: boolean;
+  /** When it is due back, from its last visit plus its own interval. */
+  nextWakeAt: Date | null;
+  /** Seconds until then; negative once it is late. */
+  secondsUntilWake: number | null;
+  /**
+   * Late by enough that something is probably wrong rather than merely
+   * imprecise.
+   */
+  isOverdue: boolean;
+  /** 0-100 when the device reports it, else derived from the voltage. */
+  batteryPercent: number | null;
+  signal: 'good' | 'fair' | 'poor' | null;
+};
+
+/**
+ * A panel is only called overdue once it has missed its slot by half again as
+ * long as its own interval. Firmware wake-ups drift by seconds, and an alert
+ * that cries wolf on every cycle is an alert nobody reads.
+ */
+export const OVERDUE_FACTOR = 1.5;
+
+/** Li-ion, loaded: below this the panel has days rather than weeks left. */
+const EMPTY_VOLTS = 3.3;
+const FULL_VOLTS = 4.1;
+
+export function deviceHealth(device: DeviceSnapshot, now: Date): DeviceHealth {
+  if (!device.lastSeenAt) {
+    return {
+      neverSeen: true,
+      nextWakeAt: null,
+      secondsUntilWake: null,
+      isOverdue: false,
+      batteryPercent: batteryPercent(device),
+      signal: signalQuality(device.rssi),
+    };
+  }
+
+  const interval = device.lastRefreshRate && device.lastRefreshRate > 0 ? device.lastRefreshRate : null;
+  const nextWakeAt = interval ? new Date(device.lastSeenAt.getTime() + interval * 1000) : null;
+  const secondsUntilWake = nextWakeAt
+    ? Math.round((nextWakeAt.getTime() - now.getTime()) / 1000)
+    : null;
+
+  const overdueAfter = interval
+    ? device.lastSeenAt.getTime() + interval * OVERDUE_FACTOR * 1000
+    : null;
+
+  return {
+    neverSeen: false,
+    nextWakeAt,
+    secondsUntilWake,
+    isOverdue: overdueAfter !== null && now.getTime() > overdueAfter,
+    batteryPercent: batteryPercent(device),
+    signal: signalQuality(device.rssi),
+  };
+}
+
+function batteryPercent(device: DeviceSnapshot): number | null {
+  if (device.percentCharged !== null) {
+    return clamp(device.percentCharged);
+  }
+  if (device.batteryVoltage === null) {
+    return null;
+  }
+  // Rough, and labelled as such in the UI: a discharge curve is not linear,
+  // but "about a third left" is the only thing anyone acts on.
+  const ratio = (device.batteryVoltage - EMPTY_VOLTS) / (FULL_VOLTS - EMPTY_VOLTS);
+  return clamp(Math.round(ratio * 100));
+}
+
+function signalQuality(rssi: number | null): DeviceHealth['signal'] {
+  if (rssi === null) {
+    return null;
+  }
+  if (rssi >= -67) {
+    return 'good';
+  }
+  return rssi >= -80 ? 'fair' : 'poor';
+}
+
+function clamp(value: number): number {
+  return Math.min(100, Math.max(0, value));
+}
+
+/** "dans 8 minutes", "il y a 2 heures" — the only two shapes the page needs. */
+export function humaniseSeconds(seconds: number): string {
+  const absolute = Math.abs(seconds);
+  const value =
+    absolute < 60
+      ? 'moins d’une minute'
+      : absolute < 3600
+        ? `${Math.round(absolute / 60)} minute${Math.round(absolute / 60) > 1 ? 's' : ''}`
+        : absolute < 86_400
+          ? `${Math.round(absolute / 3600)} heure${Math.round(absolute / 3600) > 1 ? 's' : ''}`
+          : `${Math.round(absolute / 86_400)} jour${Math.round(absolute / 86_400) > 1 ? 's' : ''}`;
+
+  return seconds >= 0 ? `dans ${value}` : `il y a ${value}`;
+}