Checkpoint, works for mac

Author: odrobnik

Tests/SwiftMCPTests/Client/MCPClient.swift

@@ -1,12 +1,6 @@
 import Foundation
 import AnyCodable
 @testable import SwiftMCP
-import Logging
-
-// Configure logging to use stdout
-private let logger = Logger(label: "com.cocoanetics.SwiftMCP.MCPClient") { label in
-    StreamLogHandler.standardOutput(label: label)
-}
 
 /// A client for communicating with an MCP server over HTTP+SSE
 public actor MCPClient {
@@ -20,21 +14,19 @@ public actor MCPClient {
     /// - Parameter endpointURL: The URL of the SSE endpoint (e.g. http://localhost:8080/sse)
     public init(endpointURL: URL) {
         self.endpointURL = endpointURL
-        logger.info("Initialized MCPClient with endpoint: \(endpointURL)")
     }
 
     /// Connect to the SSE endpoint and establish a connection
     /// - Throws: An error if the connection fails
     public func connect() async throws {
-        logger.info("Connecting to SSE endpoint: \(endpointURL)")
         var request = URLRequest(url: endpointURL)
         request.setValue("text/event-stream", forHTTPHeaderField: "Accept")
+        request.timeoutInterval = 10 // Add a 10 second timeout for the initial connection
 
         let (stream, response) = try await URLSession.shared.bytes(for: request)
         guard let httpResponse = response as? HTTPURLResponse else {
             throw MCPError.invalidResponse
         }
-        logger.info("Connected to SSE endpoint, status: \(httpResponse.statusCode)")
         self.stream = stream
 
         // Create a single message stream for all messages
@@ -47,17 +39,13 @@ public actor MCPClient {
         }
 
         // Wait for the initial message containing the messages endpoint URL
-        logger.info("Waiting for initial message with endpoint URL")
-        let initialMessage = try await nextMessage(timeout: 5)
-        logger.info("Received initial message: \(initialMessage.data)")
+        let initialMessage = try await nextMessage(timeout: 10) // Increase timeout to 10 seconds
 
         guard let messagesURL = URL(string: initialMessage.data),
               messagesURL.path.contains("/messages/") else {
-            logger.error("Invalid messages endpoint URL: \(initialMessage.data)")
             throw MCPError.invalidEndpointURL
         }
         self.messagesURL = messagesURL
-        logger.info("Successfully connected with messages URL: \(messagesURL)")
     }
 
     deinit {
@@ -72,11 +60,9 @@ public actor MCPClient {
     /// - Throws: An error if the request fails or times out
     public func send(_ message: JSONRPCMessage, timeout: TimeInterval = 5) async throws -> JSONRPCMessage {
         guard let messagesURL = messagesURL else {
-            logger.error("Not connected to server")
             throw MCPError.notConnected
         }
 
-        logger.info("Sending JSONRPC message to: \(messagesURL)")
         var request = URLRequest(url: messagesURL)
         request.httpMethod = "POST"
         request.setValue("application/json", forHTTPHeaderField: "Content-Type")
@@ -89,14 +75,11 @@ public actor MCPClient {
 
         guard let httpResponse = response as? HTTPURLResponse,
               httpResponse.statusCode == 202 else {
-            logger.error("Invalid response from server")
             throw MCPError.invalidResponse
         }
 
-        logger.info("Request accepted, waiting for SSE response")
         // Wait for the SSE response
         let responseMessage = try await nextMessage(timeout: timeout)
-        logger.info("Received SSE response")
 
         let jsonData = responseMessage.data.data(using: .utf8)!
         return try JSONDecoder().decode(JSONRPCMessage.self, from: jsonData)
@@ -118,7 +101,6 @@ public actor MCPClient {
     ///   - timeout: Timeout in seconds
     /// - Returns: The next SSE message
     private func nextMessage(from stream: AsyncStream<SSEMessage>, timeout: TimeInterval) async throws -> SSEMessage {
-        logger.info("Waiting for next message with timeout: \(timeout)s")
         return try await withThrowingTaskGroup(of: SSEMessage.self) { group in
             // Task to read the next message from the stream
             group.addTask {
@@ -144,7 +126,6 @@ public actor MCPClient {
 
     private func readMessages(continuation: AsyncStream<SSEMessage>.Continuation) async {
         guard let stream = stream else {
-            logger.error("No stream available, finishing continuation")
             continuation.finish()
             return
         }
@@ -153,12 +134,9 @@ public actor MCPClient {
             var currentEvent: String?
 
             for try await line in stream.lines {
-                logger.info("Received line: \(line)")
-                
                 if line.hasPrefix("data: ") {
                     // Handle data lines immediately
                     let data = String(line.dropFirst(6)) // Remove "data: " prefix
-                    logger.info("Found data line: \(data)")
 
                     // Format the complete SSE message
                     var messageText = ""
@@ -168,10 +146,7 @@ public actor MCPClient {
                     messageText += "data: \(data)\n"
 
                     if let message = SSEMessage(messageText) {
-                        logger.info("Successfully parsed SSE message with data: \(message.data)")
                         continuation.yield(message)
-                    } else {
-                        logger.error("Failed to parse SSE message: \(messageText)")
                     }
 
                     // Reset for next message
@@ -180,17 +155,12 @@ public actor MCPClient {
                     // Handle event lines
                     let event = String(line.dropFirst(7)) // Remove "event: " prefix
                     currentEvent = event
-                    logger.info("Found event line: \(event)")
-                } else if !line.isEmpty {
-                    // Skip non-empty lines that aren't SSE format
-                    logger.info("Skipping line: \(line)")
                 }
             }
         } catch {
-            logger.error("Error reading stream: \(error)")
+            // No logging needed for errors
         }
 
-        logger.info("Stream ended, finishing continuation")
         continuation.finish()
     }
 }