@imenam/mcp-messenger 1.0.1 → 1.0.2

package/.env.example

@@ -15,7 +15,7 @@ MESSENGER_PORT=3600
 
 # Jeton exigé sur TOUTE requête entrante (API, /health, console web).
 # OBLIGATOIRE : sans MESSENGER_TOKEN ni MESSENGER_AGENT_TOKENS, le serveur refuse
-# de démarrer. Générer par exemple avec : node -e "console.log(crypto.randomUUID())"
+# de démarrer. Générer avec : npx @imenam/mcp-messenger --generate-token
 MESSENGER_TOKEN=change-me
 
 # Alternative plus stricte : un jeton par agent (prioritaire sur MESSENGER_TOKEN).

package/README.md

@@ -37,7 +37,10 @@ identifiée par une adresse opaque du type `box_9f2c4a01b3d7e5f8` — voir
 ### 1. Lancer la boîte aux lettres
 
 ```bash
-MESSENGER_TOKEN=$(node -e "console.log(crypto.randomUUID())") npx @imenam/mcp-messenger --server
+# Un jeton, à conserver : il sera demandé au serveur, aux agents et à la console.
+npx @imenam/mcp-messenger --generate-token
+
+MESSENGER_TOKEN=<le-jeton> npx @imenam/mcp-messenger --server
 # → listening on http://127.0.0.1:3600 (loopback only)
 # → auth: shared token — required on every request
 # → web console: http://127.0.0.1:3600/ui/?token=<MESSENGER_ADMIN_TOKEN>
@@ -93,7 +96,9 @@ la session MCP démarre quand même et l'enregistrement se fera au premier appel
 
 L'agent A appelle `send_message` avec `to: ["coder"]`, l'agent B voit le message via
 `list_messages` puis `read_message`, et répond avec `reply_to` pour rester dans le fil.
-`wait_for_message` permet d'attendre une réponse sans faire tourner une boucle d'appels.
+`wait_for_message` permet d'attendre une réponse sans faire tourner une boucle d'appels : il ne
+rend la main que sur un message arrivé *après* le début de l'attente, les non-lus déjà en boîte
+ne l'interrompent pas.
 
 ---
 
@@ -114,7 +119,7 @@ L'agent A appelle `send_message` avec `to: ["coder"]`, l'agent B voit le message
 | `delete_messages` | Corbeille, ou suppression définitive (`permanent: true`) |
 | `list_folders` | Dossiers avec totaux et non-lus |
 | `create_folder` / `delete_folder` | Organiser l'espace comme une messagerie |
-| `wait_for_message` | Attente longue (jusqu'à 300 s) jusqu'à l'arrivée d'un message |
+| `wait_for_message` | Attente longue (jusqu'à 300 s) jusqu'à l'arrivée d'un message *postérieur* à l'appel |
 
 **Dossiers système** — toujours présents, non supprimables : `inbox`, `sent`, `archive`,
 `trash`. Les dossiers personnalisés sont propres à chaque boîte.
@@ -203,7 +208,7 @@ Toutes les variables sont documentées dans [`.env.example`](.env.example). L'es
 | `MESSENGER_PORT` | `3600` | Port d'écoute |
 | `MESSENGER_HOST` | `127.0.0.1` (figé) | Non configurable ; une valeur non-loopback fait échouer le démarrage |
 | `MESSENGER_DB_PATH` | `./data/messenger.db` | Fichier SQLite |
-| `MESSENGER_TOKEN` | — | **Obligatoire** (sauf si `MESSENGER_AGENT_TOKENS`) : jeton exigé sur toute requête |
+| `MESSENGER_TOKEN` | — | **Obligatoire** (sauf si `MESSENGER_AGENT_TOKENS`) : jeton exigé sur toute requête. `--generate-token` en produit un |
 | `MESSENGER_AGENT_TOKENS` | — | Un jeton par agent : `planner:tok-a,coder:tok-b` |
 | `MESSENGER_ADMIN_TOKEN` | `MESSENGER_TOKEN` | Jeton de la console ; obligatoire si seul `MESSENGER_AGENT_TOKENS` est défini |
 | `MESSENGER_RATE_LIMIT_MAX` | `600` | Requêtes par IP et par fenêtre |
@@ -278,6 +283,7 @@ cet agent lorsque `MESSENGER_AGENT_TOKENS` est utilisé.
 
 ```bash
 npm install
+npm run generate-token   # jeton aléatoire (32 octets, base64url)
 npm run build        # tsc + copie des fichiers de la console web
 npm test             # build puis suite Vitest complète
 npm run test:watch
@@ -303,7 +309,7 @@ test/                   # store, config, API HTTP, outils MCP, binaire réel
 
 ### Tests
 
-81 tests couvrant : le stockage et l'isolation des boîtes, la validation de configuration,
+86 tests couvrant : le stockage et l'isolation des boîtes, la validation de configuration,
 l'API HTTP et son authentification (refus systématique sans jeton, jeton partagé, jetons par
 agent, jeton de console distinct), les outils MCP de bout en bout (deux agents qui
 conversent à travers un vrai serveur), l'allocation des boîtes par session — deux processus

package/dist/src/cli/generate-token.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Génère un jeton aléatoire cryptographiquement sûr.
+ *
+ * L'encodage `base64url` est choisi pour que le jeton passe tel quel dans l'URL de la
+ * console web (`/ui/?token=…`) : ni `+`, ni `/`, ni `=` à échapper.
+ */
+export declare function generateToken(bytes?: number): string;

package/dist/src/cli/generate-token.js

@@ -0,0 +1,12 @@
+import { randomBytes } from "node:crypto";
+/** 32 octets : hors de portée d'une attaque par force brute, même sans rate limiting. */
+const DEFAULT_BYTES = 32;
+/**
+ * Génère un jeton aléatoire cryptographiquement sûr.
+ *
+ * L'encodage `base64url` est choisi pour que le jeton passe tel quel dans l'URL de la
+ * console web (`/ui/?token=…`) : ni `+`, ni `/`, ni `=` à échapper.
+ */
+export function generateToken(bytes = DEFAULT_BYTES) {
+    return randomBytes(bytes).toString("base64url");
+}

package/dist/src/index.js

@@ -10,6 +10,8 @@ Usage:
   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 --generate-token
+                             Print a fresh random token for MESSENGER_TOKEN.
   mcp-messenger --version    Print the version.
   mcp-messenger --help       Print this help.
 
@@ -28,6 +30,21 @@ async function main() {
         process.stdout.write(`${APP_VERSION}\n`);
         return;
     }
+    // Le jeton part seul sur stdout : la commande reste utilisable dans un pipe
+    // (`mcp-messenger --generate-token > token.txt`), les conseils vont sur stderr.
+    if (args.includes("--generate-token")) {
+        const { generateToken } = await import("./cli/generate-token.js");
+        process.stdout.write(`${generateToken()}\n`);
+        process.stderr.write([
+            "",
+            "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>",
+            "",
+        ].join("\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")) {

package/dist/src/mcp/tools.js

@@ -168,7 +168,7 @@ export const TOOLS = [
     },
     {
         name: "wait_for_message",
-        description: "Block until a new message lands in the mailbox, or until the timeout expires. Use it to wait for another agent's answer instead of polling list_messages.",
+        description: "Block until a message arrives AFTER this call starts, or until the timeout expires. Messages already in the mailbox — even unread ones — do not end the wait. Use it to wait for another agent's answer instead of polling list_messages.",
         inputSchema: {
             type: "object",
             properties: {

package/dist/src/server/app.js

@@ -186,16 +186,15 @@ export function createApp({ store, config }) {
     api.delete("/folders/:name", (req, res) => {
         res.json({ moved: store.deleteFolder(req.agentId, String(req.params.name)) });
     });
-    // Attente longue : la réponse part dès qu'un message arrive, sinon au bout du délai.
+    // 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).
     api.get("/wait", (req, res) => {
         const { timeout_seconds, folder } = waitQuerySchema.parse(req.query);
         const agentId = req.agentId;
         const timeoutSeconds = Math.min(timeout_seconds ?? 30, config.maxWaitSeconds);
-        const pending = store.listMessages(agentId, { folder: folder ?? "inbox", unread_only: true, limit: 1 });
-        const first = pending[0];
-        if (first) {
-            res.json({ timed_out: false, message: store.getMessage(agentId, first.message_id, false) });
-            return;
+        if (folder && !store.listFolders(agentId).some((f) => f.name === folder)) {
+            throw new MessengerError(`unknown folder: ${folder}`, 404);
         }
         const done = (payload) => {
             clearTimeout(timer);

package/dist/src/version.d.ts

@@ -1 +1 @@
-export declare const APP_VERSION = "1.0.1";
+export declare const APP_VERSION = "1.0.2";

package/dist/src/version.js

@@ -1,2 +1,2 @@
 // Généré par scripts/generate-version.js — ne pas modifier à la main.
-export const APP_VERSION = "1.0.1";
+export const APP_VERSION = "1.0.2";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imenam/mcp-messenger",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "main": "dist/src/index.js",
   "scripts": {
     "test": "npm run build && vitest run",
@@ -11,7 +11,8 @@
     "release": "npm version patch && npm publish && git push --follow-tags",
     "typecheck": "tsc --noEmit",
     "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage"
+    "test:coverage": "vitest run --coverage",
+    "generate-token": "node dist/src/index.js --generate-token"
   },
   "keywords": [
     "mcp",