Skip to content

Agent Mesh

add mcp auth

Antonio Ojeaa27ac6995568
diff --git a/api/constants.go b/api/constants.go
index e7ec9414..02e71ebf 100644
--- a/api/constants.go
+++ b/api/constants.go
@@ -17,4 +17,5 @@ package api
import "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.go
index 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.MetadataEntry
0, // 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.PeerProfile
5, // [5:5] is the sub-list for method output_type
5, // [5:5] is the sub-list for method input_type
5, // [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.proto
index 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.go
index 148ca166..8d1e3863 100644
--- a/cmd/sam-node/gate.go
+++ b/cmd/sam-node/gate.go
@@ -15,13 +15,20 @@
package main
import (
+ "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 netw
return 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.go
index 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.go
index b59f0573..18dde5fd 100644
--- a/cmd/sam-node/mcp.go
+++ b/cmd/sam-node/mcp.go
@@ -16,10 +16,16 @@ package main
import (
"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.go
index 215c6252..20ef4bc1 100644
--- a/cmd/sam-node/mcp_test.go
+++ b/cmd/sam-node/mcp_test.go
@@ -15,47 +15,111 @@
package main
import (
- "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.go
index 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 token
reqCtx := 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.go
index 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.P
libp2p.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 Hub
for _, addr := range hubAddrs {
addrInfo, err := peer.AddrInfoFromP2pAddr(addr)
@@ -135,8 +141,10 @@ func NewSamNode(ctx context.Context, privKey crypto.PrivKey, hubPubKey ed25519.P
go 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 ti
if !n.knownPeers[p.ID.String()] {
n.knownPeers[p.ID.String()] = true
fmt.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.go
new file mode 100644
index 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.go
index 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()
}