@imenam/mcp-organizer 1.0.1 → 1.0.2

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

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

package/dist/src/mcp/client.js

@@ -1,9 +1,9 @@
-import { AgentEnvelopeSchema, AgentErrorSchema } from "../../shared/schemas/agent-tools.schema.js";
+import { AgentEnvelopeSchema, AgentErrorSchema, WaitRequestsDataSchema } from "../../shared/schemas/agent-tools.schema.js";
 /**
  * Client HTTP de l'API agent du site : seul point de sortie réseau du mode
  * MCP. Chaque appel porte le jeton dans `Authorization: Bearer`.
  */
-/** Délai maximal d'un appel au site. */
+/** Délai maximal d'un appel au site, hors attente longue. */
 export const REQUEST_TIMEOUT_MS = 30_000;
 /** Échec d'un appel : refus du site (avec son message) ou site injoignable. */
 export class SiteError extends Error {
@@ -33,6 +33,31 @@ export class OrganizerSiteClient {
     }
     /** Exécute la requête d'un outil et renvoie le texte rédigé pour l'agent. */
     async call(request) {
+        return (await this.envelope(request)).text;
+    }
+    /**
+     * Attente longue des demandes qui passent en attente (`GET requests/wait`) ;
+     * le délai de l'appel couvre la durée de l'attente.
+     */
+    async waitForRequests(query) {
+        const params = { timeout_seconds: String(query.timeout_seconds) };
+        if (query.since !== undefined)
+            params.since = query.since;
+        if (query.watcher)
+            params.watcher = "true";
+        const envelope = await this.envelope({ method: "GET", path: "requests/wait", query: params, body: undefined }, query.timeout_seconds * 1000 + REQUEST_TIMEOUT_MS);
+        return this.parseData(WaitRequestsDataSchema, envelope.data);
+    }
+    /** Données structurées d'une réponse, validées par `schema`. */
+    parseData(schema, data) {
+        const parsed = schema.safeParse(data);
+        if (!parsed.success) {
+            throw new SiteError(`The organizer site at ${this.connection.url} sent an unexpected answer. Check that the site runs the same version of @imenam/mcp-organizer.`);
+        }
+        return parsed.data;
+    }
+    /** Exécute une requête de l'API agent et renvoie sa réponse : texte rédigé pour l'agent et données structurées. */
+    async envelope(request, timeoutMs = REQUEST_TIMEOUT_MS) {
         const url = new URL(`${this.connection.url}/api/agent/${request.path}`);
         for (const [name, value] of Object.entries(request.query))
             url.searchParams.set(name, value);
@@ -48,7 +73,7 @@ export class OrganizerSiteClient {
                 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),
+                signal: AbortSignal.timeout(timeoutMs),
             });
         }
         catch (error) {
@@ -76,6 +101,6 @@ export class OrganizerSiteClient {
         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;
+        return envelope.data;
     }
 }

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

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

package/dist/src/mcp/notifications.js

@@ -0,0 +1,54 @@
+import { NotificationsDataSchema } from "../../shared/schemas/agent-tools.schema.js";
+import { writeHandoff } from "./watch-handoff.js";
+/**
+ * Outil `enable_notifications`, exécuté par le mode MCP lui-même : il lit le
+ * jeton, l'espace et l'état du veilleur sur le site, dépose le relais du
+ * veilleur et rend l'appel `Monitor` que l'agent doit faire.
+ */
+/** Durée maximale d'un `Monitor` côté hôte. */
+export const MONITOR_TIMEOUT_MS = 1_800_000;
+const PACKAGE_NAME = "@imenam/mcp-organizer";
+export const ENABLE_NOTIFICATIONS_TOOL = {
+    name: "enable_notifications",
+    description: "Get notified in real time of the requests the members of your space send to the AI, without polling the queue. Returns immediately: it blocks nothing and starts nothing on its own. It hands you the exact Monitor call to make right after — arming that watcher is what actually delivers notifications, and until you do it no request will reach you. Call this once at the start of a session; then keep working, each new pending request interrupts you on its own. The host stops the watcher after 30 minutes at most: re-arm it with the same Monitor call each time it expires.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+};
+/** Commande du veilleur du jeton `tokenId`. */
+export function watchCommand(tokenId) {
+    return `npx -y ${PACKAGE_NAME} --watch ${tokenId}`;
+}
+export async function enableNotifications(client, connection) {
+    const envelope = await client.envelope({ method: "GET", path: "notifications", query: {}, body: undefined });
+    const { token, space, pendingCount, watcher } = client.parseData(NotificationsDataSchema, envelope.data);
+    writeHandoff({ tokenId: token.id, url: connection.url, token: connection.token });
+    const command = watchCommand(token.id);
+    if (watcher.armed) {
+        return [
+            `Notifications are already live for token "${token.name}" on space "${space.name}" (watcher armed since ${watcher.since}).`,
+            "Nothing to do: keep working, new requests will interrupt you on their own.",
+            "Do not arm a second watcher — you would get every request twice.",
+            "Only exception: if the host just told you your watcher expired or stopped, re-arm it",
+            `with the same Monitor call (command \`${command}\`, timeout_ms ${MONITOR_TIMEOUT_MS}).`,
+        ].join("\n");
+    }
+    const lines = [
+        `Notifications enabled for token "${token.name}" on space "${space.name}".`,
+        "",
+        "Last step — call the Monitor tool now, with exactly these arguments:",
+        `  command:     ${command}`,
+        "  description: New requests for the AI in the organizer",
+        `  timeout_ms:  ${MONITOR_TIMEOUT_MS}`,
+        "",
+        "Until that watcher is armed, nothing will reach you: no request will be announced.",
+        "Once it is, keep working normally — each request that becomes pending shows up on its own,",
+        "even while you are idle. One line per request; process it with claim_request.",
+        "",
+        "The host stops every monitor after 30 minutes at most. Each time it tells you this",
+        "watcher expired, call Monitor again right away with the same arguments — do not call",
+        "enable_notifications again. Skip that and notifications stop for good.",
+    ];
+    if (pendingCount > 0) {
+        lines.push("", `${pendingCount} request(s) are already pending. Only requests that become pending AFTER the`, "watcher starts are announced — process the backlog with list_requests.");
+    }
+    return lines.join("\n");
+}

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

@@ -1,6 +1,6 @@
 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.";
+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.\nWhen the queue is empty, tell the user.\n\nNotifications: call enable_notifications once at the start of the session and arm the watcher it hands you with Monitor. Each request that becomes pending in your space then arrives on its own as one line (kind, author, excerpt, request id), even while you are idle: process it with the work loop above, starting with claim_request. The host stops that watcher after 30 minutes at most: each time it tells you the watcher expired, re-arm it at once with the same Monitor call; otherwise notifications stop for good. A line \"notifications stopped\" means the site refused the token: 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`.

package/dist/src/mcp/start.js

@@ -6,6 +6,8 @@ import { createLogger, setupLogging } from "../core/logger.js";
 import { ConfigError } from "../core/errors.js";
 import { OrganizerSiteClient, SiteError } from "./client.js";
 import { AGENT_TOOLS, ToolArgumentError, findAgentTool, toolHttpRequest } from "./tools.js";
+import { ENABLE_NOTIFICATIONS_TOOL, enableNotifications } from "./notifications.js";
+import { removeOwnHandoffs } from "./watch-handoff.js";
 /** Présentation du serveur transmise au client MCP : concepts et déroulé. */
 export 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.
 
@@ -24,7 +26,9 @@ Work loop, when the user asks you to process the queue:
 3. Read what you need with get_task and search_tasks.
 4. Act with create_task, update_task, set_assignees, set_tags, edit_checklist, add_comment, create_idea, update_idea, promote_idea — always passing the request_id. Each write is one undoable action of the batch.
 5. 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.
-Nothing arrives on its own: there is no waiting tool. When the queue is empty, tell the user.
+When the queue is empty, tell the user.
+
+Notifications: call enable_notifications once at the start of the session and arm the watcher it hands you with Monitor. Each request that becomes pending in your space then arrives on its own as one line (kind, author, excerpt, request id), even while you are idle: process it with the work loop above, starting with claim_request. The host stops that watcher after 30 minutes at most: each time it tells you the watcher expired, re-arm it at once with the same Monitor call; otherwise notifications stop for good. A line "notifications stopped" means the site refused the token: tell the user.
 
 How to handle each kind of request:
 - **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.
@@ -80,9 +84,19 @@ export async function runMcpMode() {
     const logger = createLogger("mcp");
     const client = new OrganizerSiteClient(connection);
     const server = new Server({ name: "mcp-organizer", version: APP_VERSION }, { capabilities: { tools: {} }, instructions: INSTRUCTIONS });
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: AGENT_TOOLS.map((tool) => tool.definition) }));
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [...AGENT_TOOLS.map((tool) => tool.definition), ENABLE_NOTIFICATIONS_TOOL] }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
+        if (name === ENABLE_NOTIFICATIONS_TOOL.name) {
+            try {
+                return { content: [{ type: "text", text: await enableNotifications(client, connection) }] };
+            }
+            catch (error) {
+                if (!(error instanceof SiteError))
+                    logger.error(`Tool ${name} failed: ${error?.stack ?? error}`);
+                return errorResult(error?.message ?? String(error));
+            }
+        }
         const tool = findAgentTool(name);
         if (!tool)
             return errorResult(`Unknown tool "${name}". Call tools/list to get the available tools.`);
@@ -96,6 +110,11 @@ export async function runMcpMode() {
             return errorResult(error?.message ?? String(error));
         }
     });
+    // Le relais du veilleur porte le jeton : il ne survit pas au mode MCP qui l'a écrit.
+    process.on("exit", removeOwnHandoffs);
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+        process.on(signal, () => process.exit(0));
+    }
     await server.connect(new StdioServerTransport());
     logger.info(`MCP server running on stdio (version ${APP_VERSION}, site: ${connection.url})`);
 }

package/dist/src/mcp/watch-handoff.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Relais entre la session MCP et son veilleur de notifications.
+ *
+ * Le veilleur est lancé par l'agent via l'outil `Monitor` de l'hôte : c'est un
+ * processus du shell de la session, pas un enfant du mode MCP. Il n'hérite donc
+ * pas du bloc `env` du `.mcp.json` et n'a ni URL du site ni jeton. Les passer sur
+ * la ligne de commande les afficherait dans la conversation : ils transitent par
+ * un fichier en 0600, que seul l'identifiant du jeton (pas sa valeur) permet de
+ * retrouver.
+ *
+ * Le fichier est écrit par `enable_notifications`, jamais au démarrage, et retiré
+ * à l'arrêt du mode MCP qui l'a écrit en dernier.
+ */
+export interface Handoff {
+    /** Identifiant du jeton d'agent. */
+    tokenId: string;
+    url: string;
+    /** Valeur du jeton. */
+    token: string;
+    /** Processus du mode MCP qui a écrit le relais. */
+    pid: number;
+    /** Horodatage d'écriture, qui sert à purger les relais abandonnés. */
+    writtenAt: string;
+}
+/** Répertoire des relais : `<ORGANIZER_STATE_DIR>/watch`, ou `~/.mcp-organizer/watch`. */
+export declare function handoffDir(): string;
+/** Fichier du relais d'un jeton, nommé d'après le hachage de son identifiant. */
+export declare function handoffPath(tokenId: string): string;
+export declare function writeHandoff(handoff: Omit<Handoff, "pid" | "writtenAt">): string;
+/** Relais du jeton `tokenId`, ou null s'il n'existe pas ou ne concerne pas ce jeton. */
+export declare function readHandoff(tokenId: string): Handoff | null;
+/** Supprime le relais du jeton s'il a été écrit en dernier par ce processus. */
+export declare function removeHandoff(tokenId: string): void;
+/** Supprime les relais écrits en dernier par ce processus. Synchrone : appelable sur `exit`. */
+export declare function removeOwnHandoffs(): void;

package/dist/src/mcp/watch-handoff.js

@@ -0,0 +1,91 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/** Âge au-delà duquel un relais resté en place (session tuée, machine redémarrée) est supprimé. */
+const STALE_AFTER_MS = 7 * 24 * 60 * 60 * 1000;
+/** Répertoire des relais : `<ORGANIZER_STATE_DIR>/watch`, ou `~/.mcp-organizer/watch`. */
+export function handoffDir() {
+    const override = process.env.ORGANIZER_STATE_DIR?.trim();
+    return override ? path.join(override, "watch") : path.join(os.homedir(), ".mcp-organizer", "watch");
+}
+/** Fichier du relais d'un jeton, nommé d'après le hachage de son identifiant. */
+export function handoffPath(tokenId) {
+    const digest = crypto.createHash("sha256").update(tokenId).digest("hex").slice(0, 32);
+    return path.join(handoffDir(), `${digest}.json`);
+}
+/** Jetons dont ce processus a écrit le relais. */
+const written = new Set();
+export function writeHandoff(handoff) {
+    const target = handoffPath(handoff.tokenId);
+    written.add(handoff.tokenId);
+    fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
+    const payload = { ...handoff, pid: process.pid, writtenAt: new Date().toISOString() };
+    fs.writeFileSync(target, `${JSON.stringify(payload, null, 2)}\n`, { encoding: "utf-8", mode: 0o600 });
+    try {
+        fs.chmodSync(target, 0o600);
+    }
+    catch {
+        // Windows ignore les permissions POSIX ; le fichier reste dans le profil de l'utilisateur.
+    }
+    pruneStaleHandoffs();
+    return target;
+}
+/** Relais du jeton `tokenId`, ou null s'il n'existe pas ou ne concerne pas ce jeton. */
+export function readHandoff(tokenId) {
+    let raw;
+    try {
+        raw = fs.readFileSync(handoffPath(tokenId), "utf-8");
+    }
+    catch {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed.tokenId !== tokenId || typeof parsed.url !== "string" || typeof parsed.token !== "string")
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/** Supprime le relais du jeton s'il a été écrit en dernier par ce processus. */
+export function removeHandoff(tokenId) {
+    written.delete(tokenId);
+    if (readHandoff(tokenId)?.pid !== process.pid)
+        return;
+    try {
+        fs.rmSync(handoffPath(tokenId), { force: true });
+    }
+    catch {
+        // Un relais qui n'a pas pu être supprimé est purgé plus tard, par ancienneté.
+    }
+}
+/** Supprime les relais écrits en dernier par ce processus. Synchrone : appelable sur `exit`. */
+export function removeOwnHandoffs() {
+    for (const tokenId of [...written])
+        removeHandoff(tokenId);
+}
+function pruneStaleHandoffs() {
+    let entries;
+    try {
+        entries = fs.readdirSync(handoffDir());
+    }
+    catch {
+        return;
+    }
+    const now = Date.now();
+    for (const entry of entries) {
+        if (!entry.endsWith(".json"))
+            continue;
+        const file = path.join(handoffDir(), entry);
+        try {
+            if (now - fs.statSync(file).mtimeMs > STALE_AFTER_MS)
+                fs.rmSync(file, { force: true });
+        }
+        catch {
+            // Un fichier illisible ou déjà supprimé n'empêche pas l'écriture du relais.
+        }
+    }
+}

package/dist/src/server/app.js

@@ -11,6 +11,7 @@ import { MAX_ATTACHMENT_BYTES } from "../../shared/schemas/tasks-api.schema.js";
 import { MAX_TRANSCRIPTION_BYTES } from "../../shared/schemas/transcription-api.schema.js";
 import { errorKindOf, errorStatusOf, handleApiRequest } from "../gui-api.js";
 import { handleAgentRequest } from "../agent-api/router.js";
+import { waitForPendingRequests } from "../agent-api/notifications.js";
 import { LoginLimiter } from "./login-limiter.js";
 import { MAX_BODY_BYTES } from "./limits.js";
 /**
@@ -207,16 +208,30 @@ export function createSiteApp(deps) {
             return c.json(response);
         }
         catch (err) {
-            const kind = errorKindOf(err);
-            if (kind === "internal") {
-                const reference = logInternalError(`Agent request ${c.req.method} ${c.req.path}`, err);
-                return c.json({ error: `Internal error of the organizer site (reference ${reference}): retry later; if it persists, give this reference to the administrator of the site, who finds the details in its log.` }, 500);
-            }
-            if (kind === "unauthorized")
-                c.header("WWW-Authenticate", 'Bearer realm="mcp-organizer"');
-            return c.json({ error: err?.message ?? String(err) }, HTTP_STATUS_BY_ERROR_KIND[kind]);
+            return agentError(c, err);
         }
     };
+    /** Réponse d'erreur de l'API des agents, avec le code HTTP de sa nature. */
+    function agentError(c, err) {
+        const kind = errorKindOf(err);
+        if (kind === "internal") {
+            const reference = logInternalError(`Agent request ${c.req.method} ${c.req.path}`, err);
+            return c.json({ error: `Internal error of the organizer site (reference ${reference}): retry later; if it persists, give this reference to the administrator of the site, who finds the details in its log.` }, 500);
+        }
+        if (kind === "unauthorized")
+            c.header("WWW-Authenticate", 'Bearer realm="mcp-organizer"');
+        return c.json({ error: err?.message ?? String(err) }, HTTP_STATUS_BY_ERROR_KIND[kind]);
+    }
+    // Attente longue des demandes : seule route asynchrone de l'API des agents.
+    app.get(`${AGENT_API_PREFIX}/requests/wait`, async (c) => {
+        try {
+            const response = await waitForPendingRequests({ store: api.store, now: api.now }, { method: "GET", path: "/requests/wait", query: c.req.query(), bearer: bearerToken(c) }, c.req.raw.signal);
+            return c.json(response);
+        }
+        catch (err) {
+            return agentError(c, err);
+        }
+    });
     app.all(AGENT_API_PREFIX, agentApi);
     app.all(`${AGENT_API_PREFIX}/*`, agentApi);
     // Toute route `/api/*` est traitée par le routeur de l'API, avec le jeton du