@imenam/mcp-design 1.0.13 → 1.0.15

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;