@imenam/mcp-messenger 1.0.32 → 1.0.33

package/dist/src/server/console-session.js

@@ -1,72 +1,20 @@
-import { randomBytes, timingSafeEqual } from "node:crypto";
+import { generateSetupCode, safeEqual } from "../core/credentials.js";
 /**
  * Sessions de la console web.
  *
- * Le navigateur ne peut pas poser d'en-tête sur une navigation, et faire transiter le
- * jeton dans l'URL le dépose dans l'historique et les journaux d'accès du proxy. La
- * console s'ouvre donc sans jeton, le demande une fois dans un formulaire, et reçoit en
- * retour un identifiant de session opaque dans un cookie `HttpOnly`.
+ * La console s'ouvre avec un nom d'utilisateur et un mot de passe, et reçoit en retour un
+ * identifiant de session opaque dans un cookie `HttpOnly`. Le serveur n'en garde que
+ * l'empreinte, en base : une session survit à un redémarrage, et se ferme depuis la page
+ * « Mon compte ».
  *
- * Le cookie ne porte jamais le jeton lui-même : sa fuite ne donne qu'une session, à durée
- * limitée, que le serveur oublie au redémarrage. Il n'est honoré que sur `/admin` et
- * `/ui` : l'API des agents reste sur le Bearer, un site tiers ne peut donc pas faire
- * agir un agent à travers le navigateur de l'administrateur.
+ * Le cookie n'est honoré que sur `/admin` et `/ui` : l'API des agents reste sur la clé
+ * API, un site tiers ne peut donc pas faire agir un agent à travers le navigateur.
  */
 export const CONSOLE_COOKIE = "messenger_console";
-/** Durée de vie d'une session : assez pour une journée de supervision, pas plus. */
-const SESSION_TTL_MS = 12 * 60 * 60 * 1000;
-export class ConsoleSessions {
-    ttlMs;
-    now;
-    sessions = new Map();
-    constructor(ttlMs = SESSION_TTL_MS, now = Date.now) {
-        this.ttlMs = ttlMs;
-        this.now = now;
-    }
-    /** Ouvre une session et rend son identifiant, seul contenu du cookie. */
-    create() {
-        this.prune();
-        const id = randomBytes(32).toString("base64url");
-        this.sessions.set(id, { expiresAt: this.now() + this.ttlMs });
-        return id;
-    }
-    /** Vrai si l'identifiant désigne une session encore valide. */
-    has(id) {
-        if (!id)
-            return false;
-        // Parcours à temps constant : la Map compare ses clés en temps variable, ce qui
-        // laisserait deviner un identifiant octet par octet.
-        let match = null;
-        const presented = Buffer.from(id);
-        for (const [key, session] of this.sessions) {
-            const candidate = Buffer.from(key);
-            if (candidate.length === presented.length && timingSafeEqual(candidate, presented))
-                match = session;
-        }
-        if (!match)
-            return false;
-        if (match.expiresAt <= this.now()) {
-            this.sessions.delete(id);
-            return false;
-        }
-        return true;
-    }
-    revoke(id) {
-        if (id)
-            this.sessions.delete(id);
-    }
-    get size() {
-        this.prune();
-        return this.sessions.size;
-    }
-    prune() {
-        const now = this.now();
-        for (const [id, session] of this.sessions) {
-            if (session.expiresAt <= now)
-                this.sessions.delete(id);
-        }
-    }
-}
+/** Durée d'une session ordinaire : assez pour une journée de supervision, pas plus. */
+export const SESSION_TTL_MS = 12 * 60 * 60 * 1000;
+/** Durée d'une session ouverte avec « rester connecté ». */
+export const PERSISTENT_SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 /** Identifiant de session porté par la requête, s'il y en a un. */
 export function consoleSessionId(req) {
     const header = req.headers.cookie;
@@ -83,3 +31,38 @@ export function consoleSessionId(req) {
     }
     return null;
 }
+/**
+ * Code d'installation : il garde la création du premier compte.
+ *
+ * Tant qu'aucun compte n'existe, la console propose de le créer, et le premier visiteur
+ * venu le pourrait. Le code, écrit dans le journal du serveur au démarrage, prouve qu'on a
+ * accès à la machine. Il ne vit qu'en mémoire, change à chaque démarrage, et ne sert qu'une
+ * fois : dès qu'un compte existe, il n'y a plus rien à garder.
+ */
+export class SetupGate {
+    access;
+    code;
+    constructor(access) {
+        this.access = access;
+        this.code = access.hasUsers() ? null : generateSetupCode();
+    }
+    /** Le code à recopier, tant qu'aucun compte n'existe. */
+    get pendingCode() {
+        return this.access.hasUsers() ? null : this.code;
+    }
+    get required() {
+        return this.pendingCode !== null;
+    }
+    /** Vrai si le code présenté est le bon. Les tirets et la casse ne comptent pas. */
+    accepts(presented) {
+        const code = this.pendingCode;
+        if (!code)
+            return false;
+        const normalize = (value) => value.toUpperCase().replace(/[^A-Z0-9]/g, "");
+        return safeEqual(normalize(presented), normalize(code));
+    }
+    /** Le code a servi : il ne vaut plus rien. */
+    consume() {
+        this.code = null;
+    }
+}

package/dist/src/server/start.d.ts

@@ -1,10 +1,13 @@
 import type { Server } from "node:http";
+import { SetupGate } from "./console-session.js";
 import { type ServerConfig } from "../config.js";
 import { MessageStore } from "../core/store.js";
 export interface RunningServer {
     server: Server;
     store: MessageStore;
     config: ServerConfig;
+    /** Garde de la création du premier compte : son code est écrit dans le journal. */
+    setup: SetupGate;
     url: string;
     close: () => Promise<void>;
 }

package/dist/src/server/start.js

@@ -1,4 +1,5 @@
 import { createApp } from "./app.js";
+import { SetupGate } from "./console-session.js";
 import { loadServerConfig } from "../config.js";
 import { MessageStore } from "../core/store.js";
 import { logger } from "../logger.js";
@@ -6,7 +7,8 @@ import { APP_VERSION } from "../version.js";
 /** Démarre la boîte aux lettres. `port: 0` laisse l'OS choisir (utilisé par les tests). */
 export async function startServer(config = loadServerConfig()) {
     const store = new MessageStore(config.dbPath);
-    const app = createApp({ store, config });
+    const setup = new SetupGate(store.access);
+    const app = createApp({ store, config, setup });
     const server = await new Promise((resolve, reject) => {
         const httpServer = app.listen(config.port, config.host, () => resolve(httpServer));
         httpServer.once("error", reject);
@@ -31,26 +33,21 @@ export async function startServer(config = loadServerConfig()) {
         await new Promise((resolve) => server.close(() => resolve()));
         store.close();
     };
-    return { server, store, config, url, close };
+    return { server, store, config, setup, url, close };
 }
 /** Point d'entrée du mode serveur (`mcp-messenger --server`). */
 export async function runServerMode() {
     const config = loadServerConfig();
     const running = await startServer(config);
-    const authMode = config.agentTokens.size > 0
-        ? `per-agent tokens (${config.agentTokens.size})${config.token ? " + shared token" : ""}`
-        : "shared token";
     logger.info(`mcp-messenger v${APP_VERSION} listening on ${running.url} (loopback only)`);
     logger.info(`database: ${config.dbPath}`);
-    logger.info(`auth: ${authMode} — required on every request`);
-    // Le jeton partagé prouve qu'on fait partie de la flotte, pas qu'on est telle boîte :
-    // `X-Agent-Id` n'est alors adossé à rien. Le dire ici, sinon la ligne au-dessus se lit
-    // comme une garantie de cloisonnement qu'elle ne donne pas.
-    if (config.agentTokens.size === 0) {
-        logger.warn("shared token: no isolation between mailboxes — any holder can act as any address");
-        logger.warn("set MESSENGER_AGENT_TOKENS (one token per agent) to compartmentalize");
+    logger.info("auth: API keys on every agent request, console account on the web console");
+    logger.info(`web console: ${running.url}/ui/`);
+    const code = running.setup.pendingCode;
+    if (code) {
+        logger.warn("no console account yet — open the web console to create it");
+        logger.warn(`setup code: ${code}`);
     }
-    logger.info(`web console: ${running.url}/ui/ (asks for MESSENGER_ADMIN_TOKEN once)`);
     let shuttingDown = false;
     const shutdown = (signal) => {
         if (shuttingDown)