Release v0.0.2

Author: ckanthony

README.md

@@ -9,7 +9,7 @@
 
 **Generate MCP tool definitions directly from a Swagger/OpenAPI specification file.**
 
-OpenAPI-MCP is a library and command-line tool that reads a `swagger.json` or `openapi.yaml` file and generates a corresponding [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) toolset. This allows MCP-compatible clients like [Cursor](https://cursor.sh/) to interact with APIs described by standard OpenAPI specifications.
+OpenAPI-MCP is a dockerized MCP server that reads a `swagger.json` or `openapi.yaml` file and generates a corresponding [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) toolset. This allows MCP-compatible clients like [Cursor](https://cursor.sh/) to interact with APIs described by standard OpenAPI specifications. Now you can enable your AI agent to access any API by simply providing its OpenAPI/Swagger specification - no additional coding required.
 
 ## Table of Contents
 
@@ -22,22 +22,26 @@ OpenAPI-MCP is a library and command-line tool that reads a `swagger.json` or `o
 -   [Command-Line Options](#command-line-options)
     -   [Environment Variables](#environment-variables)
 
+## Demo
+
+Run the demo yourself: [Running the Weatherbit Example (Step-by-Step)](#running-the-weatherbit-example-step-by-step)
+
 ## Why OpenAPI-MCP?
 
 -   **Standard Compliance:** Leverage your existing OpenAPI/Swagger documentation.
 -   **Automatic Tool Generation:** Create MCP tools without manual configuration for each endpoint.
 -   **Flexible API Key Handling:** Securely manage API key authentication for the proxied API without exposing keys to the MCP client.
 -   **Local & Remote Specs:** Works with local specification files or remote URLs.
--   **Command-Line Tool:** Easily integrate MCP generation into build or deployment scripts.
+-   **Dockerized Tool:** Easily deploy and run as a containerized service with Docker.
 
 ## Features
 
 -   **OpenAPI v2 (Swagger) & v3 Support:** Parses standard specification formats.
 -   **Schema Generation:** Creates MCP tool schemas from OpenAPI operation parameters and request/response definitions.
 -   **Secure API Key Management:**
--   Injects API keys into requests (`header`, `query`, `path`, `cookie`) based on command-line configuration.
-    -   Loads API keys directly from flags (`--api-key`), environment variables (`--api-key-env`), or `.env` files located alongside local specs.
-    -   Keeps API keys hidden from the end MCP client (e.g., the AI assistant).
+    -   Injects API keys into requests (`header`, `query`, `path`, `cookie`) based on command-line configuration.
+        -   Loads API keys directly from flags (`--api-key`), environment variables (`--api-key-env`), or `.env` files located alongside local specs.
+        -   Keeps API keys hidden from the end MCP client (e.g., the AI assistant).
 -   **Server URL Detection:** Uses server URLs from the spec as the base for tool interactions (can be overridden).
 -   **Filtering:** Options to include/exclude specific operations or tags (`--include-tag`, `--exclude-tag`, `--include-op`, `--exclude-op`).
 -   **Request Header Injection:** Pass custom headers (e.g., for additional auth, tracing) via the `REQUEST_HEADERS` environment variable.

example/agent_demo.png

@@ -2,13 +2,15 @@ package server
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
 	"log"
 	"net/http"
 	"net/http/httptest"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 
@@ -357,6 +359,10 @@ func TestHttpMethodPostHandler(t *testing.T) {
 }
 
 func TestHttpMethodGetHandler(t *testing.T) {
+	// Basic setup
+	// cfg := &config.Config{} // Use random port - Removed Port field - Removed unused variable
+	// Setup(cfg, nil)                // No toolset needed for GET handler base functionality - Removed Setup call
+
 	// --- Test Setup ---
 	req := httptest.NewRequest(http.MethodGet, "/mcp", nil)
 	rr := httptest.NewRecorder() // Use ResponseRecorder directly for header checks
@@ -373,63 +379,84 @@ func TestHttpMethodGetHandler(t *testing.T) {
 	// Restore original connections after test
 	defer func() {
 		connMutex.Lock()
-		activeConnections = originalConnections
+		// Clean up any connection potentially added by the test run
+		// (Find the ID from the recorder if available)
+		connID := rr.Header().Get("X-Connection-ID") // Get ID written by handler
+		if connID != "" {
+			if ch, exists := activeConnections[connID]; exists {
+				close(ch) // Close the channel if it exists
+			}
+		}
+		activeConnections = originalConnections // Restore the original map
 		connMutex.Unlock()
 	}()
 
 	// --- Execute Handler (in a goroutine as it blocks waiting for context) ---
-	done := make(chan struct{})
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel() // Ensure the handler goroutine can eventually exit
+	req = req.WithContext(ctx)
+
+	hwg := sync.WaitGroup{}
+	hwg.Add(1)
 	go func() {
-		defer close(done)
+		defer hwg.Done()
 		httpMethodGetHandler(rr, req)
 	}()
 
 	// --- Assertions ---
+	var connID string
 
-	// Wait briefly for headers and initial events to be written
-	// This is tricky because the handler blocks. We might only be able to check headers reliably.
-	// Reading the body/events might require a more sophisticated setup or ending the request.
+	// Wait for the handler to write headers, initial body, and register the connection.
+	// Use Eventually to poll for multiple conditions to be met atomically before proceeding.
+	assert.Eventually(t, func() bool {
+		if rr.Code != http.StatusOK {
+			return false // Wait for status OK first
+		}
 
-	// Check Headers (before handler potentially blocks indefinitely)
-	// It seems ResponseRecorder might not capture headers written before blocking?
-	// Let's try checking status code first, which is written before blocking starts.
+		// Check headers are set correctly
+		if rr.Header().Get("Content-Type") != "text/event-stream" ||
+			rr.Header().Get("Cache-Control") != "no-cache" ||
+			rr.Header().Get("Connection") != "keep-alive" {
+			return false
+		}
+		connID = rr.Header().Get("X-Connection-ID")
+		if connID == "" {
+			return false // Wait for connection ID header
+		}
 
-	// Poll for the status code to be written (indicates headers are likely set)
-	assert.Eventually(t, func() bool {
-		return rr.Code == http.StatusOK
-	}, 100*time.Millisecond, 10*time.Millisecond, "Handler did not write StatusOK")
-
-	// If status is OK, check headers
-	if rr.Code == http.StatusOK {
-		assert.Equal(t, "text/event-stream", rr.Header().Get("Content-Type"))
-		assert.Equal(t, "no-cache", rr.Header().Get("Cache-Control"))
-		assert.Equal(t, "keep-alive", rr.Header().Get("Connection"))
-		connID := rr.Header().Get("X-Connection-ID")
-		assert.NotEmpty(t, connID, "X-Connection-ID header should be set")
-
-		// Check if connection was added to the map
+		// Check connection is registered in the map
 		connMutex.RLock()
 		_, exists := activeConnections[connID]
 		connMutex.RUnlock()
-		assert.True(t, exists, "Connection ID should be added to activeConnections map")
-
-		// Check body for initial events (might be flaky due to goroutine/blocking)
-		// Read the body content written so far
-		bodyContent := rr.Body.String()
-		assert.Contains(t, bodyContent, ":ok\n\n", "SSE stream should contain :ok preamble")
-		assert.Contains(t, bodyContent, "event: endpoint\ndata: /mcp?sessionId="+connID+"\n\n", "SSE stream should contain endpoint event")
-		assert.Contains(t, bodyContent, "event: message\ndata: {", "SSE stream should contain message event start")
-		assert.Contains(t, bodyContent, "\"method\":\"mcp-ready\"", "SSE stream should contain mcp-ready message")
-		assert.Contains(t, bodyContent, "\"connectionId\":\""+connID+"\"", "mcp-ready message should contain correct connectionId")
-
-		// Clean up the connection we added
-		cleanupTestConnection(connID)
-	} else {
-		t.Logf("Handler did not return StatusOK, headers might not be set. Code: %d", rr.Code)
-	}
+		if !exists {
+			return false // Wait for connection ID in map
+		}
 
-	// We cannot easily wait for `done` because the handler blocks indefinitely.
-	// For coverage, triggering the initial part is the main goal here.
+		// Check initial body content is present
+		bodyContent := rr.Body.String() // Read body within the check
+		if !strings.Contains(bodyContent, ":ok\n\n") ||
+			!strings.Contains(bodyContent, "event: endpoint\ndata: /mcp?sessionId="+connID+"\n\n") ||
+			!strings.Contains(bodyContent, "event: mcp-ready\ndata: {") || // Check start of ready event
+			!strings.Contains(bodyContent, `"connectionId":"`+connID+`"}`) { // Check connection ID within ready event
+			return false
+		}
+
+		return true // All initial conditions met
+	}, 5*time.Second, 50*time.Millisecond, "Handler did not initialize SSE stream correctly within timeout") // Increased timeout slightly
+
+	// If Eventually succeeded, all initial checks passed without races.
+	// connID will be set based on the header read within the successful Eventually tick.
+
+	// No need to call cleanupTestConnection(connID) explicitly here.
+	// The deferred function above will handle closing the channel and resetting the map.
+
+	// Cancel context to allow handler goroutine to exit cleanly
+	cancel()
+
+	// Wait for the handler goroutine to finish (optional but good practice for cleanup)
+	if !waitTimeout(&hwg, 1*time.Second) {
+		t.Error("Handler goroutine did not exit cleanly after context cancellation")
+	}
 }
 
 func TestExecuteToolCall(t *testing.T) {
@@ -1046,3 +1073,18 @@ func TestHttpMethodGetHandler_GoroutineErrors(t *testing.T) {
 
 	// TODO: Add sub-test for Error_on_Ping_Write
 }
+
+// Helper function to wait for a WaitGroup with a timeout
+func waitTimeout(wg *sync.WaitGroup, timeout time.Duration) bool {
+	c := make(chan struct{})
+	go func() {
+		defer close(c)
+		wg.Wait()
+	}()
+	select {
+	case <-c:
+		return true // Completed normally
+	case <-time.After(timeout):
+		return false // Timed out
+	}
+}