chainlesschain 0.165.4 → 0.165.6

package/src/harness/mcp-client.js

@@ -45,6 +45,11 @@ import {
   prepareMcpStdioExecutableIdentity,
 } from "../lib/mcp-stdio-executable-identity.js";
 import { resolveMcpStdioSandboxContext } from "../lib/mcp-stdio-workspace-authority.js";
+import {
+  closeMcpTlsDispatcher,
+  createMcpTlsDispatcher,
+  loadMcpTlsMaterial,
+} from "../lib/mcp-tls.js";
 
 /**
  * Injectable dependencies — overridable from tests.
@@ -63,6 +68,9 @@ export const _deps = {
   verifyMcpStdioApprovedWorkingDirectory,
   prepareMcpStdioExecutableIdentity,
   resolveMcpStdioSandboxContext,
+  loadMcpTlsMaterial,
+  createMcpTlsDispatcher,
+  closeMcpTlsDispatcher,
   // Backoff sleep seam (tests override with a no-op so retries don't wait).
   sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
 };
@@ -230,6 +238,24 @@ const MCP_HTTP_RESPONSE_MAX_BYTES = 16 * 1024 * 1024;
  */
 const STDIO_REQUEST_TIMEOUT_MS = 30000;
 const MCP_PROTOCOL_VERSION = "2025-11-25";
+export const SUPPORTED_MCP_PROTOCOL_VERSIONS = Object.freeze([
+  "2024-11-05",
+  "2025-03-26",
+  "2025-06-18",
+  MCP_PROTOCOL_VERSION,
+]);
+const supportedMcpProtocolVersions = new Set(SUPPORTED_MCP_PROTOCOL_VERSIONS);
+
+export function assertSupportedMcpProtocolVersion(value) {
+  if (typeof value !== "string" || !supportedMcpProtocolVersions.has(value)) {
+    const error = new Error(
+      "MCP server selected an unsupported protocol version",
+    );
+    error.code = "CC_MCP_PROTOCOL_VERSION_UNSUPPORTED";
+    throw error;
+  }
+  return value;
+}
 const URL_ELICITATION_REQUIRED = -32042;
 const MCP_RPC_ERROR_CODE = "CC_MCP_RPC_ERROR";
 const mcpRpcControlData = new WeakMap();
@@ -1287,6 +1313,10 @@ export class MCPClient extends EventEmitter {
     this._nextId = 1;
     this._reconnectors = new Map(); // name → async () => config|null
     this._reconnecting = new Map(); // name → in-flight reconnect promise
+    // Desired resource subscriptions outlive a single transport entry. Keeping
+    // them on the client lets a later reconnect retry restoration even when a
+    // previous partial reconnect was torn down fail-closed.
+    this._resourceSubscriptions = new Map(); // name → Set<uri>
     this._sessionId =
       options && options.sessionId != null ? String(options.sessionId) : null;
     this._workspaceBinding =
@@ -2082,6 +2112,17 @@ export class MCPClient extends EventEmitter {
         };
       }
     }
+    let tlsMaterial = null;
+    if (sourceConfig.tls != null) {
+      if (transportKind !== "https" && transportKind !== "wss") {
+        throw mcpTransportError(
+          "CC_MCP_TLS_TRANSPORT_REQUIRED",
+          `MCP TLS configuration requires https or wss (server "${name}")`,
+          { transport: transportKind, url: sourceConfig.url },
+        );
+      }
+      tlsMaterial = _deps.loadMcpTlsMaterial(sourceConfig.tls);
+    }
     const connectionHeaders = await this._connectionHeaders(
       name,
       sourceConfig,
@@ -2104,6 +2145,8 @@ export class MCPClient extends EventEmitter {
       _httpRequestControllers: new Set(),
       _httpDiscardControllers: new Set(),
       _httpDiscardStopping: false,
+      _httpDispatcher: null,
+      _tlsIdentityDigest: tlsMaterial?.identityDigest || null,
       _disconnectPromise: null,
       _webSocketPayloadError: null,
       _webSocketInboundError: null,
@@ -2157,6 +2200,9 @@ export class MCPClient extends EventEmitter {
         }
         entry.httpUrl = config.url;
         entry.httpHeaders = connectionHeaders;
+        entry._httpDispatcher = tlsMaterial
+          ? _deps.createMcpTlsDispatcher(tlsMaterial)
+          : null;
       } else if (isWebSocketTransport(transportKind)) {
         if (!config.url) {
           throw mcpTransportError(
@@ -2203,6 +2249,7 @@ export class MCPClient extends EventEmitter {
           ...(transportKind === "wss" && config.rejectUnauthorized === false
             ? { rejectUnauthorized: false }
             : {}),
+          ...(tlsMaterial?.connectOptions || {}),
         });
         entry.socket = socket;
 
@@ -2680,8 +2727,8 @@ export class MCPClient extends EventEmitter {
         clientInfo: { name: "chainlesschain-cli", version: "0.37.9" },
       });
 
-      entry.protocolVersion = String(
-        initResult?.protocolVersion || this._protocolVersion,
+      entry.protocolVersion = assertSupportedMcpProtocolVersion(
+        initResult?.protocolVersion,
       );
       // Send initialized notification
       this._sendNotification(name, "notifications/initialized", {});
@@ -2831,6 +2878,12 @@ export class MCPClient extends EventEmitter {
           // teardown is best-effort
         }
       }
+      try {
+        await _deps.closeMcpTlsDispatcher(entry._httpDispatcher);
+      } catch {
+        // Preserve the connection failure; dispatcher cleanup is best-effort.
+      }
+      entry._httpDispatcher = null;
       this._releaseToolInventory(entry);
       this.servers.delete(name);
       if (
@@ -2850,7 +2903,10 @@ export class MCPClient extends EventEmitter {
   /**
    * Disconnect from an MCP server.
    */
-  disconnect(name) {
+  disconnect(name, options = {}) {
+    if (options.preserveResourceSubscriptions !== true) {
+      this._resourceSubscriptions.delete(name);
+    }
     const entry = this.servers.get(name);
     if (!entry) {
       this._cancelServerElicitations(name);
@@ -2906,6 +2962,12 @@ export class MCPClient extends EventEmitter {
         }
         return true;
       } finally {
+        try {
+          await _deps.closeMcpTlsDispatcher(entry._httpDispatcher);
+        } catch {
+          // Transport teardown remains best-effort.
+        }
+        entry._httpDispatcher = null;
         entry.state = ServerState.DISCONNECTED;
         this._releaseToolInventory(entry);
         // A future connection may reuse the same name. Never let a delayed
@@ -2928,8 +2990,15 @@ export class MCPClient extends EventEmitter {
    */
   async disconnectAll() {
     const names = [...this.servers.keys()];
-    for (const name of names) {
-      await this.disconnect(name);
+    try {
+      for (const name of names) {
+        await this.disconnect(name);
+      }
+    } finally {
+      // A failed reconnect may have already removed its transport entry while
+      // retaining desired subscriptions for another retry. disconnectAll()
+      // is the explicit terminal teardown and must clear those tombstones too.
+      this._resourceSubscriptions.clear();
     }
   }
 
@@ -3173,11 +3242,22 @@ export class MCPClient extends EventEmitter {
       try {
         const currentEntry = this.servers.get(name) || null;
         const currentConfig = currentEntry?.config || null;
+        // Resource subscriptions belong to the logical client/server
+        // relationship, not to one transport connection. Snapshot them before
+        // disconnect() removes the old entry so a hot reconnect cannot
+        // silently stop delivering resource update notifications.
+        const resourceSubscriptions = new Set([
+          ...(this._resourceSubscriptions.get(name) || []),
+          ...(currentEntry?.resourceSubscriptions || []),
+        ]);
+        if (resourceSubscriptions.size > 0) {
+          this._resourceSubscriptions.set(name, new Set(resourceSubscriptions));
+        }
         const resolver = this._reconnectors.get(name);
         const fresh = resolver ? await resolver() : currentConfig;
         if (!fresh) return false;
         try {
-          await this.disconnect(name);
+          await this.disconnect(name, { preserveResourceSubscriptions: true });
         } catch {
           // entry may already be gone — connect() below is what matters
         }
@@ -3195,6 +3275,25 @@ export class MCPClient extends EventEmitter {
           reconnectConfig,
           options.connectAuthRetryUsed === true,
         );
+        try {
+          for (const uri of resourceSubscriptions) {
+            await this.subscribeResource(name, uri);
+          }
+        } catch {
+          // A partially restored connection is unsafe: callers would believe
+          // the reconnect recovered their live subscriptions while some were
+          // already lost. Tear it down and let the original operation surface
+          // its connection error.
+          try {
+            await this.disconnect(name, {
+              preserveResourceSubscriptions: true,
+            });
+          } catch {
+            // The outer reconnect result remains fail-closed even if cleanup
+            // itself reports an error.
+          }
+          return false;
+        }
         this.emit("server-reconnected", { name, url: fresh.url || null });
         return true;
       } catch {
@@ -3269,9 +3368,23 @@ export class MCPClient extends EventEmitter {
   async subscribeResource(serverName, uri) {
     const entry = this.servers.get(serverName);
     if (!entry) throw new Error(`Server "${serverName}" not found`);
-    await this._sendRequest(serverName, "resources/subscribe", { uri });
+    if (typeof uri !== "string" || !uri.trim()) {
+      throw new TypeError(
+        "MCP resource subscription URI must be a non-empty string",
+      );
+    }
+    const normalizedUri = uri;
+    await this._sendRequest(serverName, "resources/subscribe", {
+      uri: normalizedUri,
+    });
     entry.resourceSubscriptions ||= new Set();
-    entry.resourceSubscriptions.add(String(uri));
+    entry.resourceSubscriptions.add(normalizedUri);
+    let desired = this._resourceSubscriptions.get(serverName);
+    if (!desired) {
+      desired = new Set();
+      this._resourceSubscriptions.set(serverName, desired);
+    }
+    desired.add(normalizedUri);
     return true;
   }
 
@@ -3279,8 +3392,19 @@ export class MCPClient extends EventEmitter {
   async unsubscribeResource(serverName, uri) {
     const entry = this.servers.get(serverName);
     if (!entry) throw new Error(`Server "${serverName}" not found`);
-    await this._sendRequest(serverName, "resources/unsubscribe", { uri });
-    entry.resourceSubscriptions?.delete(String(uri));
+    if (typeof uri !== "string" || !uri.trim()) {
+      throw new TypeError(
+        "MCP resource subscription URI must be a non-empty string",
+      );
+    }
+    const normalizedUri = uri;
+    await this._sendRequest(serverName, "resources/unsubscribe", {
+      uri: normalizedUri,
+    });
+    entry.resourceSubscriptions?.delete(normalizedUri);
+    const desired = this._resourceSubscriptions.get(serverName);
+    desired?.delete(normalizedUri);
+    if (desired?.size === 0) this._resourceSubscriptions.delete(serverName);
     return true;
   }
 
@@ -3752,6 +3876,9 @@ export class MCPClient extends EventEmitter {
                 ...(stream.controller
                   ? { signal: stream.controller.signal }
                   : {}),
+                ...(entry._httpDispatcher
+                  ? { dispatcher: entry._httpDispatcher }
+                  : {}),
               }),
               stream.controller?.signal,
             );
@@ -3997,6 +4124,9 @@ export class MCPClient extends EventEmitter {
             headers,
             body,
             ...(controller ? { signal: controller.signal } : {}),
+            ...(entry._httpDispatcher
+              ? { dispatcher: entry._httpDispatcher }
+              : {}),
           });
         },
       );
@@ -4729,6 +4859,7 @@ async function _fetchAndDiscardHttpResponse(entry, options) {
     const response = await _deps.fetch(entry.httpUrl, {
       ...options,
       ...(controller ? { signal: controller.signal } : {}),
+      ...(entry._httpDispatcher ? { dispatcher: entry._httpDispatcher } : {}),
     });
     _cancelHttpResponseBody(response);
     if (timedOut) {

package/src/lib/artifact-access-ledger.js

@@ -18,6 +18,7 @@ export const ARTIFACT_ACCESS_CLIENTS = Object.freeze([
   "cli",
   "vscode",
   "jetbrains",
+  "desktop",
   "websocket",
   "web",
 ]);

package/src/lib/artifact-deletion-ledger.js

@@ -21,6 +21,7 @@ export const ARTIFACT_DELETION_CLIENTS = Object.freeze([
   "cli",
   "vscode",
   "jetbrains",
+  "desktop",
   "websocket",
   "system",
 ]);