@imenam/mcp-organizer 0.0.0-stage → 1.0.2

package/dist/src/core/errors.js

@@ -0,0 +1,42 @@
+/** Erreur métier : son message dit à l'appelant ce qui ne va pas et quoi faire. */
+export class OrganizerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "OrganizerError";
+    }
+}
+/** Entité introuvable. */
+export class NotFoundError extends OrganizerError {
+    constructor(message) {
+        super(message);
+        this.name = "NotFoundError";
+    }
+}
+/** Mutation refusée parce qu'elle violerait un invariant du modèle. */
+export class InvariantError extends OrganizerError {
+    constructor(message) {
+        super(message);
+        this.name = "InvariantError";
+    }
+}
+/** Requête sans session valide, ou identifiants refusés. */
+export class UnauthorizedError extends OrganizerError {
+    constructor(message) {
+        super(message);
+        this.name = "UnauthorizedError";
+    }
+}
+/** Action refusée à l'utilisateur connecté par les règles de droits. */
+export class ForbiddenError extends OrganizerError {
+    constructor(message) {
+        super(message);
+        this.name = "ForbiddenError";
+    }
+}
+/** Erreur de configuration : le message suffit, sans pile d'appels. */
+export class ConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ConfigError";
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { Mutation } from "./store.js";
+import { type AgentAction, type TaskSnapshot } from "../../shared/schemas/entities.schema.js";
+/**
+ * Retour à un état antérieur : annulation d'une action de l'agent, après
+ * comparaison de l'état courant de l'entité avec celui que l'action a
+ * laissé, et restauration des champs d'une version de tâche.
+ */
+/** Champs d'une tâche comparés et restaurés par l'historique. */
+declare const TASK_FIELDS: readonly ["title", "description", "status", "priority", "type", "parentId", "testedTaskId"];
+/**
+ * Annule une action de l'agent dans la mutation `tx` (acteur utilisateur).
+ * L'état courant de l'entité doit être celui que l'action a laissé ; sinon le
+ * refus nomme l'auteur de la modification. Une création est supprimée, une
+ * suppression recréée, une modification ramenée à l'état d'avant.
+ */
+export declare function undoAgentAction(tx: Mutation, action: AgentAction): void;
+/** Libellés français des champs restaurables d'une tâche ; « position » est le rang dans une même colonne. */
+export declare const TASK_FIELD_LABELS: Record<(typeof TASK_FIELDS)[number] | "position" | "assigneeIds" | "tagIds", string>;
+/**
+ * Champs qui diffèrent entre deux instantanés de tâche, dans l'ordre des
+ * libellés. La position ne compte que dans une même colonne : un changement
+ * de colonne la change toujours.
+ */
+export declare function changedTaskFields(from: TaskSnapshot, to: TaskSnapshot): (keyof typeof TASK_FIELD_LABELS)[];
+/**
+ * Ramène une tâche aux champs de `target` (titre, description, statut,
+ * priorité, type, parent, tâche testée, position, assignés, tags) et renvoie
+ * les champs changés. La tâche reprend sa position d'alors si elle est
+ * libre ; revenue dans une autre colonne où cette position est prise, elle va
+ * en fin de colonne ; dans sa colonne, une position prise rend la
+ * restauration impossible.
+ */
+export declare function restoreTaskFields(tx: Mutation, taskId: string, target: TaskSnapshot): (keyof typeof TASK_FIELD_LABELS)[];
+export {};

package/dist/src/core/history.js

@@ -0,0 +1,279 @@
+import { InvariantError, NotFoundError } from "./errors.js";
+import { CheckpointSnapshotSchema, isTracked, snapshotOf, taskIdOfAction } from "./snapshots.js";
+import { ChecklistItemSchema, CommentSchema, IdeaSchema, TaskSnapshotSchema, TestCheckpointSchema, } from "../../shared/schemas/entities.schema.js";
+/**
+ * Retour à un état antérieur : annulation d'une action de l'agent, après
+ * comparaison de l'état courant de l'entité avec celui que l'action a
+ * laissé, et restauration des champs d'une version de tâche.
+ */
+/** Champs d'une tâche comparés et restaurés par l'historique. */
+const TASK_FIELDS = ["title", "description", "status", "priority", "type", "parentId", "testedTaskId"];
+/** Partie d'un instantané qui doit être identique pour qu'une action soit annulable sans écraser une modification. */
+function comparable(entityType, snapshot) {
+    switch (entityType) {
+        case "task": {
+            const task = TaskSnapshotSchema.parse(snapshot);
+            return [...TASK_FIELDS.map((field) => task[field]), task.position, [...task.assigneeIds].sort(), [...task.tagIds].sort()];
+        }
+        case "checklist_item": {
+            const item = ChecklistItemSchema.parse(snapshot);
+            return [item.text, item.done];
+        }
+        case "test_checkpoint":
+            return [TestCheckpointSchema.parse(snapshot).text];
+        case "comment":
+            return [CommentSchema.parse(snapshot).body];
+        case "idea": {
+            const idea = IdeaSchema.parse(snapshot);
+            return [idea.text, idea.promotedTaskId, idea.archivedAt !== null];
+        }
+    }
+}
+function sameState(entityType, a, b) {
+    return JSON.stringify(comparable(entityType, a)) === JSON.stringify(comparable(entityType, b));
+}
+/** Désignation d'une entité dans les messages, avec l'accord du participe. */
+function describe(store, entityType, snapshot) {
+    switch (entityType) {
+        case "task": {
+            const task = TaskSnapshotSchema.parse(snapshot);
+            const space = store.findSpace(task.spaceId);
+            return { label: `La tâche ${space ? `${space.keyPrefix}-${task.number}` : `« ${task.title} »`}`, feminine: true };
+        }
+        case "checklist_item":
+            return { label: `L'élément de checklist « ${ChecklistItemSchema.parse(snapshot).text} »`, feminine: false };
+        case "test_checkpoint":
+            return { label: `Le point de vérification « ${TestCheckpointSchema.parse(snapshot).text} »`, feminine: false };
+        case "comment":
+            return { label: "Le commentaire de l'agent", feminine: false };
+        case "idea":
+            return { label: `L'idée « ${excerpt(IdeaSchema.parse(snapshot).text)} »`, feminine: true };
+    }
+}
+function excerpt(text) {
+    const line = text.trim().split(/\r?\n/)[0];
+    return line.length > 60 ? `${line.slice(0, 59)}…` : line;
+}
+/** Auteur de la dernière modification d'une entité, pour le refus d'une annulation. */
+function lastModifier(store, entityType, entityId, action) {
+    const author = store.lastChangeAuthor(entityType, entityId);
+    if (!author)
+        return "quelqu'un d'autre";
+    if (author.actorType === "agent")
+        return author.requestId === action.requestId ? "une action plus récente de l'agent dans ce lot" : "l'agent";
+    const user = author.actorId === null ? null : store.findUser(author.actorId);
+    return user ? (user.displayName ?? user.email) : "un ancien membre";
+}
+/**
+ * Annule une action de l'agent dans la mutation `tx` (acteur utilisateur).
+ * L'état courant de l'entité doit être celui que l'action a laissé ; sinon le
+ * refus nomme l'auteur de la modification. Une création est supprimée, une
+ * suppression recréée, une modification ramenée à l'état d'avant.
+ */
+export function undoAgentAction(tx, action) {
+    if (action.undoneAt !== null)
+        throw new InvariantError("Cette action est déjà annulée.");
+    if (!isTracked(action.entityType))
+        throw new InvariantError(`Une action sur ${action.entityType} ne s'annule pas.`);
+    const entityType = action.entityType;
+    const store = tx.store;
+    const current = snapshotOf(store, entityType, action.entityId);
+    if (action.after === null) {
+        const { label } = describe(store, entityType, action.before);
+        if (current !== null)
+            throw new InvariantError(`${label} existe de nouveau : rien à recréer.`);
+        recreate(tx, entityType, action.before);
+    }
+    else {
+        const { label, feminine } = describe(store, entityType, current ?? action.after);
+        const agreement = feminine ? "e" : "";
+        if (current === null) {
+            throw new InvariantError(`${label} a été supprimé${agreement} depuis par ${lastModifier(store, entityType, action.entityId, action)} : annulation impossible.`);
+        }
+        if (!sameState(entityType, current, action.after)) {
+            throw new InvariantError(`${label} a été modifié${agreement} depuis par ${lastModifier(store, entityType, action.entityId, action)} : l'annulation écraserait cette modification.`);
+        }
+        if (action.before === null)
+            remove(tx, entityType, current, label);
+        else
+            restore(tx, entityType, action.entityId, action.before);
+    }
+    tx.markAgentActionUndone(action.id, taskIdOfAction(action));
+}
+/** Supprime une entité créée par l'agent ; une tâche qui porte d'autres éléments est refusée. */
+function remove(tx, entityType, current, label) {
+    const store = tx.store;
+    switch (entityType) {
+        case "task": {
+            const task = TaskSnapshotSchema.parse(current);
+            const dependents = [
+                [store.listChildren(task.id).length, "des sous-tâches"],
+                [store.listChecklist(task.id).length, "une checklist"],
+                [store.listCheckpoints(task.id).length, "des points de vérification"],
+                [store.listComments(task.id).length, "des commentaires"],
+                [store.listAttachments(task.id).length, "des pièces jointes"],
+            ];
+            const found = dependents.filter(([count]) => count > 0).map(([, what]) => what);
+            if (found.length > 0) {
+                throw new InvariantError(`${label} porte ${found.join(", ")} : annulez d'abord les actions qui les ont ajoutés, ou supprimez-les.`);
+            }
+            tx.deleteTask(task.id);
+            return;
+        }
+        case "checklist_item":
+            tx.deleteChecklistItem(ChecklistItemSchema.parse(current).id);
+            return;
+        case "test_checkpoint": {
+            const checkpoint = CheckpointSnapshotSchema.parse(current);
+            if (checkpoint.results.length > 0)
+                throw new InvariantError(`${label} a reçu des résultats de test depuis : annulation impossible sans les perdre.`);
+            tx.deleteCheckpoint(checkpoint.id);
+            return;
+        }
+        case "comment":
+            tx.deleteAgentComment(CommentSchema.parse(current).id);
+            return;
+        case "idea":
+            tx.deleteIdea(IdeaSchema.parse(current).id);
+            return;
+    }
+}
+/** Recrée une entité supprimée par l'agent. */
+function recreate(tx, entityType, before) {
+    switch (entityType) {
+        case "checklist_item": {
+            const item = ChecklistItemSchema.parse(before);
+            if (!tx.store.findTask(item.taskId))
+                throw new InvariantError(`La tâche de l'élément « ${item.text} » n'existe plus : rien à recréer.`);
+            tx.restoreChecklistItem(item);
+            return;
+        }
+        case "test_checkpoint": {
+            const checkpoint = CheckpointSnapshotSchema.parse(before);
+            if (!tx.store.findTask(checkpoint.taskId))
+                throw new InvariantError(`La tâche du point « ${checkpoint.text} » n'existe plus : rien à recréer.`);
+            const { results, ...fields } = checkpoint;
+            tx.restoreCheckpoint(fields, results);
+            return;
+        }
+        default:
+            throw new InvariantError(`La suppression d'un élément de type ${entityType} ne s'annule pas.`);
+    }
+}
+/** Ramène une entité modifiée par l'agent à son état d'avant. */
+function restore(tx, entityType, entityId, before) {
+    switch (entityType) {
+        case "task":
+            restoreTaskFields(tx, entityId, TaskSnapshotSchema.parse(before));
+            return;
+        case "checklist_item": {
+            const item = ChecklistItemSchema.parse(before);
+            tx.updateChecklistItem(entityId, { text: item.text, done: item.done });
+            return;
+        }
+        case "test_checkpoint":
+            tx.updateCheckpoint(entityId, TestCheckpointSchema.parse(before).text);
+            return;
+        case "idea": {
+            const idea = IdeaSchema.parse(before);
+            if (idea.promotedTaskId !== null && !tx.store.findTask(idea.promotedTaskId)) {
+                throw new InvariantError("La tâche issue de cette idée n'existe plus : annulation impossible.");
+            }
+            tx.updateIdea(entityId, { text: idea.text, promotedTaskId: idea.promotedTaskId, archived: idea.archivedAt !== null });
+            return;
+        }
+        case "comment":
+            throw new InvariantError("La modification d'un commentaire ne s'annule pas.");
+    }
+}
+/** Libellés français des champs restaurables d'une tâche ; « position » est le rang dans une même colonne. */
+export const TASK_FIELD_LABELS = {
+    title: "Titre",
+    description: "Description",
+    status: "Statut",
+    priority: "Priorité",
+    type: "Type",
+    parentId: "Tâche parente",
+    testedTaskId: "Tâche testée",
+    position: "Position",
+    assigneeIds: "Assignés",
+    tagIds: "Tags",
+};
+/**
+ * Champs qui diffèrent entre deux instantanés de tâche, dans l'ordre des
+ * libellés. La position ne compte que dans une même colonne : un changement
+ * de colonne la change toujours.
+ */
+export function changedTaskFields(from, to) {
+    const changed = TASK_FIELDS.filter((field) => from[field] !== to[field]);
+    if (from.status === to.status && from.parentId === to.parentId && from.position !== to.position)
+        changed.push("position");
+    if (JSON.stringify([...from.assigneeIds].sort()) !== JSON.stringify([...to.assigneeIds].sort()))
+        changed.push("assigneeIds");
+    if (JSON.stringify([...from.tagIds].sort()) !== JSON.stringify([...to.tagIds].sort()))
+        changed.push("tagIds");
+    return changed;
+}
+/**
+ * Ramène une tâche aux champs de `target` (titre, description, statut,
+ * priorité, type, parent, tâche testée, position, assignés, tags) et renvoie
+ * les champs changés. La tâche reprend sa position d'alors si elle est
+ * libre ; revenue dans une autre colonne où cette position est prise, elle va
+ * en fin de colonne ; dans sa colonne, une position prise rend la
+ * restauration impossible.
+ */
+export function restoreTaskFields(tx, taskId, target) {
+    const store = tx.store;
+    const current = store.taskSnapshot(taskId);
+    const changed = changedTaskFields(current, target);
+    const patch = {};
+    if (target.title !== current.title)
+        patch.title = target.title;
+    if (target.description !== current.description)
+        patch.description = target.description;
+    if (target.status !== current.status)
+        patch.status = target.status;
+    if (target.priority !== current.priority)
+        patch.priority = target.priority;
+    if (target.type !== current.type)
+        patch.type = target.type;
+    if (target.parentId !== current.parentId) {
+        if (target.parentId !== null && !store.findTask(target.parentId))
+            throw new InvariantError("La tâche parente d'alors n'existe plus : restauration impossible.");
+        patch.parentId = target.parentId;
+    }
+    if (target.testedTaskId !== current.testedTaskId) {
+        if (target.testedTaskId !== null && !store.findTask(target.testedTaskId))
+            throw new InvariantError("La tâche testée d'alors n'existe plus : restauration impossible.");
+        patch.testedTaskId = target.testedTaskId;
+    }
+    const sameColumn = patch.status === undefined && patch.parentId === undefined;
+    if (!sameColumn || target.position !== current.position) {
+        const column = store.listColumn(current.spaceId, target.parentId, target.status, taskId);
+        if (!column.some((task) => task.position === target.position))
+            patch.position = target.position;
+        else if (sameColumn)
+            throw new InvariantError("La position d'alors est désormais occupée par une autre tâche de la colonne : restauration impossible.");
+    }
+    if (Object.keys(patch).length > 0)
+        tx.updateTask(taskId, patch);
+    if (changed.includes("assigneeIds")) {
+        for (const userId of target.assigneeIds) {
+            if (!store.isMember(current.spaceId, userId)) {
+                const user = store.findUser(userId);
+                throw new InvariantError(`${user ? (user.displayName ?? user.email) : "Un ancien assigné"} n'est plus membre de l'espace : restauration impossible.`);
+            }
+        }
+        tx.setAssignees(taskId, target.assigneeIds);
+    }
+    if (changed.includes("tagIds")) {
+        const names = target.tagIds.map((tagId) => {
+            const tag = store.findTag(tagId);
+            if (!tag)
+                throw new NotFoundError(`Un tag de cet état n'existe plus : restauration impossible.`);
+            return tag.name;
+        });
+        tx.setTags(taskId, names);
+    }
+    return changed;
+}

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

@@ -0,0 +1,16 @@
+import type { Store } from "./store.js";
+import type { IdeaListResponse, IdeaView, PromoteIdeaRequest } from "../../shared/schemas/ideas-api.schema.js";
+/** Idées de l'espace, de la plus récente à la plus ancienne, avec le nombre d'idées actives. */
+export declare function listIdeas(store: Store, userId: string, spaceId: string): IdeaListResponse;
+/** Ajoute une idée saisie par l'utilisateur. */
+export declare function createIdea(store: Store, userId: string, spaceId: string, text: string): IdeaView;
+/** Archive ou désarchive une idée. */
+export declare function setIdeaArchived(store: Store, userId: string, ideaId: string, archived: boolean): IdeaView;
+/**
+ * Promeut une idée en tâche (colonne « À faire ») avec le titre, le type et la
+ * priorité choisis ; l'idée devient la description de la tâche et sort de la
+ * liste active.
+ */
+export declare function promoteIdea(store: Store, userId: string, ideaId: string, input: PromoteIdeaRequest): IdeaView;
+/** Confie la promotion d'une idée à l'agent : demande `idea_promotion`, dans l'espace de l'idée, avec l'idée pour contexte. */
+export declare function delegatePromotion(store: Store, userId: string, ideaId: string): IdeaView;

package/dist/src/core/ideas.js

@@ -0,0 +1,100 @@
+import { InvariantError, NotFoundError } from "./errors.js";
+import { requireMember } from "./spaces.js";
+/**
+ * Boîte à idées d'un espace, pour ses membres : liste, ajout, archivage,
+ * promotion manuelle en tâche et promotion confiée à l'agent (demande
+ * `idea_promotion` qui porte l'idée).
+ */
+const asUser = (userId) => ({ type: "user", userId });
+/** Idée d'un espace dont `userId` est membre ; un non-membre reçoit la même réponse qu'une idée inexistante. */
+function requireIdea(store, ideaId, userId) {
+    const idea = store.findIdea(ideaId);
+    if (!idea || !store.isMember(idea.spaceId, userId))
+        throw new NotFoundError("Idée introuvable, ou vous n'êtes pas membre de son espace.");
+    return idea;
+}
+function ideaView(store, idea, promotion) {
+    const author = store.findUser(idea.authorId);
+    const task = idea.promotedTaskId === null ? null : store.findTask(idea.promotedTaskId);
+    return {
+        id: idea.id,
+        text: idea.text,
+        origin: idea.origin,
+        authorId: idea.authorId,
+        authorName: author ? (author.displayName ?? author.email) : "Ancien membre",
+        createdAt: idea.createdAt,
+        archivedAt: idea.archivedAt,
+        promotedTask: task ? { id: task.id, key: `${store.getSpace(task.spaceId).keyPrefix}-${task.number}`, title: task.title } : null,
+        pendingPromotion: promotion && (promotion.status === "pending" || promotion.status === "processing") ? { requestId: promotion.id, status: promotion.status } : null,
+    };
+}
+/** Promotion confiée à l'agent encore ouverte sur une idée. */
+function openPromotion(store, idea) {
+    return store.listOpenPromotionRequests(idea.spaceId).find((request) => request.contextIdeaId === idea.id) ?? null;
+}
+function viewOf(store, ideaId) {
+    const idea = store.getIdea(ideaId);
+    return ideaView(store, idea, openPromotion(store, idea));
+}
+/** Vrai pour une idée de la liste active : ni archivée ni promue. */
+function isActive(idea) {
+    return idea.archivedAt === null && idea.promotedTaskId === null;
+}
+/** Idée encore à promouvoir : ni archivée, ni déjà promue, ni confiée à l'agent. */
+function requirePromotable(store, idea) {
+    if (idea.promotedTaskId !== null)
+        throw new InvariantError("Cette idée est déjà promue en tâche.");
+    if (idea.archivedAt !== null)
+        throw new InvariantError("Cette idée est archivée : désarchivez-la avant de la promouvoir.");
+    if (openPromotion(store, idea))
+        throw new InvariantError("La promotion de cette idée est déjà confiée à l'agent : annulez sa demande sur la page Agent pour la promouvoir vous-même.");
+}
+/** Idées de l'espace, de la plus récente à la plus ancienne, avec le nombre d'idées actives. */
+export function listIdeas(store, userId, spaceId) {
+    requireMember(store, spaceId, userId);
+    const promotions = new Map(store.listOpenPromotionRequests(spaceId).map((request) => [request.contextIdeaId, request]));
+    const ideas = store.listIdeas(spaceId);
+    return {
+        ideas: ideas.map((idea) => ideaView(store, idea, promotions.get(idea.id) ?? null)),
+        activeCount: ideas.filter(isActive).length,
+    };
+}
+/** Ajoute une idée saisie par l'utilisateur. */
+export function createIdea(store, userId, spaceId, text) {
+    const idea = store.mutate(asUser(userId), (tx) => {
+        requireMember(tx.store, spaceId, userId);
+        return tx.createIdea({ spaceId, text, origin: "manual" });
+    });
+    return viewOf(store, idea.id);
+}
+/** Archive ou désarchive une idée. */
+export function setIdeaArchived(store, userId, ideaId, archived) {
+    store.mutate(asUser(userId), (tx) => {
+        requireIdea(tx.store, ideaId, userId);
+        tx.updateIdea(ideaId, { archived });
+    });
+    return viewOf(store, ideaId);
+}
+/**
+ * Promeut une idée en tâche (colonne « À faire ») avec le titre, le type et la
+ * priorité choisis ; l'idée devient la description de la tâche et sort de la
+ * liste active.
+ */
+export function promoteIdea(store, userId, ideaId, input) {
+    store.mutate(asUser(userId), (tx) => {
+        const idea = requireIdea(tx.store, ideaId, userId);
+        requirePromotable(tx.store, idea);
+        const task = tx.createTask({ spaceId: idea.spaceId, title: input.title, type: input.type, priority: input.priority, description: idea.text });
+        tx.updateIdea(idea.id, { promotedTaskId: task.id });
+    });
+    return viewOf(store, ideaId);
+}
+/** Confie la promotion d'une idée à l'agent : demande `idea_promotion`, dans l'espace de l'idée, avec l'idée pour contexte. */
+export function delegatePromotion(store, userId, ideaId) {
+    store.mutate(asUser(userId), (tx) => {
+        const idea = requireIdea(tx.store, ideaId, userId);
+        requirePromotable(tx.store, idea);
+        tx.createAgentRequest({ targetSpaceId: idea.spaceId, kind: "idea_promotion", text: idea.text, contextIdeaId: idea.id });
+    });
+    return viewOf(store, ideaId);
+}

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

@@ -0,0 +1,2 @@
+/** Identifiant opaque d'une entité. */
+export declare function newId(): string;

package/dist/src/core/ids.js

@@ -0,0 +1,5 @@
+import { randomUUID } from "node:crypto";
+/** Identifiant opaque d'une entité. */
+export function newId() {
+    return randomUUID();
+}

package/dist/src/core/log-dir.d.ts

@@ -0,0 +1,2 @@
+/** Répertoire des logs : MCP_LOG_DIR s'il est renseigné, sinon <dataDir>/logs. */
+export declare function resolveLogDir(rootDir: string): string;

package/dist/src/core/log-dir.js

@@ -0,0 +1,9 @@
+import path from "node:path";
+import { resolveDataDir } from "./data-dir.js";
+/** Répertoire des logs : MCP_LOG_DIR s'il est renseigné, sinon <dataDir>/logs. */
+export function resolveLogDir(rootDir) {
+    const configured = process.env.MCP_LOG_DIR?.trim();
+    if (configured)
+        return path.resolve(configured);
+    return path.join(resolveDataDir(rootDir), "logs");
+}

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

@@ -0,0 +1,14 @@
+export interface Logger {
+    debug: (message: string, ...meta: unknown[]) => void;
+    info: (message: string, ...meta: unknown[]) => void;
+    warn: (message: string, ...meta: unknown[]) => void;
+    error: (message: string, ...meta: unknown[]) => void;
+}
+/** Nom du fichier de journal dans le répertoire des journaux. */
+export declare const LOG_FILENAME = "server.log";
+/**
+ * Ouvre le fichier de journal de `logDir` pour le processus `label`. Un
+ * répertoire impossible à créer est une erreur, levée à l'appelant.
+ */
+export declare function setupLogging(label: string, logDir: string): void;
+export declare function createLogger(scope: string): Logger;

package/dist/src/core/logger.js

@@ -0,0 +1,37 @@
+import fs from "node:fs";
+import path from "node:path";
+import { inspect } from "node:util";
+/** Nom du fichier de journal dans le répertoire des journaux. */
+export const LOG_FILENAME = "server.log";
+let stream = null;
+let processLabel = "mcp-organizer";
+function serialize(value) {
+    return typeof value === "string" ? value : inspect(value, { depth: 5, breakLength: 120, compact: true });
+}
+/**
+ * Ouvre le fichier de journal de `logDir` pour le processus `label`. Un
+ * répertoire impossible à créer est une erreur, levée à l'appelant.
+ */
+export function setupLogging(label, logDir) {
+    processLabel = label;
+    fs.mkdirSync(logDir, { recursive: true });
+    stream = fs.createWriteStream(path.join(logDir, LOG_FILENAME), { flags: "a", encoding: "utf8" });
+    stream.on("error", (err) => {
+        stream = null;
+        process.stderr.write(`[${processLabel}] Cannot write the log file in ${logDir}: ${err.message}\n`);
+    });
+}
+function write(level, scope, message, meta) {
+    const text = meta.length === 0 ? message : `${message} ${meta.map(serialize).join(" ")}`;
+    const line = `[${new Date().toISOString()}] [PID ${process.pid}] [${processLabel}] [${level}] [${scope}] ${text}\n`;
+    process.stderr.write(line);
+    stream?.write(line);
+}
+export function createLogger(scope) {
+    return {
+        debug: (message, ...meta) => write("DEBUG", scope, message, meta),
+        info: (message, ...meta) => write("INFO", scope, message, meta),
+        warn: (message, ...meta) => write("WARN", scope, message, meta),
+        error: (message, ...meta) => write("ERROR", scope, message, meta),
+    };
+}

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

@@ -0,0 +1,43 @@
+/** Message envoyé par e-mail, en texte brut. */
+export interface MailMessage {
+    to: string;
+    subject: string;
+    text: string;
+}
+/** Issue d'un envoi : `reason` dit pourquoi l'e-mail n'est pas parti. */
+export type MailOutcome = {
+    sent: true;
+} | {
+    sent: false;
+    reason: string;
+};
+/** Transport d'envoi : celui de nodemailer, ou un transport de test. */
+export interface MailTransport {
+    sendMail(message: {
+        from: string;
+        to: string;
+        subject: string;
+        text: string;
+    }): Promise<unknown>;
+}
+/**
+ * Envoi des e-mails. Sans configuration, l'envoi est désactivé et
+ * `disabledReason` dit quoi configurer ; chaque envoi renvoie alors cette raison.
+ */
+export interface Mailer {
+    readonly enabled: boolean;
+    readonly disabledReason: string | null;
+    send(message: MailMessage): Promise<MailOutcome>;
+}
+export interface MailConfig {
+    /** URL SMTP (`smtp://utilisateur:motdepasse@hôte:587`, `smtps://…`). */
+    smtpUrl?: string;
+    /** Expéditeur (`Organizer <organizer@example.com>`). */
+    from?: string;
+    /** Transport imposé, à la place de celui construit depuis `smtpUrl`. */
+    transport?: MailTransport;
+}
+/** Construit le mailer depuis la configuration (`SMTP_URL`, `MAIL_FROM`). */
+export declare function createMailer(config: MailConfig): Mailer;
+/** Mailer construit depuis les variables d'environnement `SMTP_URL` et `MAIL_FROM`. */
+export declare function mailerFromEnv(env?: NodeJS.ProcessEnv): Mailer;

package/dist/src/core/mail.js

@@ -0,0 +1,44 @@
+import nodemailer from "nodemailer";
+/** Mailer désactivé : chaque envoi renvoie `reason`. */
+function disabledMailer(reason) {
+    return {
+        enabled: false,
+        disabledReason: reason,
+        send: async () => ({ sent: false, reason }),
+    };
+}
+/** Construit le mailer depuis la configuration (`SMTP_URL`, `MAIL_FROM`). */
+export function createMailer(config) {
+    const smtpUrl = config.smtpUrl?.trim();
+    const from = config.from?.trim();
+    if (!config.transport && !smtpUrl) {
+        return disabledMailer("Envoi d'e-mail désactivé : SMTP_URL n'est pas défini dans la configuration du site.");
+    }
+    if (!from) {
+        return disabledMailer("Envoi d'e-mail désactivé : MAIL_FROM (adresse de l'expéditeur) n'est pas défini dans la configuration du site.");
+    }
+    let transport;
+    try {
+        transport = config.transport ?? nodemailer.createTransport(smtpUrl);
+    }
+    catch (err) {
+        return disabledMailer(`Envoi d'e-mail désactivé : SMTP_URL est invalide (${err?.message ?? err}).`);
+    }
+    return {
+        enabled: true,
+        disabledReason: null,
+        send: async (message) => {
+            try {
+                await transport.sendMail({ from, to: message.to, subject: message.subject, text: message.text });
+                return { sent: true };
+            }
+            catch (err) {
+                return { sent: false, reason: `L'envoi de l'e-mail a échoué : ${err?.message ?? err}` };
+            }
+        },
+    };
+}
+/** Mailer construit depuis les variables d'environnement `SMTP_URL` et `MAIL_FROM`. */
+export function mailerFromEnv(env = process.env) {
+    return createMailer({ smtpUrl: env.SMTP_URL, from: env.MAIL_FROM });
+}

package/dist/src/core/mcp-entry.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Entrée `mcp-organizer` d'un fichier `.mcp.json` : le mode MCP lancé par
+ * `npx`, relié à un site par son URL publique et un jeton d'agent. Le setup
+ * l'écrit ; la création d'un jeton dans la GUI la renvoie à copier.
+ */
+export declare const SERVER_NAME = "mcp-organizer";
+export declare const PACKAGE_NAME = "@imenam/mcp-organizer";
+/** Entrée d'un serveur dans `.mcp.json`. */
+export interface McpEntry {
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+}
+/** Entrée du mode MCP relié à un site : URL publique du site et jeton d'agent. */
+export declare function buildAgentEntry(input: {
+    url: string;
+    token: string;
+}): McpEntry;
+/** Texte à coller dans `.mcp.json` : l'entrée sous `mcpServers`. */
+export declare function mcpJsonText(entry: McpEntry): string;