@abraca/mcp 2.10.0 → 2.11.0

package/dist/index.d.ts

@@ -43,6 +43,8 @@ declare class AbracadabraMCPServer {
   /** Rolling buffer of the last N tool calls in the current turn, surfaced via awareness. */
   private _toolHistory;
   private static readonly TOOL_HISTORY_MAX;
+  /** De-dupes concurrent connection heals across parallel tool calls. */
+  private _reconnecting;
   private _inboxStarted;
   private _inboxDocId;
   private _inboxDoc;
@@ -102,6 +104,19 @@ declare class AbracadabraMCPServer {
    * child-content provider cache survives — content docs are keyed by global
    * guid, independent of which space is active.
    */
+  /**
+   * Heal the active connection before a tool op so a dropped/idle WebSocket or
+   * an expired JWT doesn't surface as a 15s sync timeout ("MCP not responding").
+   * Refreshes the token, lets the SDK's own auto-reconnect finish if it's mid-
+   * flight, and rebuilds the space connection from scratch if the socket is
+   * truly dead. De-duped so parallel tool calls heal once. Best-effort: never
+   * throws — a failed heal falls through to the normal (possibly erroring) op.
+   */
+  /** Whether a provider's shared WebSocket is currently connected. Isolated in
+   *  its own scope so repeated checks don't trip TS control-flow narrowing on
+   *  the live `connectionStatus` getter. */
+  private _wsConnected;
+  ensureConnected(): Promise<void>;
   ensureSpaceActive(targetId: string | null | undefined): Promise<boolean>;
   /** Get the root doc-tree Y.Map of the active space. */
   getTreeMap(): Y.Map<any> | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abraca/mcp",
-  "version": "2.10.0",
+  "version": "2.11.0",
   "description": "MCP server for Abracadabra — AI agent collaboration on CRDT documents",
   "license": "MIT",
   "type": "module",
@@ -36,7 +36,7 @@
     "y-protocols": "^1.0.6",
     "yjs": "^13.6.8",
     "zod": "^4.3.6",
-    "@abraca/convert": "2.10.0"
+    "@abraca/convert": "2.11.0"
   },
   "scripts": {
     "test": "node --no-warnings --conditions=source --experimental-transform-types --test 'tests/*.test.ts'"

package/src/server.ts

@@ -15,6 +15,7 @@ import {
 	Kind,
 	recordFromYAny,
 	SERVER_ROOT_ID,
+	WebSocketStatus,
 } from "@abraca/dabra";
 import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -99,6 +100,8 @@ export class AbracadabraMCPServer {
 	// `messages:new_message` stateless broadcast only reaches subscribers of the
 	// channel/DM doc, and the agent never subscribes to DM docs. So we observe
 	// the inbox's `entries` Y.Array and dispatch from there.
+	/** De-dupes concurrent connection heals across parallel tool calls. */
+	private _reconnecting: Promise<void> | null = null;
 	private _inboxStarted = false;
 	private _inboxDocId: string | null = null;
 	private _inboxDoc: Y.Doc | null = null;
@@ -335,9 +338,88 @@ export class AbracadabraMCPServer {
 	 * child-content provider cache survives — content docs are keyed by global
 	 * guid, independent of which space is active.
 	 */
+	/**
+	 * Heal the active connection before a tool op so a dropped/idle WebSocket or
+	 * an expired JWT doesn't surface as a 15s sync timeout ("MCP not responding").
+	 * Refreshes the token, lets the SDK's own auto-reconnect finish if it's mid-
+	 * flight, and rebuilds the space connection from scratch if the socket is
+	 * truly dead. De-duped so parallel tool calls heal once. Best-effort: never
+	 * throws — a failed heal falls through to the normal (possibly erroring) op.
+	 */
+	/** Whether a provider's shared WebSocket is currently connected. Isolated in
+	 *  its own scope so repeated checks don't trip TS control-flow narrowing on
+	 *  the live `connectionStatus` getter. */
+	private _wsConnected(provider: AbracadabraProvider): boolean {
+		return provider.connectionStatus === WebSocketStatus.Connected;
+	}
+
+	async ensureConnected(): Promise<void> {
+		if (this._reconnecting) return this._reconnecting;
+		this._reconnecting = (async () => {
+			try {
+				// 1) Refresh the JWT proactively so a reconnect doesn't retry with a
+				//    stale token (which the server rejects, stopping the WS retry loop).
+				if (!this.client.isTokenValid() && this._signFn && this._userId) {
+					try {
+						await this.client.loginWithKey(this._userId, this._signFn);
+					} catch (e) {
+						console.error("[abracadabra-mcp] Re-auth during heal failed:", e);
+					}
+				}
+
+				const conn = this._activeConnection;
+				if (!conn) return; // cold start — connect() handles it
+				if (this._wsConnected(conn.provider)) return;
+
+				// 2) Socket is Connecting/Disconnected — give the SDK's own reconnect a
+				//    bounded window to come back before we tear anything down.
+				try {
+					await waitForSync(conn.provider, 6000);
+				} catch {
+					/* fell through to rebuild */
+				}
+				// connectionStatus is a live getter — re-check via the helper (fresh
+				// scope) since the WS may have come back during the wait.
+				if (this._wsConnected(conn.provider)) return;
+
+				// 3) Still dead → rebuild the active space from scratch. A fresh
+				//    provider re-auths and reconnects cleanly; cached child providers
+				//    rode the old (now-destroyed) socket, so drop them too.
+				console.error(
+					"[abracadabra-mcp] Active connection dead — rebuilding space provider…",
+				);
+				const docId = conn.docId;
+				this._spaceConnections.delete(docId);
+				try {
+					conn.provider.destroy();
+				} catch {
+					/* already gone */
+				}
+				for (const [, cached] of this.childCache) {
+					try {
+						cached.provider.destroy();
+					} catch {
+						/* already gone */
+					}
+				}
+				this.childCache.clear();
+				try {
+					await this._connectToSpace(docId);
+					console.error("[abracadabra-mcp] Space provider rebuilt + synced");
+				} catch (e) {
+					console.error("[abracadabra-mcp] Connection rebuild failed:", e);
+				}
+			} finally {
+				this._reconnecting = null;
+			}
+		})();
+		return this._reconnecting;
+	}
+
 	async ensureSpaceActive(
 		targetId: string | null | undefined,
 	): Promise<boolean> {
+		await this.ensureConnected();
 		if (!targetId || targetId === this._rootDocId) return true;
 
 		// A top-level Space id — activate it directly (handles the common
@@ -411,11 +493,25 @@ export class AbracadabraMCPServer {
 	 * Caches providers and waits for sync before returning.
 	 */
 	async getChildProvider(docId: string): Promise<AbracadabraProvider> {
+		// Heal a dropped socket / stale JWT first; this may rebuild the active
+		// provider (and clear the child cache), so run it before the cache check.
+		await this.ensureConnected();
+
 		const cached = this.childCache.get(docId);
-		if (cached) {
+		if (cached && cached.provider.connectionStatus !== WebSocketStatus.Disconnected) {
 			cached.lastAccessed = Date.now();
 			return cached.provider;
 		}
+		if (cached) {
+			// Cached provider rode a socket that's since dropped — discard and reload
+			// so we never hand back a dead provider that times out on every op.
+			try {
+				cached.provider.destroy();
+			} catch {
+				/* already gone */
+			}
+			this.childCache.delete(docId);
+		}
 
 		const activeProvider = this._activeConnection?.provider;
 		if (!activeProvider) {