@imenam/mcp-messenger 1.0.4 → 1.0.6

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

@@ -15,6 +15,15 @@ export interface Agent {
     /** false pour un agent créé implicitement parce qu'un message lui a été adressé. */
     registered: boolean;
 }
+/**
+ * Entrée d'annuaire : la fiche de l'agent, plus le moment où sa boîte a vécu pour la
+ * dernière fois. C'est ce moment qui classe l'annuaire, pas l'identifiant : une adresse
+ * opaque ne dit rien à qui lit la console.
+ */
+export interface AgentDirectoryEntry extends Agent {
+    /** Plus récent de la dernière connexion et de la dernière livraison ; null si aucune. */
+    last_activity_at: string | null;
+}
 export interface SendMessageInput {
     from: string;
     to: string[];
@@ -24,10 +33,39 @@ export interface SendMessageInput {
     priority?: Priority;
     /** Id d'un message existant : la réponse hérite de son fil de discussion. */
     reply_to?: string | null;
+    /** Nom lisible donné au fil. Sur une réponse, renomme le fil existant. */
+    thread_title?: string | null;
+    thread_description?: string | null;
+}
+/**
+ * Intitulé d'un fil de discussion.
+ *
+ * Le titre est unique et partagé : tous les participants parlent du même sujet, ils
+ * doivent donc lire le même nom. Le dernier qui renomme a le dernier mot ; `named_by`
+ * garde la trace de qui c'était.
+ */
+export interface ThreadInfo {
+    thread_id: string;
+    title: string | null;
+    description: string | null;
+    /** Agent ayant posé le nom courant, ou null tant que le fil n'a pas été nommé. */
+    named_by: string | null;
+    created_at: string;
+    updated_at: string | null;
+}
+export interface ThreadSummary extends ThreadInfo {
+    /** Sujet du message d'ouverture : intitulé de repli tant que le fil n'est pas nommé. */
+    subject: string;
+    messages: number;
+    unread: number;
+    participants: string[];
+    last_message_at: string;
 }
 export interface SendMessageResult {
     message_id: string;
     thread_id: string;
+    /** Titre du fil après envoi, null s'il n'a jamais été nommé. */
+    thread_title: string | null;
     created_at: string;
     delivered_to: string[];
     /** Destinataires jamais enregistrés sur ce serveur — le message les attend malgré tout. */
@@ -36,6 +74,8 @@ export interface SendMessageResult {
 export interface MessageSummary {
     message_id: string;
     thread_id: string;
+    /** Titre du fil, null tant que personne ne l'a nommé — le `subject` fait alors office. */
+    thread_title: string | null;
     from: string;
     to: string[];
     cc: string[];
@@ -58,6 +98,14 @@ export interface FolderInfo {
     total: number;
     unread: number;
 }
+export interface ListThreadsOptions {
+    /** Ne garder que les fils ayant au moins un message non lu. */
+    unread_only?: boolean;
+    /** Texte libre confronté au titre, à la description et au sujet d'ouverture. */
+    search?: string;
+    limit?: number;
+    offset?: number;
+}
 export interface ListMessagesOptions {
     folder?: string;
     unread_only?: boolean;

package/dist/src/index.js

@@ -43,7 +43,7 @@ async function main() {
             "Ce jeton doit être identique aux trois endroits suivants :",
             "  1. le serveur       : MESSENGER_TOKEN",
             "  2. chaque agent     : MESSENGER_TOKEN dans son .mcp.json",
-            "  3. la console web   : http://127.0.0.1:3600/ui/?token=<jeton>",
+            "  3. la console web   : http://127.0.0.1:3600/ui/ (à saisir dans le formulaire)",
             "",
         ].join("\n"));
         return;

package/dist/src/mcp/tools.js

@@ -25,21 +25,37 @@ export const TOOLS = [
         },
     },
     {
-        name: "set_mailbox_label",
-        description: "Give this mailbox a human-readable label and description, so the user can recognise it in the directory and in the web console. Addresses are opaque: a label is what makes a mailbox findable later.",
+        name: "set_label",
+        description: "Give a plain-language name to this mailbox, or to a thread. Ids are opaque: a name is what makes a mailbox or a conversation recognisable later, both for the other agents and for the user reading the web console. Without thread_id it names this mailbox ('Développement des tests unitaires du parser'); with thread_id it names that thread ('Le test échoue sur un bug applicatif'). A thread has a single shared name: renaming it changes it for every participant, and the last caller wins.",
         inputSchema: {
             type: "object",
             properties: {
-                label: { type: "string", description: "Short name, e.g. 'Refactor du parser'." },
-                description: { type: "string", description: "What this session is working on." },
+                label: { type: "string", description: "Short name, one line. Say what the work is about, not who does it." },
+                description: { type: "string", description: "Optional longer explanation of the mailbox or the thread." },
+                thread_id: {
+                    type: "string",
+                    description: "Thread to name. Omit to name this mailbox instead. You must be a participant of the thread.",
+                },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "list_threads",
+        description: "List the conversations visible from this mailbox, most recently active first, with their name, participants and unread count. This is the readable map of the ongoing work: prefer it over list_messages when you want to know what is being discussed rather than what arrived last. A thread with no name falls back to the subject of its opening message — name it with set_label.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                unread_only: { type: "boolean", description: "Keep only threads with unread messages." },
+                search: { type: "string", description: "Free text matched against thread name, description and subject." },
+                limit: { type: "number", description: "1-100, defaults to 25." },
             },
-            required: ["label"],
             additionalProperties: false,
         },
     },
     {
         name: "list_agents",
-        description: "List the agents known to the mailbox server, with their description and last activity. Use it to find the address of the agent you want to write to.",
+        description: "List the agents known to the mailbox server, most recently active first, with their name and description. Use it to find the address of the agent you want to write to.",
         inputSchema: { type: "object", properties: {}, additionalProperties: false },
     },
     {
@@ -59,6 +75,11 @@ export const TOOLS = [
                 body: { type: "string", description: "Message body, plain text or markdown." },
                 priority: { type: "string", enum: [...PRIORITIES], description: "Defaults to normal." },
                 reply_to: { type: "string", description: "Id of the message being answered; the reply joins its thread." },
+                thread_title: {
+                    type: "string",
+                    description: "Plain-language name of the conversation, e.g. 'Résolution de l'échec du test de parsing'. Name the thread when you open it — you already know what it is about. On a reply it renames the thread for everyone, which is what you want when the discussion has drifted.",
+                },
+                thread_description: { type: "string", description: "Optional longer description of the thread." },
             },
             required: ["to", "subject", "body"],
             additionalProperties: false,
@@ -195,6 +216,8 @@ const schemas = {
         body: z.string().min(1),
         priority: z.enum(PRIORITIES).optional(),
         reply_to: z.string().optional(),
+        thread_title: z.string().trim().min(1).max(200).optional(),
+        thread_description: z.string().trim().min(1).max(2000).optional(),
     }),
     list_messages: z.object({
         folder: z.string().optional(),
@@ -215,7 +238,20 @@ const schemas = {
     move_messages: z.object({ message_ids: z.array(z.string().min(1)).min(1), folder: z.string().min(1) }),
     delete_messages: z.object({ message_ids: z.array(z.string().min(1)).min(1), permanent: z.boolean().optional() }),
     attach_to_mailbox: z.object({ mailbox_id: z.string().trim().min(1).optional() }),
-    set_mailbox_label: z.object({ label: z.string().trim().min(1).max(200), description: z.string().max(2000).optional() }),
+    set_label: z
+        .object({
+        label: z.string().trim().min(1).max(200).optional(),
+        description: z.string().trim().min(1).max(2000).optional(),
+        thread_id: z.string().trim().min(1).optional(),
+    })
+        .refine((v) => v.label !== undefined || v.description !== undefined, {
+        message: "provide `label` and/or `description`",
+    }),
+    list_threads: z.object({
+        unread_only: z.boolean().optional(),
+        search: z.string().trim().min(1).optional(),
+        limit: z.number().int().optional(),
+    }),
     create_folder: z.object({ name: z.string().min(1) }),
     delete_folder: z.object({ name: z.string().min(1) }),
     wait_for_message: z.object({ timeout_seconds: z.number().int().optional(), folder: z.string().optional() }),
@@ -233,9 +269,13 @@ export async function callTool(client, name, rawArgs) {
             const stats = await client.stats();
             const health = await client.health().catch(() => null);
             const folders = stats.folders.map((f) => `  ${f.name.padEnd(12)} ${f.total} message(s), ${f.unread} unread`);
+            const self = await client.getAgent(client.agentId).catch(() => null);
             const lines = [
                 `Mailbox address: ${client.agentId}`,
                 "  ↳ give this address to another agent so it can write to you.",
+                self?.display_name
+                    ? `Mailbox name: ${self.display_name}`
+                    : "Mailbox name: none — call set_label so the user can tell this session apart from the others.",
             ];
             if (client.isAttachedElsewhere) {
                 lines.push(`Attached to another mailbox. This session's own mailbox is ${client.sessionAgentId}.`);
@@ -273,10 +313,36 @@ export async function callTool(client, name, rawArgs) {
                 .filter(Boolean)
                 .join("\n");
         }
-        case "set_mailbox_label": {
-            const input = schemas.set_mailbox_label.parse(args);
-            const agent = await client.updateProfile({ display_name: input.label, description: input.description ?? null });
-            return `Mailbox ${agent.id} labelled "${agent.display_name}".`;
+        // `set_mailbox_label` n'est plus publié, mais reste accepté : une session en cours
+        // peut l'avoir appris avant la mise à jour du serveur.
+        case "set_mailbox_label":
+        case "set_label": {
+            const input = schemas.set_label.parse(args);
+            if (input.thread_id) {
+                const thread = await client.setThreadLabel(input.thread_id, {
+                    title: input.label ?? null,
+                    description: input.description ?? null,
+                });
+                return [
+                    `Thread ${thread.thread_id} is now named "${thread.title}".`,
+                    thread.description ? `Description: ${thread.description}` : null,
+                    "Every participant of the thread sees this name.",
+                ]
+                    .filter(Boolean)
+                    .join("\n");
+            }
+            const agent = await client.updateProfile({
+                display_name: input.label ?? null,
+                description: input.description ?? null,
+            });
+            return `Mailbox ${agent.id} named "${agent.display_name}".`;
+        }
+        case "list_threads": {
+            const input = schemas.list_threads.parse(args);
+            const threads = await client.listThreads(input);
+            if (threads.length === 0)
+                return "No thread in this mailbox matching these filters.";
+            return [`${threads.length} thread(s):`, "", ...threads.map(formatThread)].join("\n");
         }
         case "list_agents": {
             const agents = await client.listAgents();
@@ -288,7 +354,8 @@ export async function callTool(client, name, rawArgs) {
                     .filter(Boolean)
                     .join(", ");
                 const title = agent.display_name ? `${agent.id} — ${agent.display_name}` : agent.id;
-                const seen = agent.last_seen_at ? `last seen ${agent.last_seen_at}` : "never seen";
+                // L'annuaire est classé par cette date : l'afficher rend l'ordre lisible.
+                const seen = agent.last_activity_at ? `last active ${agent.last_activity_at}` : "never active";
                 return [`• ${title}${flags ? ` (${flags})` : ""}`, `  ${agent.description ?? "no description"}`, `  ${seen}`].join("\n");
             })
                 .join("\n");
@@ -302,12 +369,17 @@ export async function callTool(client, name, rawArgs) {
                 body: input.body,
                 priority: input.priority,
                 reply_to: input.reply_to ?? null,
+                thread_title: input.thread_title ?? null,
+                thread_description: input.thread_description ?? null,
             });
             const lines = [
                 `Message sent: ${result.message_id}`,
-                `Thread: ${result.thread_id}`,
+                `Thread: ${formatThreadRef(result.thread_title, result.thread_id)}`,
                 `Delivered to: ${result.delivered_to.join(", ")}`,
             ];
+            if (!result.thread_title && !input.reply_to) {
+                lines.push("This thread has no name yet — set_label with its thread_id makes it readable for everyone.");
+            }
             if (result.unknown_recipients.length > 0) {
                 lines.push(`Warning — never connected to this server, the message will wait in their mailbox: ${result.unknown_recipients.join(", ")}`);
             }
@@ -328,8 +400,14 @@ export async function callTool(client, name, rawArgs) {
         }
         case "get_thread": {
             const input = schemas.get_thread.parse(args);
-            const messages = await client.getThread(input.thread_id);
-            return [`Thread ${input.thread_id} — ${messages.length} message(s):`, "", ...messages.map(formatMessage)].join("\n\n---\n\n");
+            const { thread, messages } = await client.getThread(input.thread_id);
+            const header = [
+                `Thread ${formatThreadRef(thread?.title ?? null, input.thread_id)} — ${messages.length} message(s):`,
+                thread?.description ? `Description: ${thread.description}` : null,
+            ]
+                .filter(Boolean)
+                .join("\n");
+            return [header, "", ...messages.map(formatMessage)].join("\n\n---\n\n");
         }
         case "mark_messages": {
             const input = schemas.mark_messages.parse(args);
@@ -424,6 +502,22 @@ function asArray(value) {
         return [];
     return Array.isArray(value) ? value : [value];
 }
+/** `titre (id)`, ou l'id seul tant que le fil n'a pas été nommé. */
+function formatThreadRef(title, threadId) {
+    return title ? `${title} (${threadId})` : threadId;
+}
+function formatThread(thread) {
+    // Sans nom, le sujet d'ouverture reste le seul repère : mieux vaut l'afficher que l'id nu.
+    const name = thread.title ?? `${thread.subject} (unnamed)`;
+    return [
+        `${thread.unread > 0 ? "•" : " "} ${name}`,
+        thread.description ? `   ${thread.description}` : null,
+        `   ${thread.messages} message(s), ${thread.unread} unread · with ${thread.participants.join(", ")}`,
+        `   last activity ${thread.last_message_at} · thread ${thread.thread_id}`,
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
 function formatSummary(message) {
     const flags = [message.read ? " " : "•", message.starred ? "★" : " "].join("");
     const priority = message.priority === "normal" ? "" : ` [${message.priority}]`;
@@ -431,7 +525,7 @@ function formatSummary(message) {
         `${flags} ${message.subject}${priority}`,
         `   from ${message.from} to ${message.to.join(", ") || "—"}${message.cc.length ? ` (cc ${message.cc.join(", ")})` : ""} · ${message.created_at}`,
         `   ${message.preview}`,
-        `   id ${message.message_id} · thread ${message.thread_id}`,
+        `   id ${message.message_id} · thread ${formatThreadRef(message.thread_title, message.thread_id)}`,
     ].join("\n");
 }
 function formatMessage(message) {
@@ -443,7 +537,7 @@ function formatMessage(message) {
         `Date: ${message.created_at}`,
         `Priority: ${message.priority}`,
         `Folder: ${message.folder}${message.read ? "" : " (unread)"}${message.starred ? " ★" : ""}`,
-        `Id: ${message.message_id} · Thread: ${message.thread_id}${message.in_reply_to ? ` · reply to ${message.in_reply_to}` : ""}`,
+        `Id: ${message.message_id} · Thread: ${formatThreadRef(message.thread_title, message.thread_id)}${message.in_reply_to ? ` · reply to ${message.in_reply_to}` : ""}`,
     ]
         .filter(Boolean)
         .join("\n");

package/dist/src/server/app.js

@@ -1,5 +1,4 @@
 import express from "express";
-import fs from "node:fs";
 import helmet from "helmet";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -9,6 +8,7 @@ import { z } from "zod";
 import { MessengerError, normalizeAgentId } from "../core/store.js";
 import { PRIORITIES } from "../core/types.js";
 import { WatcherRegistry } from "./watchers.js";
+import { CONSOLE_COOKIE, ConsoleSessions, consoleSessionId } from "./console-session.js";
 import { APP_VERSION } from "../version.js";
 import { logger } from "../logger.js";
 const UI_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "ui");
@@ -27,6 +27,22 @@ const sendSchema = z.object({
     body: z.string().min(1).max(200_000),
     priority: z.enum(PRIORITIES).optional(),
     reply_to: z.string().trim().min(1).nullish(),
+    thread_title: z.string().trim().min(1).max(200).nullish(),
+    thread_description: z.string().trim().min(1).max(2000).nullish(),
+});
+const threadLabelSchema = z
+    .object({
+    title: z.string().trim().min(1).max(200).nullish(),
+    description: z.string().trim().min(1).max(2000).nullish(),
+})
+    .refine((v) => v.title != null || v.description != null, {
+    message: "provide `title` and/or `description`",
+});
+const listThreadsQuerySchema = z.object({
+    unread_only: z.coerce.boolean().optional(),
+    search: z.string().trim().min(1).optional(),
+    limit: z.coerce.number().int().min(1).max(100).optional(),
+    offset: z.coerce.number().int().min(0).optional(),
 });
 const listQuerySchema = z.object({
     folder: z.string().trim().min(1).optional(),
@@ -56,6 +72,7 @@ const waitQuerySchema = z.object({
     // attente longue, mais seul le premier prouve que l'agent est joignable en continu.
     watcher: z.enum(["true", "1"]).optional(),
 });
+const loginSchema = z.object({ token: z.string().min(1).max(1024) });
 const adminListSchema = z.object({
     search: z.string().trim().min(1).optional(),
     agent: z.string().trim().min(1).optional(),
@@ -90,8 +107,65 @@ export function createApp({ store, config }) {
         standardHeaders: "draft-8",
         legacyHeaders: false,
     }));
-    // Porte d'entrée unique : aucune requête, quelle qu'elle soit, n'est servie sans
-    // jeton valide. Les contrôles par route (identité de l'agent, console) viennent ensuite.
+    // --- Console web ----------------------------------------------------------
+    // La page et ses fichiers ne contiennent aucun secret : ils sont servis à tous. Ce sont
+    // les données (`/admin`) qui sont protégées, par une session ouverte contre le jeton
+    // admin. Voir `console-session.ts` pour le raisonnement.
+    const sessions = new ConsoleSessions();
+    const cookieOptions = (req) => ({
+        httpOnly: true,
+        sameSite: "strict",
+        // `req.secure` n'est vrai derrière un proxy TLS que si `trust proxy` est configuré.
+        secure: req.secure,
+        path: "/",
+    });
+    // Limite propre au formulaire : le jeton fait 256 bits, mais autant fermer la porte.
+    const loginLimiter = rateLimit({ windowMs: 15 * 60_000, limit: 10, standardHeaders: "draft-8", legacyHeaders: false });
+    app.post("/ui/login", loginLimiter, (req, res) => {
+        const input = loginSchema.parse(req.body ?? {});
+        if (!safeEqual(input.token, config.adminToken)) {
+            res.status(401).json({ error: "invalid admin token" });
+            return;
+        }
+        res.cookie(CONSOLE_COOKIE, sessions.create(), { ...cookieOptions(req), maxAge: sessions.ttlMs });
+        res.status(204).end();
+    });
+    app.post("/ui/logout", (req, res) => {
+        sessions.revoke(consoleSessionId(req));
+        res.clearCookie(CONSOLE_COOKIE, cookieOptions(req));
+        res.status(204).end();
+    });
+    // `maxAge: 0` + ETag : la console reflète immédiatement une mise à jour du paquet,
+    // sans laisser un navigateur servir l'ancienne version depuis son cache.
+    app.use("/ui", express.static(UI_DIR, { index: "index.html", maxAge: 0, etag: true }));
+    app.get("/", (_req, res) => {
+        res.redirect("/ui/");
+    });
+    // --- Supervision (lecture seule) -----------------------------------------
+    // 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();
+    admin.use(authenticateAdmin(config, sessions));
+    admin.get("/overview", (_req, res) => {
+        res.json(store.overview());
+    });
+    admin.get("/messages", (req, res) => {
+        const query = adminListSchema.parse(req.query);
+        res.json({ messages: store.listAllMessages(query) });
+    });
+    admin.get("/messages/:id", (req, res) => {
+        res.json(store.getMessageAdmin(String(req.params.id)));
+    });
+    admin.get("/threads/:id", (req, res) => {
+        const threadId = String(req.params.id);
+        const messages = store.listAllMessages({ thread_id: threadId, limit: 100 });
+        if (messages.length === 0)
+            throw new MessengerError(`thread not found: ${threadId}`, 404);
+        res.json({ thread_id: threadId, thread: store.getThreadInfo(threadId), messages: messages.slice().reverse() });
+    });
+    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.
     app.use(requireAnyToken(config));
     // --- État du service ------------------------------------------------------
     app.get("/health", (_req, res) => {
@@ -154,6 +228,8 @@ export function createApp({ store, config }) {
             body: input.body,
             priority: input.priority,
             reply_to: input.reply_to ?? null,
+            thread_title: input.thread_title ?? null,
+            thread_description: input.thread_description ?? null,
         });
         logger.info(`message ${result.message_id}: ${req.agentId} -> ${result.delivered_to.join(", ")}`);
         res.status(201).json(result);
@@ -179,8 +255,18 @@ export function createApp({ store, config }) {
         const markRead = req.query.mark_read !== "false";
         res.json(store.getMessage(req.agentId, String(req.params.id), markRead));
     });
+    api.get("/threads", (req, res) => {
+        const query = listThreadsQuerySchema.parse(req.query);
+        res.json({ threads: store.listThreads(req.agentId, query) });
+    });
     api.get("/threads/:id", (req, res) => {
-        res.json({ thread_id: req.params.id, messages: store.getThread(req.agentId, String(req.params.id)) });
+        const threadId = String(req.params.id);
+        const messages = store.getThread(req.agentId, threadId);
+        res.json({ thread_id: threadId, thread: store.getThreadInfo(threadId), messages });
+    });
+    api.patch("/threads/:id", (req, res) => {
+        const input = threadLabelSchema.parse(req.body ?? {});
+        res.json({ thread: store.setThreadLabel(req.agentId, String(req.params.id), input) });
     });
     api.get("/folders", (req, res) => {
         res.json({ folders: store.listFolders(req.agentId) });
@@ -232,52 +318,6 @@ export function createApp({ store, config }) {
         req.once("close", onClose);
     });
     app.use("/api", api);
-    // --- Supervision (lecture seule) -----------------------------------------
-    const admin = express.Router();
-    admin.use(authenticateAdmin(config));
-    admin.get("/overview", (_req, res) => {
-        res.json(store.overview());
-    });
-    admin.get("/messages", (req, res) => {
-        const query = adminListSchema.parse(req.query);
-        res.json({ messages: store.listAllMessages(query) });
-    });
-    admin.get("/messages/:id", (req, res) => {
-        res.json(store.getMessageAdmin(String(req.params.id)));
-    });
-    admin.get("/threads/:id", (req, res) => {
-        const messages = store.listAllMessages({ thread_id: String(req.params.id), limit: 100 });
-        if (messages.length === 0)
-            throw new MessengerError(`thread not found: ${req.params.id}`, 404);
-        res.json({ thread_id: req.params.id, messages: messages.slice().reverse() });
-    });
-    app.use("/admin", admin);
-    // --- Interface web --------------------------------------------------------
-    // Un navigateur ne peut pas poser d'en-tête sur une navigation : la console s'ouvre
-    // donc avec `?token=`. La page est servie avec ce jeton propagé sur ses ressources,
-    // sans quoi le CSS et le script seraient refusés par la porte d'entrée.
-    app.get(["/ui", "/ui/", "/ui/index.html"], (req, res, next) => {
-        const token = presentedToken(req);
-        if (!token) {
-            next();
-            return;
-        }
-        fs.readFile(path.join(UI_DIR, "index.html"), "utf-8", (error, html) => {
-            if (error) {
-                next(error);
-                return;
-            }
-            const suffix = `?token=${encodeURIComponent(token)}`;
-            res.type("html").send(html.replaceAll("./styles.css", `./styles.css${suffix}`).replaceAll("./app.js", `./app.js${suffix}`));
-        });
-    });
-    // `maxAge: 0` + ETag : la console reflète immédiatement une mise à jour du paquet,
-    // sans laisser un navigateur servir l'ancienne version depuis son cache.
-    app.use("/ui", express.static(UI_DIR, { index: false, maxAge: 0, etag: true }));
-    app.get("/", (req, res) => {
-        const token = presentedToken(req);
-        res.redirect(token ? `/ui/?token=${encodeURIComponent(token)}` : "/ui/");
-    });
     // --- Erreurs --------------------------------------------------------------
     app.use((_req, res) => {
         res.status(404).json({ error: "not found" });
@@ -350,8 +390,13 @@ function authenticateAgent(config) {
         next();
     };
 }
-function authenticateAdmin(config) {
+/** Session de console (navigateur) ou jeton admin (script, `curl`). */
+function authenticateAdmin(config, sessions) {
     return (req, res, next) => {
+        if (sessions.has(consoleSessionId(req))) {
+            next();
+            return;
+        }
         const presented = presentedToken(req);
         if (!presented || !safeEqual(presented, config.adminToken)) {
             res.status(401).json({ error: "invalid or missing admin token" });
@@ -361,19 +406,15 @@ function authenticateAdmin(config) {
     };
 }
 /**
- * Jeton présenté par l'appelant, dans l'ordre de préférence : en-tête `Authorization`,
- * en-tête `X-Messenger-Token`, puis paramètre `?token=` — ce dernier existe pour la
- * navigation navigateur vers la console, qui ne peut pas poser d'en-tête.
+ * Jeton présenté par l'appelant : en-tête `Authorization`, sinon `X-Messenger-Token`.
+ * Jamais l'URL : un jeton en query string finit dans les journaux d'accès du proxy.
  */
 function presentedToken(req) {
     const header = req.header("authorization");
     if (header?.toLowerCase().startsWith("bearer "))
         return header.slice(7).trim() || null;
     const alt = req.header("x-messenger-token");
-    if (alt?.trim())
-        return alt.trim();
-    const query = req.query.token;
-    return typeof query === "string" && query.trim() ? query.trim() : null;
+    return alt?.trim() ? alt.trim() : null;
 }
 /** Comparaison à temps constant : évite de laisser fuiter le jeton octet par octet. */
 function safeEqual(a, b) {

package/dist/src/server/console-session.d.ts

@@ -0,0 +1,30 @@
+import type { Request } from "express";
+/**
+ * Sessions de la console web.
+ *
+ * Le navigateur ne peut pas poser d'en-tête sur une navigation, et faire transiter le
+ * jeton dans l'URL le dépose dans l'historique et les journaux d'accès du proxy. La
+ * console s'ouvre donc sans jeton, le demande une fois dans un formulaire, et reçoit en
+ * retour un identifiant de session opaque dans un cookie `HttpOnly`.
+ *
+ * Le cookie ne porte jamais le jeton lui-même : sa fuite ne donne qu'une session, à durée
+ * limitée, que le serveur oublie au redémarrage. Il n'est honoré que sur `/admin` et
+ * `/ui` : l'API des agents reste sur le Bearer, un site tiers ne peut donc pas faire
+ * agir un agent à travers le navigateur de l'administrateur.
+ */
+export declare const CONSOLE_COOKIE = "messenger_console";
+export declare class ConsoleSessions {
+    readonly ttlMs: number;
+    private readonly now;
+    private readonly sessions;
+    constructor(ttlMs?: number, now?: () => number);
+    /** Ouvre une session et rend son identifiant, seul contenu du cookie. */
+    create(): string;
+    /** Vrai si l'identifiant désigne une session encore valide. */
+    has(id: string | null): boolean;
+    revoke(id: string | null): void;
+    get size(): number;
+    private prune;
+}
+/** Identifiant de session porté par la requête, s'il y en a un. */
+export declare function consoleSessionId(req: Request): string | null;

package/dist/src/server/console-session.js

@@ -0,0 +1,85 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+/**
+ * Sessions de la console web.
+ *
+ * Le navigateur ne peut pas poser d'en-tête sur une navigation, et faire transiter le
+ * jeton dans l'URL le dépose dans l'historique et les journaux d'accès du proxy. La
+ * console s'ouvre donc sans jeton, le demande une fois dans un formulaire, et reçoit en
+ * retour un identifiant de session opaque dans un cookie `HttpOnly`.
+ *
+ * Le cookie ne porte jamais le jeton lui-même : sa fuite ne donne qu'une session, à durée
+ * limitée, que le serveur oublie au redémarrage. Il n'est honoré que sur `/admin` et
+ * `/ui` : l'API des agents reste sur le Bearer, un site tiers ne peut donc pas faire
+ * agir un agent à travers le navigateur de l'administrateur.
+ */
+export const CONSOLE_COOKIE = "messenger_console";
+/** Durée de vie d'une session : assez pour une journée de supervision, pas plus. */
+const SESSION_TTL_MS = 12 * 60 * 60 * 1000;
+export class ConsoleSessions {
+    ttlMs;
+    now;
+    sessions = new Map();
+    constructor(ttlMs = SESSION_TTL_MS, now = Date.now) {
+        this.ttlMs = ttlMs;
+        this.now = now;
+    }
+    /** Ouvre une session et rend son identifiant, seul contenu du cookie. */
+    create() {
+        this.prune();
+        const id = randomBytes(32).toString("base64url");
+        this.sessions.set(id, { expiresAt: this.now() + this.ttlMs });
+        return id;
+    }
+    /** Vrai si l'identifiant désigne une session encore valide. */
+    has(id) {
+        if (!id)
+            return false;
+        // Parcours à temps constant : la Map compare ses clés en temps variable, ce qui
+        // laisserait deviner un identifiant octet par octet.
+        let match = null;
+        const presented = Buffer.from(id);
+        for (const [key, session] of this.sessions) {
+            const candidate = Buffer.from(key);
+            if (candidate.length === presented.length && timingSafeEqual(candidate, presented))
+                match = session;
+        }
+        if (!match)
+            return false;
+        if (match.expiresAt <= this.now()) {
+            this.sessions.delete(id);
+            return false;
+        }
+        return true;
+    }
+    revoke(id) {
+        if (id)
+            this.sessions.delete(id);
+    }
+    get size() {
+        this.prune();
+        return this.sessions.size;
+    }
+    prune() {
+        const now = this.now();
+        for (const [id, session] of this.sessions) {
+            if (session.expiresAt <= now)
+                this.sessions.delete(id);
+        }
+    }
+}
+/** Identifiant de session porté par la requête, s'il y en a un. */
+export function consoleSessionId(req) {
+    const header = req.headers.cookie;
+    if (!header)
+        return null;
+    for (const part of header.split(";")) {
+        const separator = part.indexOf("=");
+        if (separator < 0)
+            continue;
+        if (part.slice(0, separator).trim() !== CONSOLE_COOKIE)
+            continue;
+        const value = part.slice(separator + 1).trim();
+        return value ? decodeURIComponent(value) : null;
+    }
+    return null;
+}