@imenam/mcp-organizer 0.0.0-stage → 1.0.1

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,100 @@
+#!/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 --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()));
+    }
+    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,23 @@
+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. */
+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>;
+}

package/dist/src/mcp/client.js

@@ -0,0 +1,81 @@
+import { AgentEnvelopeSchema, AgentErrorSchema } 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. */
+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) {
+        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(REQUEST_TIMEOUT_MS),
+            });
+        }
+        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.text;
+    }
+}

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

@@ -0,0 +1,14 @@
+import { type SiteConnection } from "./client.js";
+/** Présentation du serveur transmise au client MCP : concepts et déroulé. */
+export declare const INSTRUCTIONS = "mcp-organizer connects you to an organizer site: a multi-user task manager where people organize tasks in a web app and queue requests for the AI. You, the connected agent, process those requests when the user asks you to. The site never calls an LLM: you are the intelligence.\n\nYour token covers exactly one space, with the rights of the user who created the token. Every tool works on that space.\n\nConcepts:\n- A **space** holds tasks and an idea box. A user's **personal space** is private; a **shared space** has one owner and members.\n- A **task** has a title, a markdown description, a status (todo, doing, review, done), a priority (low, medium, high, critical), assignees and tags. Tasks nest on two levels: task > sub-task > sub-sub-task. A task is either standard (with a checklist) or a test (with checkpoints that each tester marks ok, ko, blocked or untested).\n- A **request** is something a member of your space asked the AI: an idea, a remark, a test review, a message or an idea promotion. It is pending, then processing once you claim it (only your token can then act for it), then done (with your reply) or failed (with the reason).\n- A **batch** is the set of actions you perform for one request. Every action is logged with its before and after state and with your token, and users can undo one action or the whole batch.\n- The **scope** of your work is the space of your token: you see and process the requests of all its members, and you never act outside it.\n\nWork loop, when the user asks you to process the queue:\n1. list_requests to see the pending requests of your space.\n2. claim_request on the oldest one: it becomes processing for you and you get its context (text, author, context task, task tree, members, recent ideas). get_context shows the space at any time.\n3. Read what you need with get_task and search_tasks.\n4. Act with create_task, update_task, set_assignees, set_tags, edit_checklist, add_comment, create_idea, update_idea, promote_idea \u2014 always passing the request_id. Each write is one undoable action of the batch.\n5. complete_request with a short reply in the author's language (or fail_request with the reason), then go back to step 1 until no request is pending.\nNothing arrives on its own: there is no waiting tool. When the queue is empty, tell the user.\n\nHow to handle each kind of request:\n- **idea**: classify it. If it belongs to an existing task or sub-task, attach it there (sub-task, checklist item or comment). If it is actionable and important enough, create a task (or sub-task) with a fitting priority. Otherwise, put it in the idea box with create_idea. Prefer existing tasks over duplicates.\n- **test_review**: feed the tester's findings back into the existing tasks (status, checklist, comments, priority of the affected tasks), or create a task for each problem that has none.\n- **remark** and **message**: do whatever is useful \u2014 answer, update or create tasks, comment \u2014 and say what you did in the reply.\n- **idea_promotion**: turn the context idea into a well-formed task with promote_idea.\n\nRules: write titles, descriptions and replies in the language of the users; keep the reply short and factual. Errors tell you what to do next; an error about the token (missing, revoked, expired, owner no longer a member) cannot be fixed by retrying: tell the user.";
+/**
+ * Connexion au site d'après `ORGANIZER_URL` et `ORGANIZER_TOKEN` ; une valeur
+ * absente ou invalide, ou une URL http vers une autre machine, est une `ConfigError`.
+ */
+export declare function loadSiteConnection(): SiteConnection;
+/**
+ * Mode MCP (par défaut) : serveur stdio sans base ni logique métier. Il
+ * expose les outils de l'agent et relaie chaque appel à l'API agent du site
+ * désigné par `ORGANIZER_URL`, avec le jeton `ORGANIZER_TOKEN`.
+ */
+export declare function runMcpMode(): Promise<void>;