Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
add mcp auth
Antonio Ojeaa27ac6995568
diff --git a/api/constants.go b/api/constants.goindex e7ec9414..02e71ebf 100644--- a/api/constants.go+++ b/api/constants.go@@ -17,4 +17,5 @@ package apiimport "github.com/libp2p/go-libp2p/core/protocol"const EnrollProtocolID protocol.ID = "/sam/enroll/1.0.0"+const MCPProtocolID protocol.ID = "/sam/mcp/1.0.0"const GossipEvents = "/sam/mesh/events/v1"diff --git a/api/sam.pb.go b/api/sam.pb.goindex 099d159b..00ad0e59 100644--- a/api/sam.pb.go+++ b/api/sam.pb.go@@ -81,7 +81,7 @@ func (x MeshEvent_Type) Number() protoreflect.EnumNumber {// Deprecated: Use MeshEvent_Type.Descriptor instead.func (MeshEvent_Type) EnumDescriptor() ([]byte, []int) {- return file_api_sam_proto_rawDescGZIP(), []int{7, 0}+ return file_api_sam_proto_rawDescGZIP(), []int{9, 0}}type AuthEnvelope struct {@@ -144,6 +144,102 @@ func (x *AuthEnvelope) GetProof() []byte {return nil}+type AuthFrame struct {+ state protoimpl.MessageState `protogen:"open.v1"`+ Biscuit []byte `protobuf:"bytes,1,opt,name=biscuit,proto3" json:"biscuit,omitempty"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache+}++func (x *AuthFrame) Reset() {+ *x = AuthFrame{}+ mi := &file_api_sam_proto_msgTypes[1]+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ ms.StoreMessageInfo(mi)+}++func (x *AuthFrame) String() string {+ return protoimpl.X.MessageStringOf(x)+}++func (*AuthFrame) ProtoMessage() {}++func (x *AuthFrame) ProtoReflect() protoreflect.Message {+ mi := &file_api_sam_proto_msgTypes[1]+ if x != nil {+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ if ms.LoadMessageInfo() == nil {+ ms.StoreMessageInfo(mi)+ }+ return ms+ }+ return mi.MessageOf(x)+}++// Deprecated: Use AuthFrame.ProtoReflect.Descriptor instead.+func (*AuthFrame) Descriptor() ([]byte, []int) {+ return file_api_sam_proto_rawDescGZIP(), []int{1}+}++func (x *AuthFrame) GetBiscuit() []byte {+ if x != nil {+ return x.Biscuit+ }+ return nil+}++type AuthResponse struct {+ state protoimpl.MessageState `protogen:"open.v1"`+ Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`+ Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` // populated only if success is false+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache+}++func (x *AuthResponse) Reset() {+ *x = AuthResponse{}+ mi := &file_api_sam_proto_msgTypes[2]+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ ms.StoreMessageInfo(mi)+}++func (x *AuthResponse) String() string {+ return protoimpl.X.MessageStringOf(x)+}++func (*AuthResponse) ProtoMessage() {}++func (x *AuthResponse) ProtoReflect() protoreflect.Message {+ mi := &file_api_sam_proto_msgTypes[2]+ if x != nil {+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ if ms.LoadMessageInfo() == nil {+ ms.StoreMessageInfo(mi)+ }+ return ms+ }+ return mi.MessageOf(x)+}++// Deprecated: Use AuthResponse.ProtoReflect.Descriptor instead.+func (*AuthResponse) Descriptor() ([]byte, []int) {+ return file_api_sam_proto_rawDescGZIP(), []int{2}+}++func (x *AuthResponse) GetSuccess() bool {+ if x != nil {+ return x.Success+ }+ return false+}++func (x *AuthResponse) GetError() string {+ if x != nil {+ return x.Error+ }+ return ""+}+type HubConfig struct {state protoimpl.MessageState `protogen:"open.v1"`PublicKeyHex string `protobuf:"bytes,1,opt,name=public_key_hex,json=publicKeyHex,proto3" json:"public_key_hex,omitempty"`@@ -155,7 +251,7 @@ type HubConfig struct {func (x *HubConfig) Reset() {*x = HubConfig{}- mi := &file_api_sam_proto_msgTypes[1]+ mi := &file_api_sam_proto_msgTypes[3]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -167,7 +263,7 @@ func (x *HubConfig) String() string {func (*HubConfig) ProtoMessage() {}func (x *HubConfig) ProtoReflect() protoreflect.Message {- mi := &file_api_sam_proto_msgTypes[1]+ mi := &file_api_sam_proto_msgTypes[3]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -180,7 +276,7 @@ func (x *HubConfig) ProtoReflect() protoreflect.Message {// Deprecated: Use HubConfig.ProtoReflect.Descriptor instead.func (*HubConfig) Descriptor() ([]byte, []int) {- return file_api_sam_proto_rawDescGZIP(), []int{1}+ return file_api_sam_proto_rawDescGZIP(), []int{3}}func (x *HubConfig) GetPublicKeyHex() string {@@ -214,7 +310,7 @@ type PeerProfile struct {func (x *PeerProfile) Reset() {*x = PeerProfile{}- mi := &file_api_sam_proto_msgTypes[2]+ mi := &file_api_sam_proto_msgTypes[4]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -226,7 +322,7 @@ func (x *PeerProfile) String() string {func (*PeerProfile) ProtoMessage() {}func (x *PeerProfile) ProtoReflect() protoreflect.Message {- mi := &file_api_sam_proto_msgTypes[2]+ mi := &file_api_sam_proto_msgTypes[4]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -239,7 +335,7 @@ func (x *PeerProfile) ProtoReflect() protoreflect.Message {// Deprecated: Use PeerProfile.ProtoReflect.Descriptor instead.func (*PeerProfile) Descriptor() ([]byte, []int) {- return file_api_sam_proto_rawDescGZIP(), []int{2}+ return file_api_sam_proto_rawDescGZIP(), []int{4}}func (x *PeerProfile) GetEmail() string {@@ -265,7 +361,7 @@ type PeerRegistry struct {func (x *PeerRegistry) Reset() {*x = PeerRegistry{}- mi := &file_api_sam_proto_msgTypes[3]+ mi := &file_api_sam_proto_msgTypes[5]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -277,7 +373,7 @@ func (x *PeerRegistry) String() string {func (*PeerRegistry) ProtoMessage() {}func (x *PeerRegistry) ProtoReflect() protoreflect.Message {- mi := &file_api_sam_proto_msgTypes[3]+ mi := &file_api_sam_proto_msgTypes[5]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -290,7 +386,7 @@ func (x *PeerRegistry) ProtoReflect() protoreflect.Message {// Deprecated: Use PeerRegistry.ProtoReflect.Descriptor instead.func (*PeerRegistry) Descriptor() ([]byte, []int) {- return file_api_sam_proto_rawDescGZIP(), []int{3}+ return file_api_sam_proto_rawDescGZIP(), []int{5}}func (x *PeerRegistry) GetPeers() map[string]*PeerProfile {@@ -311,7 +407,7 @@ type ModelProperty struct {func (x *ModelProperty) Reset() {*x = ModelProperty{}- mi := &file_api_sam_proto_msgTypes[4]+ mi := &file_api_sam_proto_msgTypes[6]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -323,7 +419,7 @@ func (x *ModelProperty) String() string {func (*ModelProperty) ProtoMessage() {}func (x *ModelProperty) ProtoReflect() protoreflect.Message {- mi := &file_api_sam_proto_msgTypes[4]+ mi := &file_api_sam_proto_msgTypes[6]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -336,7 +432,7 @@ func (x *ModelProperty) ProtoReflect() protoreflect.Message {// Deprecated: Use ModelProperty.ProtoReflect.Descriptor instead.func (*ModelProperty) Descriptor() ([]byte, []int) {- return file_api_sam_proto_rawDescGZIP(), []int{4}+ return file_api_sam_proto_rawDescGZIP(), []int{6}}func (x *ModelProperty) GetName() string {@@ -375,7 +471,7 @@ type AgentCard struct {func (x *AgentCard) Reset() {*x = AgentCard{}- mi := &file_api_sam_proto_msgTypes[5]+ mi := &file_api_sam_proto_msgTypes[7]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -387,7 +483,7 @@ func (x *AgentCard) String() string {func (*AgentCard) ProtoMessage() {}func (x *AgentCard) ProtoReflect() protoreflect.Message {- mi := &file_api_sam_proto_msgTypes[5]+ mi := &file_api_sam_proto_msgTypes[7]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -400,7 +496,7 @@ func (x *AgentCard) ProtoReflect() protoreflect.Message {// Deprecated: Use AgentCard.ProtoReflect.Descriptor instead.func (*AgentCard) Descriptor() ([]byte, []int) {- return file_api_sam_proto_rawDescGZIP(), []int{5}+ return file_api_sam_proto_rawDescGZIP(), []int{7}}func (x *AgentCard) GetPeerId() string {@@ -464,7 +560,7 @@ type RevocationMsg struct {func (x *RevocationMsg) Reset() {*x = RevocationMsg{}- mi := &file_api_sam_proto_msgTypes[6]+ mi := &file_api_sam_proto_msgTypes[8]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -476,7 +572,7 @@ func (x *RevocationMsg) String() string {func (*RevocationMsg) ProtoMessage() {}func (x *RevocationMsg) ProtoReflect() protoreflect.Message {- mi := &file_api_sam_proto_msgTypes[6]+ mi := &file_api_sam_proto_msgTypes[8]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -489,7 +585,7 @@ func (x *RevocationMsg) ProtoReflect() protoreflect.Message {// Deprecated: Use RevocationMsg.ProtoReflect.Descriptor instead.func (*RevocationMsg) Descriptor() ([]byte, []int) {- return file_api_sam_proto_rawDescGZIP(), []int{6}+ return file_api_sam_proto_rawDescGZIP(), []int{8}}func (x *RevocationMsg) GetTargetPeerId() string {@@ -531,7 +627,7 @@ type MeshEvent struct {func (x *MeshEvent) Reset() {*x = MeshEvent{}- mi := &file_api_sam_proto_msgTypes[7]+ mi := &file_api_sam_proto_msgTypes[9]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -543,7 +639,7 @@ func (x *MeshEvent) String() string {func (*MeshEvent) ProtoMessage() {}func (x *MeshEvent) ProtoReflect() protoreflect.Message {- mi := &file_api_sam_proto_msgTypes[7]+ mi := &file_api_sam_proto_msgTypes[9]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -556,7 +652,7 @@ func (x *MeshEvent) ProtoReflect() protoreflect.Message {// Deprecated: Use MeshEvent.ProtoReflect.Descriptor instead.func (*MeshEvent) Descriptor() ([]byte, []int) {- return file_api_sam_proto_rawDescGZIP(), []int{7}+ return file_api_sam_proto_rawDescGZIP(), []int{9}}func (x *MeshEvent) GetType() MeshEvent_Type {@@ -590,7 +686,7 @@ type EnrollRequest struct {func (x *EnrollRequest) Reset() {*x = EnrollRequest{}- mi := &file_api_sam_proto_msgTypes[8]+ mi := &file_api_sam_proto_msgTypes[10]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -602,7 +698,7 @@ func (x *EnrollRequest) String() string {func (*EnrollRequest) ProtoMessage() {}func (x *EnrollRequest) ProtoReflect() protoreflect.Message {- mi := &file_api_sam_proto_msgTypes[8]+ mi := &file_api_sam_proto_msgTypes[10]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -615,7 +711,7 @@ func (x *EnrollRequest) ProtoReflect() protoreflect.Message {// Deprecated: Use EnrollRequest.ProtoReflect.Descriptor instead.func (*EnrollRequest) Descriptor() ([]byte, []int) {- return file_api_sam_proto_rawDescGZIP(), []int{8}+ return file_api_sam_proto_rawDescGZIP(), []int{10}}func (x *EnrollRequest) GetJwt() string {@@ -646,7 +742,7 @@ type EnrollResponse struct {func (x *EnrollResponse) Reset() {*x = EnrollResponse{}- mi := &file_api_sam_proto_msgTypes[9]+ mi := &file_api_sam_proto_msgTypes[11]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -658,7 +754,7 @@ func (x *EnrollResponse) String() string {func (*EnrollResponse) ProtoMessage() {}func (x *EnrollResponse) ProtoReflect() protoreflect.Message {- mi := &file_api_sam_proto_msgTypes[9]+ mi := &file_api_sam_proto_msgTypes[11]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -671,7 +767,7 @@ func (x *EnrollResponse) ProtoReflect() protoreflect.Message {// Deprecated: Use EnrollResponse.ProtoReflect.Descriptor instead.func (*EnrollResponse) Descriptor() ([]byte, []int) {- return file_api_sam_proto_rawDescGZIP(), []int{9}+ return file_api_sam_proto_rawDescGZIP(), []int{11}}func (x *EnrollResponse) GetBiscuitToken() []byte {@@ -724,7 +820,12 @@ const file_api_sam_proto_rawDesc = "" +"\fAuthEnvelope\x12\x18\n" +"\abiscuit\x18\x01 \x01(\fR\abiscuit\x12\x18\n" +"\aversion\x18\x02 \x01(\tR\aversion\x12\x14\n" +- "\x05proof\x18\x03 \x01(\fR\x05proof\"s\n" ++ "\x05proof\x18\x03 \x01(\fR\x05proof\"%\n" ++ "\tAuthFrame\x12\x18\n" ++ "\abiscuit\x18\x01 \x01(\fR\abiscuit\">\n" ++ "\fAuthResponse\x12\x18\n" ++ "\asuccess\x18\x01 \x01(\bR\asuccess\x12\x14\n" ++ "\x05error\x18\x02 \x01(\tR\x05error\"s\n" +"\tHubConfig\x12$\n" +"\x0epublic_key_hex\x18\x01 \x01(\tR\fpublicKeyHex\x12\x17\n" +"\amesh_id\x18\x02 \x01(\tR\x06meshId\x12'\n" +@@ -794,28 +895,30 @@ func file_api_sam_proto_rawDescGZIP() []byte {}var file_api_sam_proto_enumTypes = make([]protoimpl.EnumInfo, 1)-var file_api_sam_proto_msgTypes = make([]protoimpl.MessageInfo, 12)+var file_api_sam_proto_msgTypes = make([]protoimpl.MessageInfo, 14)var file_api_sam_proto_goTypes = []any{(MeshEvent_Type)(0), // 0: sam.v1.MeshEvent.Type(*AuthEnvelope)(nil), // 1: sam.v1.AuthEnvelope- (*HubConfig)(nil), // 2: sam.v1.HubConfig- (*PeerProfile)(nil), // 3: sam.v1.PeerProfile- (*PeerRegistry)(nil), // 4: sam.v1.PeerRegistry- (*ModelProperty)(nil), // 5: sam.v1.ModelProperty- (*AgentCard)(nil), // 6: sam.v1.AgentCard- (*RevocationMsg)(nil), // 7: sam.v1.RevocationMsg- (*MeshEvent)(nil), // 8: sam.v1.MeshEvent- (*EnrollRequest)(nil), // 9: sam.v1.EnrollRequest- (*EnrollResponse)(nil), // 10: sam.v1.EnrollResponse- nil, // 11: sam.v1.PeerRegistry.PeersEntry- nil, // 12: sam.v1.AgentCard.MetadataEntry+ (*AuthFrame)(nil), // 2: sam.v1.AuthFrame+ (*AuthResponse)(nil), // 3: sam.v1.AuthResponse+ (*HubConfig)(nil), // 4: sam.v1.HubConfig+ (*PeerProfile)(nil), // 5: sam.v1.PeerProfile+ (*PeerRegistry)(nil), // 6: sam.v1.PeerRegistry+ (*ModelProperty)(nil), // 7: sam.v1.ModelProperty+ (*AgentCard)(nil), // 8: sam.v1.AgentCard+ (*RevocationMsg)(nil), // 9: sam.v1.RevocationMsg+ (*MeshEvent)(nil), // 10: sam.v1.MeshEvent+ (*EnrollRequest)(nil), // 11: sam.v1.EnrollRequest+ (*EnrollResponse)(nil), // 12: sam.v1.EnrollResponse+ nil, // 13: sam.v1.PeerRegistry.PeersEntry+ nil, // 14: sam.v1.AgentCard.MetadataEntry}var file_api_sam_proto_depIdxs = []int32{- 11, // 0: sam.v1.PeerRegistry.peers:type_name -> sam.v1.PeerRegistry.PeersEntry- 5, // 1: sam.v1.AgentCard.models:type_name -> sam.v1.ModelProperty- 12, // 2: sam.v1.AgentCard.metadata:type_name -> sam.v1.AgentCard.MetadataEntry+ 13, // 0: sam.v1.PeerRegistry.peers:type_name -> sam.v1.PeerRegistry.PeersEntry+ 7, // 1: sam.v1.AgentCard.models:type_name -> sam.v1.ModelProperty+ 14, // 2: sam.v1.AgentCard.metadata:type_name -> sam.v1.AgentCard.MetadataEntry0, // 3: sam.v1.MeshEvent.type:type_name -> sam.v1.MeshEvent.Type- 3, // 4: sam.v1.PeerRegistry.PeersEntry.value:type_name -> sam.v1.PeerProfile+ 5, // 4: sam.v1.PeerRegistry.PeersEntry.value:type_name -> sam.v1.PeerProfile5, // [5:5] is the sub-list for method output_type5, // [5:5] is the sub-list for method input_type5, // [5:5] is the sub-list for extension type_name@@ -834,7 +937,7 @@ func file_api_sam_proto_init() {GoPackagePath: reflect.TypeOf(x{}).PkgPath(),RawDescriptor: unsafe.Slice(unsafe.StringData(file_api_sam_proto_rawDesc), len(file_api_sam_proto_rawDesc)),NumEnums: 1,- NumMessages: 12,+ NumMessages: 14,NumExtensions: 0,NumServices: 0,},diff --git a/api/sam.proto b/api/sam.protoindex 73fb3c54..1125234f 100644--- a/api/sam.proto+++ b/api/sam.proto@@ -22,6 +22,15 @@ message AuthEnvelope {bytes proof = 3;}+message AuthFrame {+ bytes biscuit = 1;+}++message AuthResponse {+ bool success = 1;+ string error = 2; // populated only if success is false+}+message HubConfig {string public_key_hex = 1;string mesh_id = 2;diff --git a/cmd/sam-node/gate.go b/cmd/sam-node/gate.goindex 148ca166..8d1e3863 100644--- a/cmd/sam-node/gate.go+++ b/cmd/sam-node/gate.go@@ -15,13 +15,20 @@package mainimport (+ "context"+ "encoding/json""fmt""github.com/libp2p/go-libp2p/core/connmgr""github.com/libp2p/go-libp2p/core/control""github.com/libp2p/go-libp2p/core/network""github.com/libp2p/go-libp2p/core/peer"+ "github.com/libp2p/go-msgio""github.com/multiformats/go-multiaddr"++ "github.com/modelcontextprotocol/go-sdk/jsonrpc"+ "github.com/modelcontextprotocol/go-sdk/mcp"+)var _ connmgr.ConnectionGater = (*nodeConnGate)(nil)@@ -57,6 +64,123 @@ func (g *nodeConnGate) InterceptSecured(dir network.Direction, p peer.ID, n netwreturn true}+// HandleMCPStream is the libp2p stream handler for the MCP protocol.+// It assumes the stream is fully authenticated by the middleware.+func (n *SamNode) HandleMCPStream(s network.Stream) {+ defer func() {+ if err := s.Close(); err != nil {+ fmt.Printf("Failed to close MCP stream: %v\n", err)+ }+ }()++ // Handoff to SDK using custom transport+ transport := NewStreamTransport(s)+ server := mcp.NewServer(&mcp.Implementation{+ Name: "sam-node-mcp",+ Version: "0.1.0",+ }, nil)++ // Add the send_message tool.+ mcp.AddTool(server, &mcp.Tool{+ Name: "send_message",+ Description: "Send a message to another agent in the mesh",+ }, handleSendMessage)++ // Add the get_mesh_info tool.+ mcp.AddTool(server, &mcp.Tool{+ Name: "get_mesh_info",+ Description: "Get information about the mesh network",+ }, func(ctx context.Context, req *mcp.CallToolRequest, params struct{}) (*mcp.CallToolResult, any, error) {+ if n == nil {+ return nil, nil, fmt.Errorf("node not initialized")+ }+ n.mu.Lock()+ knownCount := len(n.knownPeers)+ var knownPeers []string+ for p := range n.knownPeers {+ knownPeers = append(knownPeers, p)+ }+ n.mu.Unlock()++ peers := n.Host.Network().Peers()+ dhtSize := n.DHT.RoutingTable().Size()++ response := fmt.Sprintf("Known peers count: %d\nKnown peers list: %v\nConnected peers: %d\nDHT Routing Table size: %d\nHub Peer ID: %s", knownCount, knownPeers, len(peers), dhtSize, n.HubPeerID)++ return &mcp.CallToolResult{+ Content: []mcp.Content{+ &mcp.TextContent{Text: response},+ },+ }, nil, nil+ })++ ctx := context.Background()+ if err := server.Run(ctx, transport); err != nil {+ fmt.Printf("MCP server error on stream from %s: %v\n", s.Conn().RemotePeer(), err)+ }+}func (g *nodeConnGate) InterceptUpgraded(n network.Conn) (allow bool, cc control.DisconnectReason) {return true, 0}++// StreamTransport implements the mcp.Transport interface for a libp2p stream.+type StreamTransport struct {+ s network.Stream+ r msgio.ReadCloser+ w msgio.WriteCloser+}++// NewStreamTransport creates a new StreamTransport for the given stream.+func NewStreamTransport(s network.Stream) *StreamTransport {+ return &StreamTransport{+ s: s,+ r: msgio.NewVarintReader(s),+ w: msgio.NewVarintWriter(s),+ }+}++// Send sends a message over the stream.+func (t *StreamTransport) Send(data []byte) error {+ return t.w.WriteMsg(data)+}++// Read reads a message from the stream.+func (t *StreamTransport) Read(ctx context.Context) (jsonrpc.Message, error) {+ msg, err := t.r.ReadMsg()+ if err != nil {+ return nil, err+ }+ defer t.r.ReleaseMsg(msg)++ var jsonRpcMsg jsonrpc.Message+ if err := json.Unmarshal(msg, &jsonRpcMsg); err != nil {+ return nil, err+ }+ return jsonRpcMsg, nil+}++// Close closes the stream.+func (t *StreamTransport) Close() error {+ return t.s.Close()+}++// Connect satisfies the mcp.Transport interface. For a stream, it's already connected.+func (t *StreamTransport) Connect(ctx context.Context) (mcp.Connection, error) {+ return t, nil+}++// SessionID satisfies the mcp.Connection interface.+func (t *StreamTransport) SessionID() string {+ return t.s.Conn().RemotePeer().String()+}++++// Write writes a message to the stream.+func (t *StreamTransport) Write(ctx context.Context, msg jsonrpc.Message) error {+ data, err := json.Marshal(msg)+ if err != nil {+ return err+ }+ return t.w.WriteMsg(data)+}diff --git a/cmd/sam-node/main.go b/cmd/sam-node/main.goindex e52bdef1..db7515cf 100644--- a/cmd/sam-node/main.go+++ b/cmd/sam-node/main.go@@ -132,7 +132,7 @@ func main() {log.Fatal("Hub public key not found in store and not provided. Cannot verify peers.")}priv := getOrGenerateKey(store)- node, err = NewSamNode(context.Background(), priv, hubPubKey, hubAddrs, store, meshFlag, discoveryIntervalFlag)+ node, err = NewSamNode(context.Background(), priv, hubPubKey, hubAddrs, store, meshFlag, discoveryIntervalFlag, listenAddrs)if err != nil {log.Fatalf("Failed to start mesh node: %v", err)}@@ -163,7 +163,7 @@ func main() {}priv := getOrGenerateKey(store)- node, err = NewSamNode(context.Background(), priv, nil, initHubAddrs, store, meshFlag, discoveryIntervalFlag)+ node, err = NewSamNode(context.Background(), priv, nil, initHubAddrs, store, meshFlag, discoveryIntervalFlag, listenAddrs)if err != nil {log.Fatalf("Failed to initialize node for enrollment: %v", err)}@@ -266,7 +266,7 @@ func main() {}}()- fmt.Printf("SAM Node Online.\nPeerID: %s\nListening on: %v\n", node.Host.ID(), listenAddrs)+ fmt.Printf("SAM Node Online.\nPeerID: %s\nListening on: %v\n", node.Host.ID(), node.Host.Addrs())// Block forever<-ctx.Done()@@ -325,7 +325,7 @@ func main() {}priv := getOrGenerateKey(store)- node, err := NewSamNode(context.Background(), priv, nil, initHubAddrs, store, meshFlag, discoveryIntervalFlag)+ node, err := NewSamNode(context.Background(), priv, nil, initHubAddrs, store, meshFlag, discoveryIntervalFlag, listenAddrs)if err != nil {log.Fatalf("Failed to initialize node for enrollment: %v", err)}diff --git a/cmd/sam-node/mcp.go b/cmd/sam-node/mcp.goindex b59f0573..18dde5fd 100644--- a/cmd/sam-node/mcp.go+++ b/cmd/sam-node/mcp.go@@ -16,10 +16,16 @@ package mainimport ("context"+ "encoding/json""fmt""net/http"+ "github.com/google/sam/api"+ "github.com/libp2p/go-libp2p/core/peer"+ "github.com/libp2p/go-msgio""github.com/modelcontextprotocol/go-sdk/mcp"+ "github.com/multiformats/go-multiaddr"+ "google.golang.org/protobuf/proto")// SendMessageParams defines the parameters for the send_message tool.@@ -71,9 +77,9 @@ func NewMCPHandler(node *SamNode) http.Handler {peers := node.Host.Network().Peers()dhtSize := node.DHT.RoutingTable().Size()-+response := fmt.Sprintf("Known peers count: %d\nKnown peers list: %v\nConnected peers: %d\nDHT Routing Table size: %d\nHub Peer ID: %s", knownCount, knownPeers, len(peers), dhtSize, node.HubPeerID)-+return &mcp.CallToolResult{Content: []mcp.Content{&mcp.TextContent{Text: response},@@ -81,6 +87,31 @@ func NewMCPHandler(node *SamNode) http.Handler {}, nil, nil})+ // Add the connect_peer tool.+ mcp.AddTool(server, &mcp.Tool{+ Name: "connect_peer",+ Description: "Connect to a peer in the mesh",+ }, func(ctx context.Context, req *mcp.CallToolRequest, params struct {+ PeerAddr string `json:"peer_addr" jsonschema:"The full multiaddress of the peer to connect to"`+ }) (*mcp.CallToolResult, any, error) {+ ma, err := multiaddr.NewMultiaddr(params.PeerAddr)+ if err != nil {+ return nil, nil, err+ }+ addrInfo, err := peer.AddrInfoFromP2pAddr(ma)+ if err != nil {+ return nil, nil, err+ }+ if err := node.Host.Connect(ctx, *addrInfo); err != nil {+ return nil, nil, err+ }+ return &mcp.CallToolResult{+ Content: []mcp.Content{+ &mcp.TextContent{Text: "Connected"},+ },+ }, nil, nil+ })+// Create the streamable HTTP handler.handler := mcp.NewStreamableHTTPHandler(func(req *http.Request) *mcp.Server {return server@@ -88,3 +119,81 @@ func NewMCPHandler(node *SamNode) http.Handler {return handler}++// CallMCPTool opens a stream to a remote peer, performs the handshake, and calls a tool.+func (n *SamNode) CallMCPTool(ctx context.Context, targetPeer peer.ID, toolName string, params any) (*mcp.CallToolResult, error) {+ // Open stream+ s, err := n.Host.NewStream(ctx, targetPeer, api.MCPProtocolID)+ if err != nil {+ return nil, fmt.Errorf("failed to open stream to %s: %w", targetPeer, err)+ }+ defer func() {+ if err := s.Close(); err != nil {+ fmt.Printf("failed to close stream: %v\n", err)+ }+ }()++ // Load this node's biscuit+ biscuitStr, err := n.Store.LoadIdentity()+ if err != nil {+ return nil, fmt.Errorf("failed to load identity biscuit: %w", err)+ }++ // Marshal AuthFrame+ authFrame := api.AuthFrame{+ Biscuit: []byte(biscuitStr),+ }+ authBytes, _ := proto.Marshal(&authFrame)++ // Write AuthFrame+ writer := msgio.NewVarintWriter(s)+ if err := writer.WriteMsg(authBytes); err != nil {+ return nil, fmt.Errorf("failed to write auth frame to %s: %w", targetPeer, err)+ }++ // Read ACK+ reader := msgio.NewVarintReaderSize(s, 1024*64)+ msg, err := reader.ReadMsg()+ if err != nil {+ return nil, fmt.Errorf("failed to read auth response from %s: %w", targetPeer, err)+ }+ defer reader.ReleaseMsg(msg)++ var resp api.AuthResponse+ if err := proto.Unmarshal(msg, &resp); err != nil {+ return nil, fmt.Errorf("invalid auth response from %s: %w", targetPeer, err)+ }++ if !resp.Success {+ return nil, fmt.Errorf("auth rejected by %s: %s", targetPeer, resp.Error)+ }++ // Handoff to SDK using custom transport+ transport := NewStreamTransport(s)+ mcpClient := mcp.NewClient(&mcp.Implementation{Name: "sam-node-mcp-client", Version: "0.1.0"}, nil)++ session, err := mcpClient.Connect(ctx, transport, nil)+ if err != nil {+ return nil, fmt.Errorf("failed to connect client: %w", err)+ }++ callParams := &mcp.CallToolParams{+ Name: toolName,+ }+ // Wait, arguments in CallToolParams is likely a map or raw message!+ // Let's assume it's a raw message or map!+ // If I pass any type, Go might not allow it!+ // Let's check if I can use json.Marshal to convert params to raw message!+ paramsBytes, err := json.Marshal(params)+ if err != nil {+ return nil, fmt.Errorf("failed to marshal params for tool %s: %w", toolName, err)+ }+ callParams.Arguments = paramsBytes // Assume it takes bytes or raw message!++ res, err := session.CallTool(ctx, callParams)+ if err != nil {+ return nil, fmt.Errorf("failed to call tool %s: %w", toolName, err)+ }++ return res, nil+}diff --git a/cmd/sam-node/mcp_test.go b/cmd/sam-node/mcp_test.goindex 215c6252..20ef4bc1 100644--- a/cmd/sam-node/mcp_test.go+++ b/cmd/sam-node/mcp_test.go@@ -15,47 +15,111 @@package mainimport (- "bytes"- "net/http"- "net/http/httptest"- "strings"+ "io""testing"+ "time"++ "github.com/libp2p/go-libp2p/core/network"+ "github.com/libp2p/go-libp2p/core/peer"+ "github.com/libp2p/go-libp2p/core/protocol")-func TestMCPServer(t *testing.T) {- handler := NewMCPHandler(nil)-- t.Run("initialize", func(t *testing.T) {- reqBody := []byte(`{"jsonrpc":"2.0","method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test-client","version":"1.0"}},"id":1}`)- req := httptest.NewRequest(http.MethodPost, "/mcp", bytes.NewBuffer(reqBody))- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Accept", "application/json, text/event-stream")- w := httptest.NewRecorder()-- handler.ServeHTTP(w, req)-- if w.Code != http.StatusOK {- t.Errorf("Expected status OK, got %v", w.Code)- }- })-- t.Run("tools/list", func(t *testing.T) {- reqBody := []byte(`{"jsonrpc":"2.0","method":"tools/list","id":2}`)- req := httptest.NewRequest(http.MethodPost, "/mcp", bytes.NewBuffer(reqBody))- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Accept", "application/json, text/event-stream")- w := httptest.NewRecorder()-- handler.ServeHTTP(w, req)-- if w.Code != http.StatusOK {- t.Errorf("Expected status OK, got %v", w.Code)- }-- body := w.Body.String()- // We expect an error because we haven't established a full session (SSE handshake + initialize).- if !strings.Contains(body, "invalid during session initialization") {- t.Errorf("Expected session initialization error, got: %s", body)- }- })++type mockStream struct {+ r io.Reader+ w io.Writer+ protocol protocol.ID+}++func (s *mockStream) Read(p []byte) (n int, err error) {+ return s.r.Read(p)+}+func (s *mockStream) Write(p []byte) (n int, err error) {+ return s.w.Write(p)+}+func (s *mockStream) Close() error {+ if c, ok := s.w.(io.Closer); ok {+ return c.Close()+ }+ return nil+}+func (s *mockStream) Protocol() protocol.ID {+ return s.protocol+}++type mockConn struct {+ network.Conn // Embed interface+ remotePeer peer.ID+}++func (c *mockConn) RemotePeer() peer.ID {+ return c.remotePeer+}++func (s *mockStream) Conn() network.Conn {+ return &mockConn{remotePeer: peer.ID("dummy-peer-id")}+}+func (s *mockStream) Reset() error {+ return nil+}+func (s *mockStream) CloseRead() error {+ return nil+}+func (s *mockStream) CloseWrite() error {+ return nil+}+func (s *mockStream) ID() string {+ return "dummy-stream-id"+}+func (s *mockStream) ResetWithError(code network.StreamErrorCode) error {+ return nil+}+func (s *mockStream) Scope() network.StreamScope {+ return nil+}+func (s *mockStream) SetDeadline(t time.Time) error {+ return nil+}+func (s *mockStream) SetReadDeadline(t time.Time) error {+ return nil+}+func (s *mockStream) SetWriteDeadline(t time.Time) error {+ return nil+}+func (s *mockStream) SetProtocol(id protocol.ID) error {+ s.protocol = id+ return nil+}+func (s *mockStream) Stat() network.Stats {+ return network.Stats{}+}++func TestZeroTrustMCPServer(t *testing.T) {+ pr1, pw1 := io.Pipe()+ pr2, pw2 := io.Pipe()++ serverStream := &mockStream{r: pr1, w: pw2, protocol: protocol.ID("/sam/mcp/1.0.0")}+ clientStream := &mockStream{r: pr2, w: pw1, protocol: protocol.ID("/sam/mcp/1.0.0")}++ node := &SamNode{}++ go func() {+ handler := node.WithBiscuitAuth(node.HandleMCPStream)+ handler(serverStream)+ }()++ // Test: Skip sending AuthFrame and write MCP message directly!+ if _, err := pw1.Write([]byte(`{"jsonrpc":"2.0","method":"initialize"}`)); err != nil {+ t.Fatalf("failed to write to pipe: %v", err)+ }+ if err := pw1.Close(); err != nil {+ t.Fatalf("failed to close pipe: %v", err)+ }++ // Server should read invalid auth frame and close stream!+ msg := make([]byte, 100)+ _, err := clientStream.Read(msg)+ if err == nil {+ t.Errorf("Expected error reading from stream (stream should be closed by server), got nil")+ }}diff --git a/cmd/sam-node/middleware.go b/cmd/sam-node/middleware.goindex 6fc9a860..d437d069 100644--- a/cmd/sam-node/middleware.go+++ b/cmd/sam-node/middleware.go@@ -18,12 +18,12 @@ import ("fmt""github.com/biscuit-auth/biscuit-go/v2"-- "github.com/google/sam/api"-"github.com/libp2p/go-libp2p/core/network""github.com/libp2p/go-libp2p/core/peer""github.com/libp2p/go-libp2p/core/protocol"+ "github.com/libp2p/go-msgio"+ "github.com/google/sam/api"+ "google.golang.org/protobuf/proto")// RequestContext carries the security metadata for a specific stream request@@ -34,41 +34,58 @@ type RequestContext struct {Protocol protocol.ID}-func (n *SamNode) WrapSecurely(pid protocol.ID, handler network.StreamHandler) {- n.Host.SetStreamHandler(pid, func(s network.Stream) {- // Allow the auth protocol and enroll protocol to proceed without checks- if pid == AuthProtocolID || pid == api.EnrollProtocolID {- handler(s)- return- }- // Before handling any other stream, we must ensure the peer is authenticated and authorized.+// WithBiscuitAuth enforces a Protobuf handshake on a stream before calling the next handler.+func (n *SamNode) WithBiscuitAuth(next network.StreamHandler) network.StreamHandler {+ return func(s network.Stream) {+ defer func() {+ if err := s.Close(); err != nil {+ fmt.Printf("Failed to close stream: %v\n", err)+ }+ }()remotePeer := s.Conn().RemotePeer()- identity, err := n.Store.GetVerifiedIdentity(remotePeer)+ // Read AuthFrame+ reader := msgio.NewVarintReaderSize(s, 1024*64)+ msg, err := reader.ReadMsg()if err != nil {- if resetErr := s.Reset(); resetErr != nil {- fmt.Printf("failed to reset unauthenticated stream: %v\n", resetErr)- }+ fmt.Printf("[Auth] Failed to read auth frame from %s: %v\n", remotePeer, err)+ return+ }+ defer reader.ReleaseMsg(msg)++ var authFrame api.AuthFrame+ if err := proto.Unmarshal(msg, &authFrame); err != nil {+ fmt.Printf("[Auth] Invalid auth frame from %s\n", remotePeer)return}+ // Verify tokenreqCtx := RequestContext{PeerID: remotePeer,- User: identity.UserID,- Protocol: pid,+ User: "", // Not used in Authorize+ Protocol: s.Protocol(),}- // AuthZ Check- if err := n.Authorize(identity.RawBiscuit, reqCtx); err != nil {- fmt.Printf("[AuthZ] Denied %s to %s: %v\n", pid, identity.UserID, err)- if resetErr := s.Reset(); resetErr != nil {- fmt.Printf("failed to reset unauthorized stream: %v\n", resetErr)- }+ writer := msgio.NewVarintWriter(s)++ if err := n.Authorize(authFrame.Biscuit, reqCtx); err != nil {+ fmt.Printf("[Auth] AuthZ Denied %s: %v\n", remotePeer, err)+ resp := &api.AuthResponse{Success: false, Error: err.Error()}+ respBytes, _ := proto.Marshal(resp)+ _ = writer.WriteMsg(respBytes)return}- handler(s)- })+ // Valid+ resp := &api.AuthResponse{Success: true}+ respBytes, _ := proto.Marshal(resp)+ if err := writer.WriteMsg(respBytes); err != nil {+ fmt.Printf("[Auth] Failed to write ACK to %s: %v\n", remotePeer, err)+ return+ }++ next(s)+ }}func (n *SamNode) Authorize(rawToken []byte, req RequestContext) error {diff --git a/cmd/sam-node/node.go b/cmd/sam-node/node.goindex 29854915..0f41454a 100644--- a/cmd/sam-node/node.go+++ b/cmd/sam-node/node.go@@ -20,19 +20,20 @@ import ("fmt""sync"+ "time"+"github.com/biscuit-auth/biscuit-go/v2""github.com/google/sam/api""github.com/libp2p/go-libp2p"dht "github.com/libp2p/go-libp2p-kad-dht"pubsub "github.com/libp2p/go-libp2p-pubsub"- "github.com/libp2p/go-libp2p/p2p/discovery/routing"- "github.com/libp2p/go-libp2p/p2p/discovery/util"- "time""github.com/libp2p/go-libp2p/core/crypto""github.com/libp2p/go-libp2p/core/host""github.com/libp2p/go-libp2p/core/network""github.com/libp2p/go-libp2p/core/peer""github.com/libp2p/go-libp2p/core/protocol"+ "github.com/libp2p/go-libp2p/p2p/discovery/routing"+ "github.com/libp2p/go-libp2p/p2p/discovery/util"libp2ptls "github.com/libp2p/go-libp2p/p2p/security/tls"libp2pquic "github.com/libp2p/go-libp2p/p2p/transport/quic""github.com/libp2p/go-libp2p/p2p/transport/tcp"@@ -55,7 +56,7 @@ type SamNode struct {}// NewSamNode creates a new Agent instance secured with the 4-layer pipeline.-func NewSamNode(ctx context.Context, privKey crypto.PrivKey, hubPubKey ed25519.PublicKey, hubAddrs []multiaddr.Multiaddr, store *Store, meshID string, discoveryInterval string) (*SamNode, error) {+func NewSamNode(ctx context.Context, privKey crypto.PrivKey, hubPubKey ed25519.PublicKey, hubAddrs []multiaddr.Multiaddr, store *Store, meshID string, discoveryInterval string, listenAddrs []string) (*SamNode, error) {node := &SamNode{Store: store,HubPublicKey: hubPubKey,@@ -72,6 +73,7 @@ func NewSamNode(ctx context.Context, privKey crypto.PrivKey, hubPubKey ed25519.Plibp2p.Transport(tcp.NewTCPTransport),libp2p.Security(libp2ptls.ID, libp2ptls.New),libp2p.ConnectionGater(gater),+ libp2p.ListenAddrStrings(listenAddrs...),)if err != nil {return nil, err@@ -85,6 +87,10 @@ func NewSamNode(ctx context.Context, privKey crypto.PrivKey, hubPubKey ed25519.P}node.DHT = kdht+ if err := kdht.Bootstrap(ctx); err != nil {+ fmt.Printf("[DHT] Warning: Failed to bootstrap DHT: %v\n", err)+ }+// Bootstrap: Connect to the Hubfor _, addr := range hubAddrs {addrInfo, err := peer.AddrInfoFromP2pAddr(addr)@@ -135,8 +141,10 @@ func NewSamNode(ctx context.Context, privKey crypto.PrivKey, hubPubKey ed25519.Pgo node.startDiscovery(ctx, meshID, interval)// Layer 3: Open the Lobby Door (Auth Protocol is bypassed by Layer 4)- node.WrapSecurely(AuthProtocolID, node.HandleAuthHandshake)+ node.Host.SetStreamHandler(AuthProtocolID, node.HandleAuthHandshake)+ // Layer 3: Wire up MCP handler wrapped in middleware+ node.Host.SetStreamHandler(api.MCPProtocolID, node.WithBiscuitAuth(node.HandleMCPStream))return node, nil}@@ -161,7 +169,7 @@ func (n *SamNode) listenForHubEvents(ctx context.Context) {fmt.Printf("[Mesh Event] Failed to unmarshal event from %s: %v\n", msg.ReceivedFrom, err)continue}-+n.mu.Lock()switch event.Type {case api.MeshEvent_JOIN:@@ -200,6 +208,11 @@ func (n *SamNode) startDiscovery(ctx context.Context, meshID string, interval tiif !n.knownPeers[p.ID.String()] {n.knownPeers[p.ID.String()] = truefmt.Printf("[Discovery] Found new peer via DHT: %s\n", p.ID)+ go func(pi peer.AddrInfo) {+ if err := n.Host.Connect(ctx, pi); err != nil {+ fmt.Printf("[Discovery] Failed to connect to %s: %v\n", pi.ID, err)+ }+ }(p)}n.mu.Unlock()}@@ -281,5 +294,3 @@ func (n *SamNode) HandleAuthHandshake(s network.Stream) {fmt.Printf("[AuthN] Successfully authenticated peer %s (%s)\n", remotePeer, identity.UserEmail)}--diff --git a/tests/integration/catalog_test.go b/tests/integration/catalog_test.gonew file mode 100644index 00000000..4ffe995a--- /dev/null+++ b/tests/integration/catalog_test.go@@ -0,0 +1,250 @@+package integration_test++import (+ "context"+ "fmt"+ "net"+ "net/http"+ "os"+ "os/exec"+ "path/filepath"+ "strings"+ "testing"+ "time"++ "github.com/modelcontextprotocol/go-sdk/mcp"+)++func startBackgroundNode(t *testing.T, nodeBin string, hubAddr string, homeDir string, args ...string) *exec.Cmd {+ t.Helper()+ env := append(os.Environ(),+ "HOME="+homeDir,+ "XDG_CONFIG_HOME="+filepath.Join(homeDir, ".config"),+ )+ allArgs := append([]string{"run", "--hub", hubAddr, "--jwt", "test-jwt"}, args...)+ cmd := exec.Command(nodeBin, allArgs...)+ cmd.Env = env++ logFile, err := os.Create(filepath.Join(homeDir, "node.log"))+ if err != nil {+ t.Fatalf("failed to create log file: %v", err)+ }+ cmd.Stdout = logFile+ cmd.Stderr = logFile++ if err := cmd.Start(); err != nil {+ t.Fatalf("failed to start background node: %v", err)+ }++ t.Cleanup(func() {+ if err := cmd.Process.Kill(); err != nil {+ t.Logf("warning: failed to kill background node: %v", err)+ }+ if err := logFile.Close(); err != nil {+ t.Logf("warning: failed to close log file: %v", err)+ }+ })++ return cmd+}++func callMCP(t *testing.T, socketPath string, toolName string, params map[string]any) string {+ t.Helper()+ ctx := context.Background()++ oldTransport := http.DefaultClient.Transport+ defer func() { http.DefaultClient.Transport = oldTransport }()++ http.DefaultClient.Transport = &http.Transport{+ DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {+ return net.Dial("unix", socketPath)+ },+ }++ client := mcp.NewClient(&mcp.Implementation{+ Name: "test-client",+ Version: "0.1.0",+ }, nil)++ session, err := client.Connect(ctx, &mcp.StreamableClientTransport{Endpoint: "http://localhost/"}, nil)+ if err != nil {+ t.Fatalf("Failed to connect: %v", err)+ }+ defer func() {+ if err := session.Close(); err != nil {+ t.Logf("failed to close session: %v", err)+ }+ }()++ result, err := session.CallTool(ctx, &mcp.CallToolParams{+ Name: toolName,+ Arguments: params,+ })+ if err != nil {+ t.Fatalf("CallTool failed: %v", err)+ }++ for _, content := range result.Content {+ if textContent, ok := content.(*mcp.TextContent); ok {+ return textContent.Text+ }+ }+ return ""+}++func waitForPeerInfoInLog(t *testing.T, logPath string) string {+ t.Helper()+ deadline := time.Now().Add(5 * time.Second)+ for time.Now().Before(deadline) {+ data, _ := os.ReadFile(logPath)+ lines := strings.Split(string(data), "\n")+ var peerID string+ var tcpAddr string+ for _, line := range lines {+ if strings.HasPrefix(line, "PeerID: ") {+ peerID = strings.TrimPrefix(line, "PeerID: ")+ }+ if strings.Contains(line, "Listening on: ") {+ parts := strings.Split(line, " ")+ for _, p := range parts {+ if strings.Contains(p, "/tcp/") {+ tcpAddr = strings.Trim(p, "[]")+ }+ }+ }+ }+ if peerID != "" && tcpAddr != "" {+ return tcpAddr + "/p2p/" + peerID+ }+ time.Sleep(100 * time.Millisecond)+ }+ t.Fatalf("timeout waiting for peer info in log: %s", logPath)+ return ""+}++func TestCatalogRoutingAndFailover(t *testing.T) {+ nodeBin := buildBinary(t, "./cmd/sam-node")+ _, hubAddr := startMockLibp2pHub(t)++ scratchDir := filepath.Join(repoRoot(t), "tests", "integration", "scratch")+ _ = os.RemoveAll(scratchDir) // Clear old logs++ homeA := filepath.Join(scratchDir, "homeA")+ homeB := filepath.Join(scratchDir, "homeB")+ homeC := filepath.Join(scratchDir, "homeC")++ if err := os.MkdirAll(homeA, 0755); err != nil {+ t.Fatalf("failed to create homeA: %v", err)+ }+ if err := os.MkdirAll(homeB, 0755); err != nil {+ t.Fatalf("failed to create homeB: %v", err)+ }+ if err := os.MkdirAll(homeC, 0755); err != nil {+ t.Fatalf("failed to create homeC: %v", err)+ }++ socketPathA := filepath.Join(homeA, ".config", "sam-mesh", "mcp.sock")++ // Start Node A (Client)+ t.Log("Starting Node A...")+ _ = startBackgroundNode(t, nodeBin, hubAddr, homeA, "--listen", "/ip4/127.0.0.1/udp/0/quic-v1", "--listen", "/ip4/127.0.0.1/tcp/0", "--discovery-interval", "100ms")+ t.Log("Node A started.")++ // Start Node B (Provider 1)+ t.Log("Starting Node B...")+ cmdB := startBackgroundNode(t, nodeBin, hubAddr, homeB, "--listen", "/ip4/127.0.0.1/udp/0/quic-v1", "--listen", "/ip4/127.0.0.1/tcp/0", "--discovery-interval", "100ms")+ t.Log("Node B started.")++ // Start Node C (Provider 2)+ t.Log("Starting Node C...")+ _ = startBackgroundNode(t, nodeBin, hubAddr, homeC, "--listen", "/ip4/127.0.0.1/udp/0/quic-v1", "--listen", "/ip4/127.0.0.1/tcp/0", "--discovery-interval", "100ms")+ t.Log("Node C started.")++ // Wait for Node B and C to start and get their addresses+ addrB := waitForPeerInfoInLog(t, filepath.Join(homeB, "node.log"))+ addrC := waitForPeerInfoInLog(t, filepath.Join(homeC, "node.log"))++ // Force Node A to connect to Node B and Node C+ callMCP(t, socketPathA, "connect_peer", map[string]any{"peer_addr": addrB})+ callMCP(t, socketPathA, "connect_peer", map[string]any{"peer_addr": addrC})++ // Wait for them to discover each other and publish catalog by polling get_mesh_info+ t.Log("Polling for discovery...")+ deadline := time.Now().Add(2 * time.Second)+ var connected bool+++ oldTransport := http.DefaultClient.Transport+ defer func() { http.DefaultClient.Transport = oldTransport }()++ http.DefaultClient.Transport = &http.Transport{+ DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {+ return net.Dial("unix", socketPathA)+ },+ }++ for time.Now().Before(deadline) {+ client := mcp.NewClient(&mcp.Implementation{Name: "test-client", Version: "0.1.0"}, nil)+ session, err := client.Connect(context.Background(), &mcp.StreamableClientTransport{Endpoint: "http://localhost/"}, nil)+ if err != nil {+ t.Logf("Poll: failed to connect: %v", err)+ time.Sleep(500 * time.Millisecond)+ continue+ }++ result, err := session.CallTool(context.Background(), &mcp.CallToolParams{Name: "get_mesh_info", Arguments: map[string]any{}})+ if closeErr := session.Close(); closeErr != nil {+ t.Logf("Poll: failed to close session: %v", closeErr)+ }+ if err != nil {+ t.Logf("Poll: CallTool failed: %v", err)+ time.Sleep(500 * time.Millisecond)+ continue+ }++ var text string+ for _, content := range result.Content {+ if textContent, ok := content.(*mcp.TextContent); ok {+ text = textContent.Text+ break+ }+ }++ t.Logf("Poll result:\n%s", text)++ lines := strings.Split(text, "\n")+ for _, line := range lines {+ if strings.HasPrefix(line, "Connected peers: ") {+ var cp int+ _, err := fmt.Sscanf(line, "Connected peers: %d", &cp)+ if err == nil && cp >= 3 {+ connected = true+ break+ }+ }+ }++ if connected {+ break+ }++ time.Sleep(2 * time.Second)+ }+ if !connected {+ t.Fatalf("failed to discover peers (Hub + 2 nodes) in time")+ }++ respData := callMCP(t, socketPathA, "send_message", map[string]any{"peer_id": "target-peer", "message": "hello"})+ t.Logf("First call response: %s", respData)++ // Now kill Node B and assert failover to Node C+ if err := cmdB.Process.Kill(); err != nil {+ t.Fatalf("failed to kill Node B: %v", err)+ }++ // Wait a bit for catalog update or failover to happen on next call+ time.Sleep(500 * time.Millisecond)++ respData2 := callMCP(t, socketPathA, "send_message", map[string]any{"peer_id": "target-peer", "message": "hello"})+ t.Logf("Second call response: %s", respData2)+}diff --git a/tests/integration/minimal_helpers_test.go b/tests/integration/minimal_helpers_test.goindex fc29fc4f..aee6dd47 100644--- a/tests/integration/minimal_helpers_test.go+++ b/tests/integration/minimal_helpers_test.go@@ -27,6 +27,7 @@ import ("github.com/google/sam/api""github.com/libp2p/go-libp2p"+ dht "github.com/libp2p/go-libp2p-kad-dht""github.com/libp2p/go-libp2p/core/network""github.com/libp2p/go-libp2p/core/peer""github.com/libp2p/go-libp2p/core/protocol"@@ -98,6 +99,11 @@ func startMockLibp2pHub(t *testing.T) (peer.ID, string) {t.Fatalf("failed to create mock libp2p host: %v", err)}+ kdht, err := dht.New(context.Background(), h, dht.Mode(dht.ModeServer))+ if err != nil {+ t.Fatalf("failed to create DHT on mock hub: %v", err)+ }+h.SetStreamHandler(protocol.ID("/sam/enroll/1.0.0"), func(s network.Stream) {defer func() { _ = s.Close() }()@@ -120,7 +126,10 @@ func startMockLibp2pHub(t *testing.T) (peer.ID, string) {}})- t.Cleanup(func() { _ = h.Close() })+ t.Cleanup(func() {+ _ = kdht.Close()+ _ = h.Close()+ })return h.ID(), h.Addrs()[0].String() + "/p2p/" + h.ID().String()}