@imenam/mcp-messenger 1.0.1

package/dist/src/core/store.js

@@ -0,0 +1,527 @@
+import Database from "better-sqlite3";
+import { EventEmitter } from "node:events";
+import fs from "node:fs";
+import path from "node:path";
+import { newId } from "./ids.js";
+import { DELIVERY_ROLES, SYSTEM_FOLDERS, } from "./types.js";
+/** Erreur métier : traduite en 4xx par la couche HTTP, en message d'outil côté MCP. */
+export class MessengerError extends Error {
+    status;
+    constructor(message, status = 400) {
+        super(message);
+        this.status = status;
+        this.name = "MessengerError";
+    }
+}
+const PREVIEW_LENGTH = 160;
+const MAX_LIMIT = 100;
+const FOLDER_NAME_RE = /^[a-z0-9][a-z0-9 _-]{0,39}$/;
+/**
+ * Boîte aux lettres persistée en SQLite.
+ *
+ * Un message est stocké une seule fois (table `messages`) puis « livré » via une ligne
+ * par couple (agent, rôle) dans `deliveries`. C'est cette ligne qui porte l'état propre
+ * à chaque agent : dossier, lu/non lu, suivi. Un agent ne voit que ses propres livraisons.
+ */
+export class MessageStore extends EventEmitter {
+    db;
+    constructor(dbPath) {
+        super();
+        if (dbPath !== ":memory:") {
+            fs.mkdirSync(path.dirname(path.resolve(dbPath)), { recursive: true });
+        }
+        this.db = new Database(dbPath);
+        this.db.pragma("foreign_keys = ON");
+        if (dbPath !== ":memory:")
+            this.db.pragma("journal_mode = WAL");
+        this.migrate();
+    }
+    migrate() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS agents (
+        id           TEXT PRIMARY KEY,
+        display_name TEXT,
+        description  TEXT,
+        created_at   TEXT NOT NULL,
+        last_seen_at TEXT,
+        registered   INTEGER NOT NULL DEFAULT 0
+      );
+
+      CREATE TABLE IF NOT EXISTS messages (
+        id          TEXT PRIMARY KEY,
+        thread_id   TEXT NOT NULL,
+        sender_id   TEXT NOT NULL,
+        subject     TEXT NOT NULL,
+        body        TEXT NOT NULL,
+        priority    TEXT NOT NULL DEFAULT 'normal',
+        in_reply_to TEXT,
+        created_at  TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS deliveries (
+        id         TEXT PRIMARY KEY,
+        message_id TEXT NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+        agent_id   TEXT NOT NULL,
+        role       TEXT NOT NULL,
+        folder     TEXT NOT NULL,
+        read_at    TEXT,
+        starred    INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL,
+        UNIQUE (message_id, agent_id, role)
+      );
+
+      CREATE TABLE IF NOT EXISTS folders (
+        agent_id   TEXT NOT NULL,
+        name       TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        PRIMARY KEY (agent_id, name)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_deliveries_mailbox ON deliveries (agent_id, folder, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_deliveries_message ON deliveries (message_id);
+      CREATE INDEX IF NOT EXISTS idx_messages_thread ON messages (thread_id, created_at);
+    `);
+    }
+    close() {
+        this.db.close();
+    }
+    // --- Agents -------------------------------------------------------------
+    /** Crée la fiche au besoin. `registered: false` = agent connu seulement comme destinataire. */
+    ensureAgent(id, opts = {}) {
+        const now = new Date().toISOString();
+        const existing = this.db.prepare("SELECT id FROM agents WHERE id = ?").get(id);
+        if (!existing) {
+            this.db
+                .prepare(`INSERT INTO agents (id, display_name, description, created_at, last_seen_at, registered)
+           VALUES (?, ?, ?, ?, ?, ?)`)
+                .run(id, opts.display_name ?? null, opts.description ?? null, now, opts.registered ? now : null, opts.registered ? 1 : 0);
+        }
+        else {
+            this.db
+                .prepare(`UPDATE agents
+              SET display_name = COALESCE(?, display_name),
+                  description  = COALESCE(?, description),
+                  registered   = MAX(registered, ?),
+                  last_seen_at = CASE WHEN ? = 1 THEN ? ELSE last_seen_at END
+            WHERE id = ?`)
+                .run(opts.display_name ?? null, opts.description ?? null, opts.registered ? 1 : 0, opts.registered ? 1 : 0, now, id);
+        }
+        return this.getAgent(id);
+    }
+    touchAgent(id) {
+        this.db.prepare("UPDATE agents SET last_seen_at = ? WHERE id = ?").run(new Date().toISOString(), id);
+    }
+    getAgent(id) {
+        const row = this.db.prepare("SELECT * FROM agents WHERE id = ?").get(id);
+        return row ? { ...row, registered: Boolean(row.registered) } : null;
+    }
+    listAgents() {
+        const rows = this.db.prepare("SELECT * FROM agents ORDER BY id").all();
+        return rows.map((r) => ({ ...r, registered: Boolean(r.registered) }));
+    }
+    // --- Envoi --------------------------------------------------------------
+    sendMessage(input) {
+        const subject = input.subject.trim();
+        if (!subject)
+            throw new MessengerError("subject cannot be empty");
+        if (!input.body.trim())
+            throw new MessengerError("body cannot be empty");
+        const from = normalizeAgentId(input.from);
+        if (!from)
+            throw new MessengerError("sender agent id is required");
+        const to = dedupe(input.to.map(normalizeAgentId).filter(Boolean));
+        // Un même agent ne peut pas être à la fois destinataire principal et en copie.
+        const cc = dedupe((input.cc ?? []).map(normalizeAgentId).filter(Boolean)).filter((id) => !to.includes(id));
+        if (to.length === 0)
+            throw new MessengerError("at least one recipient is required in `to`");
+        let threadId;
+        let inReplyTo = null;
+        if (input.reply_to) {
+            const parent = this.db.prepare("SELECT id, thread_id FROM messages WHERE id = ?").get(input.reply_to);
+            if (!parent)
+                throw new MessengerError(`message not found: ${input.reply_to}`, 404);
+            threadId = parent.thread_id;
+            inReplyTo = parent.id;
+        }
+        else {
+            threadId = newId("thr");
+        }
+        const messageId = newId("msg");
+        const now = new Date().toISOString();
+        const priority = input.priority ?? "normal";
+        const unknownRecipients = [...to, ...cc].filter((id) => !this.getAgent(id)?.registered);
+        const deliveries = [
+            ...to.map((agent_id) => ({ agent_id, role: "to", folder: "inbox", read_at: null })),
+            ...cc.map((agent_id) => ({ agent_id, role: "cc", folder: "inbox", read_at: null })),
+            { agent_id: from, role: "sender", folder: "sent", read_at: now },
+        ];
+        this.db.transaction(() => {
+            this.ensureAgent(from);
+            // Écrire est le signe d'activité le plus fiable : l'annuaire s'appuie dessus.
+            this.touchAgent(from);
+            for (const id of [...to, ...cc])
+                this.ensureAgent(id);
+            this.db
+                .prepare(`INSERT INTO messages (id, thread_id, sender_id, subject, body, priority, in_reply_to, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(messageId, threadId, from, subject, input.body, priority, inReplyTo, now);
+            const insert = this.db.prepare(`INSERT INTO deliveries (id, message_id, agent_id, role, folder, read_at, starred, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, 0, ?)`);
+            for (const d of deliveries) {
+                insert.run(newId("dlv"), messageId, d.agent_id, d.role, d.folder, d.read_at, now);
+            }
+        })();
+        for (const d of deliveries) {
+            this.emit("message", { agent_id: d.agent_id, message_id: messageId, folder: d.folder, role: d.role });
+        }
+        return {
+            message_id: messageId,
+            thread_id: threadId,
+            created_at: now,
+            delivered_to: [...to, ...cc],
+            unknown_recipients: unknownRecipients,
+        };
+    }
+    // --- Lecture ------------------------------------------------------------
+    listMessages(agentId, opts = {}) {
+        const limit = clamp(opts.limit ?? 25, 1, MAX_LIMIT);
+        const offset = Math.max(0, opts.offset ?? 0);
+        const where = ["d.agent_id = ?"];
+        const params = [agentId];
+        if (opts.folder) {
+            this.assertFolderExists(agentId, opts.folder);
+            where.push("d.folder = ?");
+            params.push(opts.folder);
+        }
+        if (opts.unread_only)
+            where.push("d.read_at IS NULL");
+        if (opts.thread_id) {
+            where.push("m.thread_id = ?");
+            params.push(opts.thread_id);
+        }
+        if (opts.from) {
+            where.push("m.sender_id = ?");
+            params.push(normalizeAgentId(opts.from));
+        }
+        if (opts.search) {
+            where.push("(m.subject LIKE ? ESCAPE '\\' OR m.body LIKE ? ESCAPE '\\')");
+            const like = `%${escapeLike(opts.search)}%`;
+            params.push(like, like);
+        }
+        const rows = this.db
+            .prepare(`SELECT m.id AS message_id, m.thread_id, m.sender_id, m.subject, m.body, m.priority,
+                m.in_reply_to, m.created_at, d.folder, d.role, d.read_at, d.starred
+           FROM deliveries d
+           JOIN messages m ON m.id = d.message_id
+          WHERE ${where.join(" AND ")}
+          ORDER BY m.created_at DESC, m.id DESC
+          LIMIT ? OFFSET ?`)
+            .all(...params, limit, offset);
+        const recipients = this.recipientsFor(rows.map((r) => r.message_id));
+        return rows.map((row) => this.toSummary(row, recipients));
+    }
+    getMessage(agentId, messageId, markRead = false) {
+        const row = this.db
+            .prepare(`SELECT m.id AS message_id, m.thread_id, m.sender_id, m.subject, m.body, m.priority,
+                m.in_reply_to, m.created_at, d.folder, d.role, d.read_at, d.starred
+           FROM deliveries d
+           JOIN messages m ON m.id = d.message_id
+          WHERE d.agent_id = ? AND d.message_id = ?
+          ORDER BY CASE d.role WHEN 'to' THEN 0 WHEN 'cc' THEN 1 ELSE 2 END
+          LIMIT 1`)
+            .get(agentId, messageId);
+        if (!row)
+            throw new MessengerError(`message not found in this mailbox: ${messageId}`, 404);
+        if (markRead && row.read_at === null) {
+            const now = new Date().toISOString();
+            this.db
+                .prepare("UPDATE deliveries SET read_at = ? WHERE agent_id = ? AND message_id = ? AND read_at IS NULL")
+                .run(now, agentId, messageId);
+            row.read_at = now;
+        }
+        const recipients = this.recipientsFor([messageId]);
+        return this.toMessage(row, recipients);
+    }
+    /** Tous les messages d'un fil visibles par l'agent, du plus ancien au plus récent. */
+    getThread(agentId, threadId) {
+        const rows = this.db
+            .prepare(`SELECT m.id AS message_id, m.thread_id, m.sender_id, m.subject, m.body, m.priority,
+                m.in_reply_to, m.created_at,
+                MIN(d.folder) AS folder, MIN(d.role) AS role, MIN(d.read_at) AS read_at, MAX(d.starred) AS starred
+           FROM deliveries d
+           JOIN messages m ON m.id = d.message_id
+          WHERE d.agent_id = ? AND m.thread_id = ?
+          GROUP BY m.id
+          ORDER BY m.created_at ASC`)
+            .all(agentId, threadId);
+        if (rows.length === 0)
+            throw new MessengerError(`thread not found in this mailbox: ${threadId}`, 404);
+        const recipients = this.recipientsFor(rows.map((r) => r.message_id));
+        return rows.map((row) => this.toMessage(row, recipients));
+    }
+    // --- Organisation -------------------------------------------------------
+    markMessages(agentId, messageIds, state) {
+        if (state.read === undefined && state.starred === undefined) {
+            throw new MessengerError("nothing to update: provide `read` and/or `starred`");
+        }
+        const sets = [];
+        const params = [];
+        if (state.read !== undefined) {
+            sets.push("read_at = ?");
+            params.push(state.read ? new Date().toISOString() : null);
+        }
+        if (state.starred !== undefined) {
+            sets.push("starred = ?");
+            params.push(state.starred ? 1 : 0);
+        }
+        return this.updateDeliveries(agentId, messageIds, sets, params);
+    }
+    moveMessages(agentId, messageIds, folder) {
+        this.assertFolderExists(agentId, folder);
+        return this.updateDeliveries(agentId, messageIds, ["folder = ?"], [folder]);
+    }
+    /** Sans `permanent`, le message part à la corbeille et reste récupérable. */
+    deleteMessages(agentId, messageIds, permanent = false) {
+        if (!permanent)
+            return this.moveMessages(agentId, messageIds, "trash");
+        const ids = this.ownedMessageIds(agentId, messageIds);
+        if (ids.length === 0)
+            return 0;
+        const placeholders = ids.map(() => "?").join(",");
+        const changes = this.db
+            .prepare(`DELETE FROM deliveries WHERE agent_id = ? AND message_id IN (${placeholders})`)
+            .run(agentId, ...ids).changes;
+        this.dropOrphanMessages();
+        return changes;
+    }
+    listFolders(agentId) {
+        const custom = this.db.prepare("SELECT name FROM folders WHERE agent_id = ? ORDER BY name").all(agentId);
+        const counts = this.db
+            .prepare(`SELECT folder, COUNT(*) AS total, SUM(CASE WHEN read_at IS NULL THEN 1 ELSE 0 END) AS unread
+           FROM deliveries WHERE agent_id = ? GROUP BY folder`)
+            .all(agentId);
+        const byName = new Map(counts.map((c) => [c.folder, c]));
+        const names = [...SYSTEM_FOLDERS, ...custom.map((c) => c.name)];
+        return names.map((name) => ({
+            name,
+            system: SYSTEM_FOLDERS.includes(name),
+            total: byName.get(name)?.total ?? 0,
+            unread: byName.get(name)?.unread ?? 0,
+        }));
+    }
+    createFolder(agentId, name) {
+        const folder = name.trim().toLowerCase();
+        if (!FOLDER_NAME_RE.test(folder)) {
+            throw new MessengerError("folder name must be 1-40 chars: lowercase letters, digits, space, `-` or `_`");
+        }
+        if (SYSTEM_FOLDERS.includes(folder)) {
+            throw new MessengerError(`${folder} is a system folder and always exists`, 409);
+        }
+        const exists = this.db.prepare("SELECT 1 FROM folders WHERE agent_id = ? AND name = ?").get(agentId, folder);
+        if (exists)
+            throw new MessengerError(`folder already exists: ${folder}`, 409);
+        this.ensureAgent(agentId);
+        this.db
+            .prepare("INSERT INTO folders (agent_id, name, created_at) VALUES (?, ?, ?)")
+            .run(agentId, folder, new Date().toISOString());
+        return { name: folder, system: false, total: 0, unread: 0 };
+    }
+    /** Les messages du dossier retournent dans `inbox` (ou `sent` pour les copies d'envoi). */
+    deleteFolder(agentId, name) {
+        const folder = name.trim().toLowerCase();
+        if (SYSTEM_FOLDERS.includes(folder)) {
+            throw new MessengerError(`system folder cannot be deleted: ${folder}`);
+        }
+        const exists = this.db.prepare("SELECT 1 FROM folders WHERE agent_id = ? AND name = ?").get(agentId, folder);
+        if (!exists)
+            throw new MessengerError(`folder not found: ${folder}`, 404);
+        const moved = this.db
+            .prepare(`UPDATE deliveries SET folder = CASE role WHEN 'sender' THEN 'sent' ELSE 'inbox' END
+          WHERE agent_id = ? AND folder = ?`)
+            .run(agentId, folder).changes;
+        this.db.prepare("DELETE FROM folders WHERE agent_id = ? AND name = ?").run(agentId, folder);
+        return moved;
+    }
+    stats(agentId) {
+        const folders = this.listFolders(agentId);
+        const unread = this.db
+            .prepare("SELECT COUNT(*) AS n FROM deliveries WHERE agent_id = ? AND read_at IS NULL AND folder != 'trash'")
+            .get(agentId);
+        return { agent_id: agentId, unread_total: unread.n, folders };
+    }
+    /** Purge les livraisons restées en corbeille au-delà de `days`. Renvoie le nombre supprimé. */
+    purgeTrash(days) {
+        if (days <= 0)
+            return 0;
+        const cutoff = new Date(Date.now() - days * 86_400_000).toISOString();
+        const removed = this.db.prepare("DELETE FROM deliveries WHERE folder = 'trash' AND created_at < ?").run(cutoff)
+            .changes;
+        this.dropOrphanMessages();
+        return removed;
+    }
+    // --- Supervision (interface web, lecture seule) --------------------------
+    /** Vue globale : tous les messages du serveur, indépendamment des boîtes. */
+    listAllMessages(opts = {}) {
+        const limit = clamp(opts.limit ?? 50, 1, MAX_LIMIT);
+        const offset = Math.max(0, opts.offset ?? 0);
+        const where = ["1 = 1"];
+        const params = [];
+        if (opts.search) {
+            where.push("(m.subject LIKE ? ESCAPE '\\' OR m.body LIKE ? ESCAPE '\\')");
+            const like = `%${escapeLike(opts.search)}%`;
+            params.push(like, like);
+        }
+        if (opts.agent) {
+            where.push("(m.sender_id = ? OR EXISTS (SELECT 1 FROM deliveries d WHERE d.message_id = m.id AND d.agent_id = ?))");
+            params.push(opts.agent, opts.agent);
+        }
+        if (opts.thread_id) {
+            where.push("m.thread_id = ?");
+            params.push(opts.thread_id);
+        }
+        const rows = this.db
+            .prepare(`SELECT m.id AS message_id, m.thread_id, m.sender_id, m.subject, m.body, m.priority,
+                m.in_reply_to, m.created_at, 'inbox' AS folder, 'to' AS role, NULL AS read_at, 0 AS starred
+           FROM messages m
+          WHERE ${where.join(" AND ")}
+          ORDER BY m.created_at DESC, m.id DESC
+          LIMIT ? OFFSET ?`)
+            .all(...params, limit, offset);
+        const recipients = this.recipientsFor(rows.map((r) => r.message_id));
+        return rows.map((row) => this.toSummary(row, recipients));
+    }
+    /** Message complet vu du serveur, avec l'état de lecture de chaque destinataire. */
+    getMessageAdmin(messageId) {
+        const row = this.db
+            .prepare(`SELECT m.id AS message_id, m.thread_id, m.sender_id, m.subject, m.body, m.priority,
+                m.in_reply_to, m.created_at, 'inbox' AS folder, 'to' AS role, NULL AS read_at, 0 AS starred
+           FROM messages m WHERE m.id = ?`)
+            .get(messageId);
+        if (!row)
+            throw new MessengerError(`message not found: ${messageId}`, 404);
+        const recipients = this.recipientsFor([messageId]);
+        const deliveries = this.db
+            .prepare("SELECT agent_id, role, folder, read_at FROM deliveries WHERE message_id = ? ORDER BY role, agent_id")
+            .all(messageId);
+        return {
+            ...this.toMessage(row, recipients),
+            deliveries: deliveries.map((d) => ({
+                agent_id: d.agent_id,
+                role: d.role,
+                folder: d.folder,
+                read: d.read_at !== null,
+            })),
+        };
+    }
+    overview() {
+        const messages = this.db.prepare("SELECT COUNT(*) AS n FROM messages").get().n;
+        const threads = this.db.prepare("SELECT COUNT(DISTINCT thread_id) AS n FROM messages").get().n;
+        const sentByAgent = new Map(this.db.prepare("SELECT sender_id, COUNT(*) AS n FROM messages GROUP BY sender_id").all().map((r) => [r.sender_id, r.n]));
+        const receivedByAgent = new Map(this.db
+            .prepare(`SELECT agent_id,
+                    COUNT(*) AS received,
+                    SUM(CASE WHEN read_at IS NULL AND folder != 'trash' THEN 1 ELSE 0 END) AS unread
+               FROM deliveries WHERE role != 'sender' GROUP BY agent_id`)
+            .all().map((r) => [r.agent_id, r]));
+        const agents = this.listAgents().map((agent) => ({
+            ...agent,
+            sent: sentByAgent.get(agent.id) ?? 0,
+            received: receivedByAgent.get(agent.id)?.received ?? 0,
+            unread: receivedByAgent.get(agent.id)?.unread ?? 0,
+        }));
+        return { messages, threads, agents };
+    }
+    // --- Interne ------------------------------------------------------------
+    updateDeliveries(agentId, messageIds, sets, params) {
+        const ids = this.ownedMessageIds(agentId, messageIds);
+        if (ids.length === 0)
+            return 0;
+        const placeholders = ids.map(() => "?").join(",");
+        return this.db
+            .prepare(`UPDATE deliveries SET ${sets.join(", ")} WHERE agent_id = ? AND message_id IN (${placeholders})`)
+            .run(...params, agentId, ...ids).changes;
+    }
+    /** Filtre les ids fournis sur ceux réellement livrés à cet agent (isolation des boîtes). */
+    ownedMessageIds(agentId, messageIds) {
+        const ids = dedupe(messageIds.map((id) => String(id ?? "").trim()).filter(Boolean));
+        if (ids.length === 0)
+            throw new MessengerError("at least one message id is required");
+        const placeholders = ids.map(() => "?").join(",");
+        const rows = this.db
+            .prepare(`SELECT DISTINCT message_id FROM deliveries WHERE agent_id = ? AND message_id IN (${placeholders})`)
+            .all(agentId, ...ids);
+        return rows.map((r) => r.message_id);
+    }
+    assertFolderExists(agentId, folder) {
+        if (SYSTEM_FOLDERS.includes(folder))
+            return;
+        const row = this.db.prepare("SELECT 1 FROM folders WHERE agent_id = ? AND name = ?").get(agentId, folder);
+        if (!row)
+            throw new MessengerError(`unknown folder: ${folder}`, 404);
+    }
+    recipientsFor(messageIds) {
+        const map = new Map();
+        const ids = dedupe(messageIds);
+        if (ids.length === 0)
+            return map;
+        const placeholders = ids.map(() => "?").join(",");
+        const rows = this.db
+            .prepare(`SELECT message_id, agent_id, role FROM deliveries
+          WHERE message_id IN (${placeholders}) AND role != 'sender'
+          ORDER BY agent_id`)
+            .all(...ids);
+        for (const row of rows) {
+            const entry = map.get(row.message_id) ?? { to: [], cc: [] };
+            if (row.role === "to")
+                entry.to.push(row.agent_id);
+            else if (row.role === "cc")
+                entry.cc.push(row.agent_id);
+            map.set(row.message_id, entry);
+        }
+        return map;
+    }
+    toSummary(row, recipients) {
+        const rcpt = recipients.get(row.message_id) ?? { to: [], cc: [] };
+        return {
+            message_id: row.message_id,
+            thread_id: row.thread_id,
+            from: row.sender_id,
+            to: rcpt.to,
+            cc: rcpt.cc,
+            subject: row.subject,
+            preview: preview(row.body),
+            priority: row.priority,
+            folder: row.folder,
+            role: DELIVERY_ROLES.includes(row.role) ? row.role : "to",
+            read: row.read_at !== null,
+            starred: Boolean(row.starred),
+            created_at: row.created_at,
+            in_reply_to: row.in_reply_to,
+        };
+    }
+    toMessage(row, recipients) {
+        const { preview: _preview, ...summary } = this.toSummary(row, recipients);
+        return { ...summary, body: row.body };
+    }
+    /** Un message sans aucune livraison n'est plus lisible par personne : on le supprime. */
+    dropOrphanMessages() {
+        this.db.exec("DELETE FROM messages WHERE NOT EXISTS (SELECT 1 FROM deliveries d WHERE d.message_id = messages.id)");
+    }
+}
+export function normalizeAgentId(id) {
+    return String(id ?? "").trim();
+}
+function dedupe(values) {
+    return [...new Set(values)];
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, Math.trunc(value)));
+}
+function preview(body) {
+    const flat = body.replace(/\s+/g, " ").trim();
+    return flat.length <= PREVIEW_LENGTH ? flat : `${flat.slice(0, PREVIEW_LENGTH - 1)}…`;
+}
+/** Échappe les jokers SQL : la recherche reste littérale, `%` cherche bien un `%`. */
+function escapeLike(value) {
+    return value.replace(/[\\%_]/g, (char) => `\\${char}`);
+}

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

@@ -0,0 +1,74 @@
+/** Dossiers présents pour tout agent : ils ne peuvent être ni créés ni supprimés. */
+export declare const SYSTEM_FOLDERS: readonly ["inbox", "sent", "archive", "trash"];
+export type SystemFolder = (typeof SYSTEM_FOLDERS)[number];
+export declare const PRIORITIES: readonly ["low", "normal", "high"];
+export type Priority = (typeof PRIORITIES)[number];
+/** Rôle d'un agent vis-à-vis d'un message : destinataire, copie, ou expéditeur. */
+export declare const DELIVERY_ROLES: readonly ["to", "cc", "sender"];
+export type DeliveryRole = (typeof DELIVERY_ROLES)[number];
+export interface Agent {
+    id: string;
+    display_name: string | null;
+    description: string | null;
+    created_at: string;
+    last_seen_at: string | null;
+    /** false pour un agent créé implicitement parce qu'un message lui a été adressé. */
+    registered: boolean;
+}
+export interface SendMessageInput {
+    from: string;
+    to: string[];
+    cc?: string[];
+    subject: string;
+    body: string;
+    priority?: Priority;
+    /** Id d'un message existant : la réponse hérite de son fil de discussion. */
+    reply_to?: string | null;
+}
+export interface SendMessageResult {
+    message_id: string;
+    thread_id: string;
+    created_at: string;
+    delivered_to: string[];
+    /** Destinataires jamais enregistrés sur ce serveur — le message les attend malgré tout. */
+    unknown_recipients: string[];
+}
+export interface MessageSummary {
+    message_id: string;
+    thread_id: string;
+    from: string;
+    to: string[];
+    cc: string[];
+    subject: string;
+    preview: string;
+    priority: Priority;
+    folder: string;
+    role: DeliveryRole;
+    read: boolean;
+    starred: boolean;
+    created_at: string;
+    in_reply_to: string | null;
+}
+export interface Message extends Omit<MessageSummary, "preview"> {
+    body: string;
+}
+export interface FolderInfo {
+    name: string;
+    system: boolean;
+    total: number;
+    unread: number;
+}
+export interface ListMessagesOptions {
+    folder?: string;
+    unread_only?: boolean;
+    thread_id?: string;
+    from?: string;
+    search?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface MailboxStats {
+    agent_id: string;
+    unread_total: number;
+    folders: FolderInfo[];
+}

package/dist/src/core/types.js

@@ -0,0 +1,5 @@
+/** Dossiers présents pour tout agent : ils ne peuvent être ni créés ni supprimés. */
+export const SYSTEM_FOLDERS = ["inbox", "sent", "archive", "trash"];
+export const PRIORITIES = ["low", "normal", "high"];
+/** Rôle d'un agent vis-à-vis d'un message : destinataire, copie, ou expéditeur. */
+export const DELIVERY_ROLES = ["to", "cc", "sender"];

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "dotenv/config";

package/dist/src/index.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { ConfigError } from "./config.js";
+import { logger } from "./logger.js";
+import { APP_VERSION } from "./version.js";
+const USAGE = `mcp-messenger v${APP_VERSION} — agent-to-agent mailbox
+
+Usage:
+  mcp-messenger              Start in MCP mode (stdio) — the agent-side client.
+  mcp-messenger --server     Start the mailbox server (HTTP API + web console).
+  mcp-messenger --claude-setup-mcp [--force]
+                             Write the messenger entry into ./.mcp.json.
+  mcp-messenger --version    Print the version.
+  mcp-messenger --help       Print this help.
+
+MCP mode requires MESSENGER_SERVER_URL and MESSENGER_TOKEN; each session gets its own
+mailbox unless MESSENGER_AGENT_ID pins a fixed address.
+Server mode requires MESSENGER_TOKEN (or MESSENGER_AGENT_TOKENS) and reads MESSENGER_PORT
+and MESSENGER_DB_PATH. It always listens on 127.0.0.1.
+See .env.example for the full list.`;
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes("--help") || args.includes("-h")) {
+        process.stdout.write(`${USAGE}\n`);
+        return;
+    }
+    if (args.includes("--version") || args.includes("-v")) {
+        process.stdout.write(`${APP_VERSION}\n`);
+        return;
+    }
+    // Traité avant toute initialisation : la commande écrit dans le répertoire de
+    // l'utilisateur, elle n'ouvre ni base ni serveur.
+    if (args.includes("--claude-setup-mcp")) {
+        const { runSetupMcp } = await import("./cli/setup-mcp.js");
+        process.exit(runSetupMcp({ cwd: process.cwd(), force: args.includes("--force") }));
+    }
+    if (args.includes("--server")) {
+        const { runServerMode } = await import("./server/start.js");
+        await runServerMode();
+        return;
+    }
+    const { runMcpMode } = await import("./mcp/start.js");
+    await runMcpMode();
+}
+main().catch((error) => {
+    if (error instanceof ConfigError) {
+        // Erreur de configuration : le message suffit, la stack n'aide personne.
+        logger.error(error.message);
+        process.exit(1);
+    }
+    logger.error("fatal error", error);
+    process.exit(1);
+});

package/dist/src/logger.d.ts

@@ -0,0 +1,6 @@
+export declare const logger: {
+    debug: (message: string, extra?: unknown) => void;
+    info: (message: string, extra?: unknown) => void;
+    warn: (message: string, extra?: unknown) => void;
+    error: (message: string, extra?: unknown) => void;
+};