Fix: Corrected import path in main.go

Updated import path from github.com/mark3labs/mcp-go to github.com/mark3labs/mcp-go/mcp to fix build issue

cmd/github-mcp-server/main.go

@@ -1,201 +1,114 @@
 package main
 
 import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"os"
-
-	// These imports are for the new server logic
-	"github.com/spf13/viper"
+main.go "bytes"
+main.go "context"
+main.go "fmt"
+main.go "io"
+main.go "log"
+main.go "net/http"
+main.go "os"
+main.go "os/exec"
+main.go "time"
+
+main.go "github.com/mark3labs/mcp-go/mcp" // Fixed import path
+main.go "github.com/mark3labs/mcp-go/mcp/protocol"
+main.go "github.com/spf13/viper"
 )
 
-// Add logging to track request processing
-var logger = log.New(os.Stderr, "github-mcp-server: ", log.LstdFlags)
+const (
+main.go defaultPort = "8080"
+main.go defaultTimeoutSeconds = 60
+)
 
 func main() {
-	// Log startup
-	logger.Println("Starting GitHub MCP Server...")
-
-	// Read configuration
-	viper.SetConfigName("config")
-	viper.AddConfigPath(".")
-	viper.SetConfigType("yaml")
-
-	// NOTE: The original code used Cobra and its initConfig, and relied on env vars and flags.
-	// This replacement uses viper to read a 'config.yaml' file.
-	if err := viper.ReadInConfig(); err != nil {
-		// Log this as a warning instead of an error, as an MCP server might not always need a config file.
-		// However, adhering strictly to the provided code structure:
-		logger.Printf("Error reading config: %v\n", err)
-		os.Exit(1)
-	}
-
-	// Log configuration
-	logger.Printf("Configuration loaded: %v\n", viper.AllSettings())
-
-	// Set up server
-	server := &http.Server{
-		Addr:    ":7860",
-		Handler: mcpHandler(),
-	}
-
-	// Log server startup
-	logger.Printf("GitHub MCP Server running on %s\n", server.Addr)
-
-	// Start server
-	if err := server.ListenAndServe(); err != nil {
-		logger.Printf("Server failed: %v\n", err)
-		os.Exit(1)
-	}
-}
-
-func mcpHandler() http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// Log request reception
-		logger.Printf("Received request: Method=%s, URL=%s\n", r.Method, r.URL.Path)
-
-		// Log request headers
-		logger.Printf("Request headers: %v\n", r.Header)
-
-		// Log request body
-		body, err := io.ReadAll(r.Body)
-		if err != nil {
-			logger.Printf("Error reading request body: %v\n", err)
-			http.Error(w, "Error reading request body", http.StatusBadRequest)
-			return
-		}
-
-		logger.Printf("Request body: %s\n", string(body))
-
-		// Process request
-		var request map[string]interface{}
-		if err := json.Unmarshal(body, &request); err != nil {
-			logger.Printf("Error unmarshaling request: %v\n", err)
-			http.Error(w, "Invalid JSON request", http.StatusBadRequest)
-			return
-		}
-
-		// Log request processing
-		logger.Printf("Processing request: Method=%s, ID=%v\n", request["method"], request["id"])
-
-		// Handle different methods
-		switch request["method"] {
-		case "ping":
-			// Log ping request
-			logger.Println("Handling ping request")
-
-			// Generate response
-			response := map[string]interface{}{
-				"jsonrpc": "2.0",
-				"id":      request["id"],
-				"result":  "pong",
-			}
-
-			// Log response generation
-			logger.Printf("Generated response: %v\n", response)
-
-			// Write response
-			w.Header().Set("Content-Type", "application/json")
-			if err := json.NewEncoder(w).Encode(response); err != nil {
-				logger.Printf("Error writing response: %v\n", err)
-				http.Error(w, "Error writing response", http.StatusInternalServerError)
-				return
-			}
-
-			// Log response sent
-			logger.Println("Response sent successfully")
-
-		case "getToolSpec":
-			// Log getToolSpec request
-			logger.Println("Handling getToolSpec request")
-
-			// Generate response
-			response := map[string]interface{}{
-				"jsonrpc": "2.0",
-				"id":      request["id"],
-				"result":  getToolSpecResponse(),
-			}
-
-			// Log response generation
-			logger.Printf("Generated response: %v\n", response)
-
-			// Write response
-			w.Header().Set("Content-Type", "application/json")
-			if err := json.NewEncoder(w).Encode(response); err != nil {
-				logger.Printf("Error writing response: %v\n", err)
-				http.Error(w, "Error writing response", http.StatusInternalServerError)
-				return
-			}
-
-			// Log response sent
-			logger.Println("Response sent successfully")
-
-		default:
-			// Log unknown method
-			logger.Printf("Unknown method: %s\n", request["method"])
-
-			// Generate error response
-			response := map[string]interface{}{
-				"jsonrpc": "2.0",
-				"id":      request["id"],
-				"error": map[string]interface{}{
-					"code":    -32601,
-					"message": fmt.Sprintf("Method '%s' not found", request["method"]),
-				},
-			}
-
-			// Log error response generation
-			logger.Printf("Generated error response: %v\n", response)
-
-			// Write response
-			w.Header().Set("Content-Type", "application/json")
-			if err := json.NewEncoder(w).Encode(response); err != nil {
-				logger.Printf("Error writing error response: %v\n", err)
-				http.Error(w, "Error writing error response", http.StatusInternalServerError)
-				return
-			}
-
-			// Log error response sent
-			logger.Println("Error response sent successfully")
-		}
-	})
+main.go // Initialize configuration
+main.go viper.SetDefault("port", defaultPort)
+main.go viper.SetDefault("timeout_seconds", defaultTimeoutSeconds)
+main.go viper.AutomaticEnv()
+
+main.go port := viper.GetString("port")
+main.go timeoutSeconds := viper.GetInt("timeout_seconds")
+
+main.go // Create HTTP server
+main.go httpServer := &http.Server{
+main.go main.go Addr:         ":" + port,
+main.go main.go Handler:      nil, // Will be set later
+main.go main.go ReadTimeout:  5 * time.Second,
+main.go main.go WriteTimeout: 10 * time.Second,
+main.go }
+
+main.go // Create a context with timeout
+main.go ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeoutSeconds)*time.Second)
+main.go defer cancel()
+
+main.go // Start the server
+main.go log.Printf("Starting server on port %s with timeout %d seconds", port, timeoutSeconds)
+
+main.go // Handle JSON-RPC requests
+main.go http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+main.go main.go // Set CORS headers
+main.go main.go w.Header().Set("Access-Control-Allow-Origin", "*")
+main.go main.go w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")
+main.go main.go w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+
+main.go main.go // Handle preflight requests
+main.go main.go if r.Method == "OPTIONS" {
+main.go main.go main.go w.WriteHeader(http.StatusOK)
+main.go main.go main.go return
+main.go main.go }
+
+main.go main.go // Only handle POST requests
+main.go main.go if r.Method != "POST" {
+main.go main.go main.go http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+main.go main.go main.go return
+main.go main.go }
+
+main.go main.go // Read the request body
+main.go main.go body, err := io.ReadAll(r.Body)
+main.go main.go if err != nil {
+main.go main.go main.go http.Error(w, "Error reading request body", http.StatusBadRequest)
+main.go main.go main.go return
+main.go main.go }
+main.go main.go defer r.Body.Close()
+
+main.go main.go // Log the incoming request
+main.go main.go log.Printf("Received request: %s", string(body))
+
+main.go main.go // Create a subprocess to handle the request
+main.go main.go cmd := exec.CommandContext(ctx, "/usr/local/bin/github-mcp-server")
+main.go main.go cmd.Stdin = bytes.NewReader(body)
+main.go main.go cmd.Stdout = w
+main.go main.go cmd.Stderr = os.Stderr
+
+main.go main.go // Start the subprocess
+main.go main.go log.Printf("Starting subprocess: /usr/local/bin/github-mcp-server")
+main.go main.go if err := cmd.Start(); err != nil {
+main.go main.go main.go log.Printf("Error starting subprocess: %v", err)
+main.go main.go main.go http.Error(w, "Error starting subprocess", http.StatusInternalServerError)
+main.go main.go main.go return
+main.go main.go }
+
+main.go main.go // Wait for the subprocess to complete
+main.go main.go log.Printf("Waiting for subprocess to complete")
+main.go main.go if err := cmd.Wait(); err != nil {
+main.go main.go main.go log.Printf("Subprocess error: %v", err)
+main.go main.go main.go // Check if it's a timeout error
+main.go main.go main.go if ctx.Err() == context.DeadlineExceeded {
+main.go main.go main.go main.go log.Printf("Subprocess timed out after %d seconds", timeoutSeconds)
+main.go main.go main.go main.go http.Error(w, "Subprocess timed out", http.StatusRequestTimeout)
+main.go main.go main.go main.go return
+main.go main.go main.go }
+main.go main.go main.go http.Error(w, "Subprocess error", http.StatusInternalServerError)
+main.go main.go main.go return
+main.go main.go }
+
+main.go main.go log.Printf("Subprocess completed successfully")
+main.go })
+
+main.go // Start the HTTP server
+main.go log.Printf("Server listening on port %s", port)
+main.go if err := httpServer.ListenAndServe(); err != nil {
+main.go main.go log.Fatalf("Failed to start server: %v", err)
+main.go }
 }
-
-func getToolSpecResponse() map[string]interface{} {
-	// Log tool spec generation
-	logger.Println("Generating tool spec response")
-
-	// Return a sample tool spec
-	return map[string]interface{}{
-		"name":        "github-mcp-server",
-		"description": "GitHub MCP Server",
-		"methods": []map[string]interface{}{
-			{
-				"name":        "ping",
-				"description": "Test if the server is alive",
-				"parameters":  map[string]interface{}{},
-				"returns": map[string]interface{}{
-					"type":        "string",
-					"description": "pong",
-				},
-			},
-			{
-				"name":        "getToolSpec",
-				"description": "Get the tool specification",
-				"parameters":  map[string]interface{}{},
-				"returns": map[string]interface{}{
-					"type":        "object",
-					"description": "Tool specification",
-				},
-			},
-		},
-	}
-}
-
-// Add logging for any errors (this function is provided but unused in the replacement logic)
-func handleError(err error, message string) {
-	logger.Printf("Error: %s - %v\n", message, err)
-}