@imenam/mcp-organizer 1.0.3 → 1.0.7

package/dist/shared/schemas/notifications-api.schema.d.ts

@@ -68,6 +68,7 @@ export declare const SettingsResponseSchema: z.ZodObject<{
     notifyAssignEmail: z.ZodBoolean;
     notifyCommentApp: z.ZodBoolean;
     notifyCommentEmail: z.ZodBoolean;
+    assistantHistory: z.ZodNumber;
     email: z.ZodObject<{
         enabled: z.ZodBoolean;
         reason: z.ZodNullable<z.ZodString>;
@@ -83,5 +84,35 @@ export declare const UpdateSettingsRequestSchema: z.ZodObject<{
     notifyAssignEmail: z.ZodOptional<z.ZodBoolean>;
     notifyCommentApp: z.ZodOptional<z.ZodBoolean>;
     notifyCommentEmail: z.ZodOptional<z.ZodBoolean>;
+    assistantHistory: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 export type UpdateSettingsRequest = z.infer<typeof UpdateSettingsRequestSchema>;
+/**
+ * Notifications de l'utilisateur dans un espace : `custom` dit si l'espace a ses
+ * propres préférences ; sinon, les valeurs renvoyées sont celles du compte.
+ */
+export declare const SpaceNotificationSettingsResponseSchema: z.ZodObject<{
+    notifyAssignApp: z.ZodBoolean;
+    notifyAssignEmail: z.ZodBoolean;
+    notifyCommentApp: z.ZodBoolean;
+    notifyCommentEmail: z.ZodBoolean;
+    custom: z.ZodBoolean;
+    email: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SpaceNotificationSettingsResponse = z.infer<typeof SpaceNotificationSettingsResponseSchema>;
+/**
+ * Personnalise les notifications d'un espace (`custom: true`, avec les préférences
+ * à changer ; les autres partent des préférences en vigueur) ou revient à celles
+ * du compte (`custom: false`, sans préférence).
+ */
+export declare const UpdateSpaceNotificationSettingsRequestSchema: z.ZodObject<{
+    notifyAssignApp: z.ZodOptional<z.ZodBoolean>;
+    notifyAssignEmail: z.ZodOptional<z.ZodBoolean>;
+    notifyCommentApp: z.ZodOptional<z.ZodBoolean>;
+    notifyCommentEmail: z.ZodOptional<z.ZodBoolean>;
+    custom: z.ZodBoolean;
+}, z.core.$strict>;
+export type UpdateSpaceNotificationSettingsRequest = z.infer<typeof UpdateSpaceNotificationSettingsRequestSchema>;

package/dist/shared/schemas/notifications-api.schema.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { ActorTypeSchema, NotificationTypeSchema } from "./enums.schema.js";
-import { IdSchema, TimestampSchema } from "./entities.schema.js";
+import { AssistantHistorySchema, IdSchema, NotificationPreferencesSchema, TimestampSchema } from "./entities.schema.js";
 /** Corps des requêtes et des réponses des notifications et des paramètres de la GUI. */
 /** Nombre de notifications renvoyées par défaut, et au plus, par page. */
 export const NOTIFICATIONS_PAGE_SIZE = 20;
@@ -42,6 +42,8 @@ export const SettingsResponseSchema = z.object({
     notifyAssignEmail: z.boolean(),
     notifyCommentApp: z.boolean(),
     notifyCommentEmail: z.boolean(),
+    /** Nombre d'échanges précédents transmis à l'agent avec un message de l'assistant. */
+    assistantHistory: AssistantHistorySchema,
     /** Envoi des e-mails de notification : `reason` dit pourquoi il n'a pas lieu. */
     email: z.object({ enabled: z.boolean(), reason: z.string().nullable() }),
     /** Dictée vocale : `reason` dit pourquoi elle est indisponible. */
@@ -53,6 +55,25 @@ export const UpdateSettingsRequestSchema = z
     notifyAssignEmail: z.boolean().optional(),
     notifyCommentApp: z.boolean().optional(),
     notifyCommentEmail: z.boolean().optional(),
+    assistantHistory: AssistantHistorySchema.optional(),
 })
     .strict()
     .refine((patch) => Object.values(patch).some((value) => value !== undefined), "Aucune modification demandée.");
+/**
+ * Notifications de l'utilisateur dans un espace : `custom` dit si l'espace a ses
+ * propres préférences ; sinon, les valeurs renvoyées sont celles du compte.
+ */
+export const SpaceNotificationSettingsResponseSchema = NotificationPreferencesSchema.extend({
+    custom: z.boolean(),
+    /** Envoi des e-mails de notification : `reason` dit pourquoi il n'a pas lieu. */
+    email: z.object({ enabled: z.boolean(), reason: z.string().nullable() }),
+});
+/**
+ * Personnalise les notifications d'un espace (`custom: true`, avec les préférences
+ * à changer ; les autres partent des préférences en vigueur) ou revient à celles
+ * du compte (`custom: false`, sans préférence).
+ */
+export const UpdateSpaceNotificationSettingsRequestSchema = NotificationPreferencesSchema.partial()
+    .extend({ custom: z.boolean() })
+    .strict()
+    .refine((patch) => patch.custom || [patch.notifyAssignApp, patch.notifyAssignEmail, patch.notifyCommentApp, patch.notifyCommentEmail].every((value) => value === undefined), "Un espace qui suit les préférences du compte n'a pas de préférences propres.");

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

@@ -1,5 +1,5 @@
 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 { agentActor, ideaData, memberData, recentIdeas, requestContext, requestData, requestHistory, 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 = [
@@ -28,6 +28,7 @@ export const requestRoutes = [
             const request = store.mutate(agentActor(agent, params.requestId), (tx) => tx.claimAgentRequest());
             return respond(ClaimRequestDataSchema, requestContext(store, agent, request), {
                 request: requestData(store, agent, request),
+                history: requestHistory(store, request).map((previous) => requestData(store, agent, previous)),
                 space: spaceData(agent.space),
                 members: memberData(store, agent.space),
                 tasks: treeData(store, agent.space),

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

@@ -0,0 +1 @@
+export declare function runSetAdmin(argv: string[], dataDir: string): Promise<number>;

package/dist/src/cli/set-admin.js

@@ -0,0 +1,45 @@
+import { setAdmin } from "../core/admin.js";
+import { Store } from "../core/store.js";
+/**
+ * Commande `--set-admin <email> [--revoke]` : accorde le rôle
+ * d'administrateur du site à un compte actif, ou le lui retire avec
+ * `--revoke`. Le dernier administrateur ne peut pas perdre son rôle.
+ */
+const USAGE = "Usage : mcp-organizer --set-admin <email> [--revoke]";
+class UsageError extends Error {
+}
+function parseArgs(argv) {
+    const rest = argv.slice(argv.indexOf("--set-admin") + 1);
+    const unknown = rest.filter((arg) => arg.startsWith("-") && arg !== "--revoke");
+    if (unknown.length > 0)
+        throw new UsageError(`Option inconnue : ${unknown.join(", ")}.`);
+    const positional = rest.filter((arg) => !arg.startsWith("-"));
+    if (positional.length === 0)
+        throw new UsageError("--set-admin attend l'adresse e-mail du compte.");
+    if (positional.length > 1)
+        throw new UsageError(`Une seule adresse à la fois (reçu : ${positional.join(", ")}).`);
+    return { email: positional[0], revoke: rest.includes("--revoke") };
+}
+export async function runSetAdmin(argv, dataDir) {
+    let args;
+    try {
+        args = parseArgs(argv);
+    }
+    catch (err) {
+        process.stderr.write(`${err?.message ?? err}\n${USAGE}\n`);
+        return 1;
+    }
+    const store = Store.open(dataDir);
+    try {
+        const user = setAdmin(store, args.email, !args.revoke);
+        process.stdout.write(args.revoke ? `${user.email} n'est plus administrateur du site.\n` : `${user.email} (${user.displayName}) est administrateur du site.\n`);
+        return 0;
+    }
+    catch (err) {
+        process.stderr.write(`${err?.message ?? err}\n`);
+        return 1;
+    }
+    finally {
+        store.close();
+    }
+}

package/dist/src/core/accounts.js

@@ -147,7 +147,8 @@ export async function setAccount(store, input) {
             tx.discardUnusedAccessLinks(user.id);
             return { created: false, user };
         }
-        const created = tx.createUser({ id: userId, email: normalized, displayName: name, passwordHash, status: "active" });
+        // Le premier compte du site en est l'administrateur.
+        const created = tx.createUser({ id: userId, email: normalized, displayName: name, passwordHash, status: "active", isAdmin: tx.store.countUsers() === 0 });
         ensurePersonalSpace(tx, created.id);
         return { created: true, user: created };
     });

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

@@ -0,0 +1,24 @@
+import type { AdminSpaceView, AdminSpacesResponse, RunQueueResponse, RunnerStatus } from "../../shared/schemas/admin-api.schema.js";
+import type { User } from "../../shared/schemas/entities.schema.js";
+import type { Store } from "./store.js";
+/**
+ * Administration du site : rôle d'administrateur des comptes, et
+ * autorisation du runner par espace. Seul un administrateur voit tous les
+ * comptes et tous les espaces, et décide des espaces où le runner travaille.
+ */
+/** L'utilisateur est administrateur ; sinon, refus. */
+export declare function requireAdmin(store: Store, userId: string): User;
+/** Tous les comptes, chacun avec les espaces dont il est propriétaire, et l'état du runner. */
+export declare function listAdminSpaces(store: Store, userId: string, runner: RunnerStatus): AdminSpacesResponse;
+/** Autorise ou interdit le runner sur un espace. */
+export declare function setRunnerAllowed(store: Store, userId: string, spaceId: string, allowed: boolean): AdminSpaceView;
+/**
+ * Fait traiter une fois la file d'un espace par le runner, qu'il y soit
+ * autorisé ou non ; refus quand aucune demande n'y attend.
+ */
+export declare function processQueueNow(store: Store, userId: string, spaceId: string, runNow: (spaceId: string) => void): RunQueueResponse;
+/**
+ * Accorde ou retire le rôle d'administrateur au compte actif `email`. Le
+ * dernier administrateur garde son rôle : le site n'en reste jamais dépourvu.
+ */
+export declare function setAdmin(store: Store, email: string, isAdmin: boolean): User;

package/dist/src/core/admin.js

@@ -0,0 +1,85 @@
+import { normalizeEmail } from "./accounts.js";
+import { userLabel } from "./agent.js";
+import { ForbiddenError, InvariantError, NotFoundError, OrganizerError } from "./errors.js";
+/**
+ * Administration du site : rôle d'administrateur des comptes, et
+ * autorisation du runner par espace. Seul un administrateur voit tous les
+ * comptes et tous les espaces, et décide des espaces où le runner travaille.
+ */
+/** L'utilisateur est administrateur ; sinon, refus. */
+export function requireAdmin(store, userId) {
+    const user = store.getUser(userId);
+    if (!user.isAdmin)
+        throw new ForbiddenError("Réservé aux administrateurs du site.");
+    return user;
+}
+function spaceView(store, space) {
+    return {
+        id: space.id,
+        name: space.name,
+        kind: space.kind,
+        keyPrefix: space.keyPrefix,
+        runnerAllowed: space.runnerAllowed,
+        members: store.listMemberships(space.id).map((membership) => {
+            const member = store.getUser(membership.userId);
+            return { id: member.id, name: userLabel(member), email: member.email };
+        }),
+    };
+}
+/** Tous les comptes, chacun avec les espaces dont il est propriétaire, et l'état du runner. */
+export function listAdminSpaces(store, userId, runner) {
+    requireAdmin(store, userId);
+    const spaces = store.listAllSpaces();
+    const users = store.listUsers().map((user) => ({
+        id: user.id,
+        email: user.email,
+        displayName: user.displayName,
+        status: user.status,
+        isAdmin: user.isAdmin,
+        spaces: spaces.filter((space) => space.ownerId === user.id).map((space) => spaceView(store, space)),
+    }));
+    return { users, allowedCount: spaces.filter((space) => space.runnerAllowed).length, spaceCount: spaces.length, runner };
+}
+/** Autorise ou interdit le runner sur un espace. */
+export function setRunnerAllowed(store, userId, spaceId, allowed) {
+    return store.mutate({ type: "user", userId }, (tx) => {
+        requireAdmin(tx.store, userId);
+        if (!tx.store.findSpace(spaceId))
+            throw new NotFoundError("Espace introuvable.");
+        return spaceView(tx.store, tx.setSpaceRunnerAllowed(spaceId, allowed));
+    });
+}
+/**
+ * Fait traiter une fois la file d'un espace par le runner, qu'il y soit
+ * autorisé ou non ; refus quand aucune demande n'y attend.
+ */
+export function processQueueNow(store, userId, spaceId, runNow) {
+    requireAdmin(store, userId);
+    const space = store.findSpace(spaceId);
+    if (!space)
+        throw new NotFoundError("Espace introuvable.");
+    const pendingCount = store.countPendingRequestsOfSpace(spaceId);
+    if (pendingCount === 0)
+        throw new InvariantError(`Aucune demande en attente dans « ${space.name} ».`);
+    runNow(spaceId);
+    return { pendingCount };
+}
+/**
+ * Accorde ou retire le rôle d'administrateur au compte actif `email`. Le
+ * dernier administrateur garde son rôle : le site n'en reste jamais dépourvu.
+ */
+export function setAdmin(store, email, isAdmin) {
+    const normalized = normalizeEmail(email);
+    const target = store.findUserByEmail(normalized);
+    if (!target)
+        throw new NotFoundError(`Aucun compte pour ${normalized} : créez-le d'abord (--set-user ${normalized}).`);
+    return store.mutate({ type: "user", userId: target.id }, (tx) => {
+        const user = tx.store.getUser(target.id);
+        if (isAdmin && user.status !== "active")
+            throw new OrganizerError(`Le compte ${normalized} n'est pas actif : activez-le d'abord (--set-user ${normalized}).`);
+        if (!isAdmin && user.isAdmin && tx.store.countAdmins() === 1) {
+            throw new InvariantError(`${normalized} est le seul administrateur : désignez-en un autre (--set-admin <email>) avant de lui retirer ce rôle.`);
+        }
+        return tx.setUserAdmin(user.id, isAdmin);
+    });
+}

package/dist/src/core/agent-tokens.d.ts

@@ -7,7 +7,7 @@ export declare function generateAgentToken(): string;
 export declare function hashAgentToken(token: string): string;
 /** État d'un jeton à l'instant `now` ; la révocation l'emporte sur l'expiration, l'expiration sur la perte d'accès. */
 export declare function tokenState(store: Store, token: AgentToken, now: Date): TokenState;
-/** Jetons de l'utilisateur : actifs d'abord, puis du plus récent au plus ancien. */
+/** Jetons de l'utilisateur, sans ceux du runner : actifs d'abord, puis du plus récent au plus ancien. */
 export declare function listAgentTokens(store: Store, userId: string, now?: Date): TokenListResponse;
 /**
  * Crée un jeton de l'utilisateur sur un espace dont il est membre ; renvoie
@@ -15,6 +15,14 @@ export declare function listAgentTokens(store: Store, userId: string, now?: Date
  * relié au site `publicUrl`.
  */
 export declare function createAgentToken(store: Store, userId: string, input: CreateTokenRequest, publicUrl: string, now?: Date): CreatedTokenResponse;
+/** Nom du jeton du runner, affiché dans la page Agent et l'historique. */
+export declare const RUNNER_TOKEN_NAME = "Runner";
+/**
+ * Donne une nouvelle valeur au jeton du runner de l'espace, en le créant au
+ * nom du propriétaire de l'espace s'il n'existe pas, et la renvoie. L'ancienne
+ * valeur est aussitôt refusée.
+ */
+export declare function issueRunnerToken(store: Store, spaceId: string): string;
 /** Révoque un jeton de l'utilisateur ; un jeton d'un autre est introuvable. */
 export declare function revokeAgentToken(store: Store, userId: string, tokenId: string, now?: Date): AgentTokenView;
 /** Jeton résolu par l'API agent : le jeton, son propriétaire et l'espace couvert. */

package/dist/src/core/agent-tokens.js

@@ -49,9 +49,12 @@ function tokenView(store, token, now) {
     };
 }
 const STATE_ORDER = { active: 0, inactive: 1, expired: 2, revoked: 3 };
-/** Jetons de l'utilisateur : actifs d'abord, puis du plus récent au plus ancien. */
+/** Jetons de l'utilisateur, sans ceux du runner : actifs d'abord, puis du plus récent au plus ancien. */
 export function listAgentTokens(store, userId, now = new Date()) {
-    const tokens = store.listAgentTokensOf(userId).map((token) => tokenView(store, token, now));
+    const tokens = store
+        .listAgentTokensOf(userId)
+        .filter((token) => !token.isRunner)
+        .map((token) => tokenView(store, token, now));
     tokens.sort((a, b) => STATE_ORDER[a.state] - STATE_ORDER[b.state] || b.createdAt.localeCompare(a.createdAt));
     return { tokens };
 }
@@ -74,6 +77,26 @@ export function createAgentToken(store, userId, input, publicUrl, now = new Date
     });
     return { token: tokenView(store, token, now), value, mcpJson: mcpJsonText(buildAgentEntry({ url: publicUrl, token: value })) };
 }
+/** Nom du jeton du runner, affiché dans la page Agent et l'historique. */
+export const RUNNER_TOKEN_NAME = "Runner";
+/**
+ * Donne une nouvelle valeur au jeton du runner de l'espace, en le créant au
+ * nom du propriétaire de l'espace s'il n'existe pas, et la renvoie. L'ancienne
+ * valeur est aussitôt refusée.
+ */
+export function issueRunnerToken(store, spaceId) {
+    const value = generateAgentToken();
+    const prefix = value.slice(0, AGENT_TOKEN_PREFIX.length + PREFIX_RANDOM_CHARS);
+    const space = store.getSpace(spaceId);
+    store.mutate(asUser(space.ownerId), (tx) => {
+        const existing = tx.store.findRunnerToken(spaceId);
+        if (existing)
+            tx.rotateRunnerToken(existing.id, prefix, hashAgentToken(value));
+        else
+            tx.createAgentToken({ spaceId, name: RUNNER_TOKEN_NAME, prefix, tokenHash: hashAgentToken(value), expiresAt: null, isRunner: true });
+    });
+    return value;
+}
 /** Révoque un jeton de l'utilisateur ; un jeton d'un autre est introuvable. */
 export function revokeAgentToken(store, userId, tokenId, now = new Date()) {
     const token = store.mutate(asUser(userId), (tx) => {

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

@@ -44,6 +44,11 @@ export declare function memberLines(store: Store, space: Space): string[];
 export declare function ago(iso: string, now?: Date): string;
 /** Résumé d'une demande pour list_requests. */
 export declare function requestLine(store: Store, agent: AgentCaller, request: AgentRequest): string;
+/**
+ * Échanges précédents de l'auteur d'un message dans l'espace visé, du plus ancien
+ * au plus récent, au nombre fixé dans ses paramètres ; aucun pour les autres types.
+ */
+export declare function requestHistory(store: Store, request: AgentRequest): AgentRequest[];
 /** Contexte complet d'une demande, renvoyé par claim_request. */
 export declare function requestContext(store: Store, agent: AgentCaller, request: AgentRequest): string;
 /** Idées actives récentes de la boîte à idées d'un espace. */

package/dist/src/core/agent.js

@@ -168,6 +168,23 @@ const KIND_GUIDANCE = {
     test_review: "A test review written by a tester of the context task: feed it back into the existing tasks (status, checklist, comments, priorities) or create a task for each problem found.",
     idea_promotion: "Promote the context idea into a well-formed task (clear title, description, type, priority, parent if relevant) with promote_idea.",
 };
+/**
+ * Échanges précédents de l'auteur d'un message dans l'espace visé, du plus ancien
+ * au plus récent, au nombre fixé dans ses paramètres ; aucun pour les autres types.
+ */
+export function requestHistory(store, request) {
+    if (request.kind !== "message")
+        return [];
+    const limit = store.getUserSettings(request.authorId).assistantHistory;
+    return store.listClosedRequestsOfAuthorBefore(request.targetSpaceId, request.authorId, request, limit);
+}
+/** Lignes d'un échange précédent : demande de l'auteur, puis réponse ou raison de l'échec. */
+function historyLines(store, request) {
+    const task = request.contextTaskId === null ? null : store.findTask(request.contextTaskId);
+    const about = [request.kind !== "message" ? request.kind : null, task ? `context ${taskKey(store, task)}` : null].filter(Boolean).join(", ");
+    const answer = request.status === "done" ? `Reply: ${request.reply ?? ""}` : `Failed: ${request.failureReason ?? ""}`;
+    return [`- ${ago(request.createdAt)}${about ? ` (${about})` : ""}: ${request.text.trim()}`, `  ${answer.trim()}`];
+}
 /** Contexte complet d'une demande, renvoyé par claim_request. */
 export function requestContext(store, agent, request) {
     const author = store.getUser(request.authorId);
@@ -201,6 +218,12 @@ export function requestContext(store, agent, request) {
         if (idea)
             lines.push(`Context idea: ${idea.id} "${idea.text}".`);
     }
+    const history = requestHistory(store, request);
+    if (history.length > 0) {
+        lines.push("", `Previous exchanges of the author in this space (oldest first, ${history.length} most recent) — use them to understand the message:`);
+        for (const previous of history)
+            lines.push(...historyLines(store, previous));
+    }
     lines.push("", "Text:", request.text, "");
     lines.push(...spaceContextLines(store, target));
     lines.push("", "Next: read with get_task / search_tasks, act with the write tools (pass this request_id), then call complete_request with a short reply in the author's language.");