Support for listening on localhost with http

cmd/mcp.go

@@ -9,6 +9,11 @@ import (
 	"github.com/spf13/cobra"
 )
 
+var (
+	useHTTP  bool
+	httpPort int
+)
+
 // mcpCommand represents the run command which starts the MCP server
 var mcpCommand = &cobra.Command{
 	Use:     "mcp",
@@ -65,6 +70,9 @@ available to AI applications via the MCP protocol.
 			DescriptionOverride: descriptionOverride,
 		})
 
+		if useHTTP {
+			return srv.StartHTTP(httpPort)
+		}
 		return srv.Start()
 	},
 }
@@ -78,6 +86,10 @@ func init() {
 	mcpCommand.Flags().StringSliceVarP(&descriptionFile, "description-file", "", []string{}, "Read the MCP server description from files (optional, can be specified multiple times)")
 	mcpCommand.Flags().BoolVarP(&descriptionOverride, "description-override", "", false, "Override the description found in the config file")
 
+	// Add HTTP server flags
+	mcpCommand.Flags().BoolVar(&useHTTP, "http", false, "Enable HTTP server mode (serve MCP over HTTP/SSE instead of stdio)")
+	mcpCommand.Flags().IntVar(&httpPort, "port", 8080, "Port for HTTP server (default: 8080, only used with --http)")
+
 	// Mark required flags
 	_ = mcpCommand.MarkFlagRequired("config")
 }

docs/usage.md

@@ -74,10 +74,15 @@ mcpshell mcp [flags]
 
 Runs an MCP server that communicates using the Model Context Protocol and exposes the tools defined in a MCP configuration file. The server loads tool definitions from a YAML configuration file and makes them available to AI applications via the MCP protocol.
 
+**HTTP/SSE Mode**:
+
+- `--http`: Enable HTTP server mode (serve MCP over HTTP/SSE instead of stdio)
+- `--port`: Port for HTTP server (default: 8080, only used with --http)
+
 **Example**:
 
 ```console
-mcpshell mcp --config=examples/config.yaml --log-level=debug
+mcpshell mcp --config=examples/config.yaml --http --port=9090 --log-level=debug
 ```
 
 ### EXE Command

pkg/server/server.go

@@ -8,6 +8,8 @@
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
+	"net/http"
 	"strings"
 
 	"github.com/mark3labs/mcp-go/mcp"
@@ -602,3 +604,113 @@
 	}
 	return data
 }
+
+// StartHTTP initializes the MCP server and starts an HTTP server for MCP protocol over HTTP/SSE
+func (s *Server) StartHTTP(port int) error {
+	s.logger.Info("Initializing MCP HTTP server on port %d", port)
+	if err := s.CreateServer(); err != nil {
+		return err
+	}
+	http.HandleFunc("/sse", s.handleMCPHTTP)
+	addr := fmt.Sprintf(":%d", port)
+	s.logger.Info("Listening on http://localhost%s/sse", addr)
+	fmt.Printf("MCP HTTP server listening on http://localhost%s/sse\n", addr)
+	return http.ListenAndServe(addr, nil)
+}
+
+// handleMCPHTTP handles HTTP POST requests for MCP protocol
+func (s *Server) handleMCPHTTP(w http.ResponseWriter, r *http.Request) {
+	s.logger.Info("New HTTP connection from %s %s %s", r.RemoteAddr, r.Method, r.URL.Path)
+	if r.Method != http.MethodPost {
+		http.Error(w, "Only POST allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		http.Error(w, "Failed to read body", http.StatusBadRequest)
+		s.logger.Error("Failed to read request body from %s: %v", r.RemoteAddr, err)
+		return
+	}
+
+	s.logger.Info("Request body: %s", string(body))
+
+	// Parse the JSON-RPC request
+	var req map[string]interface{}
+	if err := json.Unmarshal(body, &req); err != nil {
+		http.Error(w, "Invalid JSON", http.StatusBadRequest)
+		s.logger.Error("Invalid JSON from %s: %v", r.RemoteAddr, err)
+		return
+	}
+
+	// Intercept "initialize" method
+	if method, ok := req["method"].(string); ok && method == "initialize" {
+		id := req["id"]
+		s.logger.Info("Received 'initialize' from %s (id=%v)", r.RemoteAddr, id)
+
+		// Extract protocolVersion from params
+		protocolVersion := ""
+		if params, ok := req["params"].(map[string]interface{}); ok {
+			if pv, ok := params["protocolVersion"].(string); ok {
+				protocolVersion = pv
+			}
+		}
+		if protocolVersion == "" {
+			protocolVersion = "2025-03-26" // fallback, should always be present
+		}
+
+		resp := map[string]interface{}{
+			"jsonrpc": "2.0",
+			"id":      id,
+			"result": map[string]interface{}{
+				"serverInfo": map[string]interface{}{
+					"name":    "MCPShell",
+					"version": s.version,
+				},
+				"capabilities": map[string]interface{}{
+					"tools": map[string]interface{}{
+						"allowedTools": s.getAllowedToolNames(),
+					},
+				},
+				"sessionId":       "local",
+				"protocolVersion": protocolVersion,
+			},
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		respBytes, _ := json.Marshal(resp)
+		s.logger.Info("Response: %s", string(respBytes))
+		w.Write(respBytes)
+		return
+	}
+
+	// Fallback to normal MCP handling
+	s.logger.Info("Received MCP request from %s: method=%v id=%v", r.RemoteAddr, req["method"], req["id"])
+	ctx := r.Context()
+	resp := s.mcpServer.HandleMessage(ctx, body)
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	var respBytes []byte
+	switch v := resp.(type) {
+	case []byte:
+		respBytes = v
+	case string:
+		respBytes = []byte(v)
+	default:
+		respBytes, _ = json.Marshal(v)
+	}
+	s.logger.Info("Response: %s", string(respBytes))
+	w.Write(respBytes)
+}
+
+// Helper to get tool names
+func (s *Server) getAllowedToolNames() []string {
+	tools, err := s.GetTools()
+	if err != nil {
+		return []string{}
+	}
+	names := make([]string, 0, len(tools))
+	for _, t := range tools {
+		names = append(names, t.Name)
+	}
+	return names
+}