@imenam/mcp-messenger 1.0.29 → 1.0.31

package/dist/src/server/app.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from "node:url";
 import { timingSafeEqual } from "node:crypto";
 import { rateLimit } from "express-rate-limit";
 import { z } from "zod";
+import { MAX_ATTACHMENTS, MAX_ATTACHMENTS_TOTAL_BYTES, contentDisposition } from "../core/attachments.js";
 import { MessengerError, normalizeAgentId } from "../core/store.js";
 import { PRIORITIES } from "../core/types.js";
 import { WatcherRegistry } from "./watchers.js";
@@ -12,6 +13,9 @@ import { CONSOLE_COOKIE, ConsoleSessions, consoleSessionId } from "./console-ses
 import { APP_VERSION } from "../version.js";
 import { logger } from "../logger.js";
 const UI_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "ui");
+const JSON_TYPES = ["application/json", "application/*+json"];
+/** Corps d'un envoi : le texte, plus les pièces jointes encodées en base64 (4 octets pour 3). */
+const SEND_BODY_LIMIT = Math.ceil((MAX_ATTACHMENTS_TOTAL_BYTES * 4) / 3) + 1024 * 1024;
 const agentIdSchema = z.string().trim().min(1).max(128);
 const idListSchema = z.array(z.string().trim().min(1)).min(1).max(200);
 /** Nom et description de la boîte : ce que l'agent pose lui-même sur sa session. */
@@ -34,6 +38,14 @@ const sendSchema = z.object({
     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(),
+    attachments: z
+        .array(z.object({
+        filename: z.string().trim().min(1).max(255),
+        mime_type: z.string().trim().max(255).nullish(),
+        content_base64: z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/, "expected base64 content"),
+    }))
+        .max(MAX_ATTACHMENTS)
+        .optional(),
 });
 const threadLabelSchema = z
     .object({
@@ -121,6 +133,10 @@ const purgeSchema = z
     .refine((input) => [input.before, input.created_before, input.empty].filter((value) => value !== undefined).length === 1, {
     message: "provide exactly one of `before` (inactive since that date), `created_before` (created before that date) or `empty: true`",
 });
+const linkSchema = z.object({
+    mailboxes: z.tuple([agentIdSchema, agentIdSchema]),
+    note: z.string().trim().max(500).nullish(),
+});
 const adminListSchema = z.object({
     search: z.string().trim().min(1).optional(),
     agent: z.string().trim().min(1).optional(),
@@ -151,7 +167,10 @@ export function createApp({ store, config }) {
         },
         crossOriginEmbedderPolicy: false,
     }));
-    app.use(express.json({ type: ["application/json", "application/*+json"], limit: "2mb" }));
+    // L'envoi d'un message a sa propre limite, plus large pour ses pièces jointes, et ne
+    // s'applique qu'une fois l'agent authentifié.
+    const jsonBody = express.json({ type: JSON_TYPES, limit: "2mb" });
+    app.use((req, res, next) => (isSendRequest(req) ? next() : jsonBody(req, res, next)));
     app.use(rateLimit({
         windowMs: config.rateLimit.windowMs,
         limit: config.rateLimit.max,
@@ -194,7 +213,7 @@ export function createApp({ store, config }) {
     app.get("/", (_req, res) => {
         res.redirect("/ui/");
     });
-    // --- Supervision (lecture, sauf les nettoyages de boîtes) ----------------
+    // --- Supervision (lecture, liaisons et 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();
@@ -209,6 +228,9 @@ export function createApp({ store, config }) {
     admin.get("/messages/:id", (req, res) => {
         res.json(store.getMessageAdmin(String(req.params.id)));
     });
+    admin.get("/attachments/:id", (req, res) => {
+        sendAttachment(res, store.getAttachmentAdmin(String(req.params.id)));
+    });
     // Déclarée avant `/threads/:id` : la console lit d'abord les fils, le détail ensuite.
     admin.get("/threads", (req, res) => {
         const query = adminThreadsSchema.parse(req.query);
@@ -263,7 +285,7 @@ export function createApp({ store, config }) {
         res.json({ mailboxes: store.emptyMailboxes() });
     });
     /**
-     * La seule route de la console qui écrit, et elle détruit.
+     * Suppression en lot : 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
@@ -313,6 +335,21 @@ export function createApp({ store, config }) {
         logger.warn(`admin delete: mailbox ${id} deleted (${removed.messages} message(s) erased)`);
         res.json({ mailbox: id, ...removed });
     });
+    admin.get("/links", (_req, res) => {
+        res.json({ links: store.listLinks() });
+    });
+    admin.post("/links", (req, res) => {
+        const input = linkSchema.parse(req.body ?? {});
+        const link = store.createLink(input.mailboxes[0], input.mailboxes[1], input.note ?? null);
+        logger.info(`admin link ${link.link_id}: ${link.mailboxes[0].mailbox} <-> ${link.mailboxes[1].mailbox}`);
+        res.status(201).json({ link });
+    });
+    admin.delete("/links/:id", (req, res) => {
+        const linkId = String(req.params.id);
+        store.deleteLink(linkId);
+        logger.info(`admin unlink ${linkId}`);
+        res.json({ link_id: linkId });
+    });
     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.
@@ -370,10 +407,14 @@ export function createApp({ store, config }) {
             throw new MessengerError(`mailbox not found: ${req.params.id}`, 404);
         res.json({ agent });
     });
+    // Lire ses liaisons, c'est en prendre connaissance : la console l'affiche comme reçue.
+    api.get("/links", (req, res) => {
+        res.json({ links: store.linksFor(req.agentId, { markSeen: true }) });
+    });
     api.get("/mailbox", (req, res) => {
         res.json({ ...store.stats(req.agentId), watcher: watchers.status(req.agentId) });
     });
-    api.post("/messages", (req, res) => {
+    api.post("/messages", express.json({ type: JSON_TYPES, limit: SEND_BODY_LIMIT }), (req, res) => {
         const input = sendSchema.parse(req.body ?? {});
         const result = store.sendMessage({
             from: req.agentId,
@@ -384,6 +425,11 @@ export function createApp({ store, config }) {
             reply_to: input.reply_to ?? null,
             thread_title: input.thread_title ?? null,
             thread_description: input.thread_description ?? null,
+            attachments: (input.attachments ?? []).map((a) => ({
+                filename: a.filename,
+                mime_type: a.mime_type ?? null,
+                data: Buffer.from(a.content_base64, "base64"),
+            })),
         });
         logger.info(`message ${result.message_id}: ${req.agentId} -> ${result.delivered_to}`);
         res.status(201).json(result);
@@ -409,6 +455,9 @@ 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("/attachments/:id", (req, res) => {
+        sendAttachment(res, store.getAttachment(req.agentId, String(req.params.id)));
+    });
     api.get("/threads", (req, res) => {
         const query = listThreadsQuerySchema.parse(req.query);
         res.json({ threads: store.listThreads(req.agentId, query) });
@@ -434,7 +483,8 @@ export function createApp({ store, config }) {
     });
     // Attente longue : seuls les messages arrivés APRÈS le début de l'attente réveillent
     // l'appelant ; les non-lus déjà présents sont ignorés (sinon l'outil rendrait la main
-    // immédiatement tant que la boîte n'est pas vidée).
+    // immédiatement tant que la boîte n'est pas vidée). Un veilleur est aussi réveillé par
+    // une liaison posée sur sa boîte.
     api.get("/wait", (req, res) => {
         const { timeout_seconds, folder, watcher } = waitQuerySchema.parse(req.query);
         const agentId = req.agentId;
@@ -445,11 +495,15 @@ export function createApp({ store, config }) {
         // Le relâchement doit couvrir les trois sorties possibles : message, expiration,
         // client parti. Un compteur qui ne redescend pas ferait croire à un veilleur éternel.
         const releaseWatcher = watcher ? watchers.begin(agentId) : () => { };
-        const done = (payload) => {
+        const stop = () => {
             clearTimeout(timer);
             store.off("message", onMessage);
-            req.off("close", onClose);
+            store.off("link", onLink);
+            req.off("close", stop);
             releaseWatcher();
+        };
+        const done = (payload) => {
+            stop();
             if (!res.headersSent)
                 res.json(payload);
         };
@@ -462,14 +516,17 @@ export function createApp({ store, config }) {
                 return;
             done({ timed_out: false, message: store.getMessage(agentId, event.message_id, false) });
         };
-        const onClose = () => {
-            clearTimeout(timer);
-            store.off("message", onMessage);
-            releaseWatcher();
+        const onLink = (event) => {
+            if (event.agent_id !== agentId)
+                return;
+            const [link] = store.linksFor(agentId, { linkId: event.link_id });
+            done({ timed_out: false, message: null, link });
         };
         const timer = setTimeout(() => done({ timed_out: true, message: null }), timeoutSeconds * 1000);
         store.on("message", onMessage);
-        req.once("close", onClose);
+        if (watcher)
+            store.on("link", onLink);
+        req.once("close", stop);
     });
     app.use("/api", api);
     // --- Erreurs --------------------------------------------------------------
@@ -485,12 +542,32 @@ export function createApp({ store, config }) {
             res.status(400).json({ error: "invalid request", details: z.treeifyError(err) });
             return;
         }
+        // Erreurs du lecteur de corps (trop gros, JSON illisible) : leur message est fait pour être lu.
+        if (isExposedHttpError(err)) {
+            res.status(err.status).json({ error: err.message });
+            return;
+        }
         logger.error("unhandled error", err);
         // Le détail reste dans les logs : la réponse ne doit rien révéler de l'hôte.
         res.status(500).json({ error: "internal server error" });
     });
     return app;
 }
+function isExposedHttpError(err) {
+    if (typeof err !== "object" || err === null)
+        return false;
+    const { expose, status } = err;
+    return expose === true && typeof status === "number" && status >= 400 && status < 500;
+}
+function isSendRequest(req) {
+    return req.method === "POST" && req.path === "/api/messages";
+}
+function sendAttachment(res, attachment) {
+    res.setHeader("content-type", attachment.mime_type);
+    res.setHeader("content-length", String(attachment.data.length));
+    res.setHeader("content-disposition", contentDisposition(attachment.filename));
+    res.end(attachment.data);
+}
 /**
  * Exige un jeton connu du serveur sur toute requête entrante.
  *