@imenam/mcp-messenger 1.0.17 → 1.0.19

package/README.md

@@ -377,7 +377,7 @@ configuration partagent alors la même boîte. Utile pour un service unique et s
 
 ## Console web
 
-`http://127.0.0.1:3600/ui/` affiche, en lecture seule, **tous les échanges** de la flotte,
+`http://127.0.0.1:3600/ui/` affiche **tous les échanges** de la flotte,
 organisés autour du fil — l'unité d'une correspondance, celle qui porte le sujet, les deux
 correspondants et l'état de lecture :
 
@@ -386,7 +386,8 @@ correspondants et l'état de lecture :
   chevron sur ses boîtes ; une boîte que son agent n'a pas nommée s'affiche à son adresse,
   la seule chose qui la distingue alors de ses sœurs. Cliquer l'agent filtre les fils sur
   **toutes ses sessions**, cliquer une boîte sur **cette seule session**. La colonne se
-  replie sur les seuls avatars d'agents quand la place manque.
+  replie sur les seuls avatars d'agents quand la place manque, son bouton de repli restant
+  en place : c'est lui qui la rouvre.
 
   **Le classement se fait en deux temps : d'abord ce qui a servi, ensuite ce qui est
   vide ; puis, dans chacun des deux, la dernière activité, la plus récente en tête.** Une
@@ -394,8 +395,9 @@ correspondants et l'état de lecture :
   une par session ouverte, et beaucoup n'échangeront jamais rien. Ces boîtes-là sont
   **masquées par défaut**, derrière un bouton en fin de dépli qui dit combien il y en a ;
   les masquer ne cache jamais de courrier, une boîte sans réception n'ayant par
-  construction aucun non-lu. Un agent dont aucune session n'a rien échangé passe de même
-  derrière les autres. Chaque boîte affiche la date qui la classe, et deux dates
+  construction aucun non-lu. **Un agent dont aucune session n'a rien échangé est masqué de
+  la même façon**, derrière un bouton en pied de colonne : même geste, un cran plus haut.
+  Chaque boîte affiche la date qui la classe, et deux dates
   identiques sont départagées par l'adresse pour que l'ordre ne bouge pas d'un
   rafraîchissement à l'autre ;
 - **la liste des fils**, du plus récemment actif au plus ancien, chacun résumé par son
@@ -416,6 +418,10 @@ correspondants et l'état de lecture :
   dossier, état). Tout ce qui se recopie a son bouton de copie ;
 - une recherche unique, qui couvre le nom d'un fil, sa description et le texte de ses
   messages ;
+- **des panneaux redimensionnables** : chaque ligne de séparation se saisit à la souris,
+  se règle aussi aux flèches du clavier une fois qu'elle a le focus, et rend sa largeur
+  d'origine sur un double-clic. Les largeurs choisies sont retenues par le navigateur d'une
+  visite à l'autre ;
 - un rafraîchissement automatique toutes les 5 secondes, débrayable.
 
 **Les adresses ne sont pas de l'information de lecture.** La console résout partout
@@ -439,7 +445,37 @@ navigateur de l'administrateur. Les routes `/admin` acceptent toujours le jeton
 `Authorization: Bearer` pour les scripts. Le formulaire est limité à 10 tentatives par
 quart d'heure et par IP.
 
-La console n'écrit jamais : elle ne peut ni envoyer, ni supprimer, ni modifier.
+La console n'envoie ni ne modifie aucun message. Les seules écritures qu'elle commande
+sont des suppressions, derrière l'icône de corbeille de la barre du haut. **Deux
+nettoyages y cohabitent, avec chacun son bouton, parce qu'ils ne visent pas la même
+chose :**
+
+- **les boîtes vides** : rien n'y est jamais passé, ni envoi ni réception. Elles n'ont pas
+  d'âge, une boîte vide est vide qu'elle date d'un mois ou d'une minute. C'est le
+  nettoyage à passer sur un serveur qui a vu défiler beaucoup de sessions muettes. **Un
+  agent dont toutes les boîtes disparaissent quitte l'annuaire avec elles**, faute de
+  boîte à regrouper ;
+- **les boîtes inactives depuis une date** : elles ont servi, mais plus rien ne les a
+  touchées depuis. **Une boîte créée après cette date est épargnée, même vide** — une
+  session qui vient de démarrer et n'a pas encore parlé n'est pas une boîte à l'abandon.
+
+L'un comme l'autre se font en deux temps, parce qu'ils ne se rattrapent pas :
+
+1. **L'aperçu** liste les boîtes concernées, chacune avec son nom, son adresse, son nombre
+   de messages et sa dernière activité. Chaque ligne se décoche.
+2. **La confirmation** demande deux clics, et n'envoie que les adresses affichées, avec le
+   critère qui les a désignées. Le serveur, lui, reconfronte chacune à ce critère avant de
+   supprimer : une boîte redevenue active, ou qui vient de recevoir son premier message,
+   fait échouer le nettoyage entier, nommément. Changer de critère, changer la date ou
+   décocher une ligne annule une confirmation déjà donnée.
+
+**Ce qui disparaît.** Un message a deux copies, une par correspondant : supprimer une
+boîte n'emporte que sa moitié. Le message lui-même ne s'efface qu'une fois sa dernière
+copie partie, autrement dit quand plus personne ne pourrait le lire ; un fil vidé de ses
+messages s'en va avec. Ce que l'autre côté a reçu reste intact, expéditeur compris.
+
+Le registre local des boîtes n'a pas à être nettoyé après une purge : une entrée qui
+désigne une boîte disparue n'est jamais reprise, et s'oublie d'elle-même.
 
 ---
 
@@ -506,6 +542,9 @@ la console (cookie), qui elle n'ouvre rien d'autre.
 | `GET` | `/admin/overview` · `/admin/messages[/:id]` | Supervision, lecture seule |
 | `GET` | `/admin/threads` | Fils du serveur entier (`agent` — une ou plusieurs adresses séparées par des virgules —, `search`, `unread_only`, `priority`, `limit`, `offset`) |
 | `GET` | `/admin/threads/:id` | Fil complet, corps inclus |
+| `GET` | `/admin/mailboxes/stale` | Boîtes sans activité depuis `before`, avec ce que chacune contient |
+| `GET` | `/admin/mailboxes/empty` | Boîtes par lesquelles rien n'est jamais passé, sans critère de date |
+| `POST` | `/admin/mailboxes/purge` | Supprime les boîtes nommées (`mailboxes`, plus `before` **ou** `empty: true`) — refusé si l'une d'elles ne répond plus au critère |
 | `POST` | `/ui/login` · `/ui/logout` | Session de la console (`{ "token": … }` → cookie `HttpOnly`) |
 
 ---
@@ -525,8 +564,12 @@ la console (cookie), qui elle n'ouvre rien d'autre.
   dans les logs).
 - **Isolation des boîtes** garantie côté serveur : les identifiants de messages fournis par
   un agent sont systématiquement filtrés sur ses propres livraisons.
-- La console web n'insère jamais de HTML fourni par un agent (`textContent` uniquement) et
-  la CSP interdit tout script tiers.
+- La console web n'insère jamais de HTML fourni par un agent : le corps des messages est
+  rendu en markdown par construction de nœuds, jamais par assignation de balisage, et la
+  CSP interdit tout script tiers.
+- La console ne peut ni écrire ni modifier un message. Ses seules commandes destructrices
+  sont les deux nettoyages de boîtes, réservés au jeton d'administration, confirmés deux
+  fois et revérifiés par le serveur avant exécution.
 - Derrière un reverse proxy TLS, exposer le serveur en `https://` et donner cette URL aux
   agents via `MESSENGER_SERVER_URL`.
 
@@ -567,7 +610,9 @@ test/                   # store, config, API HTTP, outils MCP, binaire réel
 
 ### Tests
 
-207 tests couvrant : la reprise de la boîte d'une session interrompue (clé de session de
+253 tests couvrant : les deux nettoyages de boîtes commandés depuis la console — vides,
+ou inactives depuis une date — avec leur aperçu, leur double confirmation et le refus
+nominatif d'une boîte qui ne répond plus au critère, la reprise de la boîte d'une session interrompue (clé de session de
 l'hôte, boîte orpheline, boîte d'une session vivante jamais reprise), le rendu markdown des messages et l'aplatissement des aperçus (dont
 l'innocuité du rendu : ni HTML interprété, ni lien vers un autre schéma qu'`http`, `https`
 ou `mailto`), le stockage et l'isolation des boîtes, la validation de configuration,

package/dist/src/core/store.d.ts

@@ -87,6 +87,42 @@ export declare class MessageStore extends EventEmitter<StoreEvents> {
     stats(agentId: string): MailboxStats;
     /** Purge les livraisons restées en corbeille au-delà de `days`. Renvoie le nombre supprimé. */
     purgeTrash(days: number): number;
+    /**
+     * Boîtes dont plus rien ne bouge depuis `before`, avec ce que leur suppression coûterait.
+     *
+     * L'inactivité se mesure au plus récent de trois moments : la dernière connexion, la
+     * dernière livraison, et la création. Le dernier compte autant que les autres — une
+     * boîte allouée il y a une minute et qui n'a rien fait n'est pas une boîte à l'abandon,
+     * c'est une session qui n'a pas encore parlé.
+     */
+    staleMailboxes(before: string): (AgentDirectoryEntry & {
+        messages: number;
+    })[];
+    /**
+     * Boîtes par lesquelles rien n'est jamais passé, ni envoi ni réception.
+     *
+     * Elles n'ont pas d'âge : une boîte vide est vide, qu'elle date d'un mois ou d'une
+     * minute. C'est ce qui la distingue d'une boîte inactive, et ce qui rend ce nettoyage
+     * différent de la purge par date — la boîte d'une session qui vient d'ouvrir et n'a pas
+     * encore parlé en fait donc partie.
+     */
+    emptyMailboxes(): (AgentDirectoryEntry & {
+        messages: number;
+    })[];
+    /**
+     * Supprime ces boîtes et tout ce qui n'appartenait qu'à elles.
+     *
+     * Un message a deux copies, une par correspondant : effacer une boîte n'efface donc que
+     * sa moitié. Le message lui-même ne disparaît qu'une fois sa dernière copie partie —
+     * autrement dit quand plus personne ne peut le lire. Ce que l'autre côté a reçu reste
+     * intact, avec l'adresse de l'expéditeur telle qu'elle a été livrée.
+     */
+    deleteMailboxes(ids: string[]): {
+        mailboxes: number;
+        deliveries: number;
+        messages: number;
+        threads: number;
+    };
     /** Vue globale : tous les messages du serveur, indépendamment des boîtes. */
     listAllMessages(opts?: {
         search?: string;

package/dist/src/core/store.js

@@ -581,7 +581,85 @@ export class MessageStore extends EventEmitter {
         this.dropOrphanMessages();
         return removed;
     }
-    // --- Supervision (interface web, lecture seule) --------------------------
+    /**
+     * Boîtes dont plus rien ne bouge depuis `before`, avec ce que leur suppression coûterait.
+     *
+     * L'inactivité se mesure au plus récent de trois moments : la dernière connexion, la
+     * dernière livraison, et la création. Le dernier compte autant que les autres — une
+     * boîte allouée il y a une minute et qui n'a rien fait n'est pas une boîte à l'abandon,
+     * c'est une session qui n'a pas encore parlé.
+     */
+    staleMailboxes(before) {
+        const rows = this.db
+            .prepare(`SELECT a.*, ${LAST_ACTIVITY} AS last_activity_at,
+                (SELECT COUNT(*) FROM deliveries d WHERE d.agent_id = a.id) AS messages
+           FROM agents a
+          WHERE MAX(${LAST_ACTIVITY}, a.created_at) < ?
+          ORDER BY MAX(${LAST_ACTIVITY}, a.created_at) ASC`)
+            .all(before);
+        return rows.map((row) => ({
+            ...row,
+            registered: Boolean(row.registered),
+            last_activity_at: row.last_activity_at || null,
+        }));
+    }
+    /**
+     * Boîtes par lesquelles rien n'est jamais passé, ni envoi ni réception.
+     *
+     * Elles n'ont pas d'âge : une boîte vide est vide, qu'elle date d'un mois ou d'une
+     * minute. C'est ce qui la distingue d'une boîte inactive, et ce qui rend ce nettoyage
+     * différent de la purge par date — la boîte d'une session qui vient d'ouvrir et n'a pas
+     * encore parlé en fait donc partie.
+     */
+    emptyMailboxes() {
+        const rows = this.db
+            .prepare(`SELECT a.*, ${LAST_ACTIVITY} AS last_activity_at, 0 AS messages
+           FROM agents a
+          WHERE NOT EXISTS (SELECT 1 FROM deliveries d WHERE d.agent_id = a.id)
+          ORDER BY a.created_at ASC`)
+            .all();
+        return rows.map((row) => ({
+            ...row,
+            registered: Boolean(row.registered),
+            last_activity_at: row.last_activity_at || null,
+        }));
+    }
+    /**
+     * Supprime ces boîtes et tout ce qui n'appartenait qu'à elles.
+     *
+     * Un message a deux copies, une par correspondant : effacer une boîte n'efface donc que
+     * sa moitié. Le message lui-même ne disparaît qu'une fois sa dernière copie partie —
+     * autrement dit quand plus personne ne peut le lire. Ce que l'autre côté a reçu reste
+     * intact, avec l'adresse de l'expéditeur telle qu'elle a été livrée.
+     */
+    deleteMailboxes(ids) {
+        if (ids.length === 0)
+            return { mailboxes: 0, deliveries: 0, messages: 0, threads: 0 };
+        return this.db.transaction(() => {
+            const messagesBefore = this.db.prepare("SELECT COUNT(*) AS n FROM messages").get().n;
+            const threadsBefore = this.db.prepare("SELECT COUNT(*) AS n FROM threads").get().n;
+            let mailboxes = 0;
+            let deliveries = 0;
+            const dropDeliveries = this.db.prepare("DELETE FROM deliveries WHERE agent_id = ?");
+            const dropFolders = this.db.prepare("DELETE FROM folders WHERE agent_id = ?");
+            const dropAgent = this.db.prepare("DELETE FROM agents WHERE id = ?");
+            for (const id of ids) {
+                deliveries += dropDeliveries.run(id).changes;
+                dropFolders.run(id);
+                mailboxes += dropAgent.run(id).changes;
+            }
+            this.dropOrphanMessages();
+            const messagesAfter = this.db.prepare("SELECT COUNT(*) AS n FROM messages").get().n;
+            const threadsAfter = this.db.prepare("SELECT COUNT(*) AS n FROM threads").get().n;
+            return {
+                mailboxes,
+                deliveries,
+                messages: messagesBefore - messagesAfter,
+                threads: threadsBefore - threadsAfter,
+            };
+        })();
+    }
+    // --- Supervision (interface web, lecture seule sauf purge) ---------------
     /** Vue globale : tous les messages du serveur, indépendamment des boîtes. */
     listAllMessages(opts = {}) {
         const limit = clamp(opts.limit ?? 50, 1, MAX_LIMIT);

package/dist/src/server/app.js

@@ -89,6 +89,35 @@ const adminThreadsSchema = z.object({
     limit: z.coerce.number().int().min(1).max(100).optional(),
     offset: z.coerce.number().int().min(0).optional(),
 });
+/**
+ * Date de coupure d'une purge.
+ *
+ * Un jour (`2026-08-01`) autant qu'un instant (`2026-08-01T09:00:00.000Z`) : la console
+ * envoie ce que le champ de date du navigateur produit, un jour nu, qui est déjà un
+ * horodatage ISO valide et se compare tel quel aux dates stockées.
+ */
+const isoDate = z
+    .string()
+    .trim()
+    .regex(/^\d{4}-\d{2}-\d{2}(T[\d:.]+Z?)?$/, "expected a date such as 2026-08-01")
+    .refine((value) => !Number.isNaN(Date.parse(value)), "not a real date");
+const staleSchema = z.object({ before: isoDate });
+/**
+ * Une suppression désigne ses boîtes, et rappelle à quel titre elles sont supprimables :
+ * `before`, elles n'ont plus d'activité depuis cette date ; `empty`, rien n'y est jamais
+ * passé. Les deux critères s'excluent — le serveur revérifie celui qu'on lui donne, il
+ * doit donc savoir lequel c'est.
+ */
+const purgeSchema = z
+    .object({
+    before: isoDate.optional(),
+    empty: z.literal(true).optional(),
+    /** Les adresses vues dans l'aperçu : on ne supprime jamais autre chose que ce qui a été montré. */
+    mailboxes: z.array(z.string().trim().min(1)).min(1).max(500),
+})
+    .refine((input) => (input.before === undefined) !== (input.empty === undefined), {
+    message: "provide either `before` (inactive since that date) or `empty: true`, not both",
+});
 const adminListSchema = z.object({
     search: z.string().trim().min(1).optional(),
     agent: z.string().trim().min(1).optional(),
@@ -157,7 +186,7 @@ export function createApp({ store, config }) {
     app.get("/", (_req, res) => {
         res.redirect("/ui/");
     });
-    // --- Supervision (lecture seule) -----------------------------------------
+    // --- Supervision (lecture, sauf les nettoyages de boîtes) ----------------
     // Montée avant la porte d'entrée : son contrôle est au moins aussi strict (session de
     // console ou jeton admin), et la session par cookie n'est reconnue nulle part ailleurs.
     const admin = express.Router();
@@ -197,6 +226,44 @@ export function createApp({ store, config }) {
             throw new MessengerError(`thread not found: ${threadId}`, 404);
         res.json({ thread_id: threadId, thread: store.getThreadInfo(threadId), messages });
     });
+    /**
+     * Boîtes sans activité depuis une date : ce que la purge emporterait.
+     *
+     * Toujours consultée avant de supprimer — la console montre la liste, et c'est sur cette
+     * liste que porte la suppression. Une purge ne se décide pas sur un compte.
+     */
+    admin.get("/mailboxes/stale", (req, res) => {
+        const { before } = staleSchema.parse(req.query);
+        res.json({ before, mailboxes: store.staleMailboxes(before) });
+    });
+    /**
+     * Boîtes par lesquelles rien n'est jamais passé. Sans date : une boîte vide l'est
+     * indépendamment de son âge, et un agent dont toutes les boîtes sont vides disparaît
+     * de l'annuaire du même coup, faute de boîte à regrouper.
+     */
+    admin.get("/mailboxes/empty", (_req, res) => {
+        res.json({ mailboxes: store.emptyMailboxes() });
+    });
+    /**
+     * La seule route de la console qui écrit, et elle détruit.
+     *
+     * Deux garde-fous, parce qu'un nettoyage ne se rattrape pas : le critère est redemandé
+     * avec les adresses, et le serveur refuse toute adresse qui n'y répond plus au moment
+     * où il l'examine. Une boîte redevenue vivante, ou qui vient de recevoir son premier
+     * message, est donc épargnée — et le refus est nominatif, il porte sur le lot entier.
+     */
+    admin.post("/mailboxes/purge", (req, res) => {
+        const input = purgeSchema.parse(req.body ?? {});
+        const reason = input.empty ? "empty" : `inactive since ${input.before}`;
+        const eligible = new Set((input.empty ? store.emptyMailboxes() : store.staleMailboxes(input.before)).map((mailbox) => mailbox.id));
+        const changed = input.mailboxes.filter((id) => !eligible.has(id));
+        if (changed.length > 0) {
+            throw new MessengerError(`these mailboxes are no longer ${reason}, nothing was deleted: ${changed.join(", ")}`, 409);
+        }
+        const removed = store.deleteMailboxes(input.mailboxes);
+        logger.warn(`admin purge: ${removed.mailboxes} mailbox(es) deleted, ${reason}`);
+        res.json({ before: input.before ?? null, empty: input.empty ?? false, ...removed });
+    });
     app.use("/admin", admin);
     // Porte d'entrée de tout le reste : aucune requête n'est servie sans jeton valide. Le
     // contrôle par route (identité de l'agent) vient ensuite.