@imenam/mcp-organizer 0.0.0-stage → 1.0.1

package/dist/src/agent-api/requests.js

@@ -0,0 +1,60 @@
+import { ClaimRequestBodySchema, ClaimRequestDataSchema, CompleteRequestBodySchema, FailRequestBodySchema, FinishRequestDataSchema, ListRequestsDataSchema, ListRequestsQuerySchema, } from "../../shared/schemas/agent-tools.schema.js";
+import { agentActor, ideaData, memberData, recentIdeas, requestContext, requestData, requestLine, requestOfSpace, spaceData, treeData } from "../core/agent.js";
+import { parseInput, respond } from "./types.js";
+/** Demandes de l'espace du jeton : liste, prise, fin (réussie ou en échec). */
+export const requestRoutes = [
+    {
+        method: "GET",
+        path: "/requests",
+        handle: ({ store }, { agent, query }) => {
+            const input = parseInput(ListRequestsQuerySchema, query);
+            const requests = store.listAgentRequestsTargeting(agent.space.id, input.status === "all" ? null : input.status, input.limit);
+            const data = { space: spaceData(agent.space), requests: requests.map((request) => requestData(store, agent, request)) };
+            if (requests.length === 0) {
+                const none = input.status === "pending" ? `No pending request in "${agent.space.name}".` : `No ${input.status === "all" ? "" : `${input.status} `}request in "${agent.space.name}".`;
+                return respond(ListRequestsDataSchema, none, data);
+            }
+            const next = input.status === "pending" ? "\n\nNext: call claim_request with the id of the oldest request." : "";
+            const lines = requests.map((request) => requestLine(store, agent, request)).join("\n");
+            return respond(ListRequestsDataSchema, `${requests.length} request(s) in "${agent.space.name}":\n${lines}${next}`, data);
+        },
+    },
+    {
+        method: "POST",
+        path: "/requests/:requestId/claim",
+        handle: ({ store }, { agent, params, body }) => {
+            parseInput(ClaimRequestBodySchema, body);
+            requestOfSpace(store, agent, params.requestId);
+            const request = store.mutate(agentActor(agent, params.requestId), (tx) => tx.claimAgentRequest());
+            return respond(ClaimRequestDataSchema, requestContext(store, agent, request), {
+                request: requestData(store, agent, request),
+                space: spaceData(agent.space),
+                members: memberData(store, agent.space),
+                tasks: treeData(store, agent.space),
+                ideas: recentIdeas(store, agent.space).map((idea) => ideaData(store, idea)),
+            });
+        },
+    },
+    {
+        method: "POST",
+        path: "/requests/:requestId/complete",
+        handle: ({ store }, { agent, params, body }) => {
+            const input = parseInput(CompleteRequestBodySchema, body);
+            requestOfSpace(store, agent, params.requestId);
+            const done = store.mutate(agentActor(agent, params.requestId), (tx) => tx.completeAgentRequest(input.reply));
+            const actionCount = store.listAgentActions(done.id).length;
+            return respond(FinishRequestDataSchema, `Request ${done.id} is done (${actionCount} action(s) in its batch). Call list_requests for the next one.`, { request: requestData(store, agent, done), actionCount });
+        },
+    },
+    {
+        method: "POST",
+        path: "/requests/:requestId/fail",
+        handle: ({ store }, { agent, params, body }) => {
+            const input = parseInput(FailRequestBodySchema, body);
+            requestOfSpace(store, agent, params.requestId);
+            const failed = store.mutate(agentActor(agent, params.requestId), (tx) => tx.failAgentRequest(input.reason));
+            const actionCount = store.listAgentActions(failed.id).length;
+            return respond(FinishRequestDataSchema, `Request ${failed.id} is marked as failed; its author sees your reason. Call list_requests for the next one.`, { request: requestData(store, agent, failed), actionCount });
+        },
+    },
+];

package/dist/src/agent-api/router.d.ts

@@ -0,0 +1,3 @@
+import type { AgentApiContext, AgentApiRequest, AgentApiResponse } from "./types.js";
+/** Traite une requête de l'API agent ; une erreur est levée telle quelle, avec la nature qui fixe son code HTTP. */
+export declare function handleAgentRequest(ctx: AgentApiContext, request: AgentApiRequest): AgentApiResponse;

package/dist/src/agent-api/router.js

@@ -0,0 +1,40 @@
+import { resolveAgentToken } from "../core/agent-tokens.js";
+import { NotFoundError, OrganizerError } from "../core/errors.js";
+import { checklistRoutes } from "./checklist.js";
+import { ideaRoutes } from "./ideas.js";
+import { requestRoutes } from "./requests.js";
+import { taskRoutes } from "./tasks.js";
+function compile(route) {
+    const keys = [];
+    const source = route.path.replace(/:([A-Za-z]+)/g, (_, key) => {
+        keys.push(key);
+        return "([^/]+)";
+    });
+    return { route, pattern: new RegExp(`^${source}$`), keys };
+}
+const ROUTES = [...requestRoutes, ...taskRoutes, ...checklistRoutes, ...ideaRoutes].map(compile);
+/** Segment de chemin décodé ; un encodage `%` invalide est une erreur 400. */
+function decodeSegment(raw) {
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        throw new OrganizerError(`Invalid URL: a path segment is badly encoded (${raw}).`);
+    }
+}
+/** Traite une requête de l'API agent ; une erreur est levée telle quelle, avec la nature qui fixe son code HTTP. */
+export function handleAgentRequest(ctx, request) {
+    const now = ctx.now?.() ?? new Date();
+    const agent = resolveAgentToken(ctx.store, request.bearer, now);
+    for (const candidate of ROUTES) {
+        if (candidate.route.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])));
+        return candidate.route.handle(ctx, { agent, params, query: request.query, body: request.body });
+    }
+    throw new NotFoundError(`Unknown agent API route: ${request.method} /api/agent${request.path}. Update @imenam/mcp-organizer so that the MCP mode and the site agree.`);
+}

package/dist/src/agent-api/tasks.d.ts

@@ -0,0 +1,2 @@
+import { type AgentRoute } from "./types.js";
+export declare const taskRoutes: AgentRoute[];

package/dist/src/agent-api/tasks.js

@@ -0,0 +1,290 @@
+import { AddCommentBodySchema, CommentDataSchema, ContextDataSchema, CreateTaskBodySchema, NoQuerySchema, SearchTasksDataSchema, SearchTasksQuerySchema, SetAssigneesBodySchema, SetTagsBodySchema, TaskDataSchema, TaskDetailDataSchema, UpdateTaskBodySchema, } from "../../shared/schemas/agent-tools.schema.js";
+import { combinedResult } from "../../shared/logic/test-summary.js";
+import { actFor, ago, assigneesSummary, createdTaskSummary, ideaData, memberData, recentIdeas, requireText, resolveMembers, resolveTask, spaceContextLines, spaceData, taskData, taskKey, taskUpdateSummary, treeData, userLabel, } from "../core/agent.js";
+import { OrganizerError } from "../core/errors.js";
+import { parseInput, respond } from "./types.js";
+/** Espace du jeton et ses tâches : contexte, lecture, recherche, création, modification, assignés, tags, commentaires. */
+/** Nombre de commentaires récents affichés par get_task. */
+const RECENT_COMMENTS = 15;
+export const taskRoutes = [
+    {
+        method: "GET",
+        path: "/context",
+        handle: ({ store }, { agent, query }) => {
+            parseInput(NoQuerySchema, query);
+            const space = agent.space;
+            const header = `Your space: "${space.name}" (${space.kind}, task keys ${space.keyPrefix}-<number>). You act with the rights of ${userLabel(agent.user)} <${agent.user.email}>.`;
+            return respond(ContextDataSchema, [header, "", ...spaceContextLines(store, space)].join("\n"), {
+                space: spaceData(space),
+                members: memberData(store, space),
+                tasks: treeData(store, space),
+                ideas: recentIdeas(store, space).map((idea) => ideaData(store, idea)),
+            });
+        },
+    },
+    {
+        method: "GET",
+        path: "/tasks/:ref",
+        handle: ({ store }, { agent, params, query }) => {
+            parseInput(NoQuerySchema, query);
+            const task = resolveTask(store, agent.space, params.ref);
+            const name = (id) => {
+                const user = store.findUser(id);
+                return user ? userLabel(user) : id;
+            };
+            const lines = [];
+            lines.push(`${taskKey(store, task)} "${task.title}" (id ${task.id})`);
+            lines.push(`Type: ${task.type} · Status: ${task.status} · Priority: ${task.priority} · Depth: ${task.depth}`);
+            const ancestors = [];
+            for (let parentId = task.parentId; parentId !== null;) {
+                const parent = store.getTask(parentId);
+                ancestors.unshift(`${taskKey(store, parent)} "${parent.title}"`);
+                parentId = parent.parentId;
+            }
+            if (ancestors.length > 0)
+                lines.push(`Parents: ${ancestors.join(" > ")}`);
+            const tested = task.testedTaskId === null ? null : store.findTask(task.testedTaskId);
+            if (tested)
+                lines.push(`Tests: ${taskKey(store, tested)} "${tested.title}"`);
+            const tests = store.listTestsOf(task.id);
+            if (tests.length > 0)
+                lines.push(`Tested by: ${tests.map((test) => `${taskKey(store, test)} "${test.title}"`).join(", ")}`);
+            const assignees = store.listAssigneeIds(task.id);
+            lines.push(`${task.type === "test" ? "Testers" : "Assignees"}: ${assignees.length > 0 ? assignees.map(name).join(", ") : "none"}`);
+            const summary = taskData(store, task);
+            lines.push(`Tags: ${summary.tags.length > 0 ? summary.tags.join(", ") : "none"}`);
+            lines.push(`Created by ${name(task.createdBy)} ${ago(task.createdAt)}, updated ${ago(task.updatedAt)}.`);
+            lines.push("", "Description:", task.description.trim() === "" ? "(empty)" : task.description);
+            const checklist = task.type === "standard" ? store.listChecklist(task.id) : [];
+            const checkpoints = [];
+            if (task.type === "standard") {
+                lines.push("", `Checklist (${checklist.filter((item) => item.done).length}/${checklist.length} done):`);
+                lines.push(...(checklist.length > 0 ? checklist.map((item) => `- [${item.done ? "x" : " "}] ${item.text} (id ${item.id})`) : ["(empty)"]));
+            }
+            else {
+                const results = store.listTestResults(task.id).filter((result) => assignees.includes(result.testerId));
+                const points = store.listCheckpoints(task.id);
+                lines.push("", `Test checkpoints (${points.length}):`);
+                for (const checkpoint of points) {
+                    const own = results.filter((result) => result.checkpointId === checkpoint.id);
+                    const combined = combinedResult(own.map((result) => result.result));
+                    checkpoints.push({ id: checkpoint.id, text: checkpoint.text, result: combined });
+                    const comments = own.filter((result) => result.comment.trim() !== "").map((result) => `${name(result.testerId)}: ${result.comment}`);
+                    lines.push(`- [${combined}] ${checkpoint.text} (id ${checkpoint.id})${comments.length > 0 ? ` — ${comments.join(" | ")}` : ""}`);
+                }
+                if (points.length === 0)
+                    lines.push("(none)");
+                const reviews = store.listTestReviews(task.id).filter((review) => review.submittedAt !== null);
+                if (reviews.length > 0) {
+                    lines.push("", "Submitted reviews:");
+                    for (const review of reviews)
+                        lines.push(`- ${name(review.testerId)}, ${ago(review.submittedAt)}: ${review.text}`);
+                }
+            }
+            const children = store.listChildren(task.id);
+            if (children.length > 0) {
+                lines.push("", "Sub-tasks:");
+                for (const child of children)
+                    lines.push(`- ${taskKey(store, child)} [${child.status}, ${child.priority}${child.type === "test" ? ", test" : ""}] ${child.title}`);
+            }
+            const comments = store.listComments(task.id).slice(-RECENT_COMMENTS);
+            if (comments.length > 0) {
+                lines.push("", "Recent comments:");
+                for (const comment of comments)
+                    lines.push(`- ${comment.requestId ? "agent" : name(comment.authorId)}, ${ago(comment.createdAt)}: ${comment.body}`);
+            }
+            const attachments = store.listAttachments(task.id);
+            if (attachments.length > 0)
+                lines.push("", `Attachments: ${attachments.map((attachment) => attachment.filename).join(", ")}`);
+            return respond(TaskDetailDataSchema, lines.join("\n"), {
+                task: summary,
+                description: task.description,
+                testedTaskKey: tested ? taskKey(store, tested) : null,
+                checklist: checklist.map((item) => ({ id: item.id, text: item.text, done: item.done })),
+                checkpoints,
+                children: children.map((child) => taskData(store, child)),
+                comments: comments.map((comment) => ({
+                    id: comment.id,
+                    authorName: comment.requestId ? "agent" : name(comment.authorId),
+                    byAgent: comment.requestId !== null,
+                    body: comment.body,
+                    createdAt: comment.createdAt,
+                })),
+                attachments: attachments.map((attachment) => attachment.filename),
+            });
+        },
+    },
+    {
+        method: "GET",
+        path: "/tasks",
+        handle: ({ store }, { agent, query }) => {
+            const input = parseInput(SearchTasksQuerySchema, query);
+            const space = agent.space;
+            const assignee = input.assignee === undefined ? null : resolveMembers(store, space, [input.assignee])[0];
+            const words = (input.query ?? "").toLowerCase().split(/\s+/).filter((word) => word !== "");
+            const matches = store.listTasks(space.id).filter((task) => {
+                if (input.status && task.status !== input.status)
+                    return false;
+                if (input.priority && task.priority !== input.priority)
+                    return false;
+                if (input.type && task.type !== input.type)
+                    return false;
+                if (assignee && !store.listAssigneeIds(task.id).includes(assignee.id))
+                    return false;
+                const haystack = `${taskKey(store, task)} ${task.title} ${task.description}`.toLowerCase();
+                return words.every((word) => haystack.includes(word));
+            });
+            if (matches.length === 0)
+                return respond(SearchTasksDataSchema, `No task of "${space.name}" matches. Create one with create_task if needed.`, { tasks: [], total: 0 });
+            const shown = matches.slice(0, input.limit);
+            const lines = shown.map((task) => {
+                const parent = task.parentId === null ? null : store.findTask(task.parentId);
+                return `- ${taskKey(store, task)} [${task.status}, ${task.priority}${task.type === "test" ? ", test" : ""}] ${task.title}${parent ? ` (under ${taskKey(store, parent)})` : ""}`;
+            });
+            const more = matches.length > shown.length ? `\n(${matches.length - shown.length} more: narrow the query or raise limit)` : "";
+            return respond(SearchTasksDataSchema, `${matches.length} task(s) in "${space.name}":\n${lines.join("\n")}${more}`, {
+                tasks: shown.map((task) => taskData(store, task)),
+                total: matches.length,
+            });
+        },
+    },
+    {
+        method: "POST",
+        path: "/tasks",
+        handle: ({ store }, { agent, body }) => {
+            const input = parseInput(CreateTaskBodySchema, body);
+            const title = requireText(input.title, "title");
+            const { parent, task } = actFor(store, agent, input.request_id, (tx, space) => {
+                const parent = input.parent === undefined ? null : resolveTask(tx.store, space, input.parent);
+                const created = tx.createTask({
+                    spaceId: space.id,
+                    parentId: parent?.id ?? null,
+                    title,
+                    description: input.description,
+                    type: input.type,
+                    priority: input.priority,
+                    status: input.status,
+                });
+                tx.recordAgentAction({
+                    entityType: "task",
+                    entityId: created.id,
+                    operation: "create",
+                    before: null,
+                    after: tx.store.taskSnapshot(created.id),
+                    summary: createdTaskSummary(tx.store, created),
+                    taskId: created.id,
+                });
+                return { parent, task: created };
+            });
+            return respond(TaskDataSchema, `Created ${taskKey(store, task)} "${task.title}" [${task.status}, ${task.priority}, ${task.type}]${parent ? ` under ${taskKey(store, parent)}` : ""} (id ${task.id}).`, { task: taskData(store, store.getTask(task.id)) });
+        },
+    },
+    {
+        method: "PATCH",
+        path: "/tasks/:ref",
+        handle: ({ store }, { agent, params, body }) => {
+            const input = parseInput(UpdateTaskBodySchema, body);
+            const { title, description, status, priority, type, parent, after_task, tested_task_id } = input;
+            const { task, summary } = actFor(store, agent, input.request_id, (tx, space) => {
+                if ([title, description, status, priority, type, parent, after_task, tested_task_id].every((value) => value === undefined)) {
+                    throw new OrganizerError("Nothing to change: give at least one of title, description, status, priority, type, parent, after_task or tested_task_id.");
+                }
+                const patch = {};
+                if (title !== undefined)
+                    patch.title = requireText(title, "title");
+                if (description !== undefined)
+                    patch.description = description;
+                if (status !== undefined)
+                    patch.status = status;
+                if (priority !== undefined)
+                    patch.priority = priority;
+                if (type !== undefined)
+                    patch.type = type;
+                const task = resolveTask(tx.store, space, params.ref);
+                if (parent !== undefined)
+                    patch.parentId = parent === null ? null : resolveTask(tx.store, space, parent).id;
+                if (tested_task_id !== undefined)
+                    patch.testedTaskId = tested_task_id === null ? null : resolveTask(tx.store, space, tested_task_id).id;
+                const afterId = after_task === undefined ? undefined : after_task === null ? null : resolveTask(tx.store, space, after_task).id;
+                const before = tx.store.taskSnapshot(task.id);
+                const updated = Object.keys(patch).length > 0 ? tx.updateTask(task.id, patch) : task;
+                if (afterId !== undefined)
+                    tx.moveTask(task.id, updated.status, afterId);
+                const after = tx.store.taskSnapshot(task.id);
+                const { summary, operation } = taskUpdateSummary(tx.store, before, after);
+                tx.recordAgentAction({ entityType: "task", entityId: task.id, operation, before, after, summary, taskId: task.id });
+                return { task, summary };
+            });
+            const updated = store.getTask(task.id);
+            return respond(TaskDataSchema, `Updated ${taskKey(store, updated)} "${updated.title}" [${updated.status}, ${updated.priority}, ${updated.type}]: ${summary}.`, {
+                task: taskData(store, updated),
+            });
+        },
+    },
+    {
+        method: "PUT",
+        path: "/tasks/:ref/assignees",
+        handle: ({ store }, { agent, params, body }) => {
+            const input = parseInput(SetAssigneesBodySchema, body);
+            const { task, users } = actFor(store, agent, input.request_id, (tx, space) => {
+                const task = resolveTask(tx.store, space, params.ref);
+                const users = resolveMembers(tx.store, space, input.assignees);
+                const before = tx.store.taskSnapshot(task.id);
+                tx.setAssignees(task.id, users.map((user) => user.id));
+                const after = tx.store.taskSnapshot(task.id);
+                tx.recordAgentAction({
+                    entityType: "task",
+                    entityId: task.id,
+                    operation: "assign",
+                    before,
+                    after,
+                    summary: assigneesSummary(tx.store, before.assigneeIds, after.assigneeIds, task.type === "test"),
+                    taskId: task.id,
+                });
+                return { task, users };
+            });
+            const names = users.map(userLabel);
+            return respond(TaskDataSchema, `${taskKey(store, task)} is now assigned to ${names.length > 0 ? names.join(", ") : "nobody"}.`, { task: taskData(store, store.getTask(task.id)) });
+        },
+    },
+    {
+        method: "PUT",
+        path: "/tasks/:ref/tags",
+        handle: ({ store }, { agent, params, body }) => {
+            const input = parseInput(SetTagsBodySchema, body);
+            const { task, tags } = actFor(store, agent, input.request_id, (tx, space) => {
+                const task = resolveTask(tx.store, space, params.ref);
+                const before = tx.store.taskSnapshot(task.id);
+                const tags = tx.setTags(task.id, input.tags);
+                tx.recordAgentAction({
+                    entityType: "task",
+                    entityId: task.id,
+                    operation: "update",
+                    before,
+                    after: tx.store.taskSnapshot(task.id),
+                    summary: tags.length > 0 ? `Tags : ${tags.map((tag) => tag.name).join(", ")}` : "Tags retirés",
+                    taskId: task.id,
+                });
+                return { task, tags };
+            });
+            return respond(TaskDataSchema, `${taskKey(store, task)} tags: ${tags.length > 0 ? tags.map((tag) => tag.name).join(", ") : "none"}.`, {
+                task: taskData(store, store.getTask(task.id)),
+            });
+        },
+    },
+    {
+        method: "POST",
+        path: "/tasks/:ref/comments",
+        handle: ({ store }, { agent, params, body }) => {
+            const input = parseInput(AddCommentBodySchema, body);
+            const text = requireText(input.body, "body");
+            const { task, comment } = actFor(store, agent, input.request_id, (tx, space) => {
+                const task = resolveTask(tx.store, space, params.ref);
+                const comment = tx.addComment(task.id, text);
+                tx.recordAgentAction({ entityType: "comment", entityId: comment.id, operation: "create", before: null, after: comment, summary: "Commentaire ajouté", taskId: task.id });
+                return { task, comment };
+            });
+            return respond(CommentDataSchema, `Commented on ${taskKey(store, task)} (comment id ${comment.id}).`, { task: taskData(store, task), commentId: comment.id });
+        },
+    },
+];

package/dist/src/agent-api/types.d.ts

@@ -0,0 +1,41 @@
+import type { z } from "zod";
+import type { AgentCaller } from "../core/agent.js";
+import type { Store } from "../core/store.js";
+/** Dépendances de l'API agent. */
+export interface AgentApiContext {
+    store: Store;
+    /** Horloge, imposée par les tests. */
+    now?: () => Date;
+}
+/** Requête `/api/agent/*`, telle que le serveur web la transmet au routeur. */
+export interface AgentApiRequest {
+    method: string;
+    /** Chemin sous `/api/agent`, par exemple `/requests`. */
+    path: string;
+    query: Record<string, string>;
+    body?: unknown;
+    /** Jeton de l'en-tête `Authorization: Bearer`, null sans en-tête. */
+    bearer: string | null;
+}
+/** Réponse réussie : texte rédigé pour l'agent et données structurées. */
+export interface AgentApiResponse {
+    text: string;
+    data: unknown;
+}
+/** Appel d'une route : agent authentifié, paramètres de chemin, requête et corps. */
+export interface AgentCall {
+    agent: AgentCaller;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    body: unknown;
+}
+export interface AgentRoute {
+    method: "GET" | "POST" | "PUT" | "PATCH";
+    /** Chemin sous `/api/agent`, avec `:nom` pour un paramètre. */
+    path: string;
+    handle: (ctx: AgentApiContext, call: AgentCall) => AgentApiResponse;
+}
+/** Données validées par `schema` ; une donnée invalide est une erreur qui liste les problèmes. */
+export declare function parseInput<S extends z.ZodType>(schema: S, value: unknown): z.infer<S>;
+/** Réponse dont les données sont validées par `schema`. */
+export declare function respond<S extends z.ZodType>(schema: S, text: string, data: z.infer<S>): AgentApiResponse;

package/dist/src/agent-api/types.js

@@ -0,0 +1,14 @@
+import { OrganizerError } from "../core/errors.js";
+/** Données validées par `schema` ; une donnée invalide est une erreur qui liste les problèmes. */
+export function parseInput(schema, value) {
+    const parsed = schema.safeParse(value ?? {});
+    if (!parsed.success) {
+        const issues = parsed.error.issues.map((issue) => `${issue.path.map(String).join(".") || "arguments"}: ${issue.message}`);
+        throw new OrganizerError(`Invalid arguments — ${issues.join("; ")}. Check the tool's input schema.`);
+    }
+    return parsed.data;
+}
+/** Réponse dont les données sont validées par `schema`. */
+export function respond(schema, text, data) {
+    return { text, data: schema.parse(data) };
+}

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

@@ -0,0 +1,12 @@
+/** Suffixe du dossier des pièces jointes, à côté du fichier de la base. */
+export declare const ATTACHMENTS_BACKUP_SUFFIX = ".attachments";
+/** Résultat d'une sauvegarde. */
+export interface BackupResult {
+    databaseFile: string;
+    attachmentsDir: string;
+    attachmentCount: number;
+}
+/** Sauvegarde la base de `dataDir` dans `target`, et ses pièces jointes à côté. */
+export declare function backupSite(dataDir: string, target: string, force: boolean): Promise<BackupResult>;
+/** Exécute la commande ; renvoie le code de sortie du processus. */
+export declare function runBackup(argv: readonly string[], dataDir: string): Promise<number>;

package/dist/src/cli/backup.js

@@ -0,0 +1,126 @@
+import Database from "better-sqlite3";
+import fs from "node:fs";
+import path from "node:path";
+import { ATTACHMENTS_DIRNAME } from "../core/attachments.js";
+import { BUSY_TIMEOUT_MS, databasePath } from "../core/db.js";
+/**
+ * Commande `mcp-organizer --backup <fichier> [--force]` : sauvegarde du site,
+ * en service ou non.
+ *
+ * La base est copiée par l'API de sauvegarde de SQLite, qui produit un
+ * instantané cohérent même pendant les écritures du site. Les pièces jointes
+ * référencées par cet instantané sont ensuite copiées dans le dossier
+ * `<fichier>.attachments/`, sous leur nom de stockage. Une pièce jointe
+ * référencée mais introuvable fait échouer la sauvegarde, qui ne laisse alors
+ * rien derrière elle. Une destination existante est refusée, sauf `--force`
+ * qui la remplace. Hors Windows, le fichier de la base est créé avec les
+ * droits 600 et le dossier des pièces jointes avec les droits 700.
+ */
+const USAGE = "Usage : mcp-organizer --backup <fichier> [--force]";
+/** Suffixe du dossier des pièces jointes, à côté du fichier de la base. */
+export const ATTACHMENTS_BACKUP_SUFFIX = ".attachments";
+/** Droits POSIX appliqués aux fichiers de la sauvegarde ; Windows ne les connaît pas. */
+const PRIVATE_MODES = process.platform !== "win32";
+function parseArgs(argv) {
+    const rest = argv.slice(argv.indexOf("--backup") + 1);
+    const unknown = rest.filter((arg) => arg.startsWith("-") && arg !== "--force");
+    if (unknown.length > 0)
+        throw new Error(`Option inconnue : ${unknown.join(", ")}.\n${USAGE}`);
+    const positional = rest.filter((arg) => !arg.startsWith("-"));
+    if (positional.length === 0)
+        throw new Error(`--backup attend le fichier de sauvegarde à créer.\n${USAGE}`);
+    if (positional.length > 1)
+        throw new Error(`--backup attend un seul fichier (reçu : ${positional.join(", ")}).\n${USAGE}`);
+    return { target: path.resolve(positional[0]), force: rest.includes("--force") };
+}
+function megabytes(bytes) {
+    return `${(bytes / (1024 * 1024)).toFixed(1).replace(".", ",")} Mo`;
+}
+/** Sauvegarde la base de `dataDir` dans `target`, et ses pièces jointes à côté. */
+export async function backupSite(dataDir, target, force) {
+    const source = databasePath(dataDir);
+    if (!fs.existsSync(source))
+        throw new Error(`Aucune base à sauvegarder : ${source} n'existe pas. Vérifiez le répertoire de données (MCP_ORGANIZER_DATA_DIR, ou --dotenv vers le .env du site).`);
+    const attachmentsDir = `${target}${ATTACHMENTS_BACKUP_SUFFIX}`;
+    if (path.resolve(target) === path.resolve(source))
+        throw new Error("La destination est la base elle-même : choisissez un autre fichier.");
+    const existing = [target, attachmentsDir].filter((entry) => fs.existsSync(entry));
+    if (existing.length > 0 && !force)
+        throw new Error(`La destination existe déjà : ${existing.join(", ")}. Choisissez un autre fichier, ou ajoutez --force pour la remplacer.`);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    const partial = `${target}.partial`;
+    const partialAttachments = `${attachmentsDir}.partial`;
+    fs.rmSync(partial, { force: true });
+    fs.rmSync(partialAttachments, { recursive: true, force: true });
+    try {
+        // La copie contient les empreintes des mots de passe et des jetons : lisible par son seul propriétaire dès sa création.
+        fs.writeFileSync(partial, "", { mode: 0o600, flag: "wx" });
+        if (PRIVATE_MODES)
+            fs.chmodSync(partial, 0o600);
+        const db = new Database(source, { fileMustExist: true });
+        try {
+            db.pragma(`busy_timeout = ${BUSY_TIMEOUT_MS}`);
+            await db.backup(partial);
+        }
+        finally {
+            db.close();
+        }
+        // La copie devient un fichier autonome, sans journal WAL à côté.
+        const copy = new Database(partial, { fileMustExist: true });
+        let storagePaths;
+        try {
+            copy.pragma("journal_mode = DELETE");
+            const integrity = copy.pragma("integrity_check", { simple: true });
+            if (integrity !== "ok")
+                throw new Error(`La copie de la base est corrompue (integrity_check : ${String(integrity)}).`);
+            storagePaths = copy.prepare("SELECT storage_path FROM attachments ORDER BY storage_path").all().map((row) => row.storage_path);
+        }
+        finally {
+            copy.close();
+        }
+        fs.mkdirSync(partialAttachments, { mode: 0o700 });
+        if (PRIVATE_MODES)
+            fs.chmodSync(partialAttachments, 0o700);
+        const attachmentsRoot = path.resolve(dataDir, ATTACHMENTS_DIRNAME) + path.sep;
+        const missing = [];
+        for (const storagePath of storagePaths) {
+            const file = path.resolve(dataDir, storagePath);
+            if (!file.startsWith(attachmentsRoot))
+                throw new Error(`Pièce jointe hors du dossier ${ATTACHMENTS_DIRNAME}/ : ${storagePath}.`);
+            if (!fs.existsSync(file)) {
+                missing.push(storagePath);
+                continue;
+            }
+            fs.copyFileSync(file, path.join(partialAttachments, path.relative(attachmentsRoot, file)));
+        }
+        if (missing.length > 0) {
+            throw new Error(`${missing.length} pièce(s) jointe(s) référencée(s) par la base sont introuvables dans ${attachmentsRoot} (${missing.slice(0, 5).join(", ")}${missing.length > 5 ? ", …" : ""}). Relancez la sauvegarde ; si l'erreur persiste, ces fichiers ont disparu du répertoire de données.`);
+        }
+        if (force) {
+            fs.rmSync(target, { force: true });
+            fs.rmSync(attachmentsDir, { recursive: true, force: true });
+        }
+        fs.renameSync(partial, target);
+        fs.renameSync(partialAttachments, attachmentsDir);
+        return { databaseFile: target, attachmentsDir, attachmentCount: storagePaths.length };
+    }
+    catch (err) {
+        fs.rmSync(partial, { force: true });
+        fs.rmSync(partialAttachments, { recursive: true, force: true });
+        throw err;
+    }
+}
+/** Exécute la commande ; renvoie le code de sortie du processus. */
+export async function runBackup(argv, dataDir) {
+    try {
+        const args = parseArgs(argv);
+        const result = await backupSite(dataDir, args.target, args.force);
+        process.stdout.write(`Base sauvegardée : ${result.databaseFile} (${megabytes(fs.statSync(result.databaseFile).size)}).\n` +
+            `Pièces jointes : ${result.attachmentCount} fichier(s) dans ${result.attachmentsDir}.\n`);
+        return 0;
+    }
+    catch (err) {
+        process.stderr.write(`Sauvegarde interrompue : ${err?.message ?? err}\n`);
+        return 1;
+    }
+}

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

@@ -0,0 +1,7 @@
+/** Saisies au terminal des commandes interactives (`--set-user`, `--setup`). */
+/** Lit une réponse sans écho : l'interface de lecture écrit dans une sortie qui jette tout. */
+export declare function askSecret(question: string): Promise<string>;
+/** Pose une question en clair et renvoie la réponse sans espaces de bord. */
+export declare function askLine(question: string): Promise<string>;
+/** Pose une question en clair jusqu'à obtenir une valeur non vide. */
+export declare function ask(question: string): Promise<string>;

package/dist/src/cli/prompt.js

@@ -0,0 +1,40 @@
+import { Writable } from "node:stream";
+import { createInterface } from "node:readline/promises";
+/** Saisies au terminal des commandes interactives (`--set-user`, `--setup`). */
+/** Lit une réponse sans écho : l'interface de lecture écrit dans une sortie qui jette tout. */
+export async function askSecret(question) {
+    process.stdout.write(`  ${question} : `);
+    const sink = new Writable({
+        write(_chunk, _encoding, callback) {
+            callback();
+        },
+    });
+    const rl = createInterface({ input: process.stdin, output: sink, terminal: true });
+    try {
+        const answer = await rl.question("");
+        process.stdout.write("\n");
+        return answer;
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Pose une question en clair et renvoie la réponse sans espaces de bord. */
+export async function askLine(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question(`  ${question} : `)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Pose une question en clair jusqu'à obtenir une valeur non vide. */
+export async function ask(question) {
+    for (;;) {
+        const value = await askLine(question);
+        if (value !== "")
+            return value;
+        process.stderr.write("  ! Une valeur est attendue.\n");
+    }
+}

package/dist/src/cli/set-user.d.ts

@@ -0,0 +1,2 @@
+/** Exécute la commande ; renvoie le code de sortie du processus. */
+export declare function runSetUser(argv: readonly string[], dataDir: string): Promise<number>;