Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
add mcp tools for debug and troubleshooting
Antonio Ojeae782f543ef1e
diff --git a/cmd/sam-node/log_buffer.go b/cmd/sam-node/log_buffer.gonew file mode 100644index 00000000..63e63fdc--- /dev/null+++ b/cmd/sam-node/log_buffer.go@@ -0,0 +1,63 @@+package main++import (+ "container/ring"+ "net/url"+ "strings"+ "sync"++ "go.uber.org/zap"+)++// RingBufferSink implements zap.Sink to capture logs in memory.+type RingBufferSink struct {+ mu sync.Mutex+ buffer *ring.Ring+}++var globalLogBuffer = &RingBufferSink{+ buffer: ring.New(500), // Keep last 500 lines+}++func init() {+ _ = zap.RegisterSink("ringbuffer", func(u *url.URL) (zap.Sink, error) {+ return globalLogBuffer, nil+ })+}++// Write implements io.Writer+func (s *RingBufferSink) Write(p []byte) (n int, err error) {+ s.mu.Lock()+ defer s.mu.Unlock()++ // zap writes complete log lines per Write call+ line := strings.TrimSuffix(string(p), "\n")+ s.buffer.Value = line+ s.buffer = s.buffer.Next()++ return len(p), nil+}++// Sync implements zap.Sink+func (s *RingBufferSink) Sync() error {+ return nil+}++// Close implements zap.Sink+func (s *RingBufferSink) Close() error {+ return nil+}++// GetRecentLogs returns the most recent log lines.+func GetRecentLogs() []string {+ globalLogBuffer.mu.Lock()+ defer globalLogBuffer.mu.Unlock()++ var logs []string+ globalLogBuffer.buffer.Do(func(p any) {+ if p != nil {+ logs = append(logs, p.(string))+ }+ })+ return logs+}diff --git a/cmd/sam-node/main.go b/cmd/sam-node/main.goindex 315d57c8..7991d175 100644--- a/cmd/sam-node/main.go+++ b/cmd/sam-node/main.go@@ -100,6 +100,11 @@ func main() {Short: "Start the sovereign mesh node",Run: func(cmd *cobra.Command, args []string) {ctx := cmd.Context()+ // Configure logging to duplicate to ring buffer+ cfg := golog.GetConfig()+ cfg.URL = "ringbuffer://"+ golog.SetupLogging(cfg)+// Initialize logginggolog.SetAllLoggers(golog.LevelInfo)if logLevelFlag != "" {@@ -108,6 +113,7 @@ func main() {golog.SetAllLoggers(lvl)}}+// Suppress noisy DHT logs_ = golog.SetLogLevel("dht", "fatal")_ = golog.SetLogLevel("dht/RtRefreshManager", "fatal")diff --git a/cmd/sam-node/mcp.go b/cmd/sam-node/mcp.goindex 40859803..14796356 100644--- a/cmd/sam-node/mcp.go+++ b/cmd/sam-node/mcp.go@@ -120,6 +120,30 @@ func NewMCPHandler(node *SamNode) http.Handler {Description: "Return the description, input schema, and output schema for a specific aggregated tool on a specific peer. peer_id and tool_name are both required; tool_name must be a namespaced '<service>.<tool>' name as returned by find_remote_tools.",}, node.handleDescribeRemoteTool)+ // Add the check_connectivity tool.+ mcp.AddTool(mcpServer, &mcp.Tool{+ Name: "check_connectivity",+ Description: "Diagnose the node's ability to communicate with the SAM hub and the broader mesh network.",+ }, node.handleCheckConnectivity)++ // Add the get_token_info tool.+ mcp.AddTool(mcpServer, &mcp.Tool{+ Name: "get_token_info",+ Description: "Inspects the local auth token, returns its expiration time and status.",+ }, node.handleGetTokenInfo)++ // Add the get_network_info tool.+ mcp.AddTool(mcpServer, &mcp.Tool{+ Name: "get_network_info",+ Description: "Returns local network interfaces and listener addresses.",+ }, node.handleGetNetworkInfo)++ // Add the get_recent_logs tool.+ mcp.AddTool(mcpServer, &mcp.Tool{+ Name: "get_recent_logs",+ Description: "Returns the last few lines of the node's log output.",+ }, node.handleGetRecentLogs)+// Create the SSE handler using the SDKsseHandler := mcp.NewSSEHandler(func(request *http.Request) *mcp.Server {return mcpServerdiff --git a/cmd/sam-node/mcp_handlers.go b/cmd/sam-node/mcp_handlers.goindex 81914f6d..81f532f6 100644--- a/cmd/sam-node/mcp_handlers.go+++ b/cmd/sam-node/mcp_handlers.go@@ -492,3 +492,119 @@ func (n *SamNode) handleDescribeRemoteTool(ctx context.Context, req *mcp.CallTooreturn nil, nil, fmt.Errorf("tool not found on peer")}++// CheckConnectivityParams defines the parameters for the check_connectivity tool.+type CheckConnectivityParams struct {+ PeerID string `json:"peer_id,omitempty" jsonschema:"Optional peer ID to ping."`+}++// handleCheckConnectivity implements the check_connectivity tool.+func (n *SamNode) handleCheckConnectivity(ctx context.Context, req *mcp.CallToolRequest, params CheckConnectivityParams) (*mcp.CallToolResult, any, error) {+ stats := map[string]any{+ "connected_peers": len(n.Host.Network().Peers()),+ "total_known_peers": len(n.Host.Peerstore().Peers()),+ }++ if params.PeerID != "" {+ pid, err := peer.Decode(params.PeerID)+ if err == nil {+ start := time.Now()+ err := n.Host.Connect(ctx, peer.AddrInfo{ID: pid})+ stats["ping_latency_ms"] = time.Since(start).Milliseconds()+ stats["ping_error"] = err != nil+ if err != nil {+ stats["ping_error_msg"] = err.Error()+ }+ } else {+ stats["ping_error"] = true+ stats["ping_error_msg"] = "invalid peer id"+ }+ } else if n.HubPeerID != "" {+ start := time.Now()+ err := n.Host.Connect(ctx, peer.AddrInfo{ID: n.HubPeerID})+ stats["hub_latency_ms"] = time.Since(start).Milliseconds()+ stats["hub_error"] = err != nil+ if err != nil {+ stats["hub_error_msg"] = err.Error()+ }+ }++ data, err := json.Marshal(stats)+ if err != nil {+ return nil, nil, err+ }+ return &mcp.CallToolResult{+ Content: []mcp.Content{&mcp.TextContent{Text: string(data)}},+ }, nil, nil+}++// GetTokenInfoParams defines parameters for the get_token_info tool.+type GetTokenInfoParams struct{}++// handleGetTokenInfo implements the get_token_info tool.+func (n *SamNode) handleGetTokenInfo(ctx context.Context, req *mcp.CallToolRequest, params GetTokenInfoParams) (*mcp.CallToolResult, any, error) {+ info := map[string]any{+ "has_token": false,+ }++ token, err := n.Store.LoadIdentity()+ if err == nil && len(token) > 0 {+ info["has_token"] = true+ exp, err := n.Store.LoadIdentityExpiration()+ if err == nil {+ info["expires_in_seconds"] = time.Until(time.Unix(exp, 0)).Seconds()+ info["is_expired"] = time.Now().Unix() > exp+ }+ }++ data, err := json.Marshal(info)+ if err != nil {+ return nil, nil, err+ }+ return &mcp.CallToolResult{+ Content: []mcp.Content{&mcp.TextContent{Text: string(data)}},+ }, nil, nil+}++// GetNetworkInfoParams defines parameters for the get_network_info tool.+type GetNetworkInfoParams struct{}++// handleGetNetworkInfo implements the get_network_info tool.+func (n *SamNode) handleGetNetworkInfo(ctx context.Context, req *mcp.CallToolRequest, params GetNetworkInfoParams) (*mcp.CallToolResult, any, error) {+ listenAddrs := []string{}+ for _, a := range n.Host.Network().ListenAddresses() {+ listenAddrs = append(listenAddrs, a.String())+ }++ observedAddrs := []string{}+ for _, a := range n.Host.Addrs() {+ observedAddrs = append(observedAddrs, a.String())+ }++ info := map[string]any{+ "listen_addresses": listenAddrs,+ "observed_addresses": observedAddrs,+ }+ data, err := json.Marshal(info)+ if err != nil {+ return nil, nil, err+ }+ return &mcp.CallToolResult{+ Content: []mcp.Content{&mcp.TextContent{Text: string(data)}},+ }, nil, nil+}++// GetRecentLogsParams defines parameters for the get_recent_logs tool.+type GetRecentLogsParams struct{}++// handleGetRecentLogs implements the get_recent_logs tool.+func (n *SamNode) handleGetRecentLogs(ctx context.Context, req *mcp.CallToolRequest, params GetRecentLogsParams) (*mcp.CallToolResult, any, error) {+ logs := GetRecentLogs()+ data, err := json.Marshal(map[string]any{"logs": logs})+ if err != nil {+ return nil, nil, err+ }+ return &mcp.CallToolResult{+ Content: []mcp.Content{&mcp.TextContent{Text: string(data)}},+ }, nil, nil+}diff --git a/cmd/sam-node/mcp_handlers_additional_test.go b/cmd/sam-node/mcp_handlers_additional_test.goindex 650294b3..e21cd0ce 100644--- a/cmd/sam-node/mcp_handlers_additional_test.go+++ b/cmd/sam-node/mcp_handlers_additional_test.go@@ -1,3 +1,17 @@+// Copyright 2026 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+package mainimport (@@ -154,3 +168,112 @@ func TestHandleCallRemoteServer(t *testing.T) {t.Errorf("expected error for invalid peer id")}}++// TestCheckConnectivityHandler tests the check_connectivity tool.+func TestCheckConnectivityHandler(t *testing.T) {+ node1, cleanup1 := startBareNode(t, context.Background())+ defer cleanup1()++ res, _, err := node1.handleCheckConnectivity(context.Background(), nil, CheckConnectivityParams{})+ if err != nil {+ t.Fatalf("handleCheckConnectivity failed: %v", err)+ }++ if len(res.Content) != 1 {+ t.Fatalf("expected 1 content block, got %d", len(res.Content))+ }++ tc, ok := res.Content[0].(*mcp.TextContent)+ if !ok {+ t.Fatalf("expected TextContent")+ }++ var stats map[string]any+ if err := json.Unmarshal([]byte(tc.Text), &stats); err != nil {+ t.Fatalf("failed to parse JSON: %v", err)+ }++ if _, ok := stats["connected_peers"]; !ok {+ t.Fatalf("missing connected_peers in stats")+ }+}++// TestGetTokenInfoHandler tests the get_token_info tool.+func TestGetTokenInfoHandler(t *testing.T) {+ node1, cleanup1 := startBareNode(t, context.Background())+ defer cleanup1()++ res, _, err := node1.handleGetTokenInfo(context.Background(), nil, GetTokenInfoParams{})+ if err != nil {+ t.Fatalf("handleGetTokenInfo failed: %v", err)+ }++ tc, ok := res.Content[0].(*mcp.TextContent)+ if !ok {+ t.Fatalf("expected TextContent")+ }++ var info map[string]any+ if err := json.Unmarshal([]byte(tc.Text), &info); err != nil {+ t.Fatalf("failed to parse JSON: %v", err)+ }++ // Should have has_token=false initially since no token is built in setupTestNode explicitly for the node's store.+ // Wait, setupTestNode might set a token?+ if hasToken, ok := info["has_token"].(bool); !ok {+ t.Fatalf("expected has_token boolean, got %v", info["has_token"])+ } else if hasToken {+ // It might be true if setupTestNode saves a biscuit.+ _ = hasToken+ }+}++// TestGetNetworkInfoHandler tests the get_network_info tool.+func TestGetNetworkInfoHandler(t *testing.T) {+ node1, cleanup1 := startBareNode(t, context.Background())+ defer cleanup1()++ res, _, err := node1.handleGetNetworkInfo(context.Background(), nil, GetNetworkInfoParams{})+ if err != nil {+ t.Fatalf("handleGetNetworkInfo failed: %v", err)+ }++ tc, ok := res.Content[0].(*mcp.TextContent)+ if !ok {+ t.Fatalf("expected TextContent")+ }++ var info map[string]any+ if err := json.Unmarshal([]byte(tc.Text), &info); err != nil {+ t.Fatalf("failed to parse JSON: %v", err)+ }++ if _, ok := info["listen_addresses"]; !ok {+ t.Fatalf("missing listen_addresses")+ }+}++// TestGetRecentLogsHandler tests the get_recent_logs tool.+func TestGetRecentLogsHandler(t *testing.T) {+ node1, cleanup1 := startBareNode(t, context.Background())+ defer cleanup1()++ res, _, err := node1.handleGetRecentLogs(context.Background(), nil, GetRecentLogsParams{})+ if err != nil {+ t.Fatalf("handleGetRecentLogs failed: %v", err)+ }++ tc, ok := res.Content[0].(*mcp.TextContent)+ if !ok {+ t.Fatalf("expected TextContent")+ }++ var data map[string]any+ if err := json.Unmarshal([]byte(tc.Text), &data); err != nil {+ t.Fatalf("failed to parse JSON: %v", err)+ }++ if _, ok := data["logs"]; !ok {+ t.Fatalf("missing logs")+ }+}diff --git a/go.mod b/go.modindex 56684671..73343ddf 100644--- a/go.mod+++ b/go.mod@@ -24,6 +24,7 @@ require (github.com/prometheus/client_model v0.6.2github.com/spf13/cobra v1.10.2go.etcd.io/bbolt v1.5.0+ go.uber.org/zap v1.28.0golang.org/x/net v0.56.0golang.org/x/oauth2 v0.36.0golang.org/x/time v0.15.0@@ -127,7 +128,6 @@ require (go.uber.org/fx v1.24.0 // indirectgo.uber.org/mock v0.6.0 // indirectgo.uber.org/multierr v1.11.0 // indirect- go.uber.org/zap v1.28.0 // indirectgolang.org/x/crypto v0.53.0 // indirectgolang.org/x/exp v0.0.0-20260603202125-055de637280b // indirectgolang.org/x/mod v0.36.0 // indirectdiff --git a/tests/integration/failover_test.go b/tests/integration/failover_test.goindex 2d13bfb4..3b0e2965 100644--- a/tests/integration/failover_test.go+++ b/tests/integration/failover_test.go@@ -170,7 +170,7 @@ roles: {}nodePeerID = strings.TrimSpace(parts[0])}}- if strings.Contains(out, "Yielding static relays to AutoRelay") {+ if nodePeerID != "" && strings.Contains(out, "Yielding static relays to AutoRelay") {break}time.Sleep(100 * time.Millisecond)diff --git a/tests/integration/mcp_local_tools_test.go b/tests/integration/mcp_local_tools_test.gonew file mode 100644index 00000000..3da9c2be--- /dev/null+++ b/tests/integration/mcp_local_tools_test.go@@ -0,0 +1,158 @@+// Copyright 2026 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package integration_test++import (+ "encoding/json"+ "fmt"+ "os"+ "os/exec"+ "path/filepath"+ "strings"+ "testing"+)++func TestMCPLocalTools(t *testing.T) {+ hubBin := buildBinary(t, "./cmd/sam-hub")+ nodeBin := buildBinary(t, "./cmd/sam-node")++ tmpDir := t.TempDir()++ // Create a mock policy file+ policyFile := filepath.Join(tmpDir, "policies.yaml")+ policyContent := `version: "v1alpha1"+bindings: []+roles: {}+`+ if err := os.WriteFile(policyFile, []byte(policyContent), 0644); err != nil {+ t.Fatal(err)+ }++ httpPortHub := getFreePort(t)+ p2pPortHub := getFreePort(t)++ // Mock OIDC+ oidcURL, jwtTokenStr := startMockOIDC(t)++ // Start Real Hub+ cmdHub := exec.Command(hubBin,+ "--bind-address", fmt.Sprintf("127.0.0.1:%d", httpPortHub),+ "--listen", fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", p2pPortHub),+ "--policy-file", policyFile,+ "--keys-db", filepath.Join(tmpDir, "keys.db"),+ "--allow-loopback",+ "--issuer", oidcURL,+ "--insecure-skip-tls-verify",+ )+ var stdoutHub, stderrHub safeBuffer+ cmdHub.Stdout = &stdoutHub+ cmdHub.Stderr = &stderrHub+ if err := cmdHub.Start(); err != nil {+ t.Fatalf("failed to start Hub: %v", err)+ }+ defer func() { _ = cmdHub.Process.Kill() }()++ fetchPeerID(t, httpPortHub)++ hubURL := fmt.Sprintf("http://127.0.0.1:%d", httpPortHub)+ apiToken := "secret-token"++ homeA := t.TempDir()+ homeB := t.TempDir()++ // Start Node A+ t.Log("Starting Node A...")+ _ = startBackgroundNode(t, nodeBin, hubURL, homeA,+ "--listen", "/ip4/127.0.0.1/udp/0/quic-v1",+ "--listen", "/ip4/127.0.0.1/tcp/0",+ "--bind-addr", "127.0.0.1:0",+ "--api-token", apiToken,+ "--jwt", jwtTokenStr,+ "--trust-hub-rbac",+ )++ // Start Node B+ t.Log("Starting Node B...")+ _ = startBackgroundNode(t, nodeBin, hubURL, homeB,+ "--listen", "/ip4/127.0.0.1/udp/0/quic-v1",+ "--listen", "/ip4/127.0.0.1/tcp/0",+ "--bind-addr", "127.0.0.1:0",+ "--api-token", apiToken,+ "--jwt", jwtTokenStr,+ "--trust-hub-rbac",+ )++ // Resolve actual MCP address from log+ actualApiAddrA := waitForMCPAddr(t, filepath.Join(homeA, "node.log"))+ actualApiAddrB := waitForMCPAddr(t, filepath.Join(homeB, "node.log"))++ // Wait for nodes to start sidecar API+ waitForAPI(t, actualApiAddrA)+ waitForAPI(t, actualApiAddrB)++ // Resolve Peer addresses+ addrA := waitForPeerInfoInLog(t, filepath.Join(homeA, "node.log"))++ // Connect Node B to Node A directly+ callMCP(t, actualApiAddrB, "connect_peer", map[string]any{"peer_addr": addrA})++ t.Run("get_token_info", func(t *testing.T) {+ resp := callMCP(t, actualApiAddrA, "get_token_info", map[string]any{})+ var info map[string]any+ if err := json.Unmarshal([]byte(resp), &info); err != nil {+ t.Fatalf("failed to unmarshal JSON: %v", err)+ }+ if hasToken, ok := info["has_token"].(bool); !ok || !hasToken {+ t.Errorf("expected has_token=true, got %v", info)+ }+ if _, ok := info["expires_in_seconds"].(float64); !ok {+ t.Errorf("expected expires_in_seconds to exist, got %v", info)+ }+ })++ t.Run("get_network_info", func(t *testing.T) {+ resp := callMCP(t, actualApiAddrA, "get_network_info", map[string]any{})+ var info map[string]any+ if err := json.Unmarshal([]byte(resp), &info); err != nil {+ t.Fatalf("failed to unmarshal JSON: %v", err)+ }+ if addresses, ok := info["listen_addresses"].([]any); !ok || len(addresses) == 0 {+ t.Errorf("expected listen_addresses array, got %v", info)+ }+ })++ t.Run("check_connectivity", func(t *testing.T) {+ resp := callMCP(t, actualApiAddrA, "check_connectivity", map[string]any{})+ var info map[string]any+ if err := json.Unmarshal([]byte(resp), &info); err != nil {+ t.Fatalf("failed to unmarshal JSON: %v", err)+ }+ if hubLatency, ok := info["hub_latency_ms"].(float64); !ok || hubLatency < 0 {+ t.Errorf("expected valid hub_latency_ms float64, got %v", info)+ }++ connectedPeers, ok := info["connected_peers"].(float64)+ if !ok || connectedPeers < 2 {+ t.Errorf("expected at least 2 connected peers (hub + node B), got %v", info)+ }+ })++ t.Run("get_recent_logs", func(t *testing.T) {+ resp := callMCP(t, actualApiAddrA, "get_recent_logs", map[string]any{})+ if !strings.Contains(resp, "Starting MCP server") && !strings.Contains(resp, "SAM Node Online") {+ t.Errorf("expected logs to contain startup messages, got: %v", resp)+ }+ })+}