@imenam/mcp-design 1.0.13 → 1.0.14

package/README.md

@@ -335,7 +335,7 @@ Trois colonnes : la liste des planches, le canvas, l'inspecteur et les calques.
 
 Raccourcis : `V` `R` `O` `L` `T` `I` (outils), `Ctrl+Z` / `Ctrl+Y` (annuler/rétablir), `Ctrl+G` / `Ctrl+Maj+G` (grouper / dissoudre), `Ctrl+D` (dupliquer), `Ctrl+A` (tout sélectionner), `Suppr`, flèches (déplacer d'1 px, 10 px avec `Maj`), `Échap`.
 
-La sauvegarde est automatique et différée. Une modification faite par l'agent pendant que la GUI est ouverte y apparaît en direct, via SSE ; une modification faite dans la GUI est enregistrée comme venant de l'utilisateur, et c'est ce que `get_changes` restitue.
+La sauvegarde est automatique et différée. Une modification faite par l'agent pendant que la GUI est ouverte y apparaît dans les 3 secondes : la GUI interroge `GET /api/changes` toutes les 3 s ; une modification faite dans la GUI est enregistrée comme venant de l'utilisateur, et c'est ce que `get_changes` restitue.
 
 Le point ambre d'une page indique qu'elle porte des modifications que l'agent n'a pas encore acquittées avec `mark_synced` ; leur nombre s'affiche au survol.
 
@@ -366,9 +366,9 @@ Les retours créés avant l'arrivée des noms reçoivent « Retour n°N », et a
 Deux processus, conformément au standard de l'écosystème (`@imenam/mcp-gui-interface`) :
 
 - **MCP Master** (`src/index.ts`) — protocole JSON-RPC sur stdio, stockage des designs, cycle de vie du worker via `GuiLauncher`.
-- **GUI Worker** (`src/gui-worker.ts`) — serveur Hono, enregistrement auprès du proxy via `ProxyClient`, API REST + SSE, sert la SPA React.
+- **GUI Worker** (`src/gui-worker.ts`) — serveur Hono, enregistrement auprès du proxy via `ProxyClient`, API REST, sert la SPA React.
 
-Les deux communiquent par IPC. Le worker se termine proprement quand le master disparaît (canal IPC fermé, PID parent absent) et quand une autre instance est déjà enregistrée (HTTP 409), ce qui évite les GUI orphelines.
+Les deux communiquent par IPC. Les évènements que le master pousse au worker (`DESIGNS_UPDATED`, `DESIGN_UPDATED`, `REMARKS_UPDATED`) entrent dans un journal en mémoire, numéroté et limité aux 200 dernières entrées. La GUI le relit toutes les 3 s par `GET /api/changes?since=<seq>&epoch=<epoch>`, qui répond immédiatement : aucune connexion ne reste ouverte, ce qui laisse libres les connexions que le navigateur accorde à l'origine du proxy, partagée par toutes les GUI. La réponse vaut `{ epoch, seq, reset: false, events }` avec les évènements postérieurs à `since`, ou `{ epoch, seq, reset: true }` quand la position du client n'est pas exploitable (premier appel, worker redémarré, entrées déjà sorties du journal) : la GUI recharge alors la liste des pages, les remarques et la page ouverte. Un `since` qui n'est pas un entier positif ou nul est refusé (400). Le worker se termine proprement quand le master disparaît (canal IPC fermé, PID parent absent) et quand une autre instance est déjà enregistrée (HTTP 409), ce qui évite les GUI orphelines.
 
 `shared/feedback.ts` porte le modèle des remarques, la détection des éléments d'une zone et la mise en forme d'un retour ; le serveur et la GUI l'importent tous deux, ce qui garantit que l'aperçu affiché est le texte transmis. `shared/render.ts` contient le rendu SVG d'un élément, `shared/tree.ts` la résolution de la hiérarchie en coordonnées document, `shared/instances.ts` l'expansion des instances en groupes, `shared/node-defaults.ts` les valeurs par défaut et `shared/icons/` la bibliothèque d'icônes. Tous sont importés **à la fois** par l'exporteur côté serveur et par le canvas côté navigateur : ce que l'utilisateur voit est exactement ce que `export_design` — et donc `screenshot_design`, qui rasterise ce même SVG via resvg — produit.
 

package/dist/src/gui-worker.js

@@ -1,10 +1,10 @@
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { Hono } from "hono";
-import { streamSSE } from "hono/streaming";
 import { GUI_LISTEN_HOST, ProxyClient, createLogger, honoGuiGuard, setupLogging } from "@imenam/mcp-gui-interface";
 import path from "path";
 import fs from "fs";
+import { randomUUID } from "crypto";
 import { fileURLToPath } from "url";
 import { IPCMessageSchema } from "../shared/schemas/design.schema.js";
 import { resolveLogDir } from "./core/log-dir.js";
@@ -79,7 +79,6 @@ const parentCheckInterval = setInterval(() => {
 const app = new Hono();
 app.use("*", honoGuiGuard());
 let proxyClient = null;
-const sseControllers = new Set();
 const pendingRequests = new Map();
 function safeSend(message) {
     if (process.send && process.connected) {
@@ -115,7 +114,23 @@ function ipcRequest(type, data, timeout = 5000) {
         }
     });
 }
-const PUSHED_EVENTS = new Set(["INITIAL_STATE", "DESIGNS_UPDATED", "DESIGN_UPDATED", "REMARKS_UPDATED"]);
+const PUSHED_EVENTS = new Set(["DESIGNS_UPDATED", "DESIGN_UPDATED", "REMARKS_UPDATED"]);
+/**
+ * Journal des évènements poussés par le master, relu par la GUI via
+ * `/api/changes`. Chaque entrée porte un numéro croissant ; seules les
+ * `JOURNAL_LIMIT` dernières sont gardées. `epoch` change à chaque démarrage du
+ * worker : un client qui le voit changer sait que sa position ne vaut plus rien.
+ */
+const JOURNAL_LIMIT = 200;
+const epoch = randomUUID();
+let lastSeq = 0;
+const journal = [];
+function appendToJournal(event) {
+    lastSeq += 1;
+    journal.push({ seq: lastSeq, event });
+    if (journal.length > JOURNAL_LIMIT)
+        journal.splice(0, journal.length - JOURNAL_LIMIT);
+}
 function setupIpcErrorHandlers() {
     process.on("error", (err) => {
         if (err.code === "ERR_IPC_CHANNEL_CLOSED")
@@ -123,7 +138,7 @@ function setupIpcErrorHandlers() {
         logger.error(`Process error: ${err.message}`);
     });
     process.on("disconnect", () => {
-        logger.warn("IPC disconnected from MCP master. GUI worker will exit; EventSource clients will show Disconnected.");
+        logger.warn("IPC disconnected from MCP master. GUI worker will exit.");
         process.exit(0);
     });
     process.on("message", (msg) => {
@@ -143,16 +158,8 @@ function setupIpcErrorHandlers() {
             });
             return;
         }
-        if (msg && PUSHED_EVENTS.has(msg.type)) {
-            for (const controller of sseControllers) {
-                try {
-                    controller.writeSSE({ data: JSON.stringify(msg), event: "message" });
-                }
-                catch {
-                    sseControllers.delete(controller);
-                }
-            }
-        }
+        if (msg && PUSHED_EVENTS.has(msg.type))
+            appendToJournal(msg);
     });
 }
 // --- Routes HTTP ------------------------------------------------------------
@@ -167,45 +174,27 @@ app.get("/proxy/health", (c) => {
         timestamp: new Date().toISOString(),
     });
 });
-app.get("/api/events", (c) => streamSSE(c, async (stream) => {
-    const clientId = Math.random().toString(36).slice(2, 11);
-    sseControllers.add(stream);
-    logger.info(`SSE /api/events: client connected (id=${clientId})`);
-    stream.onAbort(() => {
-        sseControllers.delete(stream);
-        logger.warn(`SSE /api/events: stream aborted (id=${clientId}).`);
-    });
-    if (!safeSend({ type: "GET_INITIAL_STATE", timestamp: new Date().toISOString() })) {
-        logger.warn(`SSE /api/events: GET_INITIAL_STATE not sent (id=${clientId}) — IPC unavailable.`);
-    }
-    try {
-        await stream.writeSSE({ data: "connected", event: "ping" });
-    }
-    catch (err) {
-        logger.warn(`SSE /api/events: initial writeSSE failed (id=${clientId}): ${err?.message ?? err}`);
-        sseControllers.delete(stream);
-        return;
-    }
-    while (true) {
-        await stream.sleep(30000);
-        try {
-            await stream.writeSSE({ data: "ping", event: "ping" });
-        }
-        catch (err) {
-            logger.warn(`SSE /api/events: keepalive ping failed (id=${clientId}): ${err?.message ?? err}`);
-            sseControllers.delete(stream);
-            break;
-        }
-    }
-}));
-app.post("/api/client-diagnostics", async (c) => {
-    try {
-        logger.warn(`Client diagnostics (SSE/EventSource): ${JSON.stringify(await c.req.json())}`);
-    }
-    catch (e) {
-        logger.warn(`Client diagnostics: invalid JSON body (${e?.message ?? e})`);
-    }
-    return c.json({ ok: true });
+/**
+ * Évènements survenus depuis la position `since` du client. `reset: true`
+ * quand cette position n'est pas exploitable — absente, d'un autre démarrage du
+ * worker, plus ancienne que le journal ou en avance sur lui : le client
+ * recharge alors tout et repart de `seq`.
+ */
+app.get("/api/changes", (c) => {
+    const rawSince = c.req.query("since");
+    const clientEpoch = c.req.query("epoch");
+    if (rawSince !== undefined && !/^\d+$/.test(rawSince)) {
+        return c.json({ error: `Invalid "since" parameter: expected a non-negative integer, got "${rawSince}"` }, 400);
+    }
+    const reset = { epoch, seq: lastSeq, reset: true };
+    if (rawSince === undefined || !clientEpoch || clientEpoch !== epoch)
+        return c.json(reset);
+    const since = Number(rawSince);
+    const oldestSeq = journal.length > 0 ? journal[0].seq : lastSeq + 1;
+    if (since > lastSeq || since < oldestSeq - 1)
+        return c.json(reset);
+    const events = journal.filter((entry) => entry.seq > since).map((entry) => entry.event);
+    return c.json({ epoch, seq: lastSeq, reset: false, events });
 });
 app.get("/api/config", async (c) => {
     const result = await ipcRequest("GET_CONFIG");

package/dist/src/index.js

@@ -140,13 +140,6 @@ function handleIPCMessage(msg) {
             logger.info(`GUI ready at ${guiUrl}`);
             guiStartWaiter?.({ outcome: "ready", url: msg.data?.url });
             return;
-        case "GET_INITIAL_STATE":
-            broadcastToGUI({
-                type: "INITIAL_STATE",
-                data: { designs: store.list(), version: APP_VERSION },
-                timestamp: new Date().toISOString(),
-            });
-            return;
         case "LIST_DESIGNS":
             reply(msg, "LIST_DESIGNS_RESPONSE", { designs: store.list() });
             return;