@imenam/mcp-messenger 1.0.31 → 1.0.33

package/dist/src/cli/reset-password.d.ts

@@ -0,0 +1,12 @@
+export interface ResetPasswordResult {
+    username: string;
+    password: string;
+    closedSessions: number;
+}
+/**
+ * Donne un mot de passe neuf au compte de la console, et ferme toutes ses sessions.
+ *
+ * La commande lit la base du serveur directement : c'est l'accès à la machine qui
+ * l'autorise, comme le code d'installation à la création du compte.
+ */
+export declare function resetPassword(dbPath?: string): Promise<ResetPasswordResult>;

package/dist/src/cli/reset-password.js

@@ -0,0 +1,29 @@
+import { ConfigError, resolveDbPath } from "../config.js";
+import { generatePassword, hashPassword } from "../core/credentials.js";
+import { MessageStore } from "../core/store.js";
+/**
+ * Donne un mot de passe neuf au compte de la console, et ferme toutes ses sessions.
+ *
+ * La commande lit la base du serveur directement : c'est l'accès à la machine qui
+ * l'autorise, comme le code d'installation à la création du compte.
+ */
+export async function resetPassword(dbPath = resolveDbPath()) {
+    const store = new MessageStore(dbPath);
+    try {
+        const users = store.access.listUsers();
+        if (users.length === 0) {
+            throw new ConfigError(`no console account in ${dbPath}: open the web console to create it.`);
+        }
+        if (users.length > 1) {
+            throw new ConfigError(`${users.length} console accounts in ${dbPath}: expected exactly one.`);
+        }
+        const user = users[0];
+        const password = generatePassword();
+        store.access.setPassword(user.id, await hashPassword(password));
+        const closedSessions = store.access.revokeOtherSessions(user.id, null);
+        return { username: user.username, password, closedSessions };
+    }
+    finally {
+        store.close();
+    }
+}

package/dist/src/cli/setup-mcp.d.ts

@@ -1,6 +1,10 @@
 export interface SetupMcpOptions {
     cwd: string;
     force: boolean;
+    /** URL du serveur à écrire ; défaut : le serveur local. */
+    serverUrl?: string | null;
+    /** Clé API à écrire ; laissée vide sinon. */
+    apiKey?: string | null;
 }
 /** Écrit l'entrée `mcp-messenger` dans le `.mcp.json` du répertoire courant. */
-export declare function runSetupMcp({ cwd, force }: SetupMcpOptions): number;
+export declare function runSetupMcp({ cwd, force, serverUrl, apiKey }: SetupMcpOptions): number;

package/dist/src/cli/setup-mcp.js

@@ -3,36 +3,19 @@ import path from "node:path";
 const SERVER_NAME = "mcp-messenger";
 const PACKAGE_NAME = "@imenam/mcp-messenger";
 const DEFAULT_SERVER_URL = "http://127.0.0.1:3600";
-/** "Mon Projet_2" -> "mon-projet-2" : un identifiant d'agent lisible et sans espace. */
-function toAgentId(folder) {
-    const slug = folder
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "");
-    return slug || "agent";
-}
-/** "mon-projet" -> "Mon Projet" */
-function toDisplayName(folder) {
-    return toAgentId(folder)
-        .split("-")
-        .filter(Boolean)
-        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-        .join(" ");
-}
-function buildServerEntry(cwd) {
-    // Le dossier courant donne une adresse d'agent par défaut : deux projets différents
-    // ne se retrouvent pas avec la même boîte aux lettres.
-    const folder = path.basename(cwd) || "agent";
+function buildServerEntry(options) {
     return {
         command: "npx",
         args: ["-y", PACKAGE_NAME],
         env: {
-            MESSENGER_SERVER_URL: DEFAULT_SERVER_URL,
-            MESSENGER_TOKEN: "",
+            MESSENGER_SERVER_URL: options.serverUrl ?? DEFAULT_SERVER_URL,
+            MESSENGER_API_KEY: options.apiKey ?? "",
             // Laissé vide : chaque session reçoit sa propre boîte. Le renseigner force au
             // contraire toutes les sessions de ce projet à partager une même adresse.
             MESSENGER_AGENT_ID: "",
-            MESSENGER_AGENT_NAME: toDisplayName(folder),
+            // Laissé vide : une clé liée à un agent donne son nom. Seule une clé valable pour
+            // tous les agents en demande un ici.
+            MESSENGER_AGENT_NAME: "",
             MESSENGER_AGENT_DESCRIPTION: "",
             MESSENGER_TIMEOUT_MS: "15000",
         },
@@ -40,11 +23,11 @@ function buildServerEntry(cwd) {
 }
 const REQUIRED_VARS = [
     ["MESSENGER_SERVER_URL", `URL du serveur boîte aux lettres (défaut : ${DEFAULT_SERVER_URL})`],
-    ["MESSENGER_TOKEN", "jeton du serveur — À REMPLIR, le MCP ne peut rien faire sans lui"],
+    ["MESSENGER_API_KEY", "clé API créée dans la console (onglet Clés API) — le MCP ne peut rien faire sans elle"],
 ];
 const OPTIONAL_VARS = [
     ["MESSENGER_AGENT_ID", "adresse fixe : à laisser vide pour une boîte par session"],
-    ["MESSENGER_AGENT_NAME", "nom de l'agent (le projet, typiquement) ; distinct du nom de la boîte, que l'agent pose lui-même"],
+    ["MESSENGER_AGENT_NAME", "nom de l'agent, pour une clé valable pour tous les agents ; une clé liée à un agent donne le sien"],
     ["MESSENGER_AGENT_DESCRIPTION", "à quoi sert cet agent, pour ses correspondants"],
     ["MESSENGER_TIMEOUT_MS", "délai maximal d'un appel HTTP (défaut : 15000)"],
 ];
@@ -88,7 +71,7 @@ function updateClaudeMd(cwd) {
     return "added";
 }
 /** Écrit l'entrée `mcp-messenger` dans le `.mcp.json` du répertoire courant. */
-export function runSetupMcp({ cwd, force }) {
+export function runSetupMcp({ cwd, force, serverUrl = null, apiKey = null }) {
     const target = path.join(cwd, ".mcp.json");
     let config = {};
     const exists = fs.existsSync(target);
@@ -119,7 +102,7 @@ export function runSetupMcp({ cwd, force }) {
         console.error("Relancez avec --force pour écraser cette entrée (les autres serveurs sont préservés).");
         return 1;
     }
-    config.mcpServers[SERVER_NAME] = buildServerEntry(cwd);
+    config.mcpServers[SERVER_NAME] = buildServerEntry({ serverUrl, apiKey });
     fs.writeFileSync(target, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
     const action = alreadyPresent ? "remplacée" : exists ? "ajoutée" : "créée";
     console.log(`Configuration ${SERVER_NAME} ${action} dans ${target}`);
@@ -142,16 +125,11 @@ export function runSetupMcp({ cwd, force }) {
         console.log(`  ${name.padEnd(28)} ${description}`);
     }
     console.log("");
-    console.log("Le serveur boîte aux lettres doit tourner à part, avec le même jeton client");
-    console.log("et un second jeton, réservé à la console — les deux doivent différer :");
-    console.log(`  npx -y ${PACKAGE_NAME} --generate-token   (une fois par jeton)`);
-    console.log(`  MESSENGER_TOKEN=<jeton-client> MESSENGER_ADMIN_TOKEN=<jeton-console> \\`);
-    console.log(`    npx -y ${PACKAGE_NAME} --server`);
-    console.log(`  console web : ${DEFAULT_SERVER_URL}/ui/ (le jeton console y est demandé une fois)`);
-    console.log("");
-    console.log("Le jeton client va dans le .mcp.json ci-dessus ; le jeton console n'y va jamais.");
-    console.log("Il ouvre toutes les boîtes de tous les projets et permet de les supprimer.");
-    console.log("");
+    if (!apiKey) {
+        console.log("La clé API se crée dans la console web du serveur (onglet Clés API). La console");
+        console.log("donne aussi cette commande avec --server-url et --api-key déjà remplis.");
+        console.log("");
+    }
     console.log("Chaque session d'agent reçoit sa propre boîte : demandez son adresse à l'agent");
     console.log("(outil whoami) pour la transmettre à un autre agent, ou pour la reprendre plus tard.");
     console.log("");

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

@@ -3,17 +3,17 @@
  *
  * Le watcher est lancé par l'agent via l'outil `Monitor` de l'hôte : c'est un processus
  * du shell de la session, pas un enfant du MCP. Il n'hérite donc **pas** du bloc `env`
- * du `.mcp.json`, et n'a ni URL de serveur ni jeton. Les passer sur la ligne de commande
+ * du `.mcp.json`, et n'a ni URL de serveur ni clé API. Les passer sur la ligne de commande
  * les afficherait dans la conversation ; ils transitent donc par un fichier en 0600 que
  * seule l'adresse de boîte permet de retrouver.
  *
  * Le fichier est écrit par `enable_notifications`, jamais au démarrage : une session qui
- * n'active pas les notifications ne dépose aucun jeton sur le disque.
+ * n'active pas les notifications ne dépose aucune clé sur le disque.
  */
 export interface Handoff {
     mailbox: string;
     serverUrl: string;
-    token: string | null;
+    apiKey: string;
     /** Horodatage d'écriture, utilisé pour purger les relais abandonnés. */
     written_at: string;
 }

package/dist/src/cli/watch-handoff.js

@@ -50,8 +50,8 @@ export function readHandoff(mailbox) {
     try {
         const parsed = JSON.parse(raw);
         // Le hachage identifie le fichier, le contenu confirme : un relais qui ne parle pas
-        // de cette boîte est ignoré plutôt qu'utilisé de travers.
-        return parsed.mailbox === mailbox ? parsed : null;
+        // de cette boîte, ou sans clé, est ignoré plutôt qu'utilisé de travers.
+        return parsed.mailbox === mailbox && typeof parsed.apiKey === "string" ? parsed : null;
     }
     catch {
         return null;

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

@@ -3,7 +3,7 @@ import type { LinkedMailbox, Message } from "../core/types.js";
 export interface WatchConfig {
     config: AgentConfig;
     mailbox: string;
-    /** D'où viennent l'URL et le jeton : utile au diagnostic quand rien n'arrive. */
+    /** D'où viennent l'URL et la clé : utile au diagnostic quand rien n'arrive. */
     source: "handoff" | "env";
 }
 /**

package/dist/src/cli/watch.js

@@ -1,4 +1,4 @@
-import { ConfigError } from "../config.js";
+import { ConfigError, requireApiKey } from "../config.js";
 import { MessengerClient } from "../client/messenger-client.js";
 import { logger } from "../logger.js";
 import { readHandoff } from "./watch-handoff.js";
@@ -35,7 +35,7 @@ export function resolveWatchConfig(mailbox, env = process.env) {
     const serverUrl = handoff?.serverUrl ?? env.MESSENGER_SERVER_URL?.trim();
     if (!serverUrl) {
         throw new ConfigError(`no connection details for mailbox \`${target}\`: the MCP session did not enable notifications ` +
-            "(call the enable_notifications tool first), or set MESSENGER_SERVER_URL and MESSENGER_TOKEN.");
+            "(call the enable_notifications tool first), or set MESSENGER_SERVER_URL and MESSENGER_API_KEY.");
     }
     return {
         mailbox: target,
@@ -43,7 +43,7 @@ export function resolveWatchConfig(mailbox, env = process.env) {
         config: {
             agentId: target,
             serverUrl: serverUrl.replace(/\/+$/, ""),
-            token: handoff?.token ?? env.MESSENGER_TOKEN?.trim() ?? null,
+            apiKey: handoff?.apiKey ?? requireApiKey(env),
             agentName: null,
             agentDescription: null,
             timeoutMs: Number(env.MESSENGER_TIMEOUT_MS) || 15_000,

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

@@ -26,7 +26,7 @@ export interface WaitResult {
  * Client HTTP du serveur boîte aux lettres.
  *
  * L'identité de l'agent voyage dans `X-Agent-Id` ; le serveur ne l'accepte que si le
- * jeton présenté correspond à sa configuration. C'est l'unique point de sortie réseau
+ * clé API présentée lui ouvre cette boîte. C'est l'unique point de sortie réseau
  * du mode MCP : les outils n'appellent jamais `fetch` directement.
  */
 export declare class MessengerClient {
@@ -49,12 +49,12 @@ export declare class MessengerClient {
     get isAttachedElsewhere(): boolean;
     get serverUrl(): string;
     /**
-     * Jeton de cette session, pour le seul relais vers le veilleur (`--watch`).
+     * Clé API de cette session, pour le seul relais vers le veilleur (`--watch`).
      *
      * Il ne doit jamais finir dans une réponse d'outil : ce que lit l'agent est lu par
      * l'utilisateur, et repart dans l'historique de la conversation.
      */
-    get tokenForHandoff(): string | null;
+    get apiKeyForHandoff(): string;
     health(): Promise<{
         status: string;
         version: string;

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

@@ -12,7 +12,7 @@ export class MessengerClientError extends Error {
  * Client HTTP du serveur boîte aux lettres.
  *
  * L'identité de l'agent voyage dans `X-Agent-Id` ; le serveur ne l'accepte que si le
- * jeton présenté correspond à sa configuration. C'est l'unique point de sortie réseau
+ * clé API présentée lui ouvre cette boîte. C'est l'unique point de sortie réseau
  * du mode MCP : les outils n'appellent jamais `fetch` directement.
  */
 export class MessengerClient {
@@ -54,13 +54,13 @@ export class MessengerClient {
         return this.config.serverUrl;
     }
     /**
-     * Jeton de cette session, pour le seul relais vers le veilleur (`--watch`).
+     * Clé API de cette session, pour le seul relais vers le veilleur (`--watch`).
      *
      * Il ne doit jamais finir dans une réponse d'outil : ce que lit l'agent est lu par
      * l'utilisateur, et repart dans l'historique de la conversation.
      */
-    get tokenForHandoff() {
-        return this.config.token;
+    get apiKeyForHandoff() {
+        return this.config.apiKey;
     }
     async health() {
         return this.request("GET", "/health");
@@ -190,8 +190,7 @@ export class MessengerClient {
             url.searchParams.set(key, String(value));
         }
         const headers = { "x-agent-id": this.agentId, accept: "application/json" };
-        if (this.config.token)
-            headers.authorization = `Bearer ${this.config.token}`;
+        headers.authorization = `Bearer ${this.config.apiKey}`;
         if (options.body !== undefined)
             headers["content-type"] = "application/json";
         try {

package/dist/src/config.d.ts

@@ -8,12 +8,6 @@ export interface ServerConfig {
     /** Toujours `127.0.0.1` — non configurable. */
     host: string;
     dbPath: string;
-    /** Jeton partagé accepté pour tous les agents (ignoré si `agentTokens` est renseigné). */
-    token: string | null;
-    /** Jeton dédié par agent : `agent_id -> token`. Prioritaire sur `token`. */
-    agentTokens: Map<string, string>;
-    /** Jeton de l'interface de supervision. Toujours distinct de `token`, et exigé. */
-    adminToken: string;
     /**
      * Valeur passée à `trust proxy` d'Express. Le serveur n'écoute qu'en loopback et se
      * déploie donc derrière un reverse proxy : sans ce réglage, `req.ip` vaut `127.0.0.1`
@@ -35,8 +29,12 @@ export interface AgentConfig {
     /** null = une boîte propre à cette session est allouée au démarrage. */
     agentId: string | null;
     serverUrl: string;
-    token: string | null;
-    /** Identité de l'agent, stable : d'où il écrit (le projet). Distincte du nom de la boîte. */
+    /** Clé API créée dans la console (`MESSENGER_API_KEY`). */
+    apiKey: string;
+    /**
+     * Nom d'agent posé par la configuration. Inutile avec une clé liée à un agent, qui donne
+     * le sien ; seule une clé valable pour tous les agents en a besoin.
+     */
     agentName: string | null;
     agentDescription: string | null;
     timeoutMs: number;
@@ -63,4 +61,11 @@ export declare function readSessionKey(env?: NodeJS.ProcessEnv): {
 } | null;
 export declare function isLoopbackHost(host: string): boolean;
 export declare function loadServerConfig(env?: NodeJS.ProcessEnv): ServerConfig;
+/** Fichier SQLite du serveur : `MESSENGER_DB_PATH`, sinon `<cwd>/data/messenger.db`. */
+export declare function resolveDbPath(env?: NodeJS.ProcessEnv): string;
 export declare function loadAgentConfig(env?: NodeJS.ProcessEnv): AgentConfig;
+/**
+ * Clé API du client. `MESSENGER_TOKEN` est refusé plutôt que repris : le serveur ne
+ * reconnaît aucun jeton, et le relire ne ferait que reporter l'échec.
+ */
+export declare function requireApiKey(env?: NodeJS.ProcessEnv): string;

package/dist/src/config.js

@@ -9,6 +9,11 @@ export class ConfigError extends Error {
 }
 /** Le serveur n'écoute jamais ailleurs : la boîte aux lettres reste locale à la machine. */
 export const SERVER_HOST = "127.0.0.1";
+/**
+ * Variables refusées au démarrage : l'authentification passe par le compte de la console
+ * et les clés API, et les ignorer laisserait croire qu'elles protègent quelque chose.
+ */
+const RETIRED_SERVER_VARS = ["MESSENGER_TOKEN", "MESSENGER_AGENT_TOKENS", "MESSENGER_ADMIN_TOKEN"];
 /**
  * Variables où chercher l'identifiant de la session hôte, dans l'ordre.
  *
@@ -36,6 +41,12 @@ export function isLoopbackHost(host) {
     return LOOPBACK_HOSTS.has(host.trim().toLowerCase().replace(/^\[|\]$/g, ""));
 }
 export function loadServerConfig(env = process.env) {
+    const retired = RETIRED_SERVER_VARS.filter((name) => nonEmpty(env[name]));
+    if (retired.length > 0) {
+        throw new ConfigError(`${retired.join(", ")} ${retired.length > 1 ? "are" : "is"} no longer supported and must be removed. ` +
+            "The web console now opens with a username and password (created at the first visit of /ui/), " +
+            "and agents authenticate with API keys created in the console (MESSENGER_API_KEY on the client side).");
+    }
     const port = parseIntEnv(env.MESSENGER_PORT, 3600, "MESSENGER_PORT");
     // L'interface d'écoute n'est pas un réglage : la boîte aux lettres reste sur la machine.
     // Une valeur non-loopback est refusée plutôt qu'ignorée en silence.
@@ -44,37 +55,10 @@ export function loadServerConfig(env = process.env) {
         throw new ConfigError(`MESSENGER_HOST=${requestedHost} is refused: the mailbox always listens on ${SERVER_HOST}. ` +
             "To reach it from another machine, put a reverse proxy in front of it.");
     }
-    const dbPath = env.MESSENGER_DB_PATH?.trim()
-        ? path.resolve(env.MESSENGER_DB_PATH.trim())
-        : path.resolve(process.cwd(), "data", "messenger.db");
-    const token = nonEmpty(env.MESSENGER_TOKEN);
-    const agentTokens = parseAgentTokens(env.MESSENGER_AGENT_TOKENS);
-    // Aucun démarrage sans jeton : un serveur qui tourne est un serveur authentifié.
-    if (!token && agentTokens.size === 0) {
-        throw new ConfigError("a token is required: set MESSENGER_TOKEN (shared) or MESSENGER_AGENT_TOKENS (one token per agent).");
-    }
-    // Jamais de repli sur `token` : la console d'administration voit toutes les boîtes de
-    // tous les projets et sait les supprimer, alors que le jeton partagé est distribué à
-    // chaque client MCP. Les faire coïncider donnerait ce pouvoir à tout porteur du jeton —
-    // en silence, et précisément dans la configuration la plus courante.
-    const adminToken = nonEmpty(env.MESSENGER_ADMIN_TOKEN);
-    if (!adminToken) {
-        throw new ConfigError("MESSENGER_ADMIN_TOKEN is required: the web console sees every mailbox and can delete them, " +
-            "so it never shares the token handed to MCP clients. " +
-            "Generate one with `npx @imenam/mcp-messenger --generate-token`.");
-    }
-    // Le poser à la même valeur à la main rouvrirait exactement la porte que l'on ferme.
-    if (token && adminToken === token) {
-        throw new ConfigError("MESSENGER_ADMIN_TOKEN must differ from MESSENGER_TOKEN: the shared token is distributed to " +
-            "every MCP client, and the admin token opens the whole console.");
-    }
     return {
         port,
         host: SERVER_HOST,
-        dbPath,
-        token,
-        agentTokens,
-        adminToken,
+        dbPath: resolveDbPath(env),
         trustProxy: parseTrustProxy(env.MESSENGER_TRUST_PROXY),
         rateLimit: {
             max: parseIntEnv(env.MESSENGER_RATE_LIMIT_MAX, 600, "MESSENGER_RATE_LIMIT_MAX"),
@@ -84,6 +68,12 @@ export function loadServerConfig(env = process.env) {
         maxWaitSeconds: parseIntEnv(env.MESSENGER_MAX_WAIT_SECONDS, 300, "MESSENGER_MAX_WAIT_SECONDS"),
     };
 }
+/** Fichier SQLite du serveur : `MESSENGER_DB_PATH`, sinon `<cwd>/data/messenger.db`. */
+export function resolveDbPath(env = process.env) {
+    return env.MESSENGER_DB_PATH?.trim()
+        ? path.resolve(env.MESSENGER_DB_PATH.trim())
+        : path.resolve(process.cwd(), "data", "messenger.db");
+}
 export function loadAgentConfig(env = process.env) {
     // Adresse fixe optionnelle. Sans elle, chaque session reçoit sa propre boîte : deux
     // sessions ouvertes sur le même projet ne partagent donc pas leur courrier.
@@ -109,7 +99,7 @@ export function loadAgentConfig(env = process.env) {
     return {
         agentId,
         serverUrl: rawUrl.replace(/\/+$/, ""),
-        token: nonEmpty(env.MESSENGER_TOKEN),
+        apiKey: requireApiKey(env),
         agentName: nonEmpty(env.MESSENGER_AGENT_NAME),
         agentDescription: nonEmpty(env.MESSENGER_AGENT_DESCRIPTION),
         timeoutMs: parseIntEnv(env.MESSENGER_TIMEOUT_MS, 15_000, "MESSENGER_TIMEOUT_MS"),
@@ -117,21 +107,20 @@ export function loadAgentConfig(env = process.env) {
         sessionKeySource: session?.source ?? null,
     };
 }
-function parseAgentTokens(raw) {
-    const map = new Map();
-    if (!raw?.trim())
-        return map;
-    for (const pair of raw.split(",")) {
-        const trimmed = pair.trim();
-        if (!trimmed)
-            continue;
-        const separator = trimmed.indexOf(":");
-        if (separator <= 0 || separator === trimmed.length - 1) {
-            throw new ConfigError(`MESSENGER_AGENT_TOKENS entry must look like "agent_id:token" (got "${trimmed}").`);
-        }
-        map.set(trimmed.slice(0, separator).trim(), trimmed.slice(separator + 1).trim());
+/**
+ * Clé API du client. `MESSENGER_TOKEN` est refusé plutôt que repris : le serveur ne
+ * reconnaît aucun jeton, et le relire ne ferait que reporter l'échec.
+ */
+export function requireApiKey(env = process.env) {
+    if (nonEmpty(env.MESSENGER_TOKEN)) {
+        throw new ConfigError("MESSENGER_TOKEN is no longer supported: create an API key in the web console (Clés API tab) " +
+            "and set it as MESSENGER_API_KEY instead.");
+    }
+    const apiKey = nonEmpty(env.MESSENGER_API_KEY);
+    if (!apiKey) {
+        throw new ConfigError("MESSENGER_API_KEY is required: create an API key in the web console (Clés API tab).");
     }
-    return map;
+    return apiKey;
 }
 /**
  * Nombre de proxys de confiance devant le serveur, ou une expression qu'Express comprend

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

@@ -0,0 +1,124 @@
+import type Database from "better-sqlite3";
+/**
+ * Comptes de la console, leurs sessions, et les clés API des agents.
+ *
+ * Les secrets n'y entrent jamais en clair : un mot de passe y est sous forme d'empreinte
+ * scrypt, une clé ou une session sous forme d'empreinte SHA-256. Une clé ne se relit donc
+ * pas ; seuls son début et sa fin sont gardés, pour la reconnaître dans une liste.
+ */
+/** Une clé est refusée dès qu'elle est révoquée ou que sa date d'expiration est passée. */
+export type ApiKeyStatus = "active" | "expired" | "revoked";
+export interface ApiKey {
+    id: string;
+    name: string;
+    /** Début de la clé, préfixe compris : `mk_7f3a`. */
+    prefix: string;
+    /** Quatre derniers caractères. */
+    suffix: string;
+    /** Agent dont la clé ouvre les boîtes ; null = tous les agents. */
+    agent_name: string | null;
+    created_at: string;
+    created_by: string | null;
+    expires_at: string | null;
+    /** Durée de validité choisie à la création, reprise par le remplacement ; null = sans fin. */
+    lifetime_days: number | null;
+    revoked_at: string | null;
+    last_used_at: string | null;
+    last_used_ip: string | null;
+    status: ApiKeyStatus;
+    /** Boîtes ouvertes avec cette clé et toujours présentes. */
+    mailboxes: number;
+}
+export interface KeyMailbox {
+    id: string;
+    agent_name: string | null;
+    display_name: string | null;
+    last_activity_at: string | null;
+}
+export interface User {
+    id: string;
+    username: string;
+    created_at: string;
+    updated_at: string | null;
+}
+export interface UserWithPassword extends User {
+    password_hash: string;
+}
+export interface ConsoleSession {
+    id: string;
+    user_id: string;
+    created_at: string;
+    last_seen_at: string;
+    expires_at: string;
+    /** Vrai quand la session a été ouverte avec « rester connecté ». */
+    persistent: boolean;
+    user_agent: string | null;
+    ip: string | null;
+}
+export declare class AccessStore {
+    private readonly db;
+    private readonly now;
+    constructor(db: Database.Database, now?: () => number);
+    private iso;
+    hasUsers(): boolean;
+    createUser(username: string, passwordHash: string): User;
+    getUser(id: string): User | null;
+    findUserByName(username: string): UserWithPassword | null;
+    listUsers(): User[];
+    getPasswordHash(id: string): string | null;
+    renameUser(id: string, username: string): User;
+    setPassword(id: string, passwordHash: string): void;
+    createSession(input: {
+        userId: string;
+        secret: string;
+        ttlMs: number;
+        persistent: boolean;
+        userAgent: string | null;
+        ip: string | null;
+    }): ConsoleSession;
+    /** Session encore valide désignée par le contenu du cookie, avec son compte. */
+    findSession(secret: string | null, seen?: {
+        ip: string | null;
+    }): {
+        session: ConsoleSession;
+        user: User;
+    } | null;
+    getSession(id: string): ConsoleSession | null;
+    listSessions(userId: string): ConsoleSession[];
+    revokeSession(userId: string, id: string): void;
+    revokeSessionBySecret(secret: string | null): void;
+    /** Ferme les sessions du compte sauf `keepId` (null : toutes). Rend le nombre fermé. */
+    revokeOtherSessions(userId: string, keepId: string | null): number;
+    private pruneSessions;
+    createApiKey(input: {
+        name: string;
+        agentName: string | null;
+        lifetimeDays: number | null;
+        createdBy: string | null;
+        secret: string;
+    }): ApiKey;
+    listApiKeys(): ApiKey[];
+    getApiKey(id: string): ApiKey | null;
+    private requireKey;
+    renameApiKey(id: string, name: string): ApiKey;
+    /**
+     * Repousse l'expiration de `days` jours, comptés depuis l'échéance encore à venir ou,
+     * pour une clé déjà expirée, depuis maintenant. `null` retire toute échéance.
+     */
+    extendApiKey(id: string, days: number | null): ApiKey;
+    revokeApiKey(id: string): ApiKey;
+    /**
+     * Remplace une clé : la nouvelle reprend le nom, l'agent et la durée de validité de
+     * l'ancienne ; l'ancienne reste acceptée `graceMs` encore, au plus jusqu'à son échéance.
+     */
+    rotateApiKey(id: string, secret: string, createdBy: string | null, graceMs: number): {
+        key: ApiKey;
+        replaced: ApiKey;
+    };
+    /** Clé active désignée par le secret présenté, ou null. Note son dernier usage. */
+    authenticateApiKey(secret: string | null, ip: string | null): ApiKey | null;
+    /** Retient la clé qui a ouvert ou repris une boîte : la dernière fait foi. */
+    recordMailboxKey(mailbox: string, apiKeyId: string): void;
+    mailboxesForKey(id: string): KeyMailbox[];
+    private toApiKey;
+}