mcp-coordinator 0.3.0 → 0.4.0

package/dist/src/server-setup.js

@@ -18,6 +18,7 @@ import { SseEmitter } from "./sse-emitter.js";
 import { MqttBridge } from "./mqtt-bridge.js";
 import { AgentActivityTracker } from "./agent-activity.js";
 import { QuotaCache } from "./quota/quota-cache.js";
+import { Metrics } from "./metrics.js";
 import { createLogger } from "./logger.js";
 import { getVersion } from "../cli/version.js";
 const VERSION = getVersion();
@@ -36,6 +37,7 @@ export function createServices(config) {
     const contextProvider = new SummaryContextProvider(registry, consultation, fileTracker);
     const sseEmitter = new SseEmitter();
     const mqttBridge = new MqttBridge(logger.child({ component: "mqtt" }));
+    const metrics = new Metrics();
     // Quota cache — macOS-only for now, Linux/Windows stubs return 503 via the
     // /api/quota handler so raids keep running without a quota guardrail there.
     // onRefresh fans the new data out to dashboard (SSE) + any live listener (MQTT)
@@ -62,8 +64,9 @@ export function createServices(config) {
         else if (event.type === "agent_offline")
             quotaCache.onAgentInactive();
     });
-    // Centralized resolution → SSE + MQTT
+    // Centralized resolution → SSE + MQTT + metrics
     consultation.onResolve((event) => {
+        metrics.recordThreadResolved(event.resolution_type);
         sseEmitter.emit("thread_resolved", {
             thread_id: event.thread_id,
             resolution_type: event.resolution_type,
@@ -77,10 +80,15 @@ export function createServices(config) {
         if (event.resolution_type !== "auto_resolved") {
             mqttBridge.publishResolution(event.thread_id, "resolved", event.resolution_summary || "");
         }
+        // P1 fix: clear the retained `coordinator/consultations/new` event so a
+        // coordinator restart doesn't re-broadcast a consultation that's already
+        // been resolved. No-op when the retained slot holds a different (newer)
+        // thread.
+        mqttBridge.clearRetainedConsultation(event.thread_id);
     });
     return {
         logger, registry, activityTracker, consultation, conflictDetector,
-        depMap, fileTracker, impactScorer, introspection, contextProvider, sseEmitter, mqttBridge, quotaCache,
+        depMap, fileTracker, impactScorer, introspection, contextProvider, sseEmitter, mqttBridge, quotaCache, metrics,
     };
 }
 /** Create a new McpServer bound to the shared services (one per MCP session). */

package/dist/src/sse-emitter.d.ts

@@ -1,10 +1,16 @@
 import type { CoordinatorEvent, EventType } from "./types.js";
 type EventListener = (event: CoordinatorEvent) => void;
+export declare const MAX_SSE_CLIENTS: number;
 export declare class SseEmitter {
     private listeners;
+    private rejectedCount;
     emit(type: EventType, payload: Record<string, unknown>): void;
     getEventsSince(lastId: number): CoordinatorEvent[];
     addListener(listener: EventListener): () => void;
     removeAllListeners(): void;
+    /** P3: introspection for tests + ops dashboards. */
+    listenerCount(): number;
+    /** P3: count of addListener calls refused due to MAX_SSE_CLIENTS. */
+    getRejectedCount(): number;
 }
 export {};

package/dist/src/sse-emitter.js

@@ -1,6 +1,25 @@
 import { getDb } from "./database.js";
+/**
+ * P3: bound the listener array so a runaway client (or DoS attempt) can't
+ * grow it without limit. Default 100 covers a small-to-mid swarm — enough
+ * headroom for a dashboard + every agent + a handful of CLI tailers, but
+ * not so large that a leak would silently exhaust memory. Override via
+ * COORDINATOR_MAX_SSE_CLIENTS for larger deployments.
+ */
+const DEFAULT_MAX_SSE_CLIENTS = 100;
+export const MAX_SSE_CLIENTS = (() => {
+    const raw = process.env.COORDINATOR_MAX_SSE_CLIENTS;
+    if (!raw)
+        return DEFAULT_MAX_SSE_CLIENTS;
+    const n = parseInt(raw, 10);
+    return Number.isFinite(n) && n > 0 ? n : DEFAULT_MAX_SSE_CLIENTS;
+})();
+const NOOP = () => { };
 export class SseEmitter {
     listeners = [];
+    // P3: track refusals so operators can see when the cap is being hit.
+    // Also lets tests assert "we refused without throwing" without scraping logs.
+    rejectedCount = 0;
     emit(type, payload) {
         const db = getDb();
         const payloadStr = JSON.stringify(payload);
@@ -13,8 +32,22 @@ export class SseEmitter {
             payload: payloadStr,
             created_at: new Date().toISOString(),
         };
-        for (const listener of this.listeners) {
-            listener(event);
+        // P3: async fan-out via setImmediate so a slow listener (e.g. a stalled
+        // SSE client whose socket buffer is full) cannot block siblings or the
+        // emit() caller. Snapshot the array first so a listener that unsubscribes
+        // mid-loop doesn't shift indices under us.
+        const snapshot = this.listeners.slice();
+        for (const listener of snapshot) {
+            setImmediate(() => {
+                try {
+                    listener(event);
+                }
+                catch {
+                    // Listener errors must not crash the emitter or affect siblings.
+                    // Drop silently — the SSE response writers swallow their own
+                    // socket errors via the unsubscribe path on req.on("close").
+                }
+            });
         }
     }
     getEventsSince(lastId) {
@@ -24,6 +57,13 @@ export class SseEmitter {
             .all(lastId);
     }
     addListener(listener) {
+        // P3: refuse-with-no-op when the cap is reached. Returning a no-op
+        // keeps the caller's unsubscribe contract intact (no special-casing
+        // upstream) while preventing the array from growing past MAX_SSE_CLIENTS.
+        if (this.listeners.length >= MAX_SSE_CLIENTS) {
+            this.rejectedCount++;
+            return NOOP;
+        }
         this.listeners.push(listener);
         return () => {
             this.listeners = this.listeners.filter((l) => l !== listener);
@@ -32,4 +72,12 @@ export class SseEmitter {
     removeAllListeners() {
         this.listeners = [];
     }
+    /** P3: introspection for tests + ops dashboards. */
+    listenerCount() {
+        return this.listeners.length;
+    }
+    /** P3: count of addListener calls refused due to MAX_SSE_CLIENTS. */
+    getRejectedCount() {
+        return this.rejectedCount;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-coordinator",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "mcpName": "io.github.swoofer/mcp-coordinator",
   "description": "Embedded MQTT broker + MCP server for multi-agent coordination",
   "type": "module",
@@ -63,6 +63,8 @@
     "jose": "^6.2.2",
     "mqtt": "^5.15.0",
     "pino": "^10.3.1",
+    "prom-client": "^15.1.3",
+    "tar": "^7.4.3",
     "ws": "^8.20.0",
     "zod": "^3.23.0"
   },