@abraca/mcp 2.10.0 → 2.11.0

package/dist/abracadabra-mcp.cjs

@@ -21477,6 +21477,7 @@ var AbracadabraMCPServer = class AbracadabraMCPServer {
 		this._activeTurnChannel = null;
 		this._signFn = null;
 		this._toolHistory = [];
+		this._reconnecting = null;
 		this._inboxStarted = false;
 		this._inboxDocId = null;
 		this._inboxDoc = null;
@@ -21647,7 +21648,60 @@ var AbracadabraMCPServer = 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. */
+	_wsConnected(provider) {
+		return provider.connectionStatus === _abraca_dabra.WebSocketStatus.Connected;
+	}
+	async ensureConnected() {
+		if (this._reconnecting) return this._reconnecting;
+		this._reconnecting = (async () => {
+			try {
+				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;
+				if (this._wsConnected(conn.provider)) return;
+				try {
+					await waitForSync(conn.provider, 6e3);
+				} catch {}
+				if (this._wsConnected(conn.provider)) return;
+				console.error("[abracadabra-mcp] Active connection dead — rebuilding space provider…");
+				const docId = conn.docId;
+				this._spaceConnections.delete(docId);
+				try {
+					conn.provider.destroy();
+				} catch {}
+				for (const [, cached] of this.childCache) try {
+					cached.provider.destroy();
+				} catch {}
+				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) {
+		await this.ensureConnected();
 		if (!targetId || targetId === this._rootDocId) return true;
 		if (this._spaces.some((s) => s.id === targetId)) {
 			await this._connectToSpace(targetId);
@@ -21704,11 +21758,18 @@ var AbracadabraMCPServer = class AbracadabraMCPServer {
 	* Caches providers and waits for sync before returning.
 	*/
 	async getChildProvider(docId) {
+		await this.ensureConnected();
 		const cached = this.childCache.get(docId);
-		if (cached) {
+		if (cached && cached.provider.connectionStatus !== _abraca_dabra.WebSocketStatus.Disconnected) {
 			cached.lastAccessed = Date.now();
 			return cached.provider;
 		}
+		if (cached) {
+			try {
+				cached.provider.destroy();
+			} catch {}
+			this.childCache.delete(docId);
+		}
 		const activeProvider = this._activeConnection?.provider;
 		if (!activeProvider) throw new Error("Not connected. Call connect() first.");
 		if (!this.client.isTokenValid() && this._signFn && this._userId) {