@imenam/mcp-messenger 1.0.13 → 1.0.15

package/README.md

@@ -345,7 +345,18 @@ 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.
+
+  **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
+  boîte est vide tant que rien n'y est passé, ni envoi ni réception — le serveur en alloue
+  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
+  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
   nom, ses correspondants, son dernier message et sa priorité la plus haute. Trois puces
   la filtrent : tous, non lus, priorité haute ;

package/dist/src/server/ui/app.js

@@ -33,6 +33,8 @@ const state = {
   selection: { kind: "all", key: null },
   /** Noms d'agents dépliés dans la colonne de gauche. Tout est replié au départ. */
   expanded: new Set(),
+  /** Agents dont on a demandé à voir les boîtes vides. Elles sont cachées au départ. */
+  showEmpty: new Set(),
   /** "all" | "unread" | "high" — les puces au-dessus de la liste des fils. */
   filter: "all",
   search: "",
@@ -287,13 +289,74 @@ function groupByAgent(boxes) {
   for (const box of boxes) {
     const key = box.agent_name || box.id;
     if (!groups.has(key)) {
-      groups.set(key, { key, name: box.agent_name || boxLabel(box), boxes: [], unread: 0 });
+      groups.set(key, { key, name: box.agent_name || boxLabel(box), boxes: [], unread: 0, filled: 0, activity: "" });
     }
     const group = groups.get(key);
     group.boxes.push(box);
     group.unread += box.unread;
+    if (!isEmptyBox(box)) group.filled += 1;
+    // L'agent hérite de l'activité de sa session la plus vivante.
+    if (activityOf(box) > group.activity) group.activity = activityOf(box);
   }
-  return [...groups.values()];
+  const list = [...groups.values()];
+  for (const group of list) group.boxes.sort(byBox);
+  // Le classement est refait ici plutôt que laissé à l'ordre d'arrivée de l'annuaire :
+  // ce que la colonne promet ne doit pas dépendre du hasard d'un tri fait ailleurs. Un
+  // agent dont aucune session n'a rien échangé passe derrière les autres, comme ses boîtes.
+  list.sort(
+    (a, b) =>
+      compareEmpty(a.filled === 0, b.filled === 0) ||
+      compareActivity(a.activity, b.activity) ||
+      (a.key < b.key ? -1 : a.key > b.key ? 1 : 0)
+  );
+  return list;
+}
+
+/**
+ * Une boîte est vide tant que rien n'y est passé, ni envoi ni réception.
+ *
+ * Le serveur alloue une boîte à chaque session ouverte : beaucoup n'échangeront jamais
+ * rien et n'ont donc rien à dire à qui supervise. Une boîte vide n'a par construction
+ * aucun non-lu — `received` à zéro l'implique — la masquer ne cache donc jamais de
+ * courrier en attente.
+ */
+function isEmptyBox(box) {
+  return box.sent + box.received === 0;
+}
+
+/** Dernière activité d'une boîte, ou chaîne vide quand elle n'a jamais rien fait. */
+function activityOf(box) {
+  return box.last_activity_at || "";
+}
+
+/**
+ * Compare deux dates ISO, la plus récente d'abord.
+ *
+ * Les dates ISO se comparent comme du texte, et la chaîne vide — une boîte qui n'a jamais
+ * vécu — est plus petite que toute date : elle finit donc en queue, sans cas particulier.
+ */
+function compareActivity(left, right) {
+  if (left === right) return 0;
+  return left < right ? 1 : -1;
+}
+
+/** Le plein avant le vide. Premier critère du classement, avant même la date. */
+function compareEmpty(left, right) {
+  if (left === right) return 0;
+  return left ? 1 : -1;
+}
+
+/**
+ * Deux classements emboîtés : d'abord les boîtes qui ont servi, puis les vides ; dans
+ * chacun des deux, la plus récemment active en tête. À égalité, l'adresse départage, pour
+ * que l'ordre ne bouge pas d'un rafraîchissement à l'autre.
+ */
+function byBox(a, b) {
+  return (
+    compareEmpty(isEmptyBox(a), isEmptyBox(b)) ||
+    compareActivity(activityOf(a), activityOf(b)) ||
+    (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
+  );
 }
 
 function isSelected(kind, key) {
@@ -386,12 +449,17 @@ function groupRow(group) {
     )
   );
 
+  const empty = group.boxes.length - group.filled;
+  // Le décompte annonce ce que le dépli va montrer : sans quoi « 5 boîtes » suivi de deux
+  // lignes se lirait comme un bug plutôt que comme des boîtes vides mises de côté.
+  const counts = empty > 0 ? `${plural(group.filled, "boîte")} · ${plural(empty, "vide")}` : plural(group.filled, "boîte");
+
   const text = node("div", "agent-text");
   text.appendChild(node("div", "agent-name", group.name));
-  text.appendChild(node("div", "agent-box", plural(group.boxes.length, "boîte")));
+  text.appendChild(node("div", "agent-box", counts));
   row.appendChild(text);
   if (group.unread > 0) row.appendChild(node("span", "count count--accent", String(group.unread)));
-  row.title = `${group.name} · ${plural(group.boxes.length, "boîte")}`;
+  row.title = `${group.name} · ${counts}`;
   row.addEventListener("click", () => {
     state.expanded.add(group.key);
     select("agent", group.key);
@@ -401,15 +469,37 @@ function groupRow(group) {
 
   if (open) {
     const list = node("ul", "box-list");
-    for (const box of group.boxes) list.appendChild(boxRow(box));
+    // Les vides sont derrière dans `group.boxes` : les montrer, c'est allonger la liste,
+    // jamais en réordonner le début.
+    const revealed = state.showEmpty.has(group.key);
+    for (const box of group.boxes) {
+      if (isEmptyBox(box) && !revealed) continue;
+      list.appendChild(boxRow(box));
+    }
+    if (empty > 0) list.appendChild(emptyToggleRow(group, empty, revealed));
     item.appendChild(list);
   }
   return item;
 }
 
+/** Dernière ligne du dépli : ouvre ou referme les boîtes qui n'ont jamais rien échangé. */
+function emptyToggleRow(group, empty, revealed) {
+  const item = node("li");
+  const what = empty > 1 ? `les ${empty} boîtes vides` : "la boîte vide";
+  const toggle = button("box-empty-toggle", `${revealed ? "Masquer" : "Afficher"} ${what}`, () => {
+    if (revealed) state.showEmpty.delete(group.key);
+    else state.showEmpty.add(group.key);
+    renderAgents({ agents: [...state.directory.values()], threads: currentThreadCount() });
+  });
+  toggle.setAttribute("aria-expanded", revealed ? "true" : "false");
+  item.appendChild(toggle);
+  return item;
+}
+
 function boxRow(box) {
   const item = node("li");
   const classes = ["agent", "box"];
+  if (isEmptyBox(box)) classes.push("is-empty");
   if (isSelected("box", box.id)) classes.push("is-selected");
   if (box.unread > 0) classes.push("has-unread");
   if (!box.registered) classes.push("agent--muted");
@@ -425,17 +515,20 @@ function boxRow(box) {
   const name = node("div", "agent-name", label);
   if (!box.display_name) name.classList.add("mono", "is-absent");
   text.appendChild(name);
-  text.appendChild(
-    node(
-      "div",
-      "agent-box",
-      box.registered ? `${plural(box.sent, "envoyé")} · ${plural(box.received, "reçu")}` : "jamais connectée"
-    )
-  );
+  // Les sessions d'un agent sont classées sur cette date : sans elle, leur ordre
+  // paraîtrait arbitraire. Les compteurs passent dans l'info-bulle, faute de place.
+  const activity = box.last_activity_at
+    ? `activité ${formatShort(box.last_activity_at)}`
+    : box.registered
+      ? "aucune activité"
+      : "jamais connectée";
+  const meta = node("div", "agent-box", activity);
+  if (!box.last_activity_at) meta.classList.add("is-absent");
+  text.appendChild(meta);
   row.appendChild(text);
 
   if (box.unread > 0) row.appendChild(node("span", "count count--accent", String(box.unread)));
-  row.title = box.id;
+  row.title = `${box.id}\n${plural(box.sent, "envoyé")} · ${plural(box.received, "reçu")}`;
   row.addEventListener("click", () => select("box", box.id));
   item.appendChild(row);
   return item;
@@ -862,6 +955,7 @@ el.logout.addEventListener("click", async () => {
   await fetch("/ui/logout", { method: "POST", credentials: "same-origin" }).catch(() => null);
   state.selection = { kind: "all", key: null };
   state.expanded = new Set();
+  state.showEmpty = new Set();
   state.threadId = null;
   state.messageId = null;
   state.directory = new Map();

package/dist/src/server/ui/styles.css

@@ -577,6 +577,42 @@ body {
   font-size: 11px;
 }
 
+/* Les boîtes vides sont repliées derrière ce bouton : le lien ferme la liste plutôt que
+   d'aligner des sessions qui n'ont jamais rien échangé. */
+.box-empty-toggle {
+  display: block;
+  width: 100%;
+  padding: 6px 10px;
+  border: 0;
+  border-radius: var(--radius);
+  background: none;
+  font: inherit;
+  font-size: 12px;
+  color: var(--muted);
+  text-align: left;
+  cursor: pointer;
+}
+
+.box-empty-toggle:hover {
+  background: var(--border-soft);
+  color: var(--accent);
+}
+
+.box-empty-toggle:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: -2px;
+}
+
+/* Une boîte vide reste lisible mais s'efface : elle est là pour être retrouvée, pas lue. */
+.box.is-empty .agent-name {
+  color: var(--muted);
+  font-weight: 400;
+}
+
+.box.is-empty .avatar {
+  opacity: 0.5;
+}
+
 .agents-foot {
   padding: 16px 20px;
   font-size: 12px;

package/dist/src/version.d.ts

@@ -1 +1 @@
-export declare const APP_VERSION = "1.0.13";
+export declare const APP_VERSION = "1.0.15";

package/dist/src/version.js

@@ -1,2 +1,2 @@
 // Généré par scripts/generate-version.js — ne pas modifier à la main.
-export const APP_VERSION = "1.0.13";
+export const APP_VERSION = "1.0.15";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imenam/mcp-messenger",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "main": "dist/src/index.js",
   "scripts": {
     "test": "npm run build && vitest run",