Add sosreport MCP tools

README.md

@@ -9,8 +9,14 @@ For connecting to the MCP server, the following steps are required:
 make build
 ```
 
+The server supports 2 operating modes:
+- `live-cluster` (default): Connect to a live Kubernetes cluster for real-time debugging
+- `offline`: Offline troubleshooting without requiring cluster access
+
 The server currently supports 2 transport modes: `stdio` and `http`.
 
+### Live Cluster Mode
+
 For `stdio` mode, the server can be run and connected to by using the following configuration in an MCP host (Cursor, Claude, etc.):
 
 ```json
@@ -27,7 +33,7 @@ For `stdio` mode, the server can be run and connected to by using the following
 }
 ```
 
-For `http` mode, the server should be started separately.
+For `http` mode, the server should be started separately:
 
 ```shell
 ./PATH-TO-THE-LOCAL-GIT-REPO/_output/ovnk-mcp-server --transport http --kubeconfig /PATH-TO-THE-KUBECONFIG-FILE
@@ -44,3 +50,26 @@ The following configuration should be used in an MCP host (Cursor, Claude, etc.)
   }
 }
 ```
+
+### Offline Mode
+
+For offline troubleshooting (e.g., analyzing sosreports), use `--mode offline`:
+
+For `stdio` mode:
+
+```json
+{
+  "mcpServers": {
+    "ovn-kubernetes": {
+      "command": "/PATH-TO-THE-LOCAL-GIT-REPO/_output/ovnk-mcp-server",
+      "args": ["--mode", "offline"]
+    }
+  }
+}
+```
+
+For `http` mode:
+
+```shell
+./PATH-TO-THE-LOCAL-GIT-REPO/_output/ovnk-mcp-server --transport http --mode offline
+```

cmd/ovnk-mcp-server/main.go

@@ -12,6 +12,7 @@ import (
 
 	mcp "github.com/modelcontextprotocol/go-sdk/mcp"
 	kubernetesmcp "github.com/ovn-kubernetes/ovn-kubernetes-mcp/pkg/kubernetes/mcp"
+	sosreportmcp "github.com/ovn-kubernetes/ovn-kubernetes-mcp/pkg/sosreport/mcp"
 )
 
 type MCPServerConfig struct {
@@ -37,6 +38,11 @@ func main() {
 		log.Println("Adding Kubernetes tools to OVN-K MCP server")
 		k8sMcpServer.AddTools(ovnkMcpServer)
 	}
+	if serverCfg.Mode == "offline" {
+		sosreportServer := sosreportmcp.NewMCPServer()
+		log.Println("Adding sosreport tools to OVN-K MCP server")
+		sosreportServer.AddTools(ovnkMcpServer)
+	}
 
 	// Create a context that can be cancelled to shutdown the server.
 	ctx, cancel := context.WithCancel(context.Background())

pkg/sosreport/mcp/commands.go

@@ -0,0 +1,149 @@
+package sosreport
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"github.com/ovn-kubernetes/ovn-kubernetes-mcp/pkg/sosreport/types"
+)
+
+const (
+	// defaultResultLimit is the default maximum number of lines/results to return
+	defaultResultLimit = 100
+)
+
+// getCommandOutput reads a command output file by filepath from manifest
+func getCommandOutput(sosreportPath, relativeFilepath, pattern string, maxLines int) (string, error) {
+	if err := validateSosreportPath(sosreportPath); err != nil {
+		return "", err
+	}
+
+	if err := validateRelativePath(relativeFilepath); err != nil {
+		return "", err
+	}
+
+	fullPath := filepath.Join(sosreportPath, relativeFilepath)
+	if _, err := os.Stat(fullPath); os.IsNotExist(err) {
+		return "", fmt.Errorf("command output file not found: %s", relativeFilepath)
+	}
+
+	file, err := os.Open(fullPath)
+	if err != nil {
+		return "", fmt.Errorf("failed to open file: %w", err)
+	}
+	defer file.Close()
+
+	var searchPattern *regexp.Regexp
+	if pattern != "" {
+		searchPattern, err = regexp.Compile(pattern)
+		if err != nil {
+			return "", fmt.Errorf("invalid pattern: %w", err)
+		}
+	}
+
+	if maxLines <= 0 {
+		maxLines = defaultResultLimit
+	}
+
+	output, err := readWithLimit(file, searchPattern, maxLines)
+	if err != nil {
+		return "", err
+	}
+
+	if output == "" && pattern != "" {
+		return fmt.Sprintf("No lines matching pattern %q found\n", pattern), nil
+	}
+
+	return output, nil
+}
+
+// listPlugins returns a list of enabled plugins with their command counts
+func listPlugins(sosreportPath string) (types.ListPluginsResult, error) {
+	manifest, err := loadManifest(sosreportPath)
+	if err != nil {
+		return types.ListPluginsResult{}, err
+	}
+
+	var result types.ListPluginsResult
+	totalCommands := 0
+
+	// Only show enabled plugins
+	for pluginName, plugin := range manifest.Components.Report.Plugins {
+		commandCount := len(plugin.Commands)
+		totalCommands += commandCount
+
+		result.Plugins = append(result.Plugins, types.PluginSummary{
+			Name:         pluginName,
+			CommandCount: commandCount,
+		})
+	}
+
+	result.TotalCommands = totalCommands
+	return result, nil
+}
+
+// listCommands returns all commands for a specific plugin
+func listCommands(sosreportPath, pluginName string) (types.ListCommandsResult, error) {
+	manifest, err := loadManifest(sosreportPath)
+	if err != nil {
+		return types.ListCommandsResult{}, err
+	}
+
+	plugin, exists := manifest.Components.Report.Plugins[pluginName]
+	if !exists {
+		return types.ListCommandsResult{}, fmt.Errorf("plugin %q not found in manifest", pluginName)
+	}
+
+	result := types.ListCommandsResult{
+		Plugin:       pluginName,
+		CommandCount: len(plugin.Commands),
+	}
+
+	for _, cmd := range plugin.Commands {
+		result.Commands = append(result.Commands, types.CommandSummary{
+			Exec:     cmd.Exec,
+			Filepath: cmd.Filepath,
+		})
+	}
+
+	return result, nil
+}
+
+// searchCommands searches for commands matching a pattern across all plugins
+func searchCommands(sosreportPath, pattern string, maxResults int) (types.SearchCommandsResult, error) {
+	manifest, err := loadManifest(sosreportPath)
+	if err != nil {
+		return types.SearchCommandsResult{}, err
+	}
+
+	searchPattern, err := regexp.Compile(pattern)
+	if err != nil {
+		return types.SearchCommandsResult{}, fmt.Errorf("invalid search pattern: %w", err)
+	}
+
+	var result types.SearchCommandsResult
+	if maxResults <= 0 {
+		maxResults = defaultResultLimit
+	}
+
+	for pluginName, plugin := range manifest.Components.Report.Plugins {
+		for _, cmd := range plugin.Commands {
+			if searchPattern.MatchString(cmd.Exec) || searchPattern.MatchString(cmd.Filepath) {
+				result.Matches = append(result.Matches, types.CommandMatch{
+					Plugin:   pluginName,
+					Exec:     cmd.Exec,
+					Filepath: cmd.Filepath,
+				})
+
+				if len(result.Matches) >= maxResults {
+					result.Total = len(result.Matches)
+					return result, nil
+				}
+			}
+		}
+	}
+
+	result.Total = len(result.Matches)
+	return result, nil
+}