@daeda/mcp-pro 0.1.19 → 0.1.21

package/dist/index.js

@@ -3320,6 +3320,8 @@ if (!LICENSE_KEY) {
   process.exit(1);
 }
 var WS_URL = process.env.MCP_CLIENT_WEBSOCKET_URL ?? process.env.websocket_url ?? "wss://mcp-ws.daeda.tech";
+var PING_INTERVAL_MS = 15e3;
+var PONG_TIMEOUT_MS = 1e4;
 var WebSocketLive = Layer5.effect(
   WebSocketService,
   Effect40.gen(function* () {
@@ -3333,6 +3335,9 @@ var WebSocketLive = Layer5.effect(
     const pendingPlanListRef = yield* Ref14.make(null);
     const handlersRef = yield* Ref14.make(null);
     const encryptionKeyRef = yield* Ref14.make(null);
+    let pingInterval = null;
+    let pongTimeout = null;
+    let awaitingPong = false;
     const requireWs = pipe33(
       Ref14.get(wsRef),
       Effect40.flatMap(
@@ -3366,26 +3371,95 @@ var WebSocketLive = Layer5.effect(
       Match.when({ type: "plan:list:response" }, (m) => handlePlanListResponse(m.payload, ctx)),
       Match.orElse(() => Effect40.void)
     );
+    const stopPing = () => {
+      if (pingInterval) {
+        clearInterval(pingInterval);
+        pingInterval = null;
+      }
+      if (pongTimeout) {
+        clearTimeout(pongTimeout);
+        pongTimeout = null;
+      }
+      awaitingPong = false;
+    };
+    const startPing = (ws) => {
+      stopPing();
+      pingInterval = setInterval(() => {
+        if (awaitingPong) {
+          console.error("[ws:ping] Pong not received in time \u2014 closing stale connection");
+          stopPing();
+          try {
+            ws.close();
+          } catch {
+          }
+          return;
+        }
+        try {
+          ws.send(JSON.stringify({ type: "ping", payload: { timestamp: Date.now() } }));
+          awaitingPong = true;
+          pongTimeout = setTimeout(() => {
+            if (awaitingPong) {
+              console.error("[ws:ping] Pong timeout \u2014 closing stale connection");
+              stopPing();
+              try {
+                ws.close();
+              } catch {
+              }
+            }
+          }, PONG_TIMEOUT_MS);
+        } catch {
+          console.error("[ws:ping] Failed to send ping \u2014 connection may be dead");
+          stopPing();
+          try {
+            ws.close();
+          } catch {
+          }
+        }
+      }, PING_INTERVAL_MS);
+    };
     const wireMessageHandler = (ws) => Effect40.sync(() => {
       ws.onmessage = (event) => {
+        let parsed;
+        try {
+          parsed = JSON.parse(event.data);
+        } catch (err) {
+          console.error("[ws:message] Failed to parse message:", err);
+          return;
+        }
+        if (parsed.type === "pong") {
+          awaitingPong = false;
+          if (pongTimeout) {
+            clearTimeout(pongTimeout);
+            pongTimeout = null;
+          }
+          return;
+        }
         console.error("Received:", event.data);
         pipe33(
-          Effect40.try({
-            try: () => JSON.parse(event.data),
-            catch: (error) => new WebSocketError({ url: WS_URL, cause: error })
-          }),
+          Effect40.succeed(parsed),
           Effect40.flatMap(routeMessage),
           Effect40.catchAll((err) => Effect40.sync(() => console.error("[ws:message] Error handling message:", err))),
           Effect40.runFork
         );
       };
     });
+    const rejectAllPending = () => {
+      const closeError = new WebSocketError({ url: WS_URL, cause: new Error("WebSocket closed") });
+      const pendingArtifact = Effect40.runSync(Ref14.getAndSet(pendingArtifactRef, null));
+      if (pendingArtifact) pendingArtifact.reject(closeError);
+      const pendingPlanCreate = Effect40.runSync(Ref14.getAndSet(pendingPlanCreateRef, null));
+      if (pendingPlanCreate) pendingPlanCreate.reject(closeError);
+      const pendingPlanList = Effect40.runSync(Ref14.getAndSet(pendingPlanListRef, null));
+      if (pendingPlanList) pendingPlanList.reject(closeError);
+      const pendingPlugins = Effect40.runSync(Ref14.getAndSet(pendingPluginRequestsRef, /* @__PURE__ */ new Map()));
+      for (const [, pending] of pendingPlugins) {
+        pending.reject(closeError);
+      }
+    };
     const wireCloseHandler = (ws) => Effect40.sync(() => {
       ws.onclose = () => {
-        const pending = Effect40.runSync(Ref14.getAndSet(pendingArtifactRef, null));
-        if (pending) {
-          pending.reject(new WebSocketError({ url: WS_URL, cause: new Error("WebSocket closed") }));
-        }
+        stopPing();
+        rejectAllPending();
         pipe33(
           Ref14.set(stateRef, "disconnected"),
           Effect40.flatMap(() => Ref14.set(wsRef, null)),
@@ -3403,6 +3477,7 @@ var WebSocketLive = Layer5.effect(
         (ws) => Effect40.async((resume) => {
           ws.onopen = () => {
             console.error(`[ws] Connected to ${WS_URL}, sending register`);
+            startPing(ws);
             pipe33(
               Ref14.set(stateRef, "connected"),
               Effect40.flatMap(() => Ref14.set(isReconnectingRef, false)),
@@ -3478,7 +3553,12 @@ var WebSocketLive = Layer5.effect(
               reject: (error) => resume(Effect40.fail(error))
             };
             Effect40.runSync(Ref14.set(pendingArtifactRef, pending));
-            ws.send(JSON.stringify({ type: "sync:artifact", payload: { artifact_id: artifactId } }));
+            try {
+              ws.send(JSON.stringify({ type: "sync:artifact", payload: { artifact_id: artifactId } }));
+            } catch (err) {
+              Effect40.runSync(Ref14.set(pendingArtifactRef, null));
+              resume(Effect40.fail(new WebSocketError({ url: WS_URL, cause: err })));
+            }
           })
         ),
         Effect40.timeoutFail({
@@ -3500,14 +3580,21 @@ var WebSocketLive = Layer5.effect(
               const next = new Map(pendingMap);
               next.set(requestId, pending);
               Effect40.runSync(Ref14.set(pendingPluginRequestsRef, next));
-              ws.send(JSON.stringify({
-                type: "sync:plugin-data",
-                payload: {
-                  target_portal: portalId,
-                  plugin_name: pluginName,
-                  request_id: requestId
-                }
-              }));
+              try {
+                ws.send(JSON.stringify({
+                  type: "sync:plugin-data",
+                  payload: {
+                    target_portal: portalId,
+                    plugin_name: pluginName,
+                    request_id: requestId
+                  }
+                }));
+              } catch (err) {
+                const cleanup = new Map(Effect40.runSync(Ref14.get(pendingPluginRequestsRef)));
+                cleanup.delete(requestId);
+                Effect40.runSync(Ref14.set(pendingPluginRequestsRef, cleanup));
+                resume(Effect40.fail(new WebSocketError({ url: WS_URL, cause: err })));
+              }
             }),
             Effect40.timeoutFail({
               duration: Duration.seconds(timeoutSeconds ?? 30),
@@ -3535,11 +3622,16 @@ var WebSocketLive = Layer5.effect(
               reject: (error) => resume(Effect40.fail(error))
             };
             Effect40.runSync(Ref14.set(pendingPlanCreateRef, pending));
-            ws.send(JSON.stringify({ type: "plan:create", payload: { target_portal: portalId, ...plan.dry_run ? { dry_run: true } : {}, plan } }));
+            try {
+              ws.send(JSON.stringify({ type: "plan:create", payload: { target_portal: portalId, ...plan.dry_run ? { dry_run: true } : {}, plan } }));
+            } catch (err) {
+              Effect40.runSync(Ref14.set(pendingPlanCreateRef, null));
+              resume(Effect40.fail(new WebSocketError({ url: WS_URL, cause: err })));
+            }
           })
         ),
         Effect40.timeoutFail({
-          duration: Duration.seconds(30),
+          duration: Duration.seconds(120),
           onTimeout: () => new WebSocketError({ url: WS_URL, cause: new Error("Plan create request timed out") })
         })
       ),
@@ -3552,7 +3644,12 @@ var WebSocketLive = Layer5.effect(
               reject: (error) => resume(Effect40.fail(error))
             };
             Effect40.runSync(Ref14.set(pendingPlanListRef, pending));
-            ws.send(JSON.stringify({ type: "plan:list", payload: { target_portal: portalId, ...status && { status } } }));
+            try {
+              ws.send(JSON.stringify({ type: "plan:list", payload: { target_portal: portalId, ...status && { status } } }));
+            } catch (err) {
+              Effect40.runSync(Ref14.set(pendingPlanListRef, null));
+              resume(Effect40.fail(new WebSocketError({ url: WS_URL, cause: err })));
+            }
           })
         ),
         Effect40.timeoutFail({
@@ -13326,16 +13423,36 @@ var buildDispatcher = (handlers) => {
     return h;
   };
   const validateOperation2 = (op, index) => getHandler(op.type).validate(op, index);
-  const validateOperationEffectful2 = (op, index) => getHandler(op.type).validateEffectful(op, index);
-  const preCheckOperation2 = (op, index) => getHandler(op.type).preCheck(op, index);
-  const executeOperation2 = (op, index) => getHandler(op.type).execute(op, index);
-  const postCheckOperation2 = (op, index, result) => getHandler(op.type).postCheck(op, index, result);
+  const getHandlerSafe = (type, index) => {
+    const h = map.get(type);
+    return h ? Effect96.succeed(h) : Effect96.fail([{ severity: "error", operation_index: index, code: "UNKNOWN_OPERATION_TYPE", message: `No handler registered for operation type: ${type}` }]);
+  };
+  const validateOperationEffectful2 = (op, index) => pipe83(
+    getHandlerSafe(op.type, index),
+    Effect96.flatMap((h) => h.validateEffectful(op, index)),
+    Effect96.catchAll((issues) => Effect96.succeed(issues))
+  );
+  const preCheckOperation2 = (op, index) => pipe83(
+    getHandlerSafe(op.type, index),
+    Effect96.flatMap((h) => h.preCheck(op, index)),
+    Effect96.catchAll((issues) => Effect96.succeed(issues))
+  );
+  const executeOperation2 = (op, index) => pipe83(
+    getHandlerSafe(op.type, index),
+    Effect96.flatMap((h) => h.execute(op, index)),
+    Effect96.catchAll(() => Effect96.succeed({ index, type: op.type, status: "failed", records_affected: 0, error: `No handler registered for operation type: ${op.type}` }))
+  );
+  const postCheckOperation2 = (op, index, result) => pipe83(
+    getHandlerSafe(op.type, index),
+    Effect96.flatMap((h) => h.postCheck(op, index, result)),
+    Effect96.catchAll((issues) => Effect96.succeed(issues))
+  );
   const validatePlan2 = (operations) => operations.flatMap((op, i) => validateOperation2(op, i));
   const validatePlanEffectful2 = (operations) => pipe83(
     Effect96.forEach(
       operations,
       (op, i) => validateOperationEffectful2(op, i),
-      { concurrency: 3 }
+      { concurrency: 5 }
     ),
     Effect96.map((results) => results.flat())
   );
@@ -13343,7 +13460,7 @@ var buildDispatcher = (handlers) => {
     Effect96.forEach(
       operations,
       (op, i) => preCheckOperation2(op, i),
-      { concurrency: 3 }
+      { concurrency: 5 }
     ),
     Effect96.map((results) => results.flat())
   );
@@ -14300,7 +14417,7 @@ No plans found${filterMsg}.` }]
 }
 
 // src/pure/plugin-sync-gate.ts
-var PLUGIN_SYNC_DEBOUNCE_MS = 1 * 60 * 1e3;
+var PLUGIN_SYNC_DEBOUNCE_MS = 10 * 60 * 1e3;
 var LAST_PLUGIN_SYNC_ALL_KEY = "last_plugin_sync_all";
 var shouldRunPluginSync = (lastSyncAllRaw) => {
   if (!lastSyncAllRaw) return true;
@@ -14439,6 +14556,12 @@ var makeEnsureFresh = (deps, options2) => createEnsureFresh(
 );
 
 // src/index.ts
+process.on("uncaughtException", (err) => {
+  console.error("[fatal:uncaughtException]", err);
+});
+process.on("unhandledRejection", (reason) => {
+  console.error("[fatal:unhandledRejection]", reason);
+});
 var server = new McpServer({
   name: "mcp-pro-client",
   version: "1.0.0"

package/dist/supervisor.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/supervisor.ts
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+var RESTART_DELAY_MS = 500;
+var MAX_RESTART_COUNT = 10;
+var RESTART_WINDOW_MS = 6e4;
+var isRequest = (msg) => "method" in msg && "id" in msg;
+var isResponse = (msg) => "id" in msg && !("method" in msg);
+var isNotification = (msg) => "method" in msg && !("id" in msg);
+var serialize = (msg) => JSON.stringify(msg) + "\n";
+var makeErrorResponse = (id, message) => ({
+  jsonrpc: "2.0",
+  id,
+  error: { code: -32603, message }
+});
+var LineBuffer = class {
+  buf = "";
+  push(chunk) {
+    this.buf += chunk;
+    const messages = [];
+    let idx;
+    while ((idx = this.buf.indexOf("\n")) !== -1) {
+      const line = this.buf.slice(0, idx).replace(/\r$/, "");
+      this.buf = this.buf.slice(idx + 1);
+      if (line.length === 0) continue;
+      try {
+        messages.push(JSON.parse(line));
+      } catch {
+        process.stderr.write(`[supervisor] Failed to parse JSON-RPC line: ${line.slice(0, 200)}
+`);
+      }
+    }
+    return messages;
+  }
+  clear() {
+    this.buf = "";
+  }
+};
+var selfDir = dirname(fileURLToPath(import.meta.url));
+var childScript = resolve(selfDir, "index.js");
+var child = null;
+var pendingRequests = /* @__PURE__ */ new Map();
+var savedInitializeRequest = null;
+var childReady = false;
+var restarting = false;
+var stdinBuffer = [];
+var recentRestarts = [];
+var childStdoutBuf = new LineBuffer();
+var stdinBuf = new LineBuffer();
+process.stdin.setEncoding("utf-8");
+process.stdin.on("data", (chunk) => {
+  const messages = stdinBuf.push(chunk);
+  for (const msg of messages) {
+    handleUpstreamMessage(msg);
+  }
+});
+function handleUpstreamMessage(msg) {
+  if (isRequest(msg)) {
+    if (msg.method === "initialize") {
+      savedInitializeRequest = msg;
+    }
+    pendingRequests.set(msg.id, msg);
+  }
+  if (!childReady || !child) {
+    stdinBuffer.push(msg);
+    return;
+  }
+  forwardToChild(msg);
+}
+function forwardToChild(msg) {
+  try {
+    child?.stdin?.write(serialize(msg));
+  } catch {
+    process.stderr.write("[supervisor] Failed to write to child stdin\n");
+  }
+}
+function handleChildStdout(chunk) {
+  const messages = childStdoutBuf.push(chunk);
+  for (const msg of messages) {
+    handleDownstreamMessage(msg);
+  }
+}
+function handleDownstreamMessage(msg) {
+  if (isResponse(msg)) {
+    pendingRequests.delete(msg.id);
+    if (restarting && savedInitializeRequest && msg.id === savedInitializeRequest.id) {
+      process.stderr.write("[supervisor] Swallowed re-initialize response from child\n");
+      finishRestart();
+      return;
+    }
+  }
+  forwardToCodex(msg);
+}
+function forwardToCodex(msg) {
+  try {
+    process.stdout.write(serialize(msg));
+  } catch {
+    process.stderr.write("[supervisor] Failed to write to stdout (Codex pipe broken)\n");
+    process.exit(1);
+  }
+}
+function spawnChild() {
+  const now = Date.now();
+  recentRestarts.push(now);
+  while (recentRestarts.length > 0 && now - recentRestarts[0] > RESTART_WINDOW_MS) {
+    recentRestarts.shift();
+  }
+  if (recentRestarts.length > MAX_RESTART_COUNT) {
+    process.stderr.write(
+      `[supervisor] Too many restarts (${recentRestarts.length} in ${RESTART_WINDOW_MS / 1e3}s) \u2014 exiting
+`
+    );
+    process.exit(1);
+  }
+  process.stderr.write(`[supervisor] Spawning MCP client: ${childScript}
+`);
+  child = spawn(process.execPath, [childScript], {
+    stdio: ["pipe", "pipe", "inherit"],
+    env: process.env
+  });
+  child.stdout.setEncoding("utf-8");
+  child.stdout.on("data", handleChildStdout);
+  child.on("exit", (code, signal) => {
+    process.stderr.write(
+      `[supervisor] Child exited: code=${code} signal=${signal ?? "none"}
+`
+    );
+    child = null;
+    childReady = false;
+    childStdoutBuf.clear();
+    handleChildExit();
+  });
+  child.on("error", (err) => {
+    process.stderr.write(`[supervisor] Child error: ${err.message}
+`);
+  });
+}
+function handleChildExit() {
+  failPendingRequests("MCP server restarted \u2014 please retry this request");
+  setTimeout(() => {
+    process.stderr.write("[supervisor] Restarting child...\n");
+    spawnChild();
+    if (savedInitializeRequest) {
+      restarting = true;
+      forwardToChild({ ...savedInitializeRequest });
+    } else {
+      childReady = true;
+      restarting = false;
+      drainStdinBuffer();
+    }
+  }, RESTART_DELAY_MS);
+}
+function finishRestart() {
+  if (savedInitializeRequest) {
+    const initialized = {
+      jsonrpc: "2.0",
+      method: "notifications/initialized"
+    };
+    forwardToChild(initialized);
+  }
+  childReady = true;
+  restarting = false;
+  process.stderr.write("[supervisor] Child re-initialized \u2014 resuming proxy\n");
+  drainStdinBuffer();
+}
+function drainStdinBuffer() {
+  const buffered = stdinBuffer;
+  stdinBuffer = [];
+  for (const msg of buffered) {
+    if (isRequest(msg) && msg.method === "initialize") continue;
+    if (isNotification(msg) && msg.method === "notifications/initialized") continue;
+    forwardToChild(msg);
+  }
+}
+function failPendingRequests(message) {
+  for (const [id] of pendingRequests) {
+    forwardToCodex(makeErrorResponse(id, message));
+  }
+  pendingRequests.clear();
+}
+process.stderr.write("[supervisor] Starting MCP supervisor\n");
+spawnChild();
+childReady = true;
+process.on("SIGINT", () => {
+  child?.kill("SIGINT");
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  child?.kill("SIGTERM");
+  process.exit(0);
+});

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@daeda/mcp-pro",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "MCP server for HubSpot CRM — sync, query, and manage your portal data",
   "type": "module",
   "bin": {
-    "mcp-pro": "dist/index.js"
+    "mcp-pro": "dist/index.js",
+    "mcp-pro-supervised": "dist/supervisor.js"
   },
   "main": "./dist/index.js",
   "exports": {