@imenam/mcp-organizer 0.0.0-stage → 1.0.2

package/dist/src/gui-api.js

@@ -0,0 +1,383 @@
+import { ActivateRequestSchema, ChangePasswordRequestSchema, CreateSpaceRequestSchema, InviteRequestSchema, LoginRequestSchema, RenameSpaceRequestSchema, UpdateProfileRequestSchema, } from "../shared/schemas/api.schema.js";
+import { schemaVersion } from "./core/migrations.js";
+import { ForbiddenError, InvariantError, NotFoundError, OrganizerError, UnauthorizedError } from "./core/errors.js";
+import { authenticate, changePassword, login, logout, redeemAccessLink, resolveAccessLink, updateDisplayName } from "./core/accounts.js";
+import { acceptReceivedInvitation, createSharedSpace, declineReceivedInvitation, deleteSpace, inviteToSpace, leaveSpace, listMembers, listReceivedInvitations, listSpaces, removeMember, renameSpace, resendInvitation, revokeInvitation, } from "./core/spaces.js";
+import { addChecklistItem, addComment, createTask, deleteAttachment, deleteChecklistItem, deleteComment, deleteTask, downloadAttachment, getBoard, getTaskDetail, listChanges, moveChecklistItem, moveTask, setAssignees, setTags, updateChecklistItem, updateComment, updateTask, uploadAttachment, } from "./core/tasks.js";
+import { addCheckpoint, deleteCheckpoint, moveCheckpoint, saveReviewDraft, setTestResult, submitReview, updateCheckpoint } from "./core/test-tasks.js";
+import { AddChecklistItemRequestSchema, CheckpointTextRequestSchema, CommentRequestSchema, CreateTaskRequestSchema, MoveAfterRequestSchema, MoveTaskRequestSchema, ReviewDraftRequestSchema, SetAssigneesRequestSchema, SetTagsRequestSchema, SetTestResultRequestSchema, SubmitReviewRequestSchema, TaskFiltersSchema, UpdateChecklistItemRequestSchema, UpdateTaskRequestSchema, UploadAttachmentRequestSchema, } from "../shared/schemas/tasks-api.schema.js";
+import { getSettings, listNotifications, markAllNotificationsRead, markNotificationRead, unreadCount, updateSettings } from "./core/notifications.js";
+import { NotificationListQuerySchema, UpdateSettingsRequestSchema } from "../shared/schemas/notifications-api.schema.js";
+import { cancelRequest, createRequest, getRequest, listRequests, releaseRequest, undoAction, undoRequest, updateRequest } from "./core/requests.js";
+import { listTaskVersions, restoreTaskVersion } from "./core/task-history.js";
+import { CreateRequestSchema, UpdateRequestSchema } from "../shared/schemas/agent-api.schema.js";
+import { createIdea, delegatePromotion, listIdeas, promoteIdea, setIdeaArchived } from "./core/ideas.js";
+import { CreateIdeaRequestSchema, PromoteIdeaRequestSchema, UpdateIdeaRequestSchema } from "../shared/schemas/ideas-api.schema.js";
+import { createAgentToken, listAgentTokens, revokeAgentToken } from "./core/agent-tokens.js";
+import { CreateTokenRequestSchema } from "../shared/schemas/tokens-api.schema.js";
+import { TranscriptionError } from "./core/transcription.js";
+import { MAX_TRANSCRIPTION_BYTES, TranscribeRequestSchema } from "../shared/schemas/transcription-api.schema.js";
+/** Erreur d'une requête de la GUI, avec la nature qui fixe son code HTTP. */
+export class ApiError extends Error {
+    kind;
+    status;
+    constructor(kind, message, 
+    /** Code HTTP imposé à la réponse, à la place de celui de `kind`. */
+    status) {
+        super(message);
+        this.kind = kind;
+        this.status = status;
+        this.name = "ApiError";
+    }
+}
+/** Nature d'une erreur levée en traitant une requête de la GUI. */
+export function errorKindOf(err) {
+    if (err instanceof ApiError)
+        return err.kind;
+    if (err instanceof TranscriptionError)
+        return err.status === 503 ? "unavailable" : "upstream";
+    if (err instanceof UnauthorizedError)
+        return "unauthorized";
+    if (err instanceof ForbiddenError)
+        return "forbidden";
+    if (err instanceof NotFoundError)
+        return "not_found";
+    if (err instanceof InvariantError)
+        return "conflict";
+    if (err instanceof OrganizerError)
+        return "invalid";
+    return "internal";
+}
+/** Code HTTP imposé par une erreur : celui que Groq a renvoyé pour une transcription refusée. */
+export function errorStatusOf(err) {
+    if (err instanceof ApiError)
+        return err.status;
+    if (err instanceof TranscriptionError)
+        return err.status;
+    return undefined;
+}
+/** Compile `/spaces/:spaceId/members` en expression régulière et noms de paramètres. */
+function compile(path) {
+    const keys = [];
+    const source = path.replace(/:([A-Za-z]+)/g, (_, key) => {
+        keys.push(key);
+        return "([^/]+)";
+    });
+    return { pattern: new RegExp(`^${source}$`), keys };
+}
+const routes = [];
+function publicRoute(method, path, handler) {
+    routes.push({ method, ...compile(path), public: handler });
+}
+function route(method, path, handler) {
+    routes.push({ method, ...compile(path), handler });
+}
+/** Segment de chemin décodé ; un encodage `%` invalide est une erreur 400. */
+function decodeSegment(raw) {
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        throw new ApiError("invalid", `Adresse invalide : un segment du chemin est mal encodé (${raw}).`);
+    }
+}
+/** Corps validé par `schema` ; une donnée invalide est une erreur 400 qui liste les problèmes. */
+function parseBody(schema, body) {
+    const parsed = schema.safeParse(body ?? {});
+    if (!parsed.success)
+        throw new ApiError("invalid", parsed.error.issues.map((issue) => issue.message).join(" "));
+    return parsed.data;
+}
+function publicUser(user) {
+    return { id: user.id, email: user.email, displayName: user.displayName, status: user.status };
+}
+const ok = { ok: true };
+/** Taille lisible d'un nombre d'octets, en Mo. */
+function megabytes(bytes) {
+    return `${(bytes / (1024 * 1024)).toFixed(1).replace(".", ",")} Mo`;
+}
+function now(ctx) {
+    return ctx.now?.() ?? new Date();
+}
+// --- Routes publiques -------------------------------------------------------------
+publicRoute("GET", "/health", (ctx) => {
+    const health = {
+        status: "ok",
+        version: ctx.version,
+        schemaVersion: schemaVersion(ctx.store.db),
+        accountsExist: ctx.store.countUsers() > 0,
+    };
+    return { body: health };
+});
+publicRoute("POST", "/auth/login", async (ctx, request) => {
+    const input = parseBody(LoginRequestSchema, request.body);
+    const { user, session } = await login(ctx.store, input.email, input.password, now(ctx));
+    const body = { user: publicUser(user) };
+    return { body, session };
+});
+publicRoute("POST", "/auth/logout", (ctx, request) => {
+    logout(ctx.store, request.sessionToken);
+    return { body: ok, session: null };
+});
+publicRoute("GET", "/access-links/:token", (ctx, _request, params) => {
+    const { link, user } = resolveAccessLink(ctx.store, params.token, now(ctx));
+    const body = { email: user.email, purpose: link.purpose, displayName: user.displayName, expiresAt: link.expiresAt };
+    return { body };
+});
+publicRoute("POST", "/access-links/:token", async (ctx, request, params) => {
+    const input = parseBody(ActivateRequestSchema, request.body);
+    const { user, session } = await redeemAccessLink(ctx.store, params.token, input, now(ctx));
+    const body = { user: publicUser(user) };
+    return { body, session };
+});
+// --- Routes authentifiées ---------------------------------------------------------
+route("GET", "/auth/me", (_ctx, { user }) => {
+    const body = { user: publicUser(user) };
+    return { body };
+});
+route("PATCH", "/profile", (ctx, { user, request }) => {
+    const input = parseBody(UpdateProfileRequestSchema, request.body);
+    const body = { user: publicUser(updateDisplayName(ctx.store, user.id, input.displayName)) };
+    return { body };
+});
+route("POST", "/profile/password", async (ctx, { user, request }) => {
+    await changePassword(ctx.store, user.id, parseBody(ChangePasswordRequestSchema, request.body), request.sessionToken);
+    return { body: ok };
+});
+route("GET", "/spaces", (ctx, { user }) => {
+    const body = { spaces: listSpaces(ctx.store, user.id) };
+    return { body };
+});
+route("POST", "/spaces", (ctx, { user, request }) => {
+    const input = parseBody(CreateSpaceRequestSchema, request.body);
+    return { body: createSharedSpace(ctx.store, user.id, input) };
+});
+route("PATCH", "/spaces/:spaceId", (ctx, { user, request, params }) => {
+    const input = parseBody(RenameSpaceRequestSchema, request.body);
+    return { body: renameSpace(ctx.store, user.id, params.spaceId, input.name) };
+});
+route("DELETE", "/spaces/:spaceId", (ctx, { user, params }) => {
+    deleteSpace(ctx.store, ctx.attachments, user.id, params.spaceId);
+    return { body: ok };
+});
+route("GET", "/spaces/:spaceId/members", (ctx, { user, params }) => ({ body: listMembers(ctx.store, user.id, params.spaceId, now(ctx)) }));
+route("DELETE", "/spaces/:spaceId/members/:userId", (ctx, { user, params }) => {
+    removeMember(ctx.store, user.id, params.spaceId, params.userId);
+    return { body: ok };
+});
+route("POST", "/spaces/:spaceId/leave", (ctx, { user, params }) => {
+    leaveSpace(ctx.store, user.id, params.spaceId);
+    return { body: ok };
+});
+route("POST", "/spaces/:spaceId/invitations", async (ctx, { user, request, params }) => {
+    const input = parseBody(InviteRequestSchema, request.body);
+    return { body: await inviteToSpace(ctx.store, ctx, user.id, params.spaceId, input.email) };
+});
+route("POST", "/spaces/:spaceId/invitations/:invitationId/resend", async (ctx, { user, params }) => ({
+    body: await resendInvitation(ctx.store, ctx, user.id, params.spaceId, params.invitationId),
+}));
+route("DELETE", "/spaces/:spaceId/invitations/:invitationId", (ctx, { user, params }) => {
+    revokeInvitation(ctx.store, user.id, params.spaceId, params.invitationId);
+    return { body: ok };
+});
+route("GET", "/invitations", (ctx, { user }) => ({ body: listReceivedInvitations(ctx.store, user.id, now(ctx)) }));
+route("POST", "/invitations/:invitationId/accept", (ctx, { user, params }) => ({
+    body: acceptReceivedInvitation(ctx.store, user.id, params.invitationId, now(ctx)),
+}));
+route("POST", "/invitations/:invitationId/decline", (ctx, { user, params }) => {
+    declineReceivedInvitation(ctx.store, user.id, params.invitationId);
+    return { body: ok };
+});
+// --- Tâches -----------------------------------------------------------------------
+route("GET", "/spaces/:spaceId/tasks", (ctx, { user, request, params }) => {
+    const parsed = TaskFiltersSchema.safeParse(request.query);
+    if (!parsed.success)
+        throw new ApiError("invalid", `Filtre invalide : ${parsed.error.issues.map((issue) => `${issue.path.join(".")} ${issue.message}`).join("; ")}.`);
+    return { body: getBoard(ctx.store, user.id, params.spaceId, parsed.data) };
+});
+route("POST", "/spaces/:spaceId/tasks", (ctx, { user, request, params }) => ({
+    body: createTask(ctx.store, user.id, params.spaceId, parseBody(CreateTaskRequestSchema, request.body)),
+}));
+route("GET", "/tasks/:taskId", (ctx, { user, params }) => ({ body: getTaskDetail(ctx.store, user.id, params.taskId) }));
+route("PATCH", "/tasks/:taskId", (ctx, { user, request, params }) => ({
+    body: updateTask(ctx.store, user.id, params.taskId, parseBody(UpdateTaskRequestSchema, request.body)),
+}));
+route("DELETE", "/tasks/:taskId", (ctx, { user, params }) => {
+    deleteTask(ctx.store, ctx.attachments, user.id, params.taskId);
+    return { body: ok };
+});
+route("POST", "/tasks/:taskId/move", (ctx, { user, request, params }) => {
+    const input = parseBody(MoveTaskRequestSchema, request.body);
+    return { body: moveTask(ctx.store, user.id, params.taskId, input.status, input.afterId) };
+});
+route("PUT", "/tasks/:taskId/assignees", (ctx, { user, request, params }) => ({
+    body: setAssignees(ctx.store, user.id, params.taskId, parseBody(SetAssigneesRequestSchema, request.body).userIds),
+}));
+route("PUT", "/tasks/:taskId/tags", (ctx, { user, request, params }) => ({
+    body: setTags(ctx.store, user.id, params.taskId, parseBody(SetTagsRequestSchema, request.body).names),
+}));
+route("POST", "/tasks/:taskId/checklist", (ctx, { user, request, params }) => ({
+    body: addChecklistItem(ctx.store, user.id, params.taskId, parseBody(AddChecklistItemRequestSchema, request.body).text),
+}));
+route("PATCH", "/checklist/:itemId", (ctx, { user, request, params }) => ({
+    body: updateChecklistItem(ctx.store, user.id, params.itemId, parseBody(UpdateChecklistItemRequestSchema, request.body)),
+}));
+route("DELETE", "/checklist/:itemId", (ctx, { user, params }) => {
+    deleteChecklistItem(ctx.store, user.id, params.itemId);
+    return { body: ok };
+});
+route("POST", "/checklist/:itemId/move", (ctx, { user, request, params }) => ({
+    body: moveChecklistItem(ctx.store, user.id, params.itemId, parseBody(MoveAfterRequestSchema, request.body).afterId),
+}));
+// --- Tâches de test ---------------------------------------------------------------
+route("POST", "/tasks/:taskId/checkpoints", (ctx, { user, request, params }) => ({
+    body: addCheckpoint(ctx.store, user.id, params.taskId, parseBody(CheckpointTextRequestSchema, request.body).text),
+}));
+route("PATCH", "/checkpoints/:checkpointId", (ctx, { user, request, params }) => ({
+    body: updateCheckpoint(ctx.store, user.id, params.checkpointId, parseBody(CheckpointTextRequestSchema, request.body).text),
+}));
+route("DELETE", "/checkpoints/:checkpointId", (ctx, { user, params }) => {
+    deleteCheckpoint(ctx.store, user.id, params.checkpointId);
+    return { body: ok };
+});
+route("POST", "/checkpoints/:checkpointId/move", (ctx, { user, request, params }) => ({
+    body: moveCheckpoint(ctx.store, user.id, params.checkpointId, parseBody(MoveAfterRequestSchema, request.body).afterId),
+}));
+route("PUT", "/checkpoints/:checkpointId/result", (ctx, { user, request, params }) => ({
+    body: setTestResult(ctx.store, user.id, params.checkpointId, parseBody(SetTestResultRequestSchema, request.body)),
+}));
+route("PUT", "/tasks/:taskId/review", (ctx, { user, request, params }) => ({
+    body: saveReviewDraft(ctx.store, user.id, params.taskId, parseBody(ReviewDraftRequestSchema, request.body).text),
+}));
+route("POST", "/tasks/:taskId/review/submit", (ctx, { user, request, params }) => ({
+    body: submitReview(ctx.store, user.id, params.taskId, parseBody(SubmitReviewRequestSchema, request.body).text),
+}));
+// --- Commentaires ------------------------------------------------------------------
+route("POST", "/tasks/:taskId/comments", (ctx, { user, request, params }) => ({
+    body: addComment(ctx.store, user.id, params.taskId, parseBody(CommentRequestSchema, request.body).body),
+}));
+route("PATCH", "/comments/:commentId", (ctx, { user, request, params }) => ({
+    body: updateComment(ctx.store, user.id, params.commentId, parseBody(CommentRequestSchema, request.body).body),
+}));
+route("DELETE", "/comments/:commentId", (ctx, { user, params }) => {
+    deleteComment(ctx.store, user.id, params.commentId);
+    return { body: ok };
+});
+route("POST", "/tasks/:taskId/attachments", (ctx, { user, request, params }) => ({
+    body: uploadAttachment(ctx.store, ctx.attachments, user.id, params.taskId, parseBody(UploadAttachmentRequestSchema, request.body)),
+}));
+route("GET", "/attachments/:attachmentId", (ctx, { user, params }) => ({
+    body: null,
+    file: downloadAttachment(ctx.store, ctx.attachments, user.id, params.attachmentId),
+}));
+route("DELETE", "/attachments/:attachmentId", (ctx, { user, params }) => {
+    deleteAttachment(ctx.store, ctx.attachments, user.id, params.attachmentId);
+    return { body: ok };
+});
+// --- Idées -------------------------------------------------------------------------
+route("GET", "/spaces/:spaceId/ideas", (ctx, { user, params }) => ({ body: listIdeas(ctx.store, user.id, params.spaceId) }));
+route("POST", "/spaces/:spaceId/ideas", (ctx, { user, request, params }) => ({
+    body: createIdea(ctx.store, user.id, params.spaceId, parseBody(CreateIdeaRequestSchema, request.body).text),
+}));
+route("PATCH", "/ideas/:ideaId", (ctx, { user, request, params }) => ({
+    body: setIdeaArchived(ctx.store, user.id, params.ideaId, parseBody(UpdateIdeaRequestSchema, request.body).archived),
+}));
+route("POST", "/ideas/:ideaId/promote", (ctx, { user, request, params }) => ({
+    body: promoteIdea(ctx.store, user.id, params.ideaId, parseBody(PromoteIdeaRequestSchema, request.body)),
+}));
+route("POST", "/ideas/:ideaId/delegate", (ctx, { user, params }) => ({ body: delegatePromotion(ctx.store, user.id, params.ideaId) }));
+// --- File de l'agent et historique -------------------------------------------------
+route("GET", "/spaces/:spaceId/requests", (ctx, { user, params }) => ({ body: listRequests(ctx.store, user.id, params.spaceId, now(ctx)) }));
+route("POST", "/spaces/:spaceId/requests", (ctx, { user, request, params }) => ({
+    body: createRequest(ctx.store, user.id, params.spaceId, parseBody(CreateRequestSchema, request.body)),
+}));
+route("GET", "/requests/:requestId", (ctx, { user, params }) => ({ body: getRequest(ctx.store, user.id, params.requestId) }));
+route("PATCH", "/requests/:requestId", (ctx, { user, request, params }) => ({
+    body: updateRequest(ctx.store, user.id, params.requestId, parseBody(UpdateRequestSchema, request.body).text),
+}));
+route("POST", "/requests/:requestId/cancel", (ctx, { user, params }) => ({ body: cancelRequest(ctx.store, user.id, params.requestId) }));
+route("POST", "/requests/:requestId/release", (ctx, { user, params }) => ({ body: releaseRequest(ctx.store, user.id, params.requestId) }));
+route("POST", "/requests/:requestId/undo", (ctx, { user, params }) => ({ body: undoRequest(ctx.store, user.id, params.requestId) }));
+route("POST", "/agent-actions/:actionId/undo", (ctx, { user, params }) => ({ body: undoAction(ctx.store, user.id, params.actionId) }));
+route("GET", "/tasks/:taskId/versions", (ctx, { user, params }) => ({ body: listTaskVersions(ctx.store, user.id, params.taskId) }));
+route("POST", "/tasks/:taskId/versions/:version/restore", (ctx, { user, params }) => {
+    const version = Number(params.version);
+    if (!Number.isInteger(version) || version < 1)
+        throw new ApiError("invalid", `Numéro de version invalide (${params.version}).`);
+    return { body: restoreTaskVersion(ctx.store, user.id, params.taskId, version) };
+});
+// --- Notifications et paramètres ---------------------------------------------------
+route("GET", "/notifications", (ctx, { user, request }) => {
+    const parsed = NotificationListQuerySchema.safeParse(request.query);
+    if (!parsed.success)
+        throw new ApiError("invalid", `Pagination invalide : ${parsed.error.issues.map((issue) => `${issue.path.join(".")} ${issue.message}`).join("; ")}.`);
+    return { body: listNotifications(ctx.store, user.id, parsed.data) };
+});
+route("GET", "/notifications/unread-count", (ctx, { user }) => ({ body: unreadCount(ctx.store, user.id) }));
+route("POST", "/notifications/read-all", (ctx, { user }) => ({ body: markAllNotificationsRead(ctx.store, user.id) }));
+route("POST", "/notifications/:notificationId/read", (ctx, { user, params }) => ({
+    body: markNotificationRead(ctx.store, user.id, params.notificationId),
+}));
+route("GET", "/settings", (ctx, { user }) => ({ body: getSettings(ctx.store, ctx, user.id) }));
+route("PUT", "/settings", (ctx, { user, request }) => ({
+    body: updateSettings(ctx.store, ctx, user.id, parseBody(UpdateSettingsRequestSchema, request.body)),
+}));
+// --- Jetons d'agent ---------------------------------------------------------------
+route("GET", "/tokens", (ctx, { user }) => ({ body: listAgentTokens(ctx.store, user.id, now(ctx)) }));
+route("POST", "/tokens", (ctx, { user, request }) => {
+    const input = parseBody(CreateTokenRequestSchema, request.body);
+    if (!ctx.publicUrl)
+        throw new ApiError("unavailable", "ORGANIZER_PUBLIC_URL n'est pas défini : l'URL du site, que l'agent appelle, est inconnue.");
+    return { body: createAgentToken(ctx.store, user.id, input, ctx.publicUrl, now(ctx)) };
+});
+route("POST", "/tokens/:tokenId/revoke", (ctx, { user, params }) => ({ body: revokeAgentToken(ctx.store, user.id, params.tokenId, now(ctx)) }));
+// --- Dictée ------------------------------------------------------------------------
+route("POST", "/transcribe", async (ctx, { request }) => {
+    const input = parseBody(TranscribeRequestSchema, request.body);
+    if (!ctx.transcriber.enabled)
+        throw new ApiError("unavailable", ctx.transcriber.disabledReason ?? "Dictée désactivée.");
+    const content = Buffer.from(input.contentBase64, "base64");
+    if (content.length > MAX_TRANSCRIPTION_BYTES) {
+        throw new ApiError("too_large", `Enregistrement trop volumineux (${megabytes(content.length)}) : la dictée accepte ${megabytes(MAX_TRANSCRIPTION_BYTES)} au plus.`);
+    }
+    if (content.length === 0)
+        throw new ApiError("invalid", "L'enregistrement est vide.");
+    const body = { text: await ctx.transcriber.transcribe({ content, filename: input.filename, mime: input.mime }) };
+    return { body };
+});
+// --- Changements -------------------------------------------------------------------
+route("GET", "/changes", (ctx, { user, request }) => {
+    const raw = request.query.since;
+    let since = null;
+    if (raw !== undefined) {
+        since = Number(raw);
+        if (!Number.isInteger(since) || since < 0)
+            throw new ApiError("invalid", `Paramètre since invalide (${raw}) : entier positif attendu.`);
+    }
+    return { body: listChanges(ctx.store, user.id, since) };
+});
+// --- Point d'entrée ---------------------------------------------------------------
+/**
+ * Traite une requête `/api/*` de la GUI. Hors des routes
+ * publiques (santé, connexion, déconnexion, liens d'accès), une session valide
+ * est exigée ; une session prolongée renvoie son nouveau cookie.
+ */
+export async function handleApiRequest(ctx, request) {
+    for (const candidate of routes) {
+        if (candidate.method !== request.method)
+            continue;
+        const match = candidate.pattern.exec(request.path);
+        if (!match)
+            continue;
+        const params = {};
+        candidate.keys.forEach((key, index) => (params[key] = decodeSegment(match[index + 1])));
+        if (candidate.public)
+            return candidate.public(ctx, request, params);
+        const auth = authenticate(ctx.store, request.sessionToken, now(ctx));
+        if (!auth)
+            throw new ApiError("unauthorized", "Session absente ou expirée : connectez-vous.");
+        const response = await candidate.handler(ctx, { request, params, user: auth.user });
+        return auth.refreshed && response.session === undefined ? { ...response, session: auth.refreshed } : response;
+    }
+    throw new ApiError("not_found", `Unknown API route: ${request.method} /api${request.path}`);
+}

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/index.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { APP_VERSION } from "./version.js";
+import { ConfigError } from "./core/errors.js";
+import { findProjectRoot } from "./core/project-root.js";
+import { loadEnvFile, resolveEnvFile, withoutEnvFileFlag } from "./core/env-file.js";
+const USAGE = `mcp-organizer v${APP_VERSION} — gestionnaire de tâches multi-utilisateur piloté par un agent
+
+Usage :
+  mcp-organizer                     Mode MCP (stdio) : outils de l'agent, relayés à l'API du site.
+  mcp-organizer --server            Site web : interface, API et base de données, sur HOST:PORT.
+  mcp-organizer --set-user [email] [--name="Prénom Nom"] [--non-interactive]
+                                    Crée un compte ou remplace son mot de passe.
+  mcp-organizer --setup [options]   Installe le site : .env, unité systemd, bloc nginx, premier compte
+                                    (interactif, ou --non-interactive ; --setup --help pour les options).
+  mcp-organizer --backup <fichier> [--force]
+                                    Sauvegarde la base (site en service ou non) et ses pièces jointes
+                                    (dossier <fichier>.attachments).
+  mcp-organizer --claude-setup-mcp [--force] --url=<URL du site> --token=<jeton>
+                                    Écrit l'entrée du mode MCP dans ./.mcp.json.
+  mcp-organizer --watch <id du jeton>
+                                    Veilleur de notifications : une ligne par demande passée en attente.
+                                    Lancé par l'outil Monitor de l'agent, avec la commande que rend
+                                    l'outil enable_notifications.
+  mcp-organizer --version           Affiche la version.
+  mcp-organizer --help              Affiche cette aide.
+
+Option commune : --dotenv=<fichier> lit ce fichier .env. Sans elle, le site et ses commandes
+lisent <package>/.env ; le mode MCP n'en lit aucun.
+Le site exige PORT et ORGANIZER_PUBLIC_URL ; HOST vaut 127.0.0.1 par défaut.
+Le mode MCP exige ORGANIZER_URL (URL publique du site, en https hors de la machine locale)
+et ORGANIZER_TOKEN (jeton d'agent), fournis par son environnement.
+Voir le README pour la liste complète des variables.`;
+/** Commandes qui ouvrent la base du site ; toute autre invocation démarre le mode MCP. */
+const SITE_COMMANDS = ["--server", "--set-user", "--setup", "--backup"];
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv.includes("--setup") && (argv.includes("--help") || argv.includes("-h"))) {
+        const { SETUP_USAGE } = await import("./cli/setup.js");
+        process.stdout.write(`${SETUP_USAGE}\n`);
+        return;
+    }
+    if (argv.includes("--help") || argv.includes("-h")) {
+        process.stdout.write(`${USAGE}\n`);
+        return;
+    }
+    if (argv.includes("--version") || argv.includes("-v")) {
+        process.stdout.write(`${APP_VERSION}\n`);
+        return;
+    }
+    // La commande de setup s'exécute dans le projet de l'utilisateur, avant toute lecture de configuration.
+    if (argv.includes("--claude-setup-mcp")) {
+        const { runSetupMcp } = await import("./cli/setup-mcp.js");
+        process.exit(runSetupMcp(argv, process.cwd()));
+    }
+    // Le veilleur lit l'URL du site et le jeton dans le relais déposé par enable_notifications.
+    const watchIndex = argv.indexOf("--watch");
+    if (watchIndex !== -1) {
+        const { runWatchMode } = await import("./cli/watch.js");
+        process.exit(await runWatchMode(argv[watchIndex + 1]));
+    }
+    const rootDir = findProjectRoot(path.dirname(fileURLToPath(import.meta.url)));
+    const siteCommand = SITE_COMMANDS.some((flag) => argv.includes(flag));
+    // Les commandes du site ouvrent la base : better-sqlite3 doit avoir son module natif.
+    if (siteCommand) {
+        const { assertSqliteLoadable } = await import("./core/native-sqlite.js");
+        await assertSqliteLoadable();
+    }
+    // Le setup écrit le .env : il le relit lui-même, sans le charger dans l'environnement.
+    if (argv.includes("--setup")) {
+        const { runSetup } = await import("./cli/setup.js");
+        process.exit(await runSetup(argv, rootDir));
+    }
+    // Le mode MCP tient sa configuration de l'environnement que lui donne l'agent ou la gateway ;
+    // il ne lit un fichier .env que désigné par --dotenv.
+    try {
+        const envFile = resolveEnvFile(argv, rootDir);
+        if (siteCommand || envFile.required)
+            loadEnvFile(envFile);
+    }
+    catch (err) {
+        throw new ConfigError(err?.message ?? String(err));
+    }
+    const args = withoutEnvFileFlag(argv);
+    if (args.includes("--set-user")) {
+        const [{ runSetUser }, { resolveDataDir }] = await Promise.all([import("./cli/set-user.js"), import("./core/data-dir.js")]);
+        process.exit(await runSetUser(args, resolveDataDir(rootDir)));
+    }
+    if (args.includes("--backup")) {
+        const [{ runBackup }, { resolveDataDir }] = await Promise.all([import("./cli/backup.js"), import("./core/data-dir.js")]);
+        process.exit(await runBackup(args, resolveDataDir(rootDir)));
+    }
+    if (args.includes("--server")) {
+        const { runServerMode } = await import("./server/start.js");
+        await runServerMode(rootDir);
+        return;
+    }
+    const { runMcpMode } = await import("./mcp/start.js");
+    await runMcpMode();
+}
+process.on("uncaughtException", (err) => {
+    process.stderr.write(`Uncaught exception: ${err.stack ?? err.message}\n`);
+    process.exit(1);
+});
+main().catch((err) => {
+    // Erreur de configuration : le message suffit, la pile d'appels n'aide personne.
+    process.stderr.write(err instanceof ConfigError ? `${err.message}\n` : `Fatal error: ${err?.stack ?? err}\n`);
+    process.exit(1);
+});

package/dist/src/mcp/client.d.ts

@@ -0,0 +1,38 @@
+import type { z } from "zod";
+import { type AgentEnvelope, type WaitRequestsData } from "../../shared/schemas/agent-tools.schema.js";
+import type { ToolHttpRequest } from "./tools.js";
+/**
+ * Client HTTP de l'API agent du site : seul point de sortie réseau du mode
+ * MCP. Chaque appel porte le jeton dans `Authorization: Bearer`.
+ */
+/** Délai maximal d'un appel au site, hors attente longue. */
+export declare const REQUEST_TIMEOUT_MS = 30000;
+/** Échec d'un appel : refus du site (avec son message) ou site injoignable. */
+export declare class SiteError extends Error {
+    readonly status?: number | undefined;
+    constructor(message: string, status?: number | undefined);
+}
+export interface SiteConnection {
+    /** URL publique du site, sans barre oblique finale. */
+    url: string;
+    token: string;
+}
+export declare class OrganizerSiteClient {
+    private readonly connection;
+    constructor(connection: SiteConnection);
+    /** Exécute la requête d'un outil et renvoie le texte rédigé pour l'agent. */
+    call(request: ToolHttpRequest): Promise<string>;
+    /**
+     * Attente longue des demandes qui passent en attente (`GET requests/wait`) ;
+     * le délai de l'appel couvre la durée de l'attente.
+     */
+    waitForRequests(query: {
+        timeout_seconds: number;
+        since?: string;
+        watcher?: boolean;
+    }): Promise<WaitRequestsData>;
+    /** Données structurées d'une réponse, validées par `schema`. */
+    parseData<S extends z.ZodType>(schema: S, data: unknown): z.infer<S>;
+    /** Exécute une requête de l'API agent et renvoie sa réponse : texte rédigé pour l'agent et données structurées. */
+    envelope(request: ToolHttpRequest, timeoutMs?: number): Promise<AgentEnvelope>;
+}

package/dist/src/mcp/client.js

@@ -0,0 +1,106 @@
+import { AgentEnvelopeSchema, AgentErrorSchema, WaitRequestsDataSchema } from "../../shared/schemas/agent-tools.schema.js";
+/**
+ * Client HTTP de l'API agent du site : seul point de sortie réseau du mode
+ * MCP. Chaque appel porte le jeton dans `Authorization: Bearer`.
+ */
+/** Délai maximal d'un appel au site, hors attente longue. */
+export const REQUEST_TIMEOUT_MS = 30_000;
+/** Échec d'un appel : refus du site (avec son message) ou site injoignable. */
+export class SiteError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "SiteError";
+    }
+}
+/** Adresse désignée par l'en-tête `Location` d'une redirection, résolue par rapport à la requête. */
+function redirectTarget(response, requestUrl) {
+    const location = response.headers.get("location");
+    if (location === null)
+        return "an address it does not give";
+    try {
+        return new URL(location, requestUrl).href;
+    }
+    catch {
+        return location;
+    }
+}
+export class OrganizerSiteClient {
+    connection;
+    constructor(connection) {
+        this.connection = connection;
+    }
+    /** Exécute la requête d'un outil et renvoie le texte rédigé pour l'agent. */
+    async call(request) {
+        return (await this.envelope(request)).text;
+    }
+    /**
+     * Attente longue des demandes qui passent en attente (`GET requests/wait`) ;
+     * le délai de l'appel couvre la durée de l'attente.
+     */
+    async waitForRequests(query) {
+        const params = { timeout_seconds: String(query.timeout_seconds) };
+        if (query.since !== undefined)
+            params.since = query.since;
+        if (query.watcher)
+            params.watcher = "true";
+        const envelope = await this.envelope({ method: "GET", path: "requests/wait", query: params, body: undefined }, query.timeout_seconds * 1000 + REQUEST_TIMEOUT_MS);
+        return this.parseData(WaitRequestsDataSchema, envelope.data);
+    }
+    /** Données structurées d'une réponse, validées par `schema`. */
+    parseData(schema, data) {
+        const parsed = schema.safeParse(data);
+        if (!parsed.success) {
+            throw new SiteError(`The organizer site at ${this.connection.url} sent an unexpected answer. Check that the site runs the same version of @imenam/mcp-organizer.`);
+        }
+        return parsed.data;
+    }
+    /** Exécute une requête de l'API agent et renvoie sa réponse : texte rédigé pour l'agent et données structurées. */
+    async envelope(request, timeoutMs = REQUEST_TIMEOUT_MS) {
+        const url = new URL(`${this.connection.url}/api/agent/${request.path}`);
+        for (const [name, value] of Object.entries(request.query))
+            url.searchParams.set(name, value);
+        let response;
+        try {
+            response = await fetch(url, {
+                method: request.method,
+                headers: {
+                    authorization: `Bearer ${this.connection.token}`,
+                    accept: "application/json",
+                    ...(request.body === undefined ? {} : { "content-type": "application/json" }),
+                },
+                body: request.body === undefined ? undefined : JSON.stringify(request.body),
+                // Une redirection n'est jamais suivie : le jeton ne part que vers ORGANIZER_URL.
+                redirect: "manual",
+                signal: AbortSignal.timeout(timeoutMs),
+            });
+        }
+        catch (error) {
+            const reason = error?.cause?.message ?? error?.message ?? String(error);
+            throw new SiteError(`Cannot reach the organizer site at ${this.connection.url} (${reason}). Check ORGANIZER_URL and that the site is running, then retry.`);
+        }
+        if (response.status >= 300 && response.status < 400) {
+            throw new SiteError(`The organizer site at ${this.connection.url} answered with a redirect (HTTP ${response.status}) to ${redirectTarget(response, url)}: the request was not sent there. Use the final https URL of the site (its ORGANIZER_PUBLIC_URL) as ORGANIZER_URL.`, response.status);
+        }
+        const text = await response.text();
+        let payload = null;
+        try {
+            payload = text === "" ? null : JSON.parse(text);
+        }
+        catch {
+            payload = null;
+        }
+        if (!response.ok) {
+            const error = AgentErrorSchema.safeParse(payload);
+            if (error.success)
+                throw new SiteError(error.data.error, response.status);
+            throw new SiteError(`The organizer site at ${this.connection.url} answered HTTP ${response.status} without an explanation. Check ORGANIZER_URL (it must be the public URL of the site).`, response.status);
+        }
+        const envelope = AgentEnvelopeSchema.safeParse(payload);
+        if (!envelope.success) {
+            throw new SiteError(`The organizer site at ${this.connection.url} sent an unexpected answer. Check ORGANIZER_URL and that the site runs the same version of @imenam/mcp-organizer.`);
+        }
+        return envelope.data;
+    }
+}

package/dist/src/mcp/notifications.d.ts

@@ -0,0 +1,13 @@
+import type { OrganizerSiteClient, SiteConnection } from "./client.js";
+import type { ToolDefinition } from "./tools.js";
+/**
+ * Outil `enable_notifications`, exécuté par le mode MCP lui-même : il lit le
+ * jeton, l'espace et l'état du veilleur sur le site, dépose le relais du
+ * veilleur et rend l'appel `Monitor` que l'agent doit faire.
+ */
+/** Durée maximale d'un `Monitor` côté hôte. */
+export declare const MONITOR_TIMEOUT_MS = 1800000;
+export declare const ENABLE_NOTIFICATIONS_TOOL: ToolDefinition;
+/** Commande du veilleur du jeton `tokenId`. */
+export declare function watchCommand(tokenId: string): string;
+export declare function enableNotifications(client: OrganizerSiteClient, connection: SiteConnection): Promise<string>;