Skip to content

Agent Mesh

hub node mesh

Antonio Ojea3c82304fcb4d
diff --git a/cmd/sam-hub/main.go b/cmd/sam-hub/main.go
index 86206b95..453140d5 100644
--- a/cmd/sam-hub/main.go
+++ b/cmd/sam-hub/main.go
@@ -51,6 +51,7 @@ import (
"github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/relay"
libp2ptls "github.com/libp2p/go-libp2p/p2p/security/tls"
"github.com/multiformats/go-multiaddr"
+ madns "github.com/multiformats/go-multiaddr-dns"
"golang.org/x/time/rate"
@@ -58,6 +59,20 @@ import (
"google.golang.org/protobuf/proto"
)
+func init() {
+ if dnsServer := os.Getenv("SAM_TEST_DNS_SERVER"); dnsServer != "" {
+ customResolver := &net.Resolver{
+ PreferGo: true,
+ Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
+ d := net.Dialer{Timeout: 5 * time.Second}
+ return d.DialContext(ctx, "udp", dnsServer)
+ },
+ }
+ net.DefaultResolver = customResolver
+ madns.DefaultResolver, _ = madns.NewResolver(madns.WithDefaultResolver(customResolver))
+ }
+}
+
const (
GracePeriod = 60 * time.Second
@@ -635,6 +650,10 @@ func main() {
// Start key rotation if enabled
h.startRotation(ctx)
+ if len(externalMultiaddrs) > 0 {
+ go startBootstrapFederation(ctx, h, externalMultiaddrs)
+ }
+
mux := http.NewServeMux()
mux.Handle("/metrics", promhttp.HandlerFor(prometheus.DefaultGatherer, promhttp.HandlerOpts{}))
mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
@@ -899,3 +918,46 @@ func (h *Hub) HandleAuthHandshake(s network.Stream) {
logger.Errorf("[AuthN] Failed to write ACK to %s: %v", remotePeer, err)
}
}
+
+func startBootstrapFederation(ctx context.Context, h *Hub, peers []string) {
+ if len(peers) == 0 {
+ return
+ }
+ ticker := time.NewTicker(30 * time.Second)
+ defer ticker.Stop()
+
+ connectBootstrap(ctx, h, peers)
+
+ for {
+ select {
+ case <-ctx.Done():
+ return
+ case <-ticker.C:
+ connectBootstrap(ctx, h, peers)
+ }
+ }
+}
+
+func connectBootstrap(ctx context.Context, h *Hub, peers []string) {
+ for _, peerStr := range peers {
+ ma, err := multiaddr.NewMultiaddr(peerStr)
+ if err != nil {
+ continue
+ }
+ resolvedAddrs, err := madns.DefaultResolver.Resolve(ctx, ma)
+ if err != nil {
+ resolvedAddrs = []multiaddr.Multiaddr{ma}
+ }
+ for _, resolved := range resolvedAddrs {
+ pi, err := peer.AddrInfoFromP2pAddr(resolved)
+ if err != nil || pi.ID == h.Host.ID() {
+ continue
+ }
+ if len(h.Host.Network().ConnsToPeer(pi.ID)) == 0 {
+ if err := h.Host.Connect(ctx, *pi); err == nil {
+ logger.Infof("[Federation] Connected to bootstrap peer: %s via %s", pi.ID, peerStr)
+ }
+ }
+ }
+ }
+}
diff --git a/cmd/sam-node/main.go b/cmd/sam-node/main.go
index 8954cd14..41c56bdf 100644
--- a/cmd/sam-node/main.go
+++ b/cmd/sam-node/main.go
@@ -249,6 +249,7 @@ func main() {
newHubAddrs = append(newHubAddrs, ma)
}
+ logger.Debugf("listenAddrs: %v, allowLoopback: %v", listenAddrs, allowLoopbackFlag)
node, err = NewSamNode(context.Background(), priv, hubPubKey, newHubAddrs, store, meshFlag, discoveryIntervalFlag, listenAddrs, enableRelayFlag, nodeConfig, keyGracePeriodFlag, allowLoopbackFlag)
if err != nil {
logger.Fatalf("Failed to start mesh node after enrollment: %v", err)
diff --git a/go.mod b/go.mod
index 1048618c..9da3ff9f 100644
--- a/go.mod
+++ b/go.mod
@@ -17,12 +17,14 @@ require (
github.com/libp2p/go-msgio v0.3.0
github.com/modelcontextprotocol/go-sdk v1.6.1
github.com/multiformats/go-multiaddr v0.16.1
+ github.com/multiformats/go-multiaddr-dns v0.5.0
github.com/multiformats/go-multihash v0.2.3
github.com/openai/openai-go v1.12.0
github.com/prometheus/client_golang v1.23.2
github.com/prometheus/client_model v0.6.2
github.com/spf13/cobra v1.10.2
go.etcd.io/bbolt v1.4.3
+ golang.org/x/net v0.55.0
golang.org/x/oauth2 v0.36.0
golang.org/x/time v0.15.0
google.golang.org/protobuf v1.36.11
@@ -77,7 +79,6 @@ require (
github.com/mr-tron/base58 v1.3.0 // indirect
github.com/multiformats/go-base32 v0.1.0 // indirect
github.com/multiformats/go-base36 v0.2.0 // indirect
- github.com/multiformats/go-multiaddr-dns v0.5.0 // indirect
github.com/multiformats/go-multiaddr-fmt v0.1.0 // indirect
github.com/multiformats/go-multibase v0.3.0 // indirect
github.com/multiformats/go-multicodec v0.10.0 // indirect
@@ -130,7 +131,6 @@ require (
golang.org/x/crypto v0.52.0 // indirect
golang.org/x/exp v0.0.0-20260603202125-055de637280b // indirect
golang.org/x/mod v0.36.0 // indirect
- golang.org/x/net v0.55.0 // indirect
golang.org/x/sync v0.20.0 // indirect
golang.org/x/sys v0.45.0 // indirect
golang.org/x/telemetry v0.0.0-20260603145448-488200d49c17 // indirect
diff --git a/tests/integration/fakedns_test.go b/tests/integration/fakedns_test.go
new file mode 100644
index 00000000..8f56216d
--- /dev/null
+++ b/tests/integration/fakedns_test.go
@@ -0,0 +1,140 @@
+package integration_test
+
+import (
+ "context"
+ "fmt"
+ "net"
+ "strings"
+ "sync"
+ "testing"
+
+ "golang.org/x/net/dns/dnsmessage"
+)
+
+var dnsHijackLock sync.Mutex
+
+type FakeDNSServer struct {
+ hosts map[string]net.IP
+ txtHosts map[string][]string
+ conn *net.UDPConn
+ mu sync.RWMutex
+}
+
+func NewFakeDNSServer(hosts map[string]string, txtHosts map[string][]string) (*FakeDNSServer, error) {
+ parsedHosts := make(map[string]net.IP, len(hosts))
+ for domain, ipStr := range hosts {
+ ip := net.ParseIP(ipStr)
+ if ip == nil {
+ return nil, fmt.Errorf("invalid IP address for domain %s: %s", domain, ipStr)
+ }
+ parsedHosts[strings.TrimSuffix(domain, ".")] = ip
+ }
+
+ parsedTxtHosts := make(map[string][]string, len(txtHosts))
+ for domain, txts := range txtHosts {
+ parsedTxtHosts[strings.TrimSuffix(domain, ".")] = txts
+ }
+
+ addr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
+ if err != nil {
+ return nil, err
+ }
+ conn, err := net.ListenUDP("udp", addr)
+ if err != nil {
+ return nil, err
+ }
+
+ server := &FakeDNSServer{
+ hosts: parsedHosts,
+ txtHosts: parsedTxtHosts,
+ conn: conn,
+ }
+ go server.serve()
+ return server, nil
+}
+
+func (s *FakeDNSServer) UpdateTXT(domain string, txts []string) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ s.txtHosts[strings.TrimSuffix(domain, ".")] = txts
+}
+
+func (s *FakeDNSServer) serve() {
+ buf := make([]byte, 512)
+ for {
+ n, addr, err := s.conn.ReadFromUDP(buf)
+ if err != nil {
+ return
+ }
+ var msg dnsmessage.Message
+ if err := msg.Unpack(buf[:n]); err != nil {
+ continue
+ }
+
+ resp := dnsmessage.Message{
+ Header: dnsmessage.Header{
+ ID: msg.Header.ID,
+ Response: true,
+ Authoritative: true,
+ },
+ Questions: msg.Questions,
+ }
+
+ if len(msg.Questions) > 0 {
+ q := msg.Questions[0]
+ domain := strings.TrimSuffix(q.Name.String(), ".")
+
+ s.mu.RLock()
+ if q.Type == dnsmessage.TypeA || q.Type == dnsmessage.TypeAAAA {
+ if ip, ok := s.hosts[domain]; ok {
+ if ipv4 := ip.To4(); ipv4 != nil && q.Type == dnsmessage.TypeA {
+ resp.Answers = append(resp.Answers, dnsmessage.Resource{
+ Header: dnsmessage.ResourceHeader{Name: q.Name, Type: dnsmessage.TypeA, Class: dnsmessage.ClassINET, TTL: 300},
+ Body: &dnsmessage.AResource{A: [4]byte(ipv4)},
+ })
+ } else if q.Type == dnsmessage.TypeAAAA && ip.To4() == nil {
+ resp.Answers = append(resp.Answers, dnsmessage.Resource{
+ Header: dnsmessage.ResourceHeader{Name: q.Name, Type: dnsmessage.TypeAAAA, Class: dnsmessage.ClassINET, TTL: 300},
+ Body: &dnsmessage.AAAAResource{AAAA: [16]byte(ip)},
+ })
+ }
+ }
+ } else if q.Type == dnsmessage.TypeTXT {
+ if txtRecords, ok := s.txtHosts[domain]; ok {
+ for _, txt := range txtRecords {
+ resp.Answers = append(resp.Answers, dnsmessage.Resource{
+ Header: dnsmessage.ResourceHeader{Name: q.Name, Type: dnsmessage.TypeTXT, Class: dnsmessage.ClassINET, TTL: 300},
+ Body: &dnsmessage.TXTResource{TXT: []string{txt}},
+ })
+ }
+ }
+ }
+ s.mu.RUnlock()
+ }
+
+ packed, err := resp.Pack()
+ if err == nil {
+ s.conn.WriteToUDP(packed, addr)
+ }
+ }
+}
+
+func (s *FakeDNSServer) Hijack(t *testing.T) {
+ t.Helper()
+ dnsHijackLock.Lock()
+
+ originalDial := net.DefaultResolver.Dial
+ originalPreferGo := net.DefaultResolver.PreferGo
+
+ net.DefaultResolver.PreferGo = true
+ net.DefaultResolver.Dial = func(ctx context.Context, network, address string) (net.Conn, error) {
+ return net.Dial("udp", s.conn.LocalAddr().String())
+ }
+
+ t.Cleanup(func() {
+ net.DefaultResolver.Dial = originalDial
+ net.DefaultResolver.PreferGo = originalPreferGo
+ s.conn.Close()
+ dnsHijackLock.Unlock()
+ })
+}
diff --git a/tests/integration/federation_test.go b/tests/integration/federation_test.go
new file mode 100644
index 00000000..913869b8
--- /dev/null
+++ b/tests/integration/federation_test.go
@@ -0,0 +1,322 @@
+package integration_test
+
+import (
+ "bytes"
+ "context"
+ "fmt"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "regexp"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/google/sam/api"
+ "google.golang.org/protobuf/proto"
+)
+
+func TestHubFederationAndRelay(t *testing.T) {
+ hubBin := buildBinary(t, "./cmd/sam-hub")
+ nodeBin := buildBinary(t, "./cmd/sam-node")
+ clientBin := buildBinary(t, "./cmd/mcp-client")
+
+ tmpDir := t.TempDir()
+
+ // Create a mock policy file
+ policyFile := filepath.Join(tmpDir, "policies.yaml")
+ policyContent := `version: "v1alpha1"
+bindings:
+ - user: mock-user
+ role: admin
+roles:
+ admin:
+ mcp:
+ allowed_tools:
+ - "/sam/mcp/1.0.0"
+ - "list_local_services"
+ - "discover_remote_services"
+ - "federated-tool"
+`
+ if err := os.WriteFile(policyFile, []byte(policyContent), 0644); err != nil {
+ t.Fatal(err)
+ }
+
+ portA := getFreePort(t)
+ portB := getFreePort(t)
+ p2pPortA := getFreePort(t)
+ p2pPortB := getFreePort(t)
+
+ // Start Fake DNS Server
+ dnsServer, err := NewFakeDNSServer(map[string]string{
+ "test-hub.local": "127.0.0.1",
+ }, map[string][]string{})
+ if err != nil {
+ t.Fatalf("failed to start fake dns: %v", err)
+ }
+ t.Cleanup(func() { dnsServer.Hijack(t) })
+
+ // Start Hub A
+ // Mock OIDC
+ oidcURL, jwtTokenStr := startMockOIDC(t)
+
+ cmdA := exec.Command(hubBin,
+ "--bind-address", fmt.Sprintf("127.0.0.1:%d", portA),
+ "--listen", fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", p2pPortA),
+ "--policy-file", policyFile,
+ "--keys-db", filepath.Join(tmpDir, "keysA.db"),
+ "--allow-loopback",
+ "--external-multiaddr", "/dnsaddr/test-hub.local",
+ "--issuer", oidcURL,
+ "--insecure-skip-tls-verify",
+ "--key", "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+ )
+ cmdA.Env = append(os.Environ(), "SAM_TEST_DNS_SERVER="+dnsServer.conn.LocalAddr().String())
+ var stdoutA, stderrA safeBuffer
+ cmdA.Stdout = &stdoutA
+ cmdA.Stderr = &stderrA
+
+ if err := cmdA.Start(); err != nil {
+ t.Fatalf("failed to start Hub A: %v", err)
+ }
+ defer func() { _ = cmdA.Process.Kill() }()
+
+ // Fetch Hub A's Peer ID (which actively loops and waits for readiness)
+ peerIDA := fetchPeerID(t, portA)
+
+ // Update Fake DNS with Hub A's TXT record
+ dnsServer.UpdateTXT("_dnsaddr.test-hub.local", []string{
+ fmt.Sprintf("dnsaddr=/ip4/127.0.0.1/tcp/%d/p2p/%s", p2pPortA, peerIDA),
+ })
+
+ // Start Hub B, explicitly federating with Hub A via DNS
+ cmdB := exec.Command(hubBin,
+ "--bind-address", fmt.Sprintf("127.0.0.1:%d", portB),
+ "--listen", fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", p2pPortB),
+ "--policy-file", policyFile,
+ "--keys-db", filepath.Join(tmpDir, "keysB.db"),
+ "--allow-loopback",
+ "--external-multiaddr", "/dnsaddr/test-hub.local",
+ "--issuer", oidcURL,
+ "--insecure-skip-tls-verify",
+ "--key", "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+ )
+ cmdB.Env = append(os.Environ(), "SAM_TEST_DNS_SERVER="+dnsServer.conn.LocalAddr().String())
+ var stdoutB, stderrB safeBuffer
+ cmdB.Stdout = io.MultiWriter(os.Stdout, &stdoutB)
+ cmdB.Stderr = io.MultiWriter(os.Stderr, &stderrB)
+
+ if err := cmdB.Start(); err != nil {
+ t.Fatalf("failed to start Hub B: %v", err)
+ }
+ defer func() { _ = cmdB.Process.Kill() }()
+
+ time.Sleep(2 * time.Second)
+
+ // Node A connects to Hub A
+ apiPortA := getFreePort(t)
+ nodeACmd := exec.Command(nodeBin, "run",
+ "--hub", fmt.Sprintf("http://127.0.0.1:%d", portA),
+ "--data-dir", filepath.Join(tmpDir, "nodeA"),
+ "--bind-addr", fmt.Sprintf("127.0.0.1:%d", apiPortA),
+ "--api-token", "tokenA",
+ "--jwt", jwtTokenStr,
+ "--listen", "/ip4/127.0.0.1/tcp/0",
+ "--listen", "/ip4/127.0.0.1/udp/0/quic-v1",
+ "--discovery-interval", "100ms",
+ "--enable-relay=true",
+ "--allow-loopback=true",
+ )
+ var nodeStdoutA, nodeStderrA safeBuffer
+ nodeACmd.Stdout = io.MultiWriter(os.Stdout, &nodeStdoutA)
+ nodeACmd.Stderr = io.MultiWriter(os.Stderr, &nodeStderrA)
+ if err := nodeACmd.Start(); err != nil {
+ t.Fatalf("failed to start Node A: %v", err)
+ }
+ defer func() { _ = nodeACmd.Process.Kill() }()
+
+ // Node B connects to Hub B
+ apiPortB := getFreePort(t)
+ nodeBCmd := exec.Command(nodeBin, "run",
+ "--hub", fmt.Sprintf("http://127.0.0.1:%d", portB),
+ "--data-dir", filepath.Join(tmpDir, "nodeB"),
+ "--bind-addr", fmt.Sprintf("127.0.0.1:%d", apiPortB),
+ "--api-token", "tokenB",
+ "--jwt", jwtTokenStr,
+ "--listen", "/ip4/127.0.0.1/tcp/0",
+ "--listen", "/ip4/127.0.0.1/udp/0/quic-v1",
+ "--discovery-interval", "100ms",
+ "--allow-loopback=true",
+ )
+ var nodeStdoutB, nodeStderrB safeBuffer
+ nodeBCmd.Stdout = io.MultiWriter(os.Stdout, &nodeStdoutB)
+ nodeBCmd.Stderr = io.MultiWriter(os.Stderr, &nodeStderrB)
+ if err := nodeBCmd.Start(); err != nil {
+ t.Fatalf("failed to start Node B: %v", err)
+ }
+ defer func() { _ = nodeBCmd.Process.Kill() }()
+
+ // Give nodes time to connect and sync
+ waitForDHTReady(t, clientBin, apiPortA, "tokenA")
+ waitForDHTReady(t, clientBin, apiPortB, "tokenB")
+
+ // Start Mock Backend on Node A
+ mcpServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(http.StatusOK)
+ _, _ = w.Write([]byte(`{"jsonrpc": "2.0", "id": 1, "result": {"success": true}}`))
+ }))
+ t.Cleanup(func() { mcpServer.Close() })
+
+ // Publish a service on Node A
+ t.Log("Publishing tool on Node A...")
+ registerService(t, fmt.Sprintf("127.0.0.1:%d", apiPortA), "tokenA", "federated-tool", mcpServer.URL)
+ time.Sleep(2 * time.Second)
+
+ // Search for the service from Node B
+ t.Log("Searching for tool from Node B...")
+ searchCmd := exec.Command(clientBin,
+ "-url", fmt.Sprintf("http://127.0.0.1:%d/mcp/events", apiPortB),
+ "-token", "tokenB",
+ "-tool", "discover_remote_services",
+ "-args", `{"type": "mcp"}`,
+ )
+
+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+ defer cancel()
+
+ var found bool
+ for {
+ select {
+ case <-ctx.Done():
+ t.Logf("Node A Stdout: %s", nodeStdoutA.String())
+ t.Logf("Node A Stderr: %s", nodeStderrA.String())
+ t.Logf("Node B Stdout: %s", nodeStdoutB.String())
+ t.Logf("Node B Stderr: %s", nodeStderrB.String())
+ t.Fatalf("timed out waiting to discover tool from Node B. Hub A logs: %s, Hub B logs: %s", stderrA.String(), stderrB.String())
+ default:
+ out, err := searchCmd.Output()
+ if err == nil {
+ // For simplicity, just check if the output contains the name
+ if strings.Contains(string(out), "federated-tool") {
+ found = true
+ break
+ }
+ }
+ time.Sleep(500 * time.Millisecond)
+ }
+ if found {
+ break
+ }
+ }
+
+ t.Log("Successfully discovered federated tool via relay!")
+
+ // Assert datapath works via Node B's local Egress Proxy
+ t.Log("Testing datapath from Node B to Node A...")
+
+ // Extract Node A's Peer ID from its logs
+ peerIDRe := regexp.MustCompile(`(?m)^PeerID:\s+([A-Za-z0-9]+)$`)
+ matches := peerIDRe.FindStringSubmatch(nodeStdoutA.String())
+ if len(matches) < 2 {
+ t.Fatalf("could not extract Node A Peer ID from logs")
+ }
+ peerIDA_node := matches[1]
+
+ // The proxy path on Node B is /sam/<peerID>/mcp/federated-tool
+ proxyURL := fmt.Sprintf("http://127.0.0.1:%d/sam/%s/mcp/federated-tool", apiPortB, peerIDA_node)
+ req, _ := http.NewRequest("POST", proxyURL, bytes.NewBuffer([]byte(`{"jsonrpc": "2.0", "id": 1, "method": "test"}`)))
+ req.Header.Set("Authorization", "Bearer tokenB")
+
+ resp, err := http.DefaultClient.Do(req)
+ if err != nil {
+ t.Fatalf("Datapath failed: %v", err)
+ }
+ defer resp.Body.Close()
+ if resp.StatusCode != http.StatusOK {
+ body, _ := io.ReadAll(resp.Body)
+ t.Fatalf("Datapath returned status %d: %s", resp.StatusCode, string(body))
+ }
+ body, _ := io.ReadAll(resp.Body)
+ if !strings.Contains(string(body), `"success": true`) {
+ t.Fatalf("Unexpected datapath response: %s", string(body))
+ }
+ t.Log("Datapath works!")
+}
+
+func fetchPeerID(t *testing.T, port int) string {
+ var bodyBytes []byte
+ var err error
+
+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+ defer cancel()
+
+ for {
+ var resp *http.Response
+ resp, err = http.Get(fmt.Sprintf("http://127.0.0.1:%d/info", port))
+ if err == nil {
+ bodyBytes, err = io.ReadAll(resp.Body)
+ resp.Body.Close()
+ if err == nil {
+ break
+ }
+ }
+
+ select {
+ case <-ctx.Done():
+ t.Fatalf("timed out waiting for /info: %v", err)
+ case <-time.After(100 * time.Millisecond):
+ }
+ }
+
+ var info api.HubInfoResponse
+ if err := proto.Unmarshal(bodyBytes, &info); err != nil {
+ t.Fatalf("failed to decode /info: %v", err)
+ }
+
+ // Hub's PeerID is derived from its first listen multiaddr's /p2p/ segment
+ var peerID string
+ if len(info.HubAddresses) > 0 {
+ peerID = extractPeerID(info.HubAddresses[0])
+ }
+ if peerID == "" {
+ t.Fatalf("empty peer id from /info")
+ }
+ return peerID
+}
+
+func extractPeerID(maddrStr string) string {
+ parts := strings.Split(maddrStr, "/")
+ for i, part := range parts {
+ if part == "p2p" && i+1 < len(parts) {
+ return parts[i+1]
+ }
+ }
+ return ""
+}
+
+func waitForDHTReady(t *testing.T, clientBin string, apiPort int, token string) {
+ t.Helper()
+ deadline := time.Now().Add(10 * time.Second)
+ cmdArgs := []string{
+ "-url", fmt.Sprintf("http://127.0.0.1:%d/mcp/events", apiPort),
+ "-token", token,
+ "-tool", "get_mesh_info",
+ "-args", `{}`,
+ }
+
+ for time.Now().Before(deadline) {
+ cmd := exec.Command(clientBin, cmdArgs...)
+ out, err := cmd.Output()
+ if err == nil {
+ if strings.Contains(string(out), `"dht_size":`) && !strings.Contains(string(out), `"dht_size":0`) {
+ return
+ }
+ }
+ time.Sleep(500 * time.Millisecond)
+ }
+ t.Fatalf("DHT not ready on port %d", apiPort)
+}
diff --git a/tests/integration/mock_oidc_test.go b/tests/integration/mock_oidc_test.go
new file mode 100644
index 00000000..c36a13c1
--- /dev/null
+++ b/tests/integration/mock_oidc_test.go
@@ -0,0 +1,64 @@
+package integration_test
+
+import (
+ "crypto/rand"
+ "crypto/rsa"
+ "encoding/base64"
+ "encoding/json"
+ "math/big"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+ "time"
+
+ "github.com/golang-jwt/jwt/v5"
+)
+
+func startMockOIDC(t *testing.T) (string, string) {
+ privKey, err := rsa.GenerateKey(rand.Reader, 2048)
+ if err != nil {
+ t.Fatalf("failed to generate rsa key: %v", err)
+ }
+
+ mux := http.NewServeMux()
+ srv := httptest.NewServer(mux)
+ issuer := srv.URL
+
+ mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "application/json")
+ json.NewEncoder(w).Encode(map[string]interface{}{
+ "issuer": issuer,
+ "jwks_uri": issuer + "/keys",
+ })
+ })
+
+ mux.HandleFunc("/keys", func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "application/json")
+ json.NewEncoder(w).Encode(map[string]interface{}{
+ "keys": []map[string]interface{}{
+ {
+ "kty": "RSA",
+ "alg": "RS256",
+ "use": "sig",
+ "kid": "mock-key",
+ "n": base64.RawURLEncoding.EncodeToString(privKey.N.Bytes()),
+ "e": base64.RawURLEncoding.EncodeToString(big.NewInt(int64(privKey.E)).Bytes()),
+ },
+ },
+ })
+ })
+
+ token := jwt.NewWithClaims(jwt.SigningMethodRS256, jwt.MapClaims{
+ "iss": issuer,
+ "aud": "sam-mesh-audience",
+ "sub": "mock-user",
+ "exp": time.Now().Add(time.Hour).Unix(),
+ })
+ token.Header["kid"] = "mock-key"
+ jwtStr, err := token.SignedString(privKey)
+ if err != nil {
+ t.Fatalf("failed to sign jwt: %v", err)
+ }
+
+ return issuer, jwtStr
+}
diff --git a/tests/integration/service_discovery_test.go b/tests/integration/service_discovery_test.go
index 4911349f..c5d2e021 100644
--- a/tests/integration/service_discovery_test.go
+++ b/tests/integration/service_discovery_test.go
@@ -95,7 +95,7 @@ func TestServiceDiscovery(t *testing.T) {
// Agent A registers a service
serviceName := "mcp:github-tools"
- registerService(t, actualApiAddrA, apiToken, serviceName)
+ registerService(t, actualApiAddrA, apiToken, serviceName, "http://localhost:8080")
// Wait for DHT propagation
t.Log("Waiting for DHT propagation...")
@@ -193,7 +193,7 @@ func TestServiceDiscoveryStreaming(t *testing.T) {
// Agent A registers a service
serviceName := "mcp:github-tools"
- registerService(t, actualApiAddrA, apiToken, serviceName)
+ registerService(t, actualApiAddrA, apiToken, serviceName, "http://localhost:8080")
// Wait for DHT propagation
t.Log("Waiting for DHT propagation...")
@@ -286,7 +286,7 @@ func waitForAPI(t *testing.T, addr string) {
t.Fatalf("timeout waiting for API at %s", addr)
}
-func registerService(t *testing.T, apiAddr, token, serviceName string) {
+func registerService(t *testing.T, apiAddr, token, serviceName, targetURL string) {
t.Helper()
reqData := &api.RegisterServiceRequest{
Service: &api.ServiceInfo{
@@ -294,7 +294,7 @@ func registerService(t *testing.T, apiAddr, token, serviceName string) {
Name: serviceName,
Description: "test desc",
},
- Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: "http://localhost:8080"},
+ Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: targetURL},
}
body, err := protojson.Marshal(reqData)
if err != nil {