@imenam/mcp-organizer 1.0.2 → 1.0.7

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.");