@imenam/mcp-messenger 1.0.29 → 1.0.31

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

@@ -35,6 +35,45 @@ 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;
 }
+/** Une des deux boîtes d'une liaison, et le moment où son agent en a pris connaissance. */
+export interface LinkEnd {
+    mailbox: string;
+    /** null tant que l'agent de cette boîte n'a pas lu la liaison (`whoami`, `list_links`, `list_agents`). */
+    seen_at: string | null;
+}
+/**
+ * Liaison posée depuis la console entre deux boîtes : chacune connaît l'autre comme
+ * correspondante désignée, sans que les agents aient à échanger d'adresse.
+ */
+export interface MailboxLink {
+    link_id: string;
+    /** Motif transmis aux deux agents. */
+    note: string | null;
+    created_at: string;
+    mailboxes: [LinkEnd, LinkEnd];
+}
+/** Liaison vue depuis l'une de ses deux boîtes : la fiche de la boîte d'en face. */
+export interface LinkedMailbox {
+    link_id: string;
+    note: string | null;
+    created_at: string;
+    correspondent: Agent;
+}
+/** Pièce jointe telle qu'elle voyage avec un message : ses métadonnées, sans son contenu. */
+export interface AttachmentInfo {
+    attachment_id: string;
+    filename: string;
+    mime_type: string;
+    /** Taille en octets. */
+    size: number;
+}
+/** Pièce jointe fournie à l'envoi. */
+export interface AttachmentUpload {
+    filename: string;
+    /** Type MIME ; `application/octet-stream` s'il est absent. */
+    mime_type?: string | null;
+    data: Buffer;
+}
 export interface SendMessageInput {
     from: string;
     /** Un échange lie exactement deux boîtes : un seul destinataire par message. */
@@ -47,6 +86,7 @@ export interface SendMessageInput {
     /** Nom lisible donné au fil. Sur une réponse, renomme le fil existant. */
     thread_title?: string | null;
     thread_description?: string | null;
+    attachments?: AttachmentUpload[];
 }
 /**
  * Intitulé d'un fil de discussion.
@@ -98,6 +138,7 @@ export interface MessageSummary {
     starred: boolean;
     created_at: string;
     in_reply_to: string | null;
+    attachments: AttachmentInfo[];
 }
 export interface Message extends Omit<MessageSummary, "preview"> {
     body: string;

package/dist/src/mcp/start.js

@@ -18,28 +18,31 @@ import { TOOLS, callTool } from "./tools.js";
  * recopier une adresse dans le corps d'un message (le serveur la pose déjà, la copie ment
  * dès qu'elle vieillit). Les dire ici, c'est les dire avant l'erreur.
  */
-const INSTRUCTIONS = `mcp-messenger gives this session a mailbox and lets it exchange messages with other agent sessions.
-
-Two words, two different things, used consistently by every tool here:
-- a **mailbox** is an address (\`box_…\`). It identifies exactly one session, and it is what you write to.
-- an **agent name** is the project a session works for. It is a label, never an address, and every session of that project carries it.
-
-Who you are, and who the others are — read this before writing to anyone:
-- A session is identified by its mailbox address, and by nothing else. \`whoami\` gives you yours.
-- The agent name (e.g. "Ai Corrector Dev") comes from the configuration and says which project the agent works on. It is NOT unique: every session started from that configuration carries it.
-- \`list_agents\` groups mailboxes under their agent name: one group per project, one line per session. A group holding several lines is several live sessions of that project, each with its own address — pick one of those addresses, never the group name.
-- One of those groups may carry the same agent name as yours. Recognising your own agent name there does not mean you are looking at yourself — those are other sessions of the same project, each a different agent with its own mailbox. Compare addresses, never names.
-- Your own mailbox is never listed in \`list_agents\`: every address you see there belongs to someone else.
-
-Resuming earlier work:
-- A resumed session usually keeps the mailbox it had: the address, the threads and the unread messages come back on their own. \`whoami\` says so when it happens.
-- When it cannot be decided automatically, \`whoami\` lists the mailboxes left by a stopped session of this project. If you are continuing that work, call \`attach_to_mailbox\` with the right address.
-- If a \`box_…\` address appears earlier in your own context, from a previous part of this conversation, that is your mailbox from before: attach to it rather than writing from a fresh one, so your correspondents keep reaching you at the address they know.
-
-Writing:
-- One message goes to exactly one mailbox, and never to your own. To reach several correspondents, send each one its own message.
-- Never write a mailbox address in the body of a message. The server attaches the sender and the recipient to every message, and the reader sees them: an address copied by hand adds nothing and misleads as soon as it is stale or mistaken.
-- Call \`enable_notifications\` once at the start of the session and arm the watcher it hands you. Until then, no incoming message reaches you.
+const INSTRUCTIONS = `mcp-messenger gives this session a mailbox and lets it exchange messages with other agent sessions.
+
+Two words, two different things, used consistently by every tool here:
+- a **mailbox** is an address (\`box_…\`). It identifies exactly one session, and it is what you write to.
+- an **agent name** is the project a session works for. It is a label, never an address, and every session of that project carries it.
+
+Who you are, and who the others are — read this before writing to anyone:
+- A session is identified by its mailbox address, and by nothing else. \`whoami\` gives you yours.
+- The agent name (e.g. "Ai Corrector Dev") comes from the configuration and says which project the agent works on. It is NOT unique: every session started from that configuration carries it.
+- \`list_agents\` groups mailboxes under their agent name: one group per project, one line per session. A group holding several lines is several live sessions of that project, each with its own address — pick one of those addresses, never the group name.
+- One of those groups may carry the same agent name as yours. Recognising your own agent name there does not mean you are looking at yourself — those are other sessions of the same project, each a different agent with its own mailbox. Compare addresses, never names.
+- Your own mailbox is never listed in \`list_agents\`: every address you see there belongs to someone else.
+
+Resuming earlier work:
+- A resumed session usually keeps the mailbox it had: the address, the threads and the unread messages come back on their own. \`whoami\` says so when it happens.
+- When it cannot be decided automatically, \`whoami\` lists the mailboxes left by a stopped session of this project. If you are continuing that work, call \`attach_to_mailbox\` with the right address.
+- If a \`box_…\` address appears earlier in your own context, from a previous part of this conversation, that is your mailbox from before: attach to it rather than writing from a fresh one, so your correspondents keep reaching you at the address they know.
+
+Linked mailboxes:
+- The user can link this mailbox to others from the web console: those are the correspondents you are meant to work with. \`whoami\` and \`list_links\` list them, and the notification watcher announces each new link as it arrives.
+
+Writing:
+- One message goes to exactly one mailbox, and never to your own. To reach several correspondents, send each one its own message.
+- Never write a mailbox address in the body of a message. The server attaches the sender and the recipient to every message, and the reader sees them: an address copied by hand adds nothing and misleads as soon as it is stale or mistaken.
+- Call \`enable_notifications\` once at the start of the session and arm the watcher it hands you. Until then, no incoming message reaches you.
 - The host stops that watcher after 30 minutes at most. Each time it tells you the watcher expired, re-arm it at once with the same Monitor call; otherwise notifications stop for good.`;
 /** Serveur MCP prêt à être branché sur n'importe quel transport (stdio en production, mémoire en test). */
 export function createMcpServer(client) {

package/dist/src/mcp/tools.js

@@ -1,5 +1,9 @@
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 import { z } from "zod";
 import { writeHandoff } from "../cli/watch-handoff.js";
+import { MAX_ATTACHMENTS, MAX_ATTACHMENTS_TOTAL_BYTES, MAX_ATTACHMENT_BYTES, formatBytes } from "../core/attachments.js";
 import { PRIORITIES, SYSTEM_FOLDERS } from "../core/types.js";
 import { rebind } from "./mailbox-registry.js";
 import { forgetCandidate, getResumeState } from "./resume-state.js";
@@ -7,6 +11,35 @@ import { forgetCandidate, getResumeState } from "./resume-state.js";
 const PACKAGE_NAME = "@imenam/mcp-messenger";
 /** Durée maximale d'un `Monitor` côté hôte : au-delà, l'hôte la ramène à cette valeur. */
 const MONITOR_TIMEOUT_MS = 1_800_000;
+/** Répertoire où `save_attachment` écrit quand l'agent ne donne pas de destination. */
+const DEFAULT_ATTACHMENT_DIR = path.join(os.tmpdir(), "mcp-messenger", "attachments");
+/** Type MIME déduit de l'extension, pour les formats courants. */
+const MIME_TYPES = {
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".csv": "text/csv",
+    ".json": "application/json",
+    ".xml": "application/xml",
+    ".yaml": "application/yaml",
+    ".yml": "application/yaml",
+    ".html": "text/html",
+    ".css": "text/css",
+    ".js": "text/javascript",
+    ".log": "text/plain",
+    ".pdf": "application/pdf",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".zip": "application/zip",
+    ".gz": "application/gzip",
+    ".tar": "application/x-tar",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+};
 const FOLDER_HINT = `Folder name. System folders: ${SYSTEM_FOLDERS.join(", ")}. Custom folders come from list_folders.`;
 export const TOOLS = [
     {
@@ -74,6 +107,11 @@ export const TOOLS = [
             additionalProperties: false,
         },
     },
+    {
+        name: "list_links",
+        description: "List the mailboxes the user has linked to this one from the web console, newest first: these are the correspondents you are meant to work with, with the reason the user gave. Write to them with send_message, using the address listed here. Links arrive while you work — the notification watcher announces each new one — and whoami lists them too.",
+        inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    },
     {
         name: "list_agents",
         description: "List the mailboxes known to the server, grouped by agent name — one group per project, one line per session mailbox inside it, most recently active first. An agent name is shared by every session of the same project, so a group with several lines means several live sessions, each with its own mailbox address. Your own mailbox is never listed — you cannot write to yourself. Use it to find the mailbox address you want to write to; pass agent_name to expand a group whose sessions were not all listed.",
@@ -107,6 +145,23 @@ export const TOOLS = [
                     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 (same effect as rename_thread).",
                 },
                 thread_description: { type: "string", description: "Optional longer description of the thread." },
+                attachments: {
+                    type: "array",
+                    maxItems: MAX_ATTACHMENTS,
+                    description: `Files to attach, read from this machine's disk. At most ${MAX_ATTACHMENTS} files, ${formatBytes(MAX_ATTACHMENT_BYTES)} each and ${formatBytes(MAX_ATTACHMENTS_TOTAL_BYTES)} in total. The recipient saves them with save_attachment.`,
+                    items: {
+                        type: "object",
+                        properties: {
+                            path: {
+                                type: "string",
+                                description: "Path of the file to attach. Prefer an absolute path; a relative one is resolved against this MCP server's working directory.",
+                            },
+                            name: { type: "string", description: "File name shown to the recipient. Defaults to the file's own name." },
+                        },
+                        required: ["path"],
+                        additionalProperties: false,
+                    },
+                },
             },
             required: ["to", "subject", "body"],
             additionalProperties: false,
@@ -152,6 +207,23 @@ export const TOOLS = [
             additionalProperties: false,
         },
     },
+    {
+        name: "save_attachment",
+        description: "Save a file attached to a message of this mailbox onto this machine's disk, and return the path it was written to. Attachment ids are listed under the message by read_message and get_thread. Read the saved file with your usual file tools.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                attachment_id: { type: "string", description: "Attachment id (att_…) shown under the message." },
+                path: {
+                    type: "string",
+                    description: "Where to save it: an existing directory (the file keeps its name) or a file path. Defaults to a directory under the system temp folder.",
+                },
+                overwrite: { type: "boolean", description: "Replace an existing file at that path. Defaults to false." },
+            },
+            required: ["attachment_id"],
+            additionalProperties: false,
+        },
+    },
     {
         name: "mark_messages",
         description: "Mark messages as read or unread, and/or star or unstar them.",
@@ -244,6 +316,15 @@ const schemas = {
         reply_to: z.string().optional(),
         thread_name: z.string().trim().min(1).max(200).optional(),
         thread_description: z.string().trim().min(1).max(2000).optional(),
+        attachments: z
+            .array(z.object({ path: z.string().trim().min(1), name: z.string().trim().min(1).max(255).optional() }))
+            .max(MAX_ATTACHMENTS)
+            .optional(),
+    }),
+    save_attachment: z.object({
+        attachment_id: z.string().trim().min(1),
+        path: z.string().trim().min(1).optional(),
+        overwrite: z.boolean().optional(),
     }),
     list_messages: z.object({
         folder: z.string().optional(),
@@ -320,6 +401,7 @@ export async function callTool(client, name, rawArgs) {
             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 links = await client.listLinks();
             const lines = [
                 `Mailbox address: ${client.agentId}`,
                 // Personne n'a besoin qu'on la lui envoie : l'annuaire la donne, et chaque message
@@ -335,6 +417,7 @@ export async function callTool(client, name, rawArgs) {
                 self?.display_name
                     ? `Mailbox name: ${self.display_name}`
                     : "Mailbox name: none — call rename_mailbox so the user can tell this session apart from the others.",
+                ...linkLines(links),
             ];
             if (client.isAttachedElsewhere) {
                 lines.push(`Attached to another mailbox. This session's own mailbox is ${client.sessionAgentId}.`);
@@ -415,16 +498,31 @@ export async function callTool(client, name, rawArgs) {
                 return `No thread in this mailbox${scope} matching these filters.`;
             return [`${threads.length} thread(s)${scope}:`, "", ...threads.map(formatThread)].join("\n");
         }
+        case "list_links": {
+            const links = await client.listLinks();
+            if (links.length === 0) {
+                return "No mailbox is linked to this one yet. The user links mailboxes from the web console; the notification watcher announces each new link.";
+            }
+            return [
+                `${links.length} mailbox(es) linked to this one by the user, newest first:`,
+                "",
+                ...links.map(formatLink),
+                "",
+                "Write to them with send_message, using the address shown. Do not repeat the address in the message body.",
+            ].join("\n");
+        }
         case "list_agents": {
             const input = schemas.list_agents.parse(args);
             const agents = await client.listAgents();
             if (agents.length === 0)
                 return "No other mailbox on this server yet.";
+            const linked = new Set((await client.listLinks()).map((link) => link.correspondent.id));
             const groups = groupByAgentName(agents);
-            return input.agent_name ? formatAgentGroup(groups, input.agent_name) : formatDirectory(groups);
+            return input.agent_name ? formatAgentGroup(groups, input.agent_name, linked) : formatDirectory(groups, linked);
         }
         case "send_message": {
             const input = schemas.send_message.parse(args);
+            const attachments = await readAttachments(input.attachments ?? []);
             const result = await client.sendMessage({
                 to: input.to,
                 subject: input.subject,
@@ -434,12 +532,16 @@ export async function callTool(client, name, rawArgs) {
                 // Le protocole HTTP et le stockage gardent `thread_title` ; seul l'outil dit `thread_name`.
                 thread_title: input.thread_name ?? null,
                 thread_description: input.thread_description ?? null,
+                attachments,
             });
             const lines = [
                 `Message sent: ${result.message_id}`,
                 `Thread: ${formatThreadRef(result.thread_title, result.thread_id)}`,
                 `Delivered to: ${result.delivered_to}`,
             ];
+            if (attachments.length > 0) {
+                lines.push(`Attachments: ${attachments.map((a) => a.filename).join(", ")}`);
+            }
             if (!result.thread_title && !input.reply_to) {
                 lines.push("This thread has no name yet — rename_thread with its thread_id makes it readable for everyone.");
             }
@@ -472,6 +574,22 @@ export async function callTool(client, name, rawArgs) {
                 .join("\n");
             return [header, "", ...messages.map(formatMessage)].join("\n\n---\n\n");
         }
+        case "save_attachment": {
+            const input = schemas.save_attachment.parse(args);
+            const attachment = await client.downloadAttachment(input.attachment_id);
+            const target = await attachmentTarget(input.path, input.attachment_id, attachment.filename);
+            await mkdir(path.dirname(target), { recursive: true });
+            try {
+                await writeFile(target, attachment.data, { flag: input.overwrite ? "w" : "wx" });
+            }
+            catch (error) {
+                if (error.code === "EEXIST") {
+                    throw new Error(`a file already exists at ${target} — pass overwrite: true or choose another path`);
+                }
+                throw error;
+            }
+            return `Saved ${attachment.filename} (${attachment.mime_type}, ${formatBytes(attachment.data.length)}) to ${target}`;
+        }
         case "mark_messages": {
             const input = schemas.mark_messages.parse(args);
             if (input.read === undefined && input.starred === undefined) {
@@ -567,6 +685,42 @@ export async function callTool(client, name, rawArgs) {
             throw new Error(`Unknown tool: ${name}`);
     }
 }
+/** Lit sur le disque local les fichiers à joindre, en refusant d'emblée ceux qui dépassent les limites. */
+async function readAttachments(entries) {
+    let total = 0;
+    const attachments = [];
+    for (const entry of entries) {
+        const file = path.resolve(entry.path);
+        const info = await stat(file).catch(() => null);
+        if (!info?.isFile())
+            throw new Error(`attachment is not a readable file: ${file}`);
+        if (info.size > MAX_ATTACHMENT_BYTES) {
+            throw new Error(`attachment exceeds ${formatBytes(MAX_ATTACHMENT_BYTES)}: ${file} (${formatBytes(info.size)})`);
+        }
+        total += info.size;
+        if (total > MAX_ATTACHMENTS_TOTAL_BYTES) {
+            throw new Error(`attachments exceed ${formatBytes(MAX_ATTACHMENTS_TOTAL_BYTES)} in total`);
+        }
+        const filename = entry.name ?? path.basename(file);
+        attachments.push({
+            filename,
+            mime_type: MIME_TYPES[path.extname(filename).toLowerCase()] ?? null,
+            content_base64: (await readFile(file)).toString("base64"),
+        });
+    }
+    return attachments;
+}
+/**
+ * Chemin d'écriture d'une pièce jointe : dans le répertoire donné sous son propre nom, au
+ * chemin donné s'il désigne un fichier, ou dans un répertoire temporaire propre à la pièce.
+ */
+async function attachmentTarget(requested, attachmentId, filename) {
+    if (!requested)
+        return path.join(DEFAULT_ATTACHMENT_DIR, attachmentId, filename);
+    const resolved = path.resolve(requested);
+    const isDirectory = /[\\/]$/.test(requested) || (await stat(resolved).catch(() => null))?.isDirectory();
+    return isDirectory ? path.join(resolved, filename) : resolved;
+}
 async function renameMailbox(client, name, description) {
     const agent = await client.updateProfile({ display_name: name, description });
     return [
@@ -611,9 +765,9 @@ function groupByAgentName(agents) {
     return [...groups.values()];
 }
 /** `boîte — nom · activité` : une ligne par session, l'adresse en tête car c'est elle qu'on copie. */
-function formatMailboxLine(agent) {
+function formatMailboxLine(agent, linked) {
     const seen = agent.last_activity_at ? `last active ${agent.last_activity_at}` : "never active";
-    const flags = agent.registered ? "" : " · never connected";
+    const flags = `${agent.registered ? "" : " · never connected"}${linked.has(agent.id) ? " · linked to you" : ""}`;
     return `  • ${agent.id} — ${agent.display_name ?? "no mailbox name"} · ${seen}${flags}`;
 }
 /**
@@ -630,7 +784,7 @@ const DIRECTORY_FOOTER = [
     "is never listed here. Always write to a mailbox address taken from this list, never to a name.",
     "To see what you have already exchanged with one of them, call list_threads with its address in with_mailbox.",
 ];
-function formatDirectory(groups) {
+function formatDirectory(groups, linked) {
     const mailboxes = groups.reduce((total, group) => total + group.mailboxes.length, 0);
     const blocks = groups.map((group) => {
         const sessions = group.mailboxes.length;
@@ -640,7 +794,7 @@ function formatDirectory(groups) {
         // Un agent à sessions nombreuses ne doit pas noyer les autres : les plus récentes
         // suffisent à écrire, `agent_name` donne le reste à qui en a besoin.
         const shown = sessions > SESSIONS_SHOWN_PER_AGENT ? group.mailboxes.slice(0, 3) : group.mailboxes;
-        lines.push(...shown.map(formatMailboxLine));
+        lines.push(...shown.map((agent) => formatMailboxLine(agent, linked)));
         if (shown.length < sessions) {
             lines.push(`  … ${sessions - shown.length} more session(s) — list_agents with agent_name: "${group.name}" lists them all.`);
         }
@@ -656,7 +810,7 @@ function formatDirectory(groups) {
     ].join("\n");
 }
 /** Toutes les sessions d'un agent, décrites une par une : le second niveau de l'annuaire. */
-function formatAgentGroup(groups, requested) {
+function formatAgentGroup(groups, requested, linked) {
     const wanted = requested.trim().toLowerCase();
     const group = groups.find((g) => g.name.toLowerCase() === wanted);
     if (!group) {
@@ -669,7 +823,7 @@ function formatAgentGroup(groups, requested) {
             `• ${agent.id}`,
             `  Mailbox: ${agent.display_name ?? "not named — this session never said what it works on"}`,
             agent.description ? `  ${agent.description}` : null,
-            `  ${seen}${agent.registered ? "" : " · never connected"}`,
+            `  ${seen}${agent.registered ? "" : " · never connected"}${linked.has(agent.id) ? " · linked to you" : ""}`,
         ]
             .filter(Boolean)
             .join("\n");
@@ -729,6 +883,23 @@ function resumeLines(client) {
     }
     return lines;
 }
+/** Ce que `whoami` dit des liaisons posées par l'utilisateur sur cette boîte. */
+function linkLines(links) {
+    if (links.length === 0) {
+        return ["Linked mailboxes: none yet — the user links mailboxes from the web console."];
+    }
+    return [
+        "Linked mailboxes — correspondents the user designated for this session:",
+        ...links.map((link) => `  ${formatLink(link)}`),
+        "  ↳ write to them with send_message; list_links details them.",
+    ];
+}
+/** `• adresse — Agent · Boîte · liée le … — motif` */
+function formatLink(link) {
+    const names = formatAgentNames(link.correspondent) || "unnamed mailbox";
+    const note = link.note ? ` — ${link.note}` : "";
+    return `• ${link.correspondent.id} — ${names} · linked ${link.created_at}${note}`;
+}
 /** `titre (id)`, ou l'id seul tant que le fil n'a pas été nommé. */
 function formatThreadRef(title, threadId) {
     return title ? `${title} (${threadId})` : threadId;
@@ -752,7 +923,7 @@ function formatSummary(message) {
         `${flags} ${message.subject}${priority}`,
         `   from ${message.from} to ${message.to || "—"} · ${message.created_at}`,
         `   ${message.preview}`,
-        `   id ${message.message_id} · thread ${formatThreadRef(message.thread_title, message.thread_id)}`,
+        `   id ${message.message_id} · thread ${formatThreadRef(message.thread_title, message.thread_id)}${message.attachments.length > 0 ? ` · ${message.attachments.length} attachment(s)` : ""}`,
     ].join("\n");
 }
 function formatMessage(message) {
@@ -767,5 +938,11 @@ function formatMessage(message) {
     ]
         .filter(Boolean)
         .join("\n");
-    return `${header}\n\n${message.body}`;
+    const attachments = message.attachments.length > 0
+        ? `\n\nAttachments (save with save_attachment):\n${message.attachments.map(formatAttachment).join("\n")}`
+        : "";
+    return `${header}\n\n${message.body}${attachments}`;
+}
+function formatAttachment(attachment) {
+    return `  ${attachment.attachment_id} · ${attachment.filename} (${attachment.mime_type}, ${formatBytes(attachment.size)})`;
 }