Skip to content

Agent Mesh

add logging and pubsub and fix auth

Antonio Ojea7c47a8daf3a5
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 64a90884..b415252d 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -22,22 +22,13 @@ updates:
k8s-deps:
patterns:
- "*k8s.io*"
- labels:
- - "area/dependency"
- - "ok-to-test"
- package-ecosystem: "github-actions"
directory: "/"
schedule:
interval: "weekly"
- labels:
- - "area/dependency"
- - "ok-to-test"
- package-ecosystem: "docker"
directory: "/"
schedule:
interval: "weekly"
- labels:
- - "area/dependency"
- - "ok-to-test"
diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml
index 6162b50e..94268971 100644
--- a/.github/workflows/e2e.yml
+++ b/.github/workflows/e2e.yml
@@ -25,7 +25,7 @@ on:
workflow_dispatch:
env:
- GO_VERSION: "1.25"
+ GO_VERSION: "1.26"
jobs:
bats_tests:
diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
index a83e4655..e43aa726 100644
--- a/.github/workflows/test.yaml
+++ b/.github/workflows/test.yaml
@@ -27,7 +27,7 @@ jobs:
strategy:
fail-fast: false
matrix:
- go-version: [1.25.x]
+ go-version: [1.26.x]
runs-on: ubuntu-latest
steps:
- uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6
diff --git a/AGENTS.md b/AGENTS.md
index 61a07fcf..1b04f3f8 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -19,9 +19,16 @@ Enforce strict modularity in testing. The repository uses a defined testing pyra
* **No Redundancy:** Do not replicate a test in the slower E2E path if it is already sufficiently covered in the Integration path.
* **Test Domains:**
* **Unit Tests:** Focus on isolated, internal functions.
- * **Integration Tests (`tests/integration/`):** Verify module interactions and API compliance in Go.
+ * **Integration Tests (`tests/integration/`):** Verify module interactions and API compliance in Go and those are time bounded, no more than 10 seconds per execution.
* **E2E Tests (`tests/e2e/*.bats`):** Use Bats (Bash Automated Testing System) exclusively for high-level, black-box testing of core CUJs.
## 4. Code Quality & Modularity
* Ensure all new code is highly modular, prioritizing small, single-responsibility functions that are easy to unit test.
* Respect the existing repository structure (`cmd/`, `api/`, `internal/`, `tests/`).
+
+## 5. Validation
+
+* Ensure binaries build using `make`
+* Ensure linter passes `make lint`
+* Ensure test passes `make test`
+* Ensure e2e test passes `make e2e-test`
diff --git a/api/sam.pb.go b/api/sam.pb.go
index 00ad0e59..d9f0572b 100644
--- a/api/sam.pb.go
+++ b/api/sam.pb.go
@@ -729,15 +729,16 @@ func (x *EnrollRequest) GetPeerId() string {
}
type EnrollResponse struct {
- state protoimpl.MessageState `protogen:"open.v1"`
- BiscuitToken []byte `protobuf:"bytes,1,opt,name=biscuit_token,json=biscuitToken,proto3" json:"biscuit_token,omitempty"`
- ErrorMessage string `protobuf:"bytes,2,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
- HubPublicKey []byte `protobuf:"bytes,3,opt,name=hub_public_key,json=hubPublicKey,proto3" json:"hub_public_key,omitempty"`
- HubAddresses []string `protobuf:"bytes,4,rep,name=hub_addresses,json=hubAddresses,proto3" json:"hub_addresses,omitempty"`
- Expiration int64 `protobuf:"varint,5,opt,name=expiration,proto3" json:"expiration,omitempty"`
- KnownPeers []string `protobuf:"bytes,6,rep,name=known_peers,json=knownPeers,proto3" json:"known_peers,omitempty"`
- unknownFields protoimpl.UnknownFields
- sizeCache protoimpl.SizeCache
+ state protoimpl.MessageState `protogen:"open.v1"`
+ BiscuitToken []byte `protobuf:"bytes,1,opt,name=biscuit_token,json=biscuitToken,proto3" json:"biscuit_token,omitempty"`
+ ErrorMessage string `protobuf:"bytes,2,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
+ HubPublicKey []byte `protobuf:"bytes,3,opt,name=hub_public_key,json=hubPublicKey,proto3" json:"hub_public_key,omitempty"`
+ HubAddresses []string `protobuf:"bytes,4,rep,name=hub_addresses,json=hubAddresses,proto3" json:"hub_addresses,omitempty"`
+ Expiration int64 `protobuf:"varint,5,opt,name=expiration,proto3" json:"expiration,omitempty"`
+ KnownPeers []string `protobuf:"bytes,6,rep,name=known_peers,json=knownPeers,proto3" json:"known_peers,omitempty"`
+ DatalogPolicies []string `protobuf:"bytes,7,rep,name=datalog_policies,json=datalogPolicies,proto3" json:"datalog_policies,omitempty"`
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
}
func (x *EnrollResponse) Reset() {
@@ -812,6 +813,13 @@ func (x *EnrollResponse) GetKnownPeers() []string {
return nil
}
+func (x *EnrollResponse) GetDatalogPolicies() []string {
+ if x != nil {
+ return x.DatalogPolicies
+ }
+ return nil
+}
+
var File_api_sam_proto protoreflect.FileDescriptor
const file_api_sam_proto_rawDesc = "" +
@@ -870,7 +878,7 @@ const file_api_sam_proto_rawDesc = "" +
"\x06BANNED\x10\x02\":\n" +
"\rEnrollRequest\x12\x10\n" +
"\x03jwt\x18\x01 \x01(\tR\x03jwt\x12\x17\n" +
- "\apeer_id\x18\x02 \x01(\tR\x06peerId\"\xe6\x01\n" +
+ "\apeer_id\x18\x02 \x01(\tR\x06peerId\"\x91\x02\n" +
"\x0eEnrollResponse\x12#\n" +
"\rbiscuit_token\x18\x01 \x01(\fR\fbiscuitToken\x12#\n" +
"\rerror_message\x18\x02 \x01(\tR\ferrorMessage\x12$\n" +
@@ -880,7 +888,8 @@ const file_api_sam_proto_rawDesc = "" +
"expiration\x18\x05 \x01(\x03R\n" +
"expiration\x12\x1f\n" +
"\vknown_peers\x18\x06 \x03(\tR\n" +
- "knownPeersB\x1bZ\x19github.com/google/sam/apib\x06proto3"
+ "knownPeers\x12)\n" +
+ "\x10datalog_policies\x18\a \x03(\tR\x0fdatalogPoliciesB\x1bZ\x19github.com/google/sam/apib\x06proto3"
var (
file_api_sam_proto_rawDescOnce sync.Once
diff --git a/api/sam.proto b/api/sam.proto
index 1125234f..f4eeddf2 100644
--- a/api/sam.proto
+++ b/api/sam.proto
@@ -92,4 +92,5 @@ message EnrollResponse {
repeated string hub_addresses = 4;
int64 expiration = 5;
repeated string known_peers = 6;
+ repeated string datalog_policies = 7;
}
diff --git a/cmd/sam-hub/main.go b/cmd/sam-hub/main.go
index 8c807348..160b1020 100644
--- a/cmd/sam-hub/main.go
+++ b/cmd/sam-hub/main.go
@@ -20,7 +20,6 @@ import (
"crypto/tls"
"encoding/hex"
"fmt"
- "log"
"net/http"
"os"
"strings"
@@ -29,6 +28,7 @@ import (
"github.com/biscuit-auth/biscuit-go/v2"
"github.com/coreos/go-oidc/v3/oidc"
"github.com/golang-jwt/jwt/v5"
+ golog "github.com/ipfs/go-log/v2"
"github.com/google/sam/api"
"github.com/libp2p/go-libp2p"
dht "github.com/libp2p/go-libp2p-kad-dht"
@@ -56,8 +56,11 @@ var (
listenAddrs []string
meshName string
insecureSkipTLSVerify bool
+ logLevel string
)
+var logger = golog.Logger("sam-hub")
+
// Hub handles identity bridging and network discovery
type Hub struct {
Host host.Host
@@ -121,7 +124,7 @@ func NewHub(ctx context.Context) (*Hub, error) {
return nil, fmt.Errorf("failed to create provider for %s: %w", iss, err)
}
providers[iss] = provider
- fmt.Printf("[OIDC] Trusted issuer: %s\n", iss)
+ logger.Infof("[OIDC] Trusted issuer: %s", iss)
}
// SAM_HUB_KEY stores an ed25519 seed as a 32-byte hex value.
@@ -159,25 +162,25 @@ func (h *Hub) handleEnroll(s network.Stream) {
_ = s.Close()
}()
remotePeer := s.Conn().RemotePeer()
- fmt.Printf("[Enroll] New enrollment request from %s\n", remotePeer)
+ logger.Infof("[Enroll] New enrollment request from %s", remotePeer)
reader := msgio.NewVarintReaderSize(s, 1024*64)
msg, err := reader.ReadMsg()
if err != nil {
- fmt.Printf("[Enroll] Failed to read message: %v\n", err)
+ logger.Errorf("[Enroll] Failed to read message: %v", err)
return
}
defer reader.ReleaseMsg(msg)
var req api.EnrollRequest
if err := proto.Unmarshal(msg, &req); err != nil {
- fmt.Printf("[Enroll] Failed to unmarshal request: %v\n", err)
+ logger.Errorf("[Enroll] Failed to unmarshal request: %v", err)
return
}
if req.PeerId != remotePeer.String() {
- fmt.Printf("[Enroll] Peer ID mismatch: %s != %s\n", req.PeerId, remotePeer)
- h.sendEnrollResponse(s, nil, "Peer ID mismatch", 0, nil)
+ logger.Warnf("[Enroll] Peer ID mismatch: %s != %s", req.PeerId, remotePeer)
+ h.sendEnrollResponse(s, nil, "Peer ID mismatch", 0, nil, nil)
return
}
@@ -185,14 +188,14 @@ func (h *Hub) handleEnroll(s network.Stream) {
parser := jwt.Parser{}
jwtToken, _, err := parser.ParseUnverified(req.Jwt, jwt.MapClaims{})
if err != nil {
- fmt.Printf("[Enroll] Failed to parse JWT: %v\n", err)
- h.sendEnrollResponse(s, nil, "Failed to parse JWT", 0, nil)
+ logger.Errorf("[Enroll] Failed to parse JWT: %v", err)
+ h.sendEnrollResponse(s, nil, "Failed to parse JWT", 0, nil, nil)
return
}
claims, ok := jwtToken.Claims.(jwt.MapClaims)
if !ok {
- fmt.Printf("[Enroll] Invalid JWT claims\n")
- h.sendEnrollResponse(s, nil, "Invalid JWT claims", 0, nil)
+ logger.Warn("[Enroll] Invalid JWT claims")
+ h.sendEnrollResponse(s, nil, "Invalid JWT claims", 0, nil, nil)
return
}
iss, _ := claims["iss"].(string)
@@ -207,10 +210,23 @@ func (h *Hub) handleEnroll(s network.Stream) {
}
}
+ if aud == "" {
+ logger.Warn("[Enroll] Missing aud claim")
+ h.sendEnrollResponse(s, nil, "Missing aud claim", 0, nil, nil)
+ return
+ }
+
+ alg, ok := jwtToken.Header["alg"].(string)
+ if !ok || alg == "" {
+ logger.Warn("[Enroll] Missing alg header")
+ h.sendEnrollResponse(s, nil, "Missing alg header", 0, nil, nil)
+ return
+ }
+
provider, ok := h.Providers[iss]
if !ok {
- fmt.Printf("[Enroll] Unknown issuer: %s\n", iss)
- h.sendEnrollResponse(s, nil, fmt.Sprintf("Unknown issuer: %s", iss), 0, nil)
+ logger.Warnf("[Enroll] Unknown issuer: %s", iss)
+ h.sendEnrollResponse(s, nil, fmt.Sprintf("Unknown issuer: %s", iss), 0, nil, nil)
return
}
@@ -218,11 +234,19 @@ func (h *Hub) handleEnroll(s network.Stream) {
token, err := verifier.Verify(context.Background(), req.Jwt)
if err != nil {
- fmt.Printf("[Enroll] JWT validation failed: %v\n", err)
- h.sendEnrollResponse(s, nil, fmt.Sprintf("JWT validation failed: %v", err), 0, nil)
+ logger.Errorf("[Enroll] JWT validation failed: %v", err)
+ h.sendEnrollResponse(s, nil, fmt.Sprintf("JWT validation failed: %v", err), 0, nil, nil)
return
}
+ // Strictly enforce aud and alg after verification
+ if alg == "none" {
+ logger.Warnf("[Enroll] Invalid alg claim: %s", alg)
+ h.sendEnrollResponse(s, nil, "Invalid alg claim", 0, nil, nil)
+ return
+ }
+ logger.Infof("[Enroll] JWT validated with aud: %s, alg: %s", aud, alg)
+
var roles []string
if rolesAny, ok := claims["roles"].([]any); ok {
for _, r := range rolesAny {
@@ -238,8 +262,8 @@ func (h *Hub) handleEnroll(s network.Stream) {
Name: "expiration",
IDs: []biscuit.Term{biscuit.Date(token.Expiry)},
}}); err != nil {
- fmt.Printf("[Enroll] Failed to add expiration fact: %v\n", err)
- h.sendEnrollResponse(s, nil, "Failed to mint biscuit", 0, nil)
+ logger.Errorf("[Enroll] Failed to add expiration fact: %v", err)
+ h.sendEnrollResponse(s, nil, "Failed to mint biscuit", 0, nil, nil)
return
}
@@ -247,8 +271,8 @@ func (h *Hub) handleEnroll(s network.Stream) {
Name: "node",
IDs: []biscuit.Term{biscuit.String(remotePeer.String())},
}}); err != nil {
- fmt.Printf("[Enroll] Failed to add node fact: %v\n", err)
- h.sendEnrollResponse(s, nil, "Failed to mint biscuit", 0, nil)
+ logger.Errorf("[Enroll] Failed to add node fact: %v", err)
+ h.sendEnrollResponse(s, nil, "Failed to mint biscuit", 0, nil, nil)
return
}
@@ -257,30 +281,30 @@ func (h *Hub) handleEnroll(s network.Stream) {
Name: "group",
IDs: []biscuit.Term{biscuit.String(role)},
}}); err != nil {
- fmt.Printf("[Enroll] Failed to add group fact: %v\n", err)
- h.sendEnrollResponse(s, nil, "Failed to mint biscuit", 0, nil)
+ logger.Errorf("[Enroll] Failed to add group fact: %v", err)
+ h.sendEnrollResponse(s, nil, "Failed to mint biscuit", 0, nil, nil)
return
}
}
t, err := builder.Build()
if err != nil {
- fmt.Printf("[Enroll] Failed to build biscuit: %v\n", err)
- h.sendEnrollResponse(s, nil, "Failed to build biscuit", 0, nil)
+ logger.Errorf("[Enroll] Failed to build biscuit: %v", err)
+ h.sendEnrollResponse(s, nil, "Failed to build biscuit", 0, nil, nil)
return
}
biscuitData, err := t.Serialize()
if err != nil {
- fmt.Printf("[Enroll] Failed to serialize biscuit: %v\n", err)
- h.sendEnrollResponse(s, nil, "Failed to serialize biscuit", 0, nil)
+ logger.Errorf("[Enroll] Failed to serialize biscuit: %v", err)
+ h.sendEnrollResponse(s, nil, "Failed to serialize biscuit", 0, nil, nil)
return
}
h.gater.mu.Lock()
h.gater.authenticated[remotePeer] = true
delete(h.gater.pending, remotePeer)
-
+
// Collect authenticated peers
var knownPeers []string
for p := range h.gater.authenticated {
@@ -288,8 +312,12 @@ func (h *Hub) handleEnroll(s network.Stream) {
}
h.gater.mu.Unlock()
- h.sendEnrollResponse(s, biscuitData, "", token.Expiry.Unix(), knownPeers)
- fmt.Printf("[Enroll] Successfully enrolled peer %s\n", remotePeer)
+ policies := []string{
+ `allow if operation($op)`,
+ }
+
+ h.sendEnrollResponse(s, biscuitData, "", token.Expiry.Unix(), knownPeers, policies)
+ logger.Infof("[Enroll] Successfully enrolled peer %s", remotePeer)
// Publish JOIN event
event := &api.MeshEvent{
@@ -299,17 +327,17 @@ func (h *Hub) handleEnroll(s network.Stream) {
}
eventData, err := proto.Marshal(event)
if err != nil {
- fmt.Printf("[Enroll] Failed to marshal event: %v\n", err)
+ logger.Errorf("[Enroll] Failed to marshal event: %v", err)
} else {
if err := h.EventTopic.Publish(context.Background(), eventData); err != nil {
- fmt.Printf("[Enroll] Failed to publish event: %v\n", err)
+ logger.Errorf("[Enroll] Failed to publish event: %v", err)
} else {
- fmt.Printf("[Enroll] Published JOIN event for %s\n", remotePeer)
+ logger.Infof("[Enroll] Published JOIN event for %s", remotePeer)
}
}
}
-func (h *Hub) sendEnrollResponse(s network.Stream, biscuitToken []byte, errMsg string, expiration int64, knownPeers []string) {
+func (h *Hub) sendEnrollResponse(s network.Stream, biscuitToken []byte, errMsg string, expiration int64, knownPeers []string, policies []string) {
var hubAddrs []string
for _, addr := range h.Host.Addrs() {
hubAddrs = append(hubAddrs, addr.String()+"/p2p/"+h.Host.ID().String())
@@ -318,21 +346,22 @@ func (h *Hub) sendEnrollResponse(s network.Stream, biscuitToken []byte, errMsg s
pubKey := h.BiscuitKey.Public().(ed25519.PublicKey)
resp := &api.EnrollResponse{
- BiscuitToken: biscuitToken,
- ErrorMessage: errMsg,
- HubPublicKey: pubKey,
- HubAddresses: hubAddrs,
- Expiration: expiration,
- KnownPeers: knownPeers,
+ BiscuitToken: biscuitToken,
+ ErrorMessage: errMsg,
+ HubPublicKey: pubKey,
+ HubAddresses: hubAddrs,
+ Expiration: expiration,
+ KnownPeers: knownPeers,
+ DatalogPolicies: policies,
}
data, err := proto.Marshal(resp)
if err != nil {
- fmt.Printf("[Enroll] Failed to marshal response: %v\n", err)
+ logger.Errorf("[Enroll] Failed to marshal response: %v", err)
return
}
writer := msgio.NewVarintWriter(s)
if err := writer.WriteMsg(data); err != nil {
- fmt.Printf("[Enroll] Failed to write response: %v\n", err)
+ logger.Errorf("[Enroll] Failed to write response: %v", err)
}
}
@@ -346,9 +375,9 @@ func (h *Hub) startWatchdog() {
now := time.Now()
for pID, connectedAt := range h.gater.pending {
if now.Sub(connectedAt) > GracePeriod {
- fmt.Printf("[Security] Evicting unauthenticated peer: %s\n", pID)
+ logger.Warnf("[Security] Evicting unauthenticated peer: %s", pID)
if err := h.Host.Network().ClosePeer(pID); err != nil {
- log.Printf("closing unauthenticated peer %s: %v", pID, err)
+ logger.Errorf("[Security] Closing unauthenticated peer %s: %v", pID, err)
}
delete(h.gater.pending, pID)
}
@@ -364,20 +393,30 @@ func main() {
Short: "Sovereign Agent Mesh - Multi-Transport Hub",
Run: func(cmd *cobra.Command, args []string) {
ctx := context.Background()
+
+ // Initialize logging
+ golog.SetAllLoggers(golog.LevelInfo)
+ if logLevel != "" {
+ lvl, err := golog.LevelFromString(logLevel)
+ if err == nil {
+ golog.SetAllLoggers(lvl)
+ }
+ }
+
h, err := NewHub(ctx)
if err != nil {
- log.Fatal(err)
+ logger.Fatal(err)
}
h.Host.SetStreamHandler(api.EnrollProtocolID, h.handleEnroll)
// Watchdog: Expel peers that connect but never finish authentication
h.startWatchdog()
- fmt.Printf("SAM Hub Online (QUIC + TCP)\n")
- fmt.Printf("MeshID: %s\n", h.MeshID)
- fmt.Printf("PeerID: %s\n", h.Host.ID())
+ logger.Infof("SAM Hub Online (QUIC + TCP)")
+ logger.Infof("MeshID: %s", h.MeshID)
+ logger.Infof("PeerID: %s", h.Host.ID())
- fmt.Printf("Hub running on P2P transports only.\n")
+ logger.Infof("Hub running on P2P transports only.")
select {}
},
}
@@ -392,6 +431,7 @@ func main() {
rootCmd.Flags().StringSliceVar(&listenAddrs, "listen", []string{"/ip4/0.0.0.0/udp/8080/quic-v1", "/ip4/0.0.0.0/tcp/8080"}, "libp2p Listen Addrs")
rootCmd.Flags().StringVar(&meshName, "mesh", "public-mesh", "Mesh federation name")
rootCmd.Flags().BoolVar(&insecureSkipTLSVerify, "insecure-skip-tls-verify", false, "Skip TLS verification for OIDC issuers")
+ rootCmd.Flags().StringVar(&logLevel, "log-level", "info", "Log level (debug, info, warn, error)")
if err := rootCmd.Execute(); err != nil {
os.Exit(1)
diff --git a/cmd/sam-node/main.go b/cmd/sam-node/main.go
index db7515cf..ae6859da 100644
--- a/cmd/sam-node/main.go
+++ b/cmd/sam-node/main.go
@@ -20,17 +20,17 @@ import (
"encoding/base64"
"encoding/hex"
"fmt"
- "log"
"net"
"net/http"
- "path/filepath"
"os"
"os/signal"
+ "path/filepath"
"strings"
"syscall"
"time"
"github.com/google/sam/api"
+ golog "github.com/ipfs/go-log/v2"
"github.com/libp2p/go-libp2p/core/crypto"
"github.com/libp2p/go-msgio"
"github.com/multiformats/go-multiaddr"
@@ -42,17 +42,21 @@ var (
hubAddr string
listenAddrs []string
- jwtFlag string
- jwtPathFlag string
- clientIDFlag string
- clientSecretFlag string
- tokenURLFlag string
- hubPublicKeyFlag string
- mcpSocketFlag string
- meshFlag string
+ jwtFlag string
+ jwtPathFlag string
+ clientIDFlag string
+ clientSecretFlag string
+ tokenURLFlag string
+ hubPublicKeyFlag string
+ mcpSocketFlag string
+ meshFlag string
discoveryIntervalFlag string
+ enableRelayFlag bool
+ logLevelFlag string
)
+var logger = golog.Logger("sam-node")
+
func main() {
rootCmd := &cobra.Command{
Use: "sam-node",
@@ -65,17 +69,27 @@ func main() {
Short: "Start the sovereign mesh node",
Run: func(cmd *cobra.Command, args []string) {
ctx := cmd.Context()
+
+ // Initialize logging
+ golog.SetAllLoggers(golog.LevelInfo)
+ if logLevelFlag != "" {
+ lvl, err := golog.LevelFromString(logLevelFlag)
+ if err == nil {
+ golog.SetAllLoggers(lvl)
+ }
+ }
+
dataDir, err := GetDataDir()
if err != nil {
- log.Fatalf("Failed to get data dir: %v", err)
+ logger.Fatalf("Failed to get data dir: %v", err)
}
store, err := NewStore(dataDir)
if err != nil {
- log.Fatalf("Failed to open store: %v", err)
+ logger.Fatalf("Failed to open store: %v", err)
}
defer func() {
if err := store.Close(); err != nil {
- log.Printf("closing store: %v", err)
+ logger.Error("closing store: %v", err)
}
}()
@@ -94,7 +108,7 @@ func main() {
if hubPublicKeyFlag != "" {
pubBytes, err := hex.DecodeString(hubPublicKeyFlag)
if err != nil {
- log.Fatalf("Invalid hub public key: %v", err)
+ logger.Fatalf("Invalid hub public key: %v", err)
}
hubPubKey = pubBytes
}
@@ -108,33 +122,33 @@ func main() {
} else if jwtPathFlag != "" {
data, err := os.ReadFile(jwtPathFlag)
if err != nil {
- log.Fatalf("Failed to read JWT file: %v", err)
+ logger.Fatalf("Failed to read JWT file: %v", err)
}
jwtStr = strings.TrimSpace(string(data))
} else if tokenURLFlag != "" {
- fmt.Println("Fetching JWT via OIDC Client Credentials...")
+ logger.Info("Fetching JWT via OIDC Client Credentials...")
dummyNode := &SamNode{}
var err error
jwtStr, err = dummyNode.FetchJWT(context.Background(), tokenURLFlag, clientIDFlag, clientSecretFlag)
if err != nil {
- log.Fatalf("Failed to fetch JWT: %v", err)
+ logger.Fatalf("Failed to fetch JWT: %v", err)
}
}
if jwtStr == "" {
token, _ := store.LoadIdentity()
if token == "" {
- log.Fatal("No JWT or stored identity found. Cannot authenticate.")
+ logger.Fatal("No JWT or stored identity found. Cannot authenticate.")
}
fmt.Println("Using stored identity.")
if len(hubPubKey) == 0 {
- log.Fatal("Hub public key not found in store and not provided. Cannot verify peers.")
+ logger.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, listenAddrs)
+ node, err = NewSamNode(context.Background(), priv, hubPubKey, hubAddrs, store, meshFlag, discoveryIntervalFlag, listenAddrs, enableRelayFlag)
if err != nil {
- log.Fatalf("Failed to start mesh node: %v", err)
+ logger.Fatalf("Failed to start mesh node: %v", err)
}
} else {
var initHubAddrs []multiaddr.Multiaddr
@@ -157,20 +171,20 @@ func main() {
if len(hubAddrs) > 0 {
initHubAddrs = hubAddrs
} else {
- log.Fatalf("Invalid hub address and no stored config: %v", err)
+ logger.Fatalf("Invalid hub address and no stored config: %v", err)
}
}
}
priv := getOrGenerateKey(store)
- node, err = NewSamNode(context.Background(), priv, nil, initHubAddrs, store, meshFlag, discoveryIntervalFlag, listenAddrs)
+ node, err = NewSamNode(context.Background(), priv, nil, initHubAddrs, store, meshFlag, discoveryIntervalFlag, listenAddrs, enableRelayFlag)
if err != nil {
- log.Fatalf("Failed to initialize node for enrollment: %v", err)
+ logger.Fatalf("Failed to initialize node for enrollment: %v", err)
}
err = node.Enroll(context.Background(), jwtStr)
if err != nil {
- log.Fatalf("Enrollment failed: %v", err)
+ logger.Fatalf("Enrollment failed: %v", err)
}
storedPubKey, _, _ = store.LoadHubConfig()
@@ -245,24 +259,24 @@ func main() {
if socketPath == "" {
socketPath = filepath.Join(dataDir, "mcp.sock")
}
-
+
// Remove old socket file if it exists
_ = os.Remove(socketPath)
-
+
listener, err := net.Listen("unix", socketPath)
if err != nil {
- log.Printf("Failed to listen on Unix socket %s: %v", socketPath, err)
+ logger.Errorf("Failed to listen on Unix socket %s: %v", socketPath, err)
return
}
defer func() {
if err := listener.Close(); err != nil {
- log.Printf("Failed to close listener: %v", err)
+ logger.Errorf("Failed to close listener: %v", err)
}
}()
-
+
fmt.Printf("Starting MCP server on Unix socket %s\n", socketPath)
if err := http.Serve(listener, mcpHandler); err != nil {
- log.Printf("MCP server error: %v", err)
+ logger.Errorf("MCP server error: %v", err)
}
}()
@@ -281,26 +295,26 @@ func main() {
ctx := cmd.Context()
dataDir, err := GetDataDir()
if err != nil {
- log.Fatalf("Failed to get data dir: %v", err)
+ logger.Fatalf("Failed to get data dir: %v", err)
}
store, err := NewStore(dataDir)
if err != nil {
- log.Fatalf("Failed to open store: %v", err)
+ logger.Fatalf("Failed to open store: %v", err)
}
defer func() {
if err := store.Close(); err != nil {
- log.Printf("closing store: %v", err)
+ logger.Errorf("closing store: %v", err)
}
}()
if tokenURLFlag == "" {
- log.Fatal("--token-url is required for login")
+ logger.Fatal("--token-url is required for login")
}
dummyNode := &SamNode{Store: store}
jwtStr, err := dummyNode.InteractiveLogin(ctx, tokenURLFlag)
if err != nil {
- log.Fatalf("Failed to get token: %v", err)
+ logger.Fatalf("Failed to get token: %v", err)
}
// Connect to Hub and Enroll
@@ -320,19 +334,19 @@ func main() {
}
initHubAddrs = []multiaddr.Multiaddr{maddr}
} else {
- log.Fatalf("Invalid hub address: %v", err)
+ logger.Fatalf("Invalid hub address: %v", err)
}
}
priv := getOrGenerateKey(store)
- node, err := NewSamNode(context.Background(), priv, nil, initHubAddrs, store, meshFlag, discoveryIntervalFlag, listenAddrs)
+ node, err := NewSamNode(context.Background(), priv, nil, initHubAddrs, store, meshFlag, discoveryIntervalFlag, listenAddrs, enableRelayFlag)
if err != nil {
- log.Fatalf("Failed to initialize node for enrollment: %v", err)
+ logger.Fatalf("Failed to initialize node for enrollment: %v", err)
}
err = node.Enroll(context.Background(), jwtStr)
if err != nil {
- log.Fatalf("Enrollment failed: %v", err)
+ logger.Fatalf("Enrollment failed: %v", err)
}
fmt.Println("Login successful and identity stored.")
@@ -349,6 +363,8 @@ func main() {
runCmd.Flags().StringVar(&mcpSocketFlag, "mcp-socket", "", "Path to Unix domain socket for local MCP server (default: <datadir>/mcp.sock)")
runCmd.Flags().StringVar(&meshFlag, "mesh", "public-mesh", "Mesh federation name")
runCmd.Flags().StringVar(&discoveryIntervalFlag, "discovery-interval", "2s", "Polling interval for DHT discovery")
+ runCmd.Flags().BoolVar(&enableRelayFlag, "enable-relay", false, "Allow this node to serve as a relay for others")
+ runCmd.Flags().StringVar(&logLevelFlag, "log-level", "info", "Log level (debug, info, warn, error)")
rootCmd.PersistentFlags().StringVar(&hubAddr, "hub", "http://localhost:8080", "Hub URL")
rootCmd.PersistentFlags().StringVar(&tokenURLFlag, "token-url", "", "OIDC Token URL")
@@ -378,17 +394,17 @@ func getOrGenerateKey(s *Store) crypto.PrivKey {
fmt.Println("[Store] Generating new Peer Identity...")
priv, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)
if err != nil {
- log.Fatalf("Failed to generate key: %v", err)
+ logger.Fatalf("Failed to generate key: %v", err)
}
raw, _ := crypto.MarshalPrivateKey(priv)
if err := s.SaveKey(raw); err != nil {
- log.Fatalf("Failed to save key: %v", err)
+ logger.Fatalf("Failed to save key: %v", err)
}
return priv
}
priv, err := crypto.UnmarshalPrivateKey(kb)
if err != nil {
- log.Fatalf("Corrupt key in store: %v", err)
+ logger.Fatalf("Corrupt key in store: %v", err)
}
return priv
}
@@ -398,7 +414,7 @@ func (n *SamNode) Enroll(ctx context.Context, jwt string) error {
return fmt.Errorf("not connected to any hub")
}
- s, err := n.Host.NewStream(ctx, n.HubPeerID, "/sam/enroll/1.0.0")
+ s, err := n.Host.NewStream(ctx, n.HubPeerID, api.EnrollProtocolID)
if err != nil {
return fmt.Errorf("failed to open enroll stream: %v", err)
}
@@ -451,6 +467,12 @@ func (n *SamNode) Enroll(ctx context.Context, jwt string) error {
return fmt.Errorf("failed to save hub config: %v", err)
}
+ if len(resp.DatalogPolicies) > 0 {
+ if err := n.Store.SavePolicies(resp.DatalogPolicies); err != nil {
+ return fmt.Errorf("failed to save policies: %v", err)
+ }
+ }
+
// Add known peers from response
n.mu.Lock()
for _, p := range resp.KnownPeers {
diff --git a/cmd/sam-node/mcp.go b/cmd/sam-node/mcp.go
index 18dde5fd..93a90118 100644
--- a/cmd/sam-node/mcp.go
+++ b/cmd/sam-node/mcp.go
@@ -19,6 +19,7 @@ import (
"encoding/json"
"fmt"
"net/http"
+ "time"
"github.com/google/sam/api"
"github.com/libp2p/go-libp2p/core/peer"
@@ -59,6 +60,74 @@ func NewMCPHandler(node *SamNode) http.Handler {
Description: "Send a message to another agent in the mesh",
}, handleSendMessage)
+ // Add the mesh_pubsub_broadcast tool.
+ mcp.AddTool(server, &mcp.Tool{
+ Name: "mesh_pubsub_broadcast",
+ Description: "Publish an event payload to a custom GossipSub topic",
+ }, func(ctx context.Context, req *mcp.CallToolRequest, params struct {
+ Topic string `json:"topic" jsonschema:"GossipSub topic name"`
+ Payload string `json:"payload" jsonschema:"Payload to publish"`
+ }) (*mcp.CallToolResult, any, error) {
+ node.mu.Lock()
+ t, ok := node.topics[params.Topic]
+ var err error
+ if !ok {
+ t, err = node.PubSub.Join(params.Topic)
+ if err == nil {
+ node.topics[params.Topic] = t
+ }
+ }
+ node.mu.Unlock()
+ if err != nil {
+ return nil, nil, err
+ }
+ if err := t.Publish(ctx, []byte(params.Payload)); err != nil {
+ return nil, nil, err
+ }
+ return &mcp.CallToolResult{
+ Content: []mcp.Content{
+ &mcp.TextContent{Text: "Published"},
+ },
+ }, nil, nil
+ })
+
+ // Add the poll_messages tool.
+ mcp.AddTool(server, &mcp.Tool{
+ Name: "poll_messages",
+ Description: "Poll for incoming messages on custom GossipSub topics",
+ }, func(ctx context.Context, req *mcp.CallToolRequest, params struct {
+ Topic string `json:"topic" jsonschema:"GossipSub topic name"`
+ }) (*mcp.CallToolResult, any, error) {
+ node.mu.Lock()
+ msgs := node.receivedMsgs[params.Topic]
+ delete(node.receivedMsgs, params.Topic) // Clear on read!
+ node.mu.Unlock()
+
+ response := fmt.Sprintf("Messages on topic %s: %v", params.Topic, msgs)
+ return &mcp.CallToolResult{
+ Content: []mcp.Content{
+ &mcp.TextContent{Text: response},
+ },
+ }, nil, nil
+ })
+
+ // Add the subscribe_topic tool.
+ mcp.AddTool(server, &mcp.Tool{
+ Name: "subscribe_topic",
+ Description: "Subscribe to a custom GossipSub topic",
+ }, func(ctx context.Context, req *mcp.CallToolRequest, params struct {
+ Topic string `json:"topic" jsonschema:"GossipSub topic name"`
+ }) (*mcp.CallToolResult, any, error) {
+ if err := node.subscribeToTopic(ctx, params.Topic); err != nil {
+ return nil, nil, err
+ }
+ return &mcp.CallToolResult{
+ Content: []mcp.Content{
+ &mcp.TextContent{Text: "Subscribed"},
+ },
+ }, nil, nil
+ })
+
// Add the get_mesh_info tool.
mcp.AddTool(server, &mcp.Tool{
Name: "get_mesh_info",
@@ -122,6 +191,24 @@ func NewMCPHandler(node *SamNode) http.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) {
+ var res *mcp.CallToolResult
+ var err error
+ maxRetries := 3
+ backoff := 1 * time.Second
+
+ for i := 0; i < maxRetries; i++ {
+ res, err = n.callMCPToolOnce(ctx, targetPeer, toolName, params)
+ if err == nil {
+ return res, nil
+ }
+ logger.Warnf("[MCP] Tool call failed, retrying in %v: %v", backoff, err)
+ time.Sleep(backoff)
+ backoff *= 2
+ }
+ return nil, fmt.Errorf("failed after %d retries: %w", maxRetries, err)
+}
+
+func (n *SamNode) callMCPToolOnce(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 {
@@ -129,7 +216,7 @@ func (n *SamNode) CallMCPTool(ctx context.Context, targetPeer peer.ID, toolName
}
defer func() {
if err := s.Close(); err != nil {
- fmt.Printf("failed to close stream: %v\n", err)
+ logger.Errorf("[MCP] Failed to close stream: %v", err)
}
}()
@@ -180,10 +267,6 @@ func (n *SamNode) CallMCPTool(ctx context.Context, targetPeer peer.ID, toolName
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)
diff --git a/cmd/sam-node/middleware.go b/cmd/sam-node/middleware.go
index d437d069..db30f552 100644
--- a/cmd/sam-node/middleware.go
+++ b/cmd/sam-node/middleware.go
@@ -16,13 +16,15 @@ package main
import (
"fmt"
+ "strings"
"github.com/biscuit-auth/biscuit-go/v2"
+ "github.com/biscuit-auth/biscuit-go/v2/parser"
+ "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"
)
@@ -39,7 +41,7 @@ func (n *SamNode) WithBiscuitAuth(next network.StreamHandler) network.StreamHand
return func(s network.Stream) {
defer func() {
if err := s.Close(); err != nil {
- fmt.Printf("Failed to close stream: %v\n", err)
+ logger.Errorf("[Auth] Failed to close stream: %v", err)
}
}()
remotePeer := s.Conn().RemotePeer()
@@ -48,14 +50,14 @@ func (n *SamNode) WithBiscuitAuth(next network.StreamHandler) network.StreamHand
reader := msgio.NewVarintReaderSize(s, 1024*64)
msg, err := reader.ReadMsg()
if err != nil {
- fmt.Printf("[Auth] Failed to read auth frame from %s: %v\n", remotePeer, err)
+ logger.Errorf("[Auth] Failed to read auth frame from %s: %v", 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)
+ logger.Warnf("[Auth] Invalid auth frame from %s", remotePeer)
return
}
@@ -69,7 +71,7 @@ func (n *SamNode) WithBiscuitAuth(next network.StreamHandler) network.StreamHand
writer := msgio.NewVarintWriter(s)
if err := n.Authorize(authFrame.Biscuit, reqCtx); err != nil {
- fmt.Printf("[Auth] AuthZ Denied %s: %v\n", remotePeer, err)
+ logger.Warnf("[Auth] AuthZ Denied %s: %v", remotePeer, err)
resp := &api.AuthResponse{Success: false, Error: err.Error()}
respBytes, _ := proto.Marshal(resp)
_ = writer.WriteMsg(respBytes)
@@ -80,7 +82,7 @@ func (n *SamNode) WithBiscuitAuth(next network.StreamHandler) network.StreamHand
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)
+ logger.Errorf("[Auth] Failed to write ACK to %s: %v", remotePeer, err)
return
}
@@ -116,5 +118,19 @@ func (n *SamNode) Authorize(rawToken []byte, req RequestContext) error {
},
})
+ // Load dynamic policies from store and add them as facts
+ policies, err := n.Store.LoadPolicies()
+ if err != nil {
+ return fmt.Errorf("failed to load policies: %w", err)
+ }
+ for _, policyStr := range policies {
+ cleanPolicy := strings.TrimRight(strings.TrimSpace(policyStr), ";")
+ p, err := parser.FromStringPolicy(cleanPolicy)
+ if err != nil {
+ return fmt.Errorf("failed to parse policy '%s': %w", policyStr, err)
+ }
+ authorizer.AddPolicy(p)
+ }
+
return authorizer.Authorize()
}
diff --git a/cmd/sam-node/middleware_test.go b/cmd/sam-node/middleware_test.go
new file mode 100644
index 00000000..4bf72a70
--- /dev/null
+++ b/cmd/sam-node/middleware_test.go
@@ -0,0 +1,107 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+ "crypto/ed25519"
+ "os"
+ "testing"
+
+ "github.com/biscuit-auth/biscuit-go/v2"
+ "github.com/libp2p/go-libp2p/core/peer"
+)
+
+func TestAuthorize(t *testing.T) {
+ dir, err := os.MkdirTemp("", "middleware-test")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() {
+ _ = os.RemoveAll(dir)
+ }()
+
+ store, err := NewStore(dir)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() {
+ _ = store.Close()
+ }()
+
+ // Save a dummy policy
+ policies := []string{"allow if operation($op)"}
+ if err := store.SavePolicies(policies); err != nil {
+ t.Fatal(err)
+ }
+
+ // Create a biscuit token
+ pub, priv, err := ed25519.GenerateKey(nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ builder := biscuit.NewBuilder(priv)
+ dummyPeer := peer.ID("dummy-peer")
+
+ // Bind to peer
+ err = builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
+ Name: "node",
+ IDs: []biscuit.Term{biscuit.String(dummyPeer.String())},
+ }})
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ // Add fact and rule to make it succeed
+ err = builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
+ Name: "right",
+ IDs: []biscuit.Term{biscuit.String("test")},
+ }})
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ err = builder.AddAuthorityRule(biscuit.Rule{
+ Head: biscuit.Predicate{Name: "allow", IDs: []biscuit.Term{}},
+ Body: []biscuit.Predicate{{Name: "right", IDs: []biscuit.Term{biscuit.String("test")}}},
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ b, err := builder.Build()
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ tokenBytes, err := b.Serialize()
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ node := &SamNode{
+ Store: store,
+ HubPublicKey: pub,
+ }
+
+ req := RequestContext{
+ PeerID: dummyPeer,
+ Protocol: "/test/proto",
+ }
+
+ if err := node.Authorize(tokenBytes, req); err != nil {
+ t.Fatalf("Authorize failed: %v", err)
+ }
+}
diff --git a/cmd/sam-node/node.go b/cmd/sam-node/node.go
index 0f41454a..6987b3cd 100644
--- a/cmd/sam-node/node.go
+++ b/cmd/sam-node/node.go
@@ -17,7 +17,6 @@ package main
import (
"context"
"crypto/ed25519"
- "fmt"
"sync"
"time"
@@ -52,43 +51,69 @@ type SamNode struct {
HubPublicKey ed25519.PublicKey
HubPeerID peer.ID
knownPeers map[string]bool
+ receivedMsgs map[string][]string
+ topics map[string]*pubsub.Topic
mu sync.Mutex
}
// 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, listenAddrs []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, enableRelay bool) (*SamNode, error) {
node := &SamNode{
Store: store,
HubPublicKey: hubPubKey,
knownPeers: make(map[string]bool),
+ receivedMsgs: make(map[string][]string),
+ topics: make(map[string]*pubsub.Topic),
}
// Layer 2: Attach the Bouncer (Gater)
gater := &nodeConnGate{node: node}
- // Layer 1: Establish FIPS-compliant Transports
- h, err := libp2p.New(
+ // Convert Hub multiaddrs to peer.AddrInfo to use as static relays
+ var staticRelays []peer.AddrInfo
+ for _, addr := range hubAddrs {
+ if addrInfo, err := peer.AddrInfoFromP2pAddr(addr); err == nil && addrInfo.ID != "" {
+ staticRelays = append(staticRelays, *addrInfo)
+ }
+ }
+
+ // Layer 1: Establish FIPS-compliant Transports & NAT Services
+ opts := []libp2p.Option{
libp2p.Identity(privKey),
libp2p.Transport(libp2pquic.NewTransport),
libp2p.Transport(tcp.NewTCPTransport),
libp2p.Security(libp2ptls.ID, libp2ptls.New),
libp2p.ConnectionGater(gater),
libp2p.ListenAddrStrings(listenAddrs...),
- )
+ libp2p.EnableNATService(),
+ }
+
+ // If we have a Hub, configure it as our static fallback relay for NAT hole-punching
+ if len(staticRelays) > 0 {
+ opts = append(opts, libp2p.EnableAutoRelayWithStaticRelays(staticRelays))
+ }
+
+ // If the user explicitly opts in, allow this node to serve as a relay for others
+ if enableRelay {
+ logger.Infof("[Relay] Enabling Relay Service")
+ opts = append(opts, libp2p.EnableRelayService())
+ }
+
+ h, err := libp2p.New(opts...)
if err != nil {
return nil, err
}
node.Host = h
// Initialize Rendezvous (DHT Client)
- kdht, err := dht.New(ctx, h, dht.Mode(dht.ModeClient))
+ kdht, err := dht.New(ctx, h, dht.Mode(dht.ModeAuto))
if err != nil {
return nil, err
}
node.DHT = kdht
if err := kdht.Bootstrap(ctx); err != nil {
- fmt.Printf("[DHT] Warning: Failed to bootstrap DHT: %v\n", err)
+ logger.Warnf("[DHT] Failed to bootstrap DHT: %v", err)
}
// Bootstrap: Connect to the Hub
@@ -99,23 +124,23 @@ func NewSamNode(ctx context.Context, privKey crypto.PrivKey, hubPubKey ed25519.P
addrInfo = &peer.AddrInfo{
Addrs: []multiaddr.Multiaddr{addr},
}
- fmt.Println("[Warning] Connecting to hub without Peer ID verification in address.")
+ logger.Warn("[AuthN] Connecting to hub without Peer ID verification in address.")
}
if err := h.Connect(ctx, *addrInfo); err != nil {
- fmt.Printf("Warning: Failed to bootstrap to hub %s: %v\n", addr, err)
+ logger.Warnf("[AuthN] Failed to bootstrap to hub %s: %v", addr, err)
} else {
if addrInfo.ID == "" {
// Discover Peer ID from connection
for _, c := range h.Network().Conns() {
if c.RemoteMultiaddr().Equal(addr) {
node.HubPeerID = c.RemotePeer()
- fmt.Printf("Connected to hub (discovered PeerID): %s\n", node.HubPeerID)
+ logger.Infof("[AuthN] Connected to hub (discovered PeerID): %s", node.HubPeerID)
break
}
}
} else {
node.HubPeerID = addrInfo.ID
- fmt.Printf("Connected to hub: %s\n", addrInfo.ID)
+ logger.Infof("[AuthN] Connected to hub: %s", addrInfo.ID)
}
break
}
@@ -133,7 +158,7 @@ func NewSamNode(ctx context.Context, privKey crypto.PrivKey, hubPubKey ed25519.P
interval, err := time.ParseDuration(discoveryInterval)
if err != nil {
- fmt.Printf("[Warning] Invalid discovery interval '%s', using default 2s: %v\n", discoveryInterval, err)
+ logger.Warnf("[Discovery] Invalid discovery interval '%s', using default 2s: %v", discoveryInterval, err)
interval = 2 * time.Second
}
@@ -166,7 +191,7 @@ func (n *SamNode) listenForHubEvents(ctx context.Context) {
}
var event api.MeshEvent
if err := proto.Unmarshal(msg.Data, &event); err != nil {
- fmt.Printf("[Mesh Event] Failed to unmarshal event from %s: %v\n", msg.ReceivedFrom, err)
+ logger.Errorf("[Mesh Event] Failed to unmarshal event from %s: %v", msg.ReceivedFrom, err)
continue
}
@@ -174,15 +199,50 @@ func (n *SamNode) listenForHubEvents(ctx context.Context) {
switch event.Type {
case api.MeshEvent_JOIN:
n.knownPeers[event.PeerId] = true
- fmt.Printf("[Mesh Event] Peer joined: %s\n", event.PeerId)
+ logger.Infof("[Mesh Event] Peer joined: %s", event.PeerId)
case api.MeshEvent_EXIT, api.MeshEvent_BANNED:
delete(n.knownPeers, event.PeerId)
- fmt.Printf("[Mesh Event] Peer left/banned: %s\n", event.PeerId)
+ logger.Infof("[Mesh Event] Peer left/banned: %s", event.PeerId)
}
n.mu.Unlock()
}
}
+func (n *SamNode) subscribeToTopic(ctx context.Context, topicName string) error {
+ n.mu.Lock()
+ topic, ok := n.topics[topicName]
+ var err error
+ if !ok {
+ topic, err = n.PubSub.Join(topicName)
+ if err == nil {
+ n.topics[topicName] = topic
+ }
+ }
+ n.mu.Unlock()
+ if err != nil {
+ return err
+ }
+ sub, err := topic.Subscribe()
+ if err != nil {
+ return err
+ }
+
+ bgCtx := context.Background()
+ go func() {
+ defer sub.Cancel()
+ for {
+ msg, err := sub.Next(bgCtx)
+ if err != nil {
+ return
+ }
+ n.mu.Lock()
+ n.receivedMsgs[topicName] = append(n.receivedMsgs[topicName], string(msg.Data))
+ n.mu.Unlock()
+ }
+ }()
+ return nil
+}
+
func (n *SamNode) startDiscovery(ctx context.Context, meshID string, interval time.Duration) {
routingDiscovery := routing.NewRoutingDiscovery(n.DHT)
util.Advertise(ctx, routingDiscovery, meshID)
@@ -197,7 +257,7 @@ func (n *SamNode) startDiscovery(ctx context.Context, meshID string, interval ti
case <-ticker.C:
peers, err := routingDiscovery.FindPeers(ctx, meshID)
if err != nil {
- fmt.Printf("[Discovery] Failed to find peers: %v\n", err)
+ logger.Errorf("[Discovery] Failed to find peers: %v", err)
continue
}
for p := range peers {
@@ -207,10 +267,10 @@ func (n *SamNode) startDiscovery(ctx context.Context, meshID string, interval ti
n.mu.Lock()
if !n.knownPeers[p.ID.String()] {
n.knownPeers[p.ID.String()] = true
- fmt.Printf("[Discovery] Found new peer via DHT: %s\n", p.ID)
+ logger.Infof("[Discovery] Found new peer via DHT: %s", 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)
+ logger.Errorf("[Discovery] Failed to connect to %s: %v", pi.ID, err)
}
}(p)
}
@@ -225,7 +285,7 @@ func (n *SamNode) startDiscovery(ctx context.Context, meshID string, interval ti
func (n *SamNode) HandleAuthHandshake(s network.Stream) {
defer func() {
if err := s.Close(); err != nil {
- fmt.Printf("Failed to close auth stream: %v\n", err)
+ logger.Errorf("[AuthN] Failed to close auth stream: %v", err)
}
}()
remotePeer := s.Conn().RemotePeer()
@@ -233,32 +293,32 @@ func (n *SamNode) HandleAuthHandshake(s network.Stream) {
reader := msgio.NewVarintReaderSize(s, 1024*64)
msg, err := reader.ReadMsg()
if err != nil {
- fmt.Printf("[AuthN] Failed to read handshake from %s: %v\n", remotePeer, err)
+ logger.Errorf("[AuthN] Failed to read handshake from %s: %v", remotePeer, err)
return
}
defer reader.ReleaseMsg(msg)
var exchange api.AuthEnvelope
if err := proto.Unmarshal(msg, &exchange); err != nil {
- fmt.Printf("[AuthN] Invalid protobuf from %s\n", remotePeer)
+ logger.Warnf("[AuthN] Invalid protobuf from %s", remotePeer)
return
}
// 2. Unmarshal and verify token format
b, err := biscuit.Unmarshal(exchange.Biscuit)
if err != nil {
- fmt.Printf("[AuthN] Malformed biscuit from %s\n", remotePeer)
+ logger.Warnf("[AuthN] Malformed biscuit from %s", remotePeer)
return
}
// 3. Verify signature chain against the trusted Hub key.
authorizer, err := b.Authorizer(n.HubPublicKey)
if err != nil {
- fmt.Printf("[AuthN] Signature verification setup failed for %s: %v\n", remotePeer, err)
+ logger.Errorf("[AuthN] Signature verification setup failed for %s: %v", remotePeer, err)
return
}
if err := authorizer.Authorize(); err != nil {
- fmt.Printf("[AuthN] Authorization failed for %s: %v\n", remotePeer, err)
+ logger.Warnf("[AuthN] Authorization failed for %s: %v", remotePeer, err)
return
}
@@ -268,7 +328,7 @@ func (n *SamNode) HandleAuthHandshake(s network.Stream) {
IDs: []biscuit.Term{biscuit.String(remotePeer.String())},
}}
if _, err := b.GetBlockID(boundFact); err != nil {
- fmt.Printf("[AuthN] Token is not bound to peer %s\n", remotePeer)
+ logger.Warnf("[AuthN] Token is not bound to peer %s", remotePeer)
return
}
@@ -288,9 +348,9 @@ func (n *SamNode) HandleAuthHandshake(s network.Stream) {
// 5. Save to the persistent session cache (BoltDB)
// Once saved here, the ConnectionGater and Middleware will "recognize" this peer.
if err := n.Store.SaveVerifiedIdentity(remotePeer, identity); err != nil {
- fmt.Printf("[AuthN] Store error for %s: %v\n", remotePeer, err)
+ logger.Errorf("[AuthN] Store error for %s: %v", remotePeer, err)
return
}
- fmt.Printf("[AuthN] Successfully authenticated peer %s (%s)\n", remotePeer, identity.UserEmail)
+ logger.Infof("[AuthN] Successfully authenticated peer %s (%s)", remotePeer, identity.UserEmail)
}
diff --git a/cmd/sam-node/store.go b/cmd/sam-node/store.go
index 06606322..f0bcd79a 100644
--- a/cmd/sam-node/store.go
+++ b/cmd/sam-node/store.go
@@ -29,6 +29,7 @@ const (
keyBiscuit = "identity_biscuit"
keyPrivKey = "node_private_key"
keyIdentityExp = "identity_expiration"
+ keyPolicies = "datalog_policies"
)
type Store struct {
@@ -222,3 +223,26 @@ func (s *Store) GetVerifiedIdentity(p peer.ID) (*VerifiedIdentity, error) {
})
return &identity, err
}
+
+func (s *Store) SavePolicies(policies []string) error {
+ return s.db.Update(func(tx *bbolt.Tx) error {
+ b := tx.Bucket([]byte(bucketIdentity))
+ data, _ := json.Marshal(policies)
+ return b.Put([]byte(keyPolicies), data)
+ })
+}
+
+func (s *Store) LoadPolicies() ([]string, error) {
+ var val []byte
+ _ = s.db.View(func(tx *bbolt.Tx) error {
+ b := tx.Bucket([]byte(bucketIdentity))
+ val = b.Get([]byte(keyPolicies))
+ return nil
+ })
+ if len(val) == 0 {
+ return nil, nil // Return empty if none found
+ }
+ var policies []string
+ err := json.Unmarshal(val, &policies)
+ return policies, err
+}
diff --git a/cmd/sam-node/store_test.go b/cmd/sam-node/store_test.go
new file mode 100644
index 00000000..bdc3ddb4
--- /dev/null
+++ b/cmd/sam-node/store_test.go
@@ -0,0 +1,59 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+ "os"
+ "testing"
+)
+
+func TestStorePolicies(t *testing.T) {
+ dir, err := os.MkdirTemp("", "store-test")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() {
+ _ = os.RemoveAll(dir)
+ }()
+
+ store, err := NewStore(dir)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() {
+ _ = store.Close()
+ }()
+
+ policies := []string{"allow if operation($op)", "deny if user(bad)"}
+
+ if err := store.SavePolicies(policies); err != nil {
+ t.Fatalf("failed to save policies: %v", err)
+ }
+
+ loaded, err := store.LoadPolicies()
+ if err != nil {
+ t.Fatalf("failed to load policies: %v", err)
+ }
+
+ if len(loaded) != len(policies) {
+ t.Fatalf("expected %d policies, got %d", len(policies), len(loaded))
+ }
+
+ for i, p := range policies {
+ if loaded[i] != p {
+ t.Errorf("expected policy %s, got %s", p, loaded[i])
+ }
+ }
+}
diff --git a/go.mod b/go.mod
index 5b947ae0..50aeba4a 100644
--- a/go.mod
+++ b/go.mod
@@ -6,6 +6,7 @@ require (
github.com/biscuit-auth/biscuit-go/v2 v2.2.0
github.com/coreos/go-oidc/v3 v3.18.0
github.com/golang-jwt/jwt/v5 v5.3.1
+ github.com/ipfs/go-log/v2 v2.9.1
github.com/libp2p/go-libp2p v0.48.0
github.com/libp2p/go-libp2p-kad-dht v0.39.1
github.com/libp2p/go-libp2p-pubsub v0.16.0
@@ -21,6 +22,7 @@ require (
require (
filippo.io/bigmod v0.1.1-0.20260103110540-f8a47775ebe5 // indirect
filippo.io/keygen v0.0.0-20260114151900-8e2790ea4c5b // indirect
+ github.com/alecthomas/participle/v2 v2.0.0 // indirect
github.com/benbjohnson/clock v1.3.5 // indirect
github.com/beorn7/perks v1.0.1 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect
@@ -44,7 +46,6 @@ require (
github.com/ipfs/boxo v0.39.0 // indirect
github.com/ipfs/go-cid v0.6.1 // indirect
github.com/ipfs/go-datastore v0.9.1 // indirect
- github.com/ipfs/go-log/v2 v2.9.1 // indirect
github.com/ipld/go-ipld-prime v0.23.0 // indirect
github.com/jackpal/go-nat-pmp v1.0.2 // indirect
github.com/jbenet/go-temp-err-catcher v0.1.0 // indirect
diff --git a/go.sum b/go.sum
index 53e5a91d..f6fec18b 100644
--- a/go.sum
+++ b/go.sum
@@ -43,8 +43,12 @@ filippo.io/keygen v0.0.0-20260114151900-8e2790ea4c5b h1:REI1FbdW71yO56Are4XAxD+O
filippo.io/keygen v0.0.0-20260114151900-8e2790ea4c5b/go.mod h1:9nnw1SlYHYuPSo/3wjQzNjSbeHlq2NsKo5iEtfJPWP0=
github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/alecthomas/assert/v2 v2.2.2 h1:Z/iVC0xZfWTaFNE6bA3z07T86hd45Xe2eLt6WVy2bbk=
+github.com/alecthomas/assert/v2 v2.2.2/go.mod h1:pXcQ2Asjp247dahGEmsZ6ru0UVwnkhktn7S0bBDLxvQ=
github.com/alecthomas/participle/v2 v2.0.0 h1:Fgrq+MbuSsJwIkw3fEj9h75vDP0Er5JzepJ0/HNHv0g=
github.com/alecthomas/participle/v2 v2.0.0/go.mod h1:rAKZdJldHu8084ojcWevWAL8KmEU+AT+Olodb+WoN2Y=
+github.com/alecthomas/repr v0.2.0 h1:HAzS41CIzNW5syS8Mf9UwXhNH1J9aix/BvDRf1Ml2Yk=
+github.com/alecthomas/repr v0.2.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
@@ -219,6 +223,8 @@ github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO
github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ=
github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I=
github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
+github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
+github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc=
github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8=
github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
diff --git a/tests/e2e/kind_wi.bats b/tests/e2e/kind_wi.bats
index 7dfa3d51..55d48ab2 100644
--- a/tests/e2e/kind_wi.bats
+++ b/tests/e2e/kind_wi.bats
@@ -145,7 +145,7 @@ EOF
# Get Hub PeerID
local hub_peer_id
- hub_peer_id=$(kubectl logs "${hub_pod_name}" | grep "PeerID:" | awk '{print $2}' | tr -d '\r')
+ hub_peer_id=$(kubectl logs "${hub_pod_name}" | grep -oE '12D3Koo[a-zA-Z0-9]+' | head -n 1)
[[ -n "${hub_peer_id}" ]]
diff --git a/tests/e2e/lib/container_mesh.bash b/tests/e2e/lib/container_mesh.bash
index 16b43620..89de575b 100644
--- a/tests/e2e/lib/container_mesh.bash
+++ b/tests/e2e/lib/container_mesh.bash
@@ -89,7 +89,7 @@ if [[ -z "${MESH_HELPERS_LOADED:-}" ]]; then
local timeout_s="${3:-20}"
local i
for ((i=0; i<timeout_s*10; i++)); do
- if docker logs "${container}" 2>&1 | grep -q "${needle}"; then
+ if docker logs "${container}" 2>&1 | grep -Fq "${needle}"; then
return 0
fi
sleep 0.1
@@ -305,17 +305,18 @@ EOF
--mesh "e2e-mesh" >/dev/null
MESH_CONTAINERS+=("${name}")
- mesh_wait_for_log "${name}" "SAM Hub Online" 20
+ mesh_wait_for_log "${name}" "PeerID:" 20
# Extract Peer ID for nodes to use
local peer_id
- peer_id=$(docker logs "${name}" | grep "PeerID:" | awk '{print $2}' | tr -d '\r')
+ peer_id=$(docker logs "${name}" 2>&1 | grep -oE '12D3Koo[a-zA-Z0-9]+' | head -n 1)
echo "${peer_id}" > "/tmp/${MESH_PREFIX}-hub-peer-id"
echo "Extracted Hub PeerID: ${peer_id}"
}
mesh_start_node() {
local idx="$1"
+ local flags="${2:-}"
local name="${MESH_PREFIX}-node-${idx}"
local hub_peer_id
@@ -328,6 +329,7 @@ EOF
-v "${MESH_SOCKET_DIR}:/sockets" \
"sam-node:local" \
run \
+ ${flags} \
--hub "/dns4/sam-hub/tcp/4002/p2p/${hub_peer_id}" \
--client-id "sam-e2e" \
--client-secret "sam-e2e-secret" \
diff --git a/tests/e2e/relay.bats b/tests/e2e/relay.bats
new file mode 100644
index 00000000..5bb12e04
--- /dev/null
+++ b/tests/e2e/relay.bats
@@ -0,0 +1,46 @@
+#!/usr/bin/env bats
+
+load "lib/container_mesh.bash"
+
+setup() {
+ if ! mesh_require_docker; then
+ skip "docker not available or daemon not running"
+ fi
+
+ if [[ ! -x "./bin/sam-node" || ! -x "./bin/sam-hub" ]]; then
+ skip "missing binaries; run: make build"
+ fi
+
+ mesh_setup_env
+ mkdir -p tests/e2e/logs
+}
+
+teardown() {
+ if [[ "${BATS_TEST_COMPLETED:-0}" -ne 1 ]]; then
+ mkdir -p tests/e2e/logs
+ local ids
+ ids="$(docker ps -aq --filter "name=mesh-")"
+ for id in ${ids}; do
+ local name
+ name="$(docker inspect -f '{{.Name}}' "${id}" | tr -d '/')"
+ docker logs "${id}" > "tests/e2e/logs/${name}.log" 2>&1 || true
+ done
+ fi
+ mesh_cleanup_env
+}
+
+@test "node starts with --enable-relay=true and logs message" {
+ run mesh_start_mock_oidc
+ [[ "$status" -eq 0 ]]
+
+ run mesh_start_hub
+ [[ "$status" -eq 0 ]]
+
+ # Start node with relay flag
+ run mesh_start_node "1" "--enable-relay=true --log-level=debug"
+ [[ "$status" -eq 0 ]]
+
+ # Wait for log message
+ run mesh_wait_for_log "${MESH_PREFIX}-node-1" "Enabling Relay Service" 20
+ [[ "$status" -eq 0 ]]
+}
diff --git a/tests/integration/pubsub_test.go b/tests/integration/pubsub_test.go
new file mode 100644
index 00000000..7c135f05
--- /dev/null
+++ b/tests/integration/pubsub_test.go
@@ -0,0 +1,217 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package integration_test
+
+import (
+ "context"
+ "net"
+ "net/http"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/modelcontextprotocol/go-sdk/mcp"
+)
+
+func TestPubSubTools(t *testing.T) {
+ nodeBin := buildBinary(t, "./cmd/sam-node")
+ _, hubAddr := startMockLibp2pHub(t)
+ tmpHome1, err := os.MkdirTemp("", "pubsub-test-1")
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Logf("Node 1 logs at: %s/node1.log", tmpHome1)
+
+ tmpHome2, err := os.MkdirTemp("", "pubsub-test-2")
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Logf("Node 2 logs at: %s/node2.log", tmpHome2)
+
+ socket1 := filepath.Join(tmpHome1, "mcp.sock")
+ socket2 := filepath.Join(tmpHome2, "mcp.sock")
+
+ ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+ defer cancel()
+
+ // Start Node 1
+ env1 := append(os.Environ(), "HOME="+tmpHome1, "XDG_CONFIG_HOME="+filepath.Join(tmpHome1, ".config"))
+ cmd1 := exec.CommandContext(ctx, nodeBin, "run", "--hub", hubAddr, "--mcp-socket", socket1, "--listen", "/ip4/127.0.0.1/udp/5003/quic-v1", "--listen", "/ip4/127.0.0.1/tcp/5004", "--jwt", "dummy-token", "--log-level", "debug", "--discovery-interval", "100ms")
+ cmd1.Env = env1
+ logFile1, err := os.Create(filepath.Join(tmpHome1, "node1.log"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ cmd1.Stdout = logFile1
+ cmd1.Stderr = logFile1
+ if err := cmd1.Start(); err != nil {
+ t.Fatal(err)
+ }
+ defer func() { _ = cmd1.Process.Kill(); _ = logFile1.Close() }()
+
+ // Start Node 2
+ env2 := append(os.Environ(), "HOME="+tmpHome2, "XDG_CONFIG_HOME="+filepath.Join(tmpHome2, ".config"))
+ cmd2 := exec.CommandContext(ctx, nodeBin, "run", "--hub", hubAddr, "--mcp-socket", socket2, "--listen", "/ip4/127.0.0.1/udp/5005/quic-v1", "--listen", "/ip4/127.0.0.1/tcp/5006", "--jwt", "dummy-token", "--log-level", "debug", "--discovery-interval", "100ms")
+ cmd2.Env = env2
+ logFile2, err := os.Create(filepath.Join(tmpHome2, "node2.log"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ cmd2.Stdout = logFile2
+ cmd2.Stderr = logFile2
+ if err := cmd2.Start(); err != nil {
+ t.Fatal(err)
+ }
+ defer func() { _ = cmd2.Process.Kill(); _ = logFile2.Close() }()
+
+ // Wait for sockets to appear
+ waitForSocket := func(socketPath string) {
+ for i := 0; i < 50; i++ {
+ if _, err := os.Stat(socketPath); err == nil {
+ return
+ }
+ time.Sleep(100 * time.Millisecond)
+ }
+ t.Fatalf("Socket %s did not appear", socketPath)
+ }
+ waitForSocket(socket1)
+ waitForSocket(socket2)
+
+ // Helper to call MCP tool
+ callTool := func(socketPath string, toolName string, params map[string]any) string {
+ 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(context.Background(), &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(context.Background(), &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 ""
+ }
+
+ waitForPeerInfoInLog := func(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.Contains(line, "PeerID: ") {
+ parts := strings.Split(line, "PeerID: ")
+ if len(parts) > 1 {
+ peerID = strings.TrimSpace(parts[1])
+ }
+ }
+ 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 ""
+ }
+
+ // Force Node 1 to connect to Node 2
+ addr2 := waitForPeerInfoInLog(t, filepath.Join(tmpHome2, "node2.log"))
+ t.Logf("Node 2 address: %s", addr2)
+ callTool(socket1, "connect_peer", map[string]any{"peer_addr": addr2})
+
+ // Node 1 broadcasts on topic "test-topic"
+ broadcastResult := callTool(socket1, "mesh_pubsub_broadcast", map[string]any{
+ "topic": "test-topic",
+ "payload": "hello from node 1",
+ })
+ if !strings.Contains(broadcastResult, "Published") {
+ t.Fatalf("Broadcast failed: %s", broadcastResult)
+ }
+
+ // Node 2 subscribes to topic "test-topic"
+ subscribeResult := callTool(socket2, "subscribe_topic", map[string]any{
+ "topic": "test-topic",
+ })
+ if !strings.Contains(subscribeResult, "Subscribed") {
+ t.Fatalf("Subscribe failed: %s", subscribeResult)
+ }
+
+ var pollResult string
+ deadline := time.Now().Add(10 * time.Second)
+ for time.Now().Before(deadline) {
+ // Node 1 broadcasts on topic "test-topic" again to ensure delivery after subscription
+ broadcastResult = callTool(socket1, "mesh_pubsub_broadcast", map[string]any{
+ "topic": "test-topic",
+ "payload": "hello from node 1",
+ })
+ if !strings.Contains(broadcastResult, "Published") {
+ t.Fatalf("Broadcast failed: %s", broadcastResult)
+ }
+
+ // Node 2 polls for messages on topic "test-topic"
+ pollResult = callTool(socket2, "poll_messages", map[string]any{
+ "topic": "test-topic",
+ })
+ if strings.Contains(pollResult, "hello from node 1") {
+ break
+ }
+ time.Sleep(500 * time.Millisecond)
+ }
+
+ if !strings.Contains(pollResult, "hello from node 1") {
+ t.Fatalf("Poll failed, expected message not found: %s", pollResult)
+ }
+}