@imenam/mcp-organizer 0.0.0-stage → 1.0.1

package/dist/src/server/app.js

@@ -0,0 +1,290 @@
+import { randomBytes } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { getConnInfo } from "@hono/node-server/conninfo";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+import { deleteCookie, getCookie, setCookie } from "hono/cookie";
+import { SESSION_COOKIE_NAME, UPSTREAM_ERROR_HEADER } from "../../shared/schemas/gui-api.schema.js";
+import { MAX_ATTACHMENT_BYTES } from "../../shared/schemas/tasks-api.schema.js";
+import { MAX_TRANSCRIPTION_BYTES } from "../../shared/schemas/transcription-api.schema.js";
+import { errorKindOf, errorStatusOf, handleApiRequest } from "../gui-api.js";
+import { handleAgentRequest } from "../agent-api/router.js";
+import { LoginLimiter } from "./login-limiter.js";
+import { MAX_BODY_BYTES } from "./limits.js";
+/**
+ * Politique de contenu de la GUI : scripts, styles et polices du site
+ * (polices intégrées en `data:` par Vite), enregistrements audio en `blob:`,
+ * appels réseau vers le site seul, aucun cadre englobant.
+ */
+export const CONTENT_SECURITY_POLICY = [
+    "default-src 'self'",
+    "script-src 'self'",
+    "style-src 'self'",
+    "img-src 'self' data: blob:",
+    "font-src 'self' data:",
+    "media-src 'self' blob:",
+    "connect-src 'self'",
+    "object-src 'none'",
+    "base-uri 'self'",
+    "form-action 'self'",
+    "frame-ancestors 'none'",
+].join("; ");
+const SECURITY_HEADERS = {
+    "Content-Security-Policy": CONTENT_SECURITY_POLICY,
+    "X-Content-Type-Options": "nosniff",
+    "X-Frame-Options": "DENY",
+    "Referrer-Policy": "same-origin",
+    "Cross-Origin-Opener-Policy": "same-origin",
+    "Cross-Origin-Resource-Policy": "same-origin",
+    "Permissions-Policy": "microphone=(self), camera=(), geolocation=()",
+};
+/** Méthodes qui modifient : elles exigent une requête de la GUI elle-même. */
+const MUTATING_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+/** Code HTTP de chaque nature d'erreur de l'API. */
+const HTTP_STATUS_BY_ERROR_KIND = {
+    invalid: 400,
+    unauthorized: 401,
+    forbidden: 403,
+    not_found: 404,
+    conflict: 409,
+    too_large: 413,
+    internal: 500,
+    upstream: 502,
+    unavailable: 503,
+};
+/** Préfixe des routes de l'API des agents. */
+const AGENT_API_PREFIX = "/api/agent";
+/** Route de l'API des agents : authentifiée par `Authorization: Bearer`, sans cookie. */
+function isAgentApiPath(path) {
+    return path === AGENT_API_PREFIX || path.startsWith(`${AGENT_API_PREFIX}/`);
+}
+/** Jeton de l'en-tête `Authorization: Bearer <jeton>`, null sans en-tête Bearer. */
+function bearerToken(c) {
+    const match = /^Bearer\s+(.+)$/i.exec(c.req.header("authorization") ?? "");
+    return match ? match[1].trim() : null;
+}
+/** Taille lisible d'un nombre d'octets, en Mo. */
+function megabytes(bytes) {
+    return `${(bytes / (1024 * 1024)).toFixed(1).replace(".", ",")} Mo`;
+}
+/** Limite de taille d'un fichier envoyé : un enregistrement à transcrire, ou une pièce jointe. */
+function uploadLimit(c) {
+    if (c.req.path === "/api/transcribe") {
+        return { maxBytes: MAX_TRANSCRIPTION_BYTES, tooLarge: (size) => `Enregistrement trop volumineux (${megabytes(size)}) : la dictée accepte ${megabytes(MAX_TRANSCRIPTION_BYTES)} au plus.` };
+    }
+    return { maxBytes: MAX_ATTACHMENT_BYTES, tooLarge: (size) => `Fichier trop volumineux (${megabytes(size)}) : une pièce jointe ne dépasse pas ${megabytes(MAX_ATTACHMENT_BYTES)}.` };
+}
+/**
+ * Formulaire multipart d'envoi de fichier (champ `file`) : pièce jointe ou
+ * enregistrement à transcrire, transmis à l'API en JSON : nom, type MIME
+ * (sans ses paramètres) et contenu en base64. Un fichier sans type déclaré par
+ * le navigateur est un flux binaire (`application/octet-stream`).
+ */
+async function readUploadBody(c) {
+    let form;
+    try {
+        form = await c.req.formData();
+    }
+    catch (err) {
+        return { response: c.json({ error: `The multipart form cannot be read: ${err?.message ?? err}` }, 400) };
+    }
+    const file = form.get("file");
+    if (!(file instanceof File))
+        return { response: c.json({ error: "Le formulaire ne contient pas de fichier (champ « file »)." }, 400) };
+    const limit = uploadLimit(c);
+    if (file.size > limit.maxBytes)
+        return { response: c.json({ error: limit.tooLarge(file.size) }, 413) };
+    const content = Buffer.from(await file.arrayBuffer());
+    const mime = file.type.split(";")[0].trim() || "application/octet-stream";
+    return { body: { filename: file.name || "fichier", mime, contentBase64: content.toString("base64") } };
+}
+/** Corps d'une requête de modification : JSON, ou formulaire multipart d'un fichier ; `undefined` sans corps. */
+async function readRequestBody(c) {
+    if (c.req.method === "GET" || c.req.method === "HEAD")
+        return { body: undefined };
+    if ((c.req.header("content-type") ?? "").toLowerCase().startsWith("multipart/form-data"))
+        return readUploadBody(c);
+    const text = await c.req.text();
+    if (text.trim() === "")
+        return { body: undefined };
+    try {
+        return { body: JSON.parse(text) };
+    }
+    catch (err) {
+        return { response: c.json({ error: `The request body is not valid JSON: ${err?.message ?? err}` }, 400) };
+    }
+}
+/** En-tête `Content-Disposition` d'un téléchargement, avec le nom du fichier en UTF-8 (RFC 6266). */
+function contentDisposition(filename) {
+    const ascii = filename.replace(/[^\x20-\x7e]|["\\]/g, "_");
+    return `attachment; filename="${ascii}"; filename*=UTF-8''${encodeURIComponent(filename)}`;
+}
+function fileResponse(c, file) {
+    return c.body(Buffer.from(file.contentBase64, "base64"), 200, {
+        "Content-Type": file.mime,
+        "Content-Disposition": contentDisposition(file.filename),
+        "Cache-Control": "private, no-store",
+    });
+}
+/** `<base href>` de la SPA : le chemin de base terminé par une barre oblique. */
+function baseHref(basePath) {
+    return basePath === "/" ? "/" : `${basePath}/`;
+}
+/** Adresse e-mail d'une tentative de connexion, normalisée, ou null si le corps n'en porte pas. */
+function loginEmail(body) {
+    const email = body?.email;
+    return typeof email === "string" && email.trim() !== "" ? email.trim().toLowerCase() : null;
+}
+export function createSiteApp(deps) {
+    const { config, api, logger, staticRoot } = deps;
+    const loginLimiter = deps.loginLimiter ?? new LoginLimiter();
+    const cookieOptions = { path: config.basePath, secure: config.secureCookie };
+    const app = new Hono();
+    /**
+     * Adresse du client : la dernière entrée de `X-Forwarded-For`, écrite par le
+     * reverse proxy, quand `ORGANIZER_TRUST_PROXY=1` ; sinon l'adresse de la connexion.
+     */
+    function clientIp(c) {
+        if (config.trustProxy) {
+            const forwarded = c.req.header("x-forwarded-for");
+            const last = forwarded?.split(",").map((part) => part.trim()).filter(Boolean).pop();
+            if (last)
+                return last;
+        }
+        const address = getConnInfo(c).remote.address;
+        if (!address)
+            throw new Error("The client address of the connection is unavailable.");
+        return address;
+    }
+    /** Journalise une erreur interne avec une référence courte, seule transmise au client avec un message générique. */
+    function logInternalError(context, err) {
+        const reference = randomBytes(4).toString("hex");
+        logger.error(`${context} failed (reference ${reference}): ${err?.stack ?? err}`);
+        return reference;
+    }
+    const securityHeaders = async (c, next) => {
+        await next();
+        for (const [name, value] of Object.entries(SECURITY_HEADERS))
+            c.res.headers.set(name, value);
+    };
+    /**
+     * Une modification vient de la GUI : `Sec-Fetch-Site: same-origin`, ou
+     * `Origin` égal à l'origine publique. L'API des agents en est exemptée : elle
+     * n'accepte aucun cookie, seulement un jeton porté par l'en-tête `Authorization`.
+     */
+    const sameOriginGuard = async (c, next) => {
+        if (!MUTATING_METHODS.has(c.req.method) || isAgentApiPath(c.req.path))
+            return next();
+        if (c.req.header("sec-fetch-site") === "same-origin" || c.req.header("origin") === config.publicOrigin)
+            return next();
+        logger.warn(`Cross-origin ${c.req.method} ${c.req.path} refused (Origin: ${c.req.header("origin") ?? "none"}, Sec-Fetch-Site: ${c.req.header("sec-fetch-site") ?? "none"})`);
+        return c.json({ error: `Requête refusée : une modification doit venir de l'application elle-même (${config.publicUrl}).` }, 403);
+    };
+    app.use("*", securityHeaders);
+    app.use("/api/*", sameOriginGuard);
+    app.use("/api/*", bodyLimit({
+        maxSize: MAX_BODY_BYTES,
+        onError: (c) => c.json({ error: `Requête trop volumineuse : ${megabytes(MAX_BODY_BYTES)} au plus.` }, 413),
+    }));
+    // API des agents : jeton de l'en-tête Authorization, corps JSON ; les cookies sont ignorés.
+    const agentApi = async (c) => {
+        let body = undefined;
+        if (c.req.method !== "GET" && c.req.method !== "HEAD") {
+            const text = await c.req.text();
+            if (text.trim() !== "") {
+                try {
+                    body = JSON.parse(text);
+                }
+                catch (err) {
+                    return c.json({ error: `The request body is not valid JSON: ${err?.message ?? err}` }, 400);
+                }
+            }
+        }
+        try {
+            const response = handleAgentRequest({ store: api.store, now: api.now }, { method: c.req.method, path: c.req.path.slice(AGENT_API_PREFIX.length) || "/", query: c.req.query(), body, bearer: bearerToken(c) });
+            return c.json(response);
+        }
+        catch (err) {
+            const kind = errorKindOf(err);
+            if (kind === "internal") {
+                const reference = logInternalError(`Agent request ${c.req.method} ${c.req.path}`, err);
+                return c.json({ error: `Internal error of the organizer site (reference ${reference}): retry later; if it persists, give this reference to the administrator of the site, who finds the details in its log.` }, 500);
+            }
+            if (kind === "unauthorized")
+                c.header("WWW-Authenticate", 'Bearer realm="mcp-organizer"');
+            return c.json({ error: err?.message ?? String(err) }, HTTP_STATUS_BY_ERROR_KIND[kind]);
+        }
+    };
+    app.all(AGENT_API_PREFIX, agentApi);
+    app.all(`${AGENT_API_PREFIX}/*`, agentApi);
+    // Toute route `/api/*` est traitée par le routeur de l'API, avec le jeton du
+    // cookie de session ; sa réponse dit s'il faut poser, prolonger ou effacer le cookie.
+    app.all("/api/*", async (c) => {
+        const read = await readRequestBody(c);
+        if ("response" in read)
+            return read.response;
+        const request = {
+            method: c.req.method,
+            path: c.req.path.slice("/api".length) || "/",
+            query: c.req.query(),
+            body: read.body,
+            sessionToken: getCookie(c, SESSION_COOKIE_NAME) ?? null,
+        };
+        // Une tentative de connexion est comptée avant la vérification du mot de passe, et décomptée si elle réussit.
+        let loginAttempt = null;
+        if (request.method === "POST" && request.path === "/auth/login") {
+            const ip = clientIp(c);
+            const email = loginEmail(request.body);
+            loginAttempt = loginLimiter.begin(ip, email);
+            if (!loginAttempt.admitted) {
+                const minutes = Math.ceil(loginAttempt.retryAfterMs / 60_000);
+                logger.warn(`Login attempts limited for ${ip}${email ? ` / ${email}` : ""}`);
+                c.header("Retry-After", String(Math.ceil(loginAttempt.retryAfterMs / 1000)));
+                return c.json({ error: `Trop de tentatives de connexion. Réessayez dans ${minutes} minute${minutes > 1 ? "s" : ""}.` }, 429);
+            }
+        }
+        let response;
+        try {
+            response = await handleApiRequest(api, request);
+        }
+        catch (err) {
+            const kind = errorKindOf(err);
+            if (kind === "unauthorized")
+                deleteCookie(c, SESSION_COOKIE_NAME, cookieOptions);
+            if (kind === "internal") {
+                const reference = logInternalError(`GUI request ${request.method} ${c.req.path}`, err);
+                return c.json({ error: `Erreur interne du site (référence ${reference}). Réessayez ; si l'erreur persiste, transmettez cette référence à l'administrateur du site, qui en trouve le détail dans son journal.` }, 500);
+            }
+            // Un refus d'un service externe (Groq) garde son code HTTP ; l'en-tête le distingue d'un refus de session.
+            if (kind === "upstream")
+                c.header(UPSTREAM_ERROR_HEADER, "upstream");
+            return c.json({ error: err?.message ?? String(err) }, errorStatusOf(err) ?? HTTP_STATUS_BY_ERROR_KIND[kind]);
+        }
+        if (loginAttempt?.admitted)
+            loginAttempt.succeeded();
+        const { body, session, file } = response;
+        if (session === null) {
+            deleteCookie(c, SESSION_COOKIE_NAME, cookieOptions);
+        }
+        else if (session !== undefined) {
+            setCookie(c, SESSION_COOKIE_NAME, session.token, { ...cookieOptions, httpOnly: true, sameSite: "Lax", expires: new Date(session.expiresAt) });
+        }
+        if (file)
+            return fileResponse(c, file);
+        return c.json(body ?? null);
+    });
+    app.use("/assets/*", serveStatic({ root: path.relative(process.cwd(), staticRoot) }));
+    // Toute autre route renvoie la page de la SPA, avec la balise <base> du chemin de base.
+    app.get("/*", (c) => {
+        const indexPath = path.join(staticRoot, "index.html");
+        if (!fs.existsSync(indexPath)) {
+            return c.text(`GUI build not found in ${staticRoot}. Run "npm run build:gui" in the mcp-organizer package.`, 500);
+        }
+        const html = fs.readFileSync(indexPath, "utf8").replace("<head>", `<head>\n    <base href="${baseHref(config.basePath)}" />`);
+        c.header("Cache-Control", "no-cache");
+        return c.html(html);
+    });
+    return app;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Configuration du mode site (`--server`), lue dans l'environnement après le
+ * chargement du `.env`. Une variable vide est traitée comme absente ; une
+ * valeur absente ou invalide est une `ConfigError` qui dit quoi corriger.
+ */
+/** Adresse d'écoute sans `HOST` : la boucle locale, derrière le reverse proxy. */
+export declare const DEFAULT_HOST = "127.0.0.1";
+export interface SiteConfig {
+    host: string;
+    port: number;
+    /** `ORGANIZER_PUBLIC_URL` sans barre oblique finale : base des liens envoyés par e-mail. */
+    publicUrl: string;
+    /** Origine de l'URL publique (`https://organizer.example.com`), seule admise dans `Origin`. */
+    publicOrigin: string;
+    /** Chemin de base vu par le navigateur, `/` ou `/organizer` : `<base href>` et `Path` du cookie. */
+    basePath: string;
+    /** Cookie de session `Secure` : l'URL publique est en https. */
+    secureCookie: boolean;
+    /** `X-Forwarded-For` donne l'adresse du client (`ORGANIZER_TRUST_PROXY=1`). */
+    trustProxy: boolean;
+}
+/** Configuration du site d'après `env`. */
+export declare function loadSiteConfig(env?: NodeJS.ProcessEnv): SiteConfig;

package/dist/src/server/config.js

@@ -0,0 +1,75 @@
+/**
+ * Configuration du mode site (`--server`), lue dans l'environnement après le
+ * chargement du `.env`. Une variable vide est traitée comme absente ; une
+ * valeur absente ou invalide est une `ConfigError` qui dit quoi corriger.
+ */
+import { ConfigError } from "../core/errors.js";
+/** Adresse d'écoute sans `HOST` : la boucle locale, derrière le reverse proxy. */
+export const DEFAULT_HOST = "127.0.0.1";
+function read(env, name) {
+    const value = env[name]?.trim();
+    return value ? value : undefined;
+}
+function parsePort(raw) {
+    if (raw === undefined)
+        throw new ConfigError("PORT n’est pas défini : indiquez le port d’écoute du site (par exemple PORT=4800 dans le fichier .env).");
+    const port = Number(raw);
+    if (!/^\d+$/.test(raw) || !Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new ConfigError(`PORT invalide (${raw}) : entier attendu entre 1 et 65535.`);
+    }
+    return port;
+}
+function parsePublicUrl(raw) {
+    if (raw === undefined) {
+        throw new ConfigError("ORGANIZER_PUBLIC_URL n’est pas défini : indiquez l’URL que les utilisateurs ouvrent dans leur navigateur (par exemple ORGANIZER_PUBLIC_URL=https://organizer.example.com dans le fichier .env). Le site y compare l’origine de chaque modification.");
+    }
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new ConfigError(`ORGANIZER_PUBLIC_URL n’est pas une URL absolue (${raw}) : attendu par exemple https://organizer.example.com.`);
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+        throw new ConfigError(`ORGANIZER_PUBLIC_URL doit être en http ou https (${raw}).`);
+    if (url.search || url.hash || url.username || url.password) {
+        throw new ConfigError(`ORGANIZER_PUBLIC_URL ne doit contenir ni identifiants, ni paramètres, ni fragment (${raw}).`);
+    }
+    return url;
+}
+/** `/organizer/` → `/organizer` ; `/` reste `/`. */
+function normalizePath(value) {
+    const withSlash = value.startsWith("/") ? value : `/${value}`;
+    const trimmed = withSlash.replace(/\/+$/, "");
+    return trimmed === "" ? "/" : trimmed;
+}
+function parseBasePath(raw, publicUrl) {
+    const basePath = raw === undefined ? "/" : normalizePath(raw);
+    if (!/^\/[A-Za-z0-9._~\-/]*$/.test(basePath))
+        throw new ConfigError(`ORGANIZER_BASE_PATH invalide (${raw}) : chemin attendu, par exemple /organizer.`);
+    const publicPath = normalizePath(publicUrl.pathname);
+    if (publicPath !== basePath) {
+        throw new ConfigError(`ORGANIZER_PUBLIC_URL (${publicUrl.href}) et ORGANIZER_BASE_PATH (${raw ?? "non défini, donc /"}) ne concordent pas : le chemin de l’URL publique est ${publicPath}. Définissez ORGANIZER_BASE_PATH=${publicPath}, ou corrigez ORGANIZER_PUBLIC_URL.`);
+    }
+    return basePath;
+}
+function parseTrustProxy(raw) {
+    if (raw === undefined)
+        return false;
+    if (raw === "1")
+        return true;
+    throw new ConfigError(`ORGANIZER_TRUST_PROXY invalide (${raw}) : 1 derrière un reverse proxy qui écrit X-Forwarded-For, vide sinon.`);
+}
+/** Configuration du site d'après `env`. */
+export function loadSiteConfig(env = process.env) {
+    const publicUrl = parsePublicUrl(read(env, "ORGANIZER_PUBLIC_URL"));
+    return {
+        host: read(env, "HOST") ?? DEFAULT_HOST,
+        port: parsePort(read(env, "PORT")),
+        publicUrl: publicUrl.href.replace(/\/+$/, ""),
+        publicOrigin: publicUrl.origin,
+        basePath: parseBasePath(read(env, "ORGANIZER_BASE_PATH"), publicUrl),
+        secureCookie: publicUrl.protocol === "https:",
+        trustProxy: parseTrustProxy(read(env, "ORGANIZER_TRUST_PROXY")),
+    };
+}

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

@@ -0,0 +1,2 @@
+/** Limite de taille des corps : le plus gros fichier accepté (enregistrement à transcrire) et l'enveloppe de son formulaire multipart. */
+export declare const MAX_BODY_BYTES: number;

package/dist/src/server/limits.js

@@ -0,0 +1,4 @@
+import { MAX_ATTACHMENT_BYTES } from "../../shared/schemas/tasks-api.schema.js";
+import { MAX_TRANSCRIPTION_BYTES } from "../../shared/schemas/transcription-api.schema.js";
+/** Limite de taille des corps : le plus gros fichier accepté (enregistrement à transcrire) et l'enveloppe de son formulaire multipart. */
+export const MAX_BODY_BYTES = Math.max(MAX_ATTACHMENT_BYTES, MAX_TRANSCRIPTION_BYTES) + 64 * 1024;

package/dist/src/server/login-limiter.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Limitation des tentatives de connexion, par adresse IP et par couple
+ * (adresse IP, adresse e-mail), sur une fenêtre glissante. Une tentative est
+ * comptée dès son arrivée, avant toute vérification du mot de passe, et
+ * décomptée si la connexion réussit : des tentatives simultanées ne dépassent
+ * donc jamais la limite. Une clé qui a atteint sa limite est refusée jusqu'à
+ * ce que sa plus ancienne tentative sorte de la fenêtre.
+ */
+export interface LoginLimits {
+    /** Durée de la fenêtre glissante. */
+    windowMs: number;
+    /** Tentatives admises par adresse IP dans la fenêtre. */
+    maxPerIp: number;
+    /** Tentatives admises par couple (adresse IP, adresse e-mail) dans la fenêtre. */
+    maxPerIpAndEmail: number;
+}
+export declare const DEFAULT_LOGIN_LIMITS: LoginLimits;
+/** Issue de `begin` : tentative admise et comptée, ou refusée avec le délai d'attente. */
+export type LoginAttempt = {
+    admitted: true;
+    succeeded: () => void;
+} | {
+    admitted: false;
+    retryAfterMs: number;
+};
+export declare class LoginLimiter {
+    private readonly now;
+    private readonly byIp;
+    private readonly byIpAndEmail;
+    constructor(limits?: LoginLimits, now?: () => number);
+    /**
+     * Admet et compte une tentative de `ip` sur `email`, ou la refuse quand une
+     * de ses clés a atteint sa limite. `succeeded` retire la tentative admise.
+     */
+    begin(ip: string, email: string | null): LoginAttempt;
+}

package/dist/src/server/login-limiter.js

@@ -0,0 +1,81 @@
+/**
+ * Limitation des tentatives de connexion, par adresse IP et par couple
+ * (adresse IP, adresse e-mail), sur une fenêtre glissante. Une tentative est
+ * comptée dès son arrivée, avant toute vérification du mot de passe, et
+ * décomptée si la connexion réussit : des tentatives simultanées ne dépassent
+ * donc jamais la limite. Une clé qui a atteint sa limite est refusée jusqu'à
+ * ce que sa plus ancienne tentative sorte de la fenêtre.
+ */
+export const DEFAULT_LOGIN_LIMITS = { windowMs: 15 * 60 * 1000, maxPerIp: 20, maxPerIpAndEmail: 5 };
+/** Nombre de clés suivies au-delà duquel les clés sans tentative récente sont purgées. */
+const PRUNE_THRESHOLD = 10_000;
+class SlidingWindow {
+    windowMs;
+    max;
+    attempts = new Map();
+    constructor(windowMs, max) {
+        this.windowMs = windowMs;
+        this.max = max;
+    }
+    recent(key, now) {
+        const kept = (this.attempts.get(key) ?? []).filter((entry) => entry.at > now - this.windowMs);
+        if (kept.length === 0)
+            this.attempts.delete(key);
+        else
+            this.attempts.set(key, kept);
+        return kept;
+    }
+    /** Millisecondes avant la prochaine tentative admise, 0 si elle l'est déjà. */
+    retryAfter(key, now) {
+        const recent = this.recent(key, now);
+        if (recent.length < this.max)
+            return 0;
+        return recent[recent.length - this.max].at + this.windowMs - now;
+    }
+    record(key, now) {
+        if (this.attempts.size > PRUNE_THRESHOLD)
+            for (const candidate of [...this.attempts.keys()])
+                this.recent(candidate, now);
+        const entry = { at: now };
+        this.attempts.set(key, [...this.recent(key, now), entry]);
+        return entry;
+    }
+    remove(key, entry) {
+        const kept = (this.attempts.get(key) ?? []).filter((candidate) => candidate !== entry);
+        if (kept.length === 0)
+            this.attempts.delete(key);
+        else
+            this.attempts.set(key, kept);
+    }
+}
+export class LoginLimiter {
+    now;
+    byIp;
+    byIpAndEmail;
+    constructor(limits = DEFAULT_LOGIN_LIMITS, now = Date.now) {
+        this.now = now;
+        this.byIp = new SlidingWindow(limits.windowMs, limits.maxPerIp);
+        this.byIpAndEmail = new SlidingWindow(limits.windowMs, limits.maxPerIpAndEmail);
+    }
+    /**
+     * Admet et compte une tentative de `ip` sur `email`, ou la refuse quand une
+     * de ses clés a atteint sa limite. `succeeded` retire la tentative admise.
+     */
+    begin(ip, email) {
+        const now = this.now();
+        const pair = email === null ? null : `${ip}\n${email}`;
+        const waitMs = Math.max(this.byIp.retryAfter(ip, now), pair === null ? 0 : this.byIpAndEmail.retryAfter(pair, now));
+        if (waitMs > 0)
+            return { admitted: false, retryAfterMs: waitMs };
+        const ipEntry = this.byIp.record(ip, now);
+        const pairEntry = pair === null ? null : this.byIpAndEmail.record(pair, now);
+        return {
+            admitted: true,
+            succeeded: () => {
+                this.byIp.remove(ip, ipEntry);
+                if (pair !== null && pairEntry !== null)
+                    this.byIpAndEmail.remove(pair, pairEntry);
+            },
+        };
+    }
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Mode site (`mcp-organizer --server`) : un processus web permanent qui
+ * détient la base, sert la GUI et son API, et écoute sur `HOST:PORT`.
+ */
+export declare function runServerMode(rootDir: string): Promise<void>;

package/dist/src/server/start.js

@@ -0,0 +1,88 @@
+import path from "node:path";
+import { serve } from "@hono/node-server";
+import { APP_VERSION } from "../version.js";
+import { resolveDataDir } from "../core/data-dir.js";
+import { resolveLogDir } from "../core/log-dir.js";
+import { createLogger, setupLogging } from "../core/logger.js";
+import { Store } from "../core/store.js";
+import { AttachmentStorage } from "../core/attachments.js";
+import { bootstrapAdmin } from "../core/accounts.js";
+import { mailerFromEnv } from "../core/mail.js";
+import { NotificationMailer } from "../core/notifications.js";
+import { transcriberFromEnv } from "../core/transcription.js";
+import { ConfigError } from "../core/errors.js";
+import { loadSiteConfig } from "./config.js";
+import { createSiteApp } from "./app.js";
+/**
+ * Mode site (`mcp-organizer --server`) : un processus web permanent qui
+ * détient la base, sert la GUI et son API, et écoute sur `HOST:PORT`.
+ */
+export async function runServerMode(rootDir) {
+    const config = loadSiteConfig();
+    setupLogging("mcp-organizer:site", resolveLogDir(rootDir));
+    const logger = createLogger("site");
+    const dataDir = resolveDataDir(rootDir);
+    let store;
+    try {
+        store = Store.open(dataDir);
+    }
+    catch (err) {
+        throw new ConfigError(`Impossible d’ouvrir la base de mcp-organizer dans ${dataDir} : ${err?.message ?? err}`);
+    }
+    const mailer = mailerFromEnv();
+    if (!mailer.enabled)
+        logger.warn(mailer.disabledReason);
+    const transcriber = transcriberFromEnv();
+    if (!transcriber.enabled)
+        logger.warn(transcriber.disabledReason);
+    new NotificationMailer(store, { mailer, publicUrl: config.publicUrl, logError: (message) => logger.error(message) }).attach();
+    let bootstrap;
+    try {
+        bootstrap = await bootstrapAdmin(store, {
+            email: process.env.ORGANIZER_ADMIN_EMAIL,
+            displayName: process.env.ORGANIZER_ADMIN_NAME,
+            password: process.env.ORGANIZER_ADMIN_PASSWORD,
+        });
+    }
+    catch (err) {
+        throw new ConfigError(`Cannot create the first account from ORGANIZER_ADMIN_EMAIL / ORGANIZER_ADMIN_NAME / ORGANIZER_ADMIN_PASSWORD: ${err?.message ?? err}`);
+    }
+    if (bootstrap.outcome === "missing")
+        logger.warn(bootstrap.message);
+    else
+        logger.info(bootstrap.message);
+    const app = createSiteApp({
+        config,
+        logger,
+        staticRoot: path.join(rootDir, "gui", "dist"),
+        api: {
+            store,
+            version: APP_VERSION,
+            mailer,
+            publicUrl: config.publicUrl,
+            attachments: new AttachmentStorage(dataDir),
+            transcriber,
+        },
+    });
+    const server = await new Promise((resolve, reject) => {
+        const instance = serve({ fetch: app.fetch, port: config.port, hostname: config.host }, () => resolve(instance));
+        instance.once("error", (err) => reject(err.code === "EADDRINUSE" ? new ConfigError(`Le port ${config.port} est déjà utilisé sur ${config.host} : libérez-le ou changez PORT.`) : err));
+    });
+    logger.info(`mcp-organizer v${APP_VERSION} listening on http://${config.host}:${config.port}, public URL ${config.publicUrl} (data dir: ${dataDir})`);
+    if (config.trustProxy)
+        logger.info("ORGANIZER_TRUST_PROXY=1: the client address is read from X-Forwarded-For.");
+    let shuttingDown = false;
+    const shutdown = (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        logger.info(`${signal} received, shutting down`);
+        server.close(() => {
+            store.close();
+            process.exit(0);
+        });
+        server.closeAllConnections();
+    };
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+}

package/dist/src/version.d.ts

@@ -0,0 +1 @@
+export declare const APP_VERSION: string;

package/dist/src/version.js

@@ -0,0 +1,16 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+// Lit la version dans le premier package.json trouvé en remontant depuis ce module.
+function readPackageVersion() {
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    while (!existsSync(path.join(dir, "package.json"))) {
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            throw new Error("package.json introuvable");
+        dir = parent;
+    }
+    const pkg = JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8"));
+    return pkg.version;
+}
+export const APP_VERSION = readPackageVersion();