@imenam/mcp-messenger 1.0.29 → 1.0.31

package/dist/src/cli/watch.d.ts

@@ -1,5 +1,5 @@
 import { type AgentConfig } from "../config.js";
-import type { Message } from "../core/types.js";
+import type { LinkedMailbox, Message } from "../core/types.js";
 export interface WatchConfig {
     config: AgentConfig;
     mailbox: string;
@@ -16,4 +16,6 @@ export interface WatchConfig {
 export declare function resolveWatchConfig(mailbox: string | null, env?: NodeJS.ProcessEnv): WatchConfig;
 /** Ligne d'évènement : une seule ligne, lisible telle quelle dans la notification. */
 export declare function formatEvent(message: Message): string;
+/** Ligne d'une liaison posée depuis la console sur la boîte surveillée. */
+export declare function formatLinkEvent(link: LinkedMailbox): string;
 export declare function runWatchMode(mailbox: string | null): Promise<void>;

package/dist/src/cli/watch.js

@@ -62,6 +62,13 @@ export function formatEvent(message) {
     const thread = message.thread_title ? ` · ${message.thread_title.replace(/\s+/g, " ").trim()}` : "";
     return `[messenger] ${flag}${message.from} — ${subject}${thread} (${message.message_id})`;
 }
+/** Ligne d'une liaison posée depuis la console sur la boîte surveillée. */
+export function formatLinkEvent(link) {
+    const who = link.correspondent;
+    const names = [who.agent_name, who.display_name].filter(Boolean).join(" · ") || "unnamed mailbox";
+    const note = link.note ? ` — ${link.note.replace(/\s+/g, " ").trim()}` : "";
+    return `[messenger] linked with ${names} (${who.id})${note} — call list_links`;
+}
 export async function runWatchMode(mailbox) {
     const { config, mailbox: target, source } = resolveWatchConfig(mailbox);
     const client = new MessengerClient(config);
@@ -71,11 +78,14 @@ export async function runWatchMode(mailbox) {
         try {
             const result = await client.waitForMessage(POLL_SECONDS, undefined, { watcher: true });
             backoff = BACKOFF_MIN_MS;
-            if (result.timed_out || !result.message)
+            if (result.timed_out)
                 continue;
             // Une ligne, un réveil. On repart aussitôt en attente : les messages suivants
             // arrivés entre-temps sont récupérés au tour d'après.
-            process.stdout.write(`${formatEvent(result.message)}\n`);
+            if (result.message)
+                process.stdout.write(`${formatEvent(result.message)}\n`);
+            else if (result.link)
+                process.stdout.write(`${formatLinkEvent(result.link)}\n`);
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : String(error);

package/dist/src/client/messenger-client.d.ts

@@ -1,13 +1,26 @@
 import type { AgentConfig } from "../config.js";
-import type { Agent, AgentDirectoryEntry, FolderInfo, ListMessagesOptions, MailboxStats, Message, MessageSummary, Priority, SendMessageResult, ThreadInfo, ThreadSummary } from "../core/types.js";
+import type { Agent, AgentDirectoryEntry, FolderInfo, LinkedMailbox, ListMessagesOptions, MailboxStats, Message, MessageSummary, Priority, SendMessageResult, ThreadInfo, ThreadSummary } from "../core/types.js";
 /** Échec d'un appel au serveur boîte aux lettres (réseau, authentification ou métier). */
 export declare class MessengerClientError extends Error {
     readonly status?: number | undefined;
     constructor(message: string, status?: number | undefined);
 }
+/** Pièce jointe à l'envoi, contenu encodé en base64. */
+export interface OutgoingAttachment {
+    filename: string;
+    mime_type: string | null;
+    content_base64: string;
+}
+export interface DownloadedAttachment {
+    filename: string;
+    mime_type: string;
+    data: Buffer;
+}
 export interface WaitResult {
     timed_out: boolean;
     message: Message | null;
+    /** Liaison posée sur la boîte pendant l'attente ; seul un veilleur en reçoit. */
+    link?: LinkedMailbox | null;
 }
 /**
  * Client HTTP du serveur boîte aux lettres.
@@ -59,6 +72,8 @@ export declare class MessengerClient {
     }): Promise<Agent>;
     getAgent(agentId: string): Promise<Agent>;
     listAgents(): Promise<AgentDirectoryEntry[]>;
+    /** Liaisons de la boîte courante. Le serveur les note comme reçues par cet agent. */
+    listLinks(): Promise<LinkedMailbox[]>;
     stats(): Promise<MailboxStats>;
     sendMessage(input: {
         to: string;
@@ -68,9 +83,11 @@ export declare class MessengerClient {
         reply_to?: string | null;
         thread_title?: string | null;
         thread_description?: string | null;
+        attachments?: OutgoingAttachment[];
     }): Promise<SendMessageResult>;
     listMessages(options?: ListMessagesOptions): Promise<MessageSummary[]>;
     getMessage(messageId: string, markRead?: boolean): Promise<Message>;
+    downloadAttachment(attachmentId: string): Promise<DownloadedAttachment>;
     markMessages(messageIds: string[], state: {
         read?: boolean;
         starred?: boolean;
@@ -104,4 +121,7 @@ export declare class MessengerClient {
         watcher?: boolean;
     }): Promise<WaitResult>;
     private request;
+    private send;
+    /** Erreur lisible tirée d'une réponse en échec. */
+    private failure;
 }

package/dist/src/client/messenger-client.js

@@ -1,3 +1,4 @@
+import { filenameFromDisposition } from "../core/attachments.js";
 /** Échec d'un appel au serveur boîte aux lettres (réseau, authentification ou métier). */
 export class MessengerClientError extends Error {
     status;
@@ -88,6 +89,11 @@ export class MessengerClient {
         const { agents } = await this.request("GET", "/api/agents");
         return agents;
     }
+    /** Liaisons de la boîte courante. Le serveur les note comme reçues par cet agent. */
+    async listLinks() {
+        const { links } = await this.request("GET", "/api/links");
+        return links;
+    }
     async stats() {
         return this.request("GET", "/api/mailbox");
     }
@@ -105,6 +111,16 @@ export class MessengerClient {
             query: { mark_read: markRead },
         });
     }
+    async downloadAttachment(attachmentId) {
+        const response = await this.send("GET", `/api/attachments/${encodeURIComponent(attachmentId)}`);
+        if (!response.ok)
+            throw await this.failure(response);
+        return {
+            filename: filenameFromDisposition(response.headers.get("content-disposition")) ?? attachmentId,
+            mime_type: response.headers.get("content-type") ?? "application/octet-stream",
+            data: Buffer.from(await response.arrayBuffer()),
+        };
+    }
     async markMessages(messageIds, state) {
         const { updated } = await this.request("POST", "/api/messages/mark", {
             body: { message_ids: messageIds, ...state },
@@ -160,6 +176,13 @@ export class MessengerClient {
         });
     }
     async request(method, routePath, options = {}) {
+        const response = await this.send(method, routePath, options);
+        if (!response.ok)
+            throw await this.failure(response);
+        const text = await response.text();
+        return (text ? safeParse(text) : null);
+    }
+    async send(method, routePath, options = {}) {
         const url = new URL(this.config.serverUrl + routePath);
         for (const [key, value] of Object.entries(options.query ?? {})) {
             if (value === undefined || value === null || value === "")
@@ -171,9 +194,8 @@ export class MessengerClient {
             headers.authorization = `Bearer ${this.config.token}`;
         if (options.body !== undefined)
             headers["content-type"] = "application/json";
-        let response;
         try {
-            response = await fetch(url, {
+            return await fetch(url, {
                 method,
                 headers,
                 body: options.body === undefined ? undefined : JSON.stringify(options.body),
@@ -184,15 +206,15 @@ export class MessengerClient {
             const reason = error instanceof Error ? error.message : String(error);
             throw new MessengerClientError(`cannot reach the messenger server at ${this.config.serverUrl}: ${reason}`);
         }
+    }
+    /** Erreur lisible tirée d'une réponse en échec. */
+    async failure(response) {
         const text = await response.text();
         const payload = text ? safeParse(text) : null;
-        if (!response.ok) {
-            const detail = payload && typeof payload === "object" && "error" in payload
-                ? String(payload.error)
-                : text.slice(0, 300) || response.statusText;
-            throw new MessengerClientError(detail, response.status);
-        }
-        return payload;
+        const detail = payload && typeof payload === "object" && "error" in payload
+            ? String(payload.error)
+            : text.slice(0, 300) || response.statusText;
+        return new MessengerClientError(detail, response.status);
     }
 }
 function safeParse(text) {

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

@@ -0,0 +1,16 @@
+/** Nombre de pièces jointes par message. */
+export declare const MAX_ATTACHMENTS = 10;
+/** Taille d'une pièce jointe, en octets. */
+export declare const MAX_ATTACHMENT_BYTES: number;
+/** Taille cumulée des pièces jointes d'un message, en octets. */
+export declare const MAX_ATTACHMENTS_TOTAL_BYTES: number;
+export declare function formatBytes(bytes: number): string;
+/**
+ * En-tête `Content-Disposition` d'un téléchargement.
+ *
+ * Toujours `attachment` : servi en ligne, un fichier HTML ou SVG s'exécuterait dans
+ * l'origine de la console.
+ */
+export declare function contentDisposition(filename: string): string;
+/** Nom de fichier porté par un en-tête produit par `contentDisposition`. */
+export declare function filenameFromDisposition(header: string | null): string | null;

package/dist/src/core/attachments.js

@@ -0,0 +1,28 @@
+/** Nombre de pièces jointes par message. */
+export const MAX_ATTACHMENTS = 10;
+/** Taille d'une pièce jointe, en octets. */
+export const MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+/** Taille cumulée des pièces jointes d'un message, en octets. */
+export const MAX_ATTACHMENTS_TOTAL_BYTES = 25 * 1024 * 1024;
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+/**
+ * En-tête `Content-Disposition` d'un téléchargement.
+ *
+ * Toujours `attachment` : servi en ligne, un fichier HTML ou SVG s'exécuterait dans
+ * l'origine de la console.
+ */
+export function contentDisposition(filename) {
+    const ascii = filename.replace(/[^\x20-\x7e]|["\\]/g, "_");
+    return `attachment; filename="${ascii}"; filename*=UTF-8''${encodeURIComponent(filename)}`;
+}
+/** Nom de fichier porté par un en-tête produit par `contentDisposition`. */
+export function filenameFromDisposition(header) {
+    const encoded = header?.match(/filename\*=UTF-8''([^;]+)/i)?.[1];
+    return encoded ? decodeURIComponent(encoded) : null;
+}

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

@@ -1,10 +1,15 @@
 import { EventEmitter } from "node:events";
-import { type AdminThreadSummary, type Agent, type AgentDirectoryEntry, type DeliveryRole, type FolderInfo, type ListMessagesOptions, type ListThreadsOptions, type MailboxStats, type Message, type MessageSummary, type Priority, type SendMessageInput, type SendMessageResult, type ThreadInfo, type ThreadSummary } from "./types.js";
+import { type AdminThreadSummary, type Agent, type AgentDirectoryEntry, type AttachmentInfo, type DeliveryRole, type FolderInfo, type LinkedMailbox, type ListMessagesOptions, type ListThreadsOptions, type MailboxLink, type MailboxStats, type Message, type MessageSummary, type Priority, type SendMessageInput, type SendMessageResult, type ThreadInfo, type ThreadSummary } from "./types.js";
 /** Erreur métier : traduite en 4xx par la couche HTTP, en message d'outil côté MCP. */
 export declare class MessengerError extends Error {
     readonly status: number;
     constructor(message: string, status?: number);
 }
+/** Contenu d'une pièce jointe, avec ses métadonnées. */
+export interface AttachmentContent extends AttachmentInfo {
+    message_id: string;
+    data: Buffer;
+}
 export interface EnsureAgentOptions {
     registered?: boolean;
     /** Identité de l'agent : d'où il vient. Posée par la configuration. */
@@ -22,6 +27,11 @@ export interface StoreEvents {
         folder: string;
         role: DeliveryRole;
     }];
+    /** Émis pour chacune des deux boîtes d'une liaison qui vient d'être créée. */
+    link: [{
+        agent_id: string;
+        link_id: string;
+    }];
 }
 /**
  * Boîte aux lettres persistée en SQLite.
@@ -55,6 +65,8 @@ export declare class MessageStore extends EventEmitter<StoreEvents> {
     getMessage(agentId: string, messageId: string, markRead?: boolean): Message;
     /** Tous les messages d'un fil visibles par l'agent, du plus ancien au plus récent. */
     getThread(agentId: string, threadId: string): Message[];
+    /** Pièce jointe d'un message livré à cet agent, contenu compris. */
+    getAttachment(agentId: string, attachmentId: string): AttachmentContent;
     getThreadInfo(threadId: string): ThreadInfo | null;
     /**
      * Renomme un fil. Le titre est unique et partagé : les participants parlent du même
@@ -134,6 +146,23 @@ export declare class MessageStore extends EventEmitter<StoreEvents> {
         messages: number;
         threads: number;
     };
+    /**
+     * Lie deux boîtes existantes. La paire est stockée dans l'ordre des adresses : une
+     * liaison n'a pas de direction, et la même paire ne peut être liée deux fois.
+     */
+    createLink(first: string, second: string, note?: string | null): MailboxLink;
+    getLink(linkId: string): MailboxLink | null;
+    /** Toutes les liaisons du serveur, la plus récente en tête. */
+    listLinks(): MailboxLink[];
+    deleteLink(linkId: string): void;
+    /**
+     * Liaisons d'une boîte, la plus récente en tête, chacune avec la fiche de la boîte d'en
+     * face. `markSeen` note que l'agent de cette boîte en a pris connaissance.
+     */
+    linksFor(agentId: string, opts?: {
+        markSeen?: boolean;
+        linkId?: string;
+    }): LinkedMailbox[];
     /** Vue globale : tous les messages du serveur, indépendamment des boîtes. */
     listAllMessages(opts?: {
         search?: string;
@@ -183,6 +212,8 @@ export declare class MessageStore extends EventEmitter<StoreEvents> {
             read: boolean;
         }[];
     };
+    /** Pièce jointe vue du serveur, quelle que soit la boîte. */
+    getAttachmentAdmin(attachmentId: string): AttachmentContent;
     overview(): {
         messages: number;
         threads: number;
@@ -196,8 +227,8 @@ export declare class MessageStore extends EventEmitter<StoreEvents> {
     /** Filtre les ids fournis sur ceux réellement livrés à cet agent (isolation des boîtes). */
     private ownedMessageIds;
     private assertFolderExists;
-    /** Destinataire de chaque message demandé, par identifiant de message. */
-    private recipientsFor;
+    /** Destinataire et pièces jointes de chaque message demandé, par identifiant de message. */
+    private relatedFor;
     private toSummary;
     private toMessage;
     /** Un message sans aucune livraison n'est plus lisible par personne : on le supprime. */