Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
add tests
Antonio Ojea31aa50368394
diff --git a/tests/e2e/sam.bats b/tests/e2e/sam.batsindex 733505c7..404cb9dc 100644--- a/tests/e2e/sam.bats+++ b/tests/e2e/sam.bats@@ -1,9 +1,14 @@#!/usr/bin/env batssetup() {- export SAM_BINARY="${SAM_BINARY:-./bin/sam-agent}"- if [[ ! -x "$SAM_BINARY" ]]; then- skip "sam binary not found at $SAM_BINARY"+ export SAM_NODE_BINARY="${SAM_NODE_BINARY:-./bin/sam-node}"+ export SAM_HUB_BINARY="${SAM_HUB_BINARY:-./bin/sam-hub}"++ if [[ ! -x "$SAM_NODE_BINARY" ]]; then+ skip "sam-node binary not found at $SAM_NODE_BINARY"+ fi+ if [[ ! -x "$SAM_HUB_BINARY" ]]; then+ skip "sam-hub binary not found at $SAM_HUB_BINARY"fiexport TEST_TMPDIR@@ -17,152 +22,32 @@ teardown() {rm -rf "$TEST_TMPDIR"}-@test "sam up --help returns success" {- run "$SAM_BINARY" up --help- [[ "$status" -eq 0 ]]- [[ "$output" == *"Run the SAM node"* ]] || [[ "$output" == *"run-for"* ]]-}--@test "sam publish --help returns success" {- run "$SAM_BINARY" publish --help- [[ "$status" -eq 0 ]]- [[ "$output" == *"--skill"* ]]-}--@test "sam identity --help lists subcommands" {- run "$SAM_BINARY" identity --help- [[ "$status" -eq 0 ]]- [[ "$output" == *"login"* ]] || [[ "$output" == *"whoami"* ]]-}--@test "sam call --help shows capability option" {- run "$SAM_BINARY" call --help- [[ "$status" -eq 0 ]]- [[ "$output" == *"--capability"* ]] || [[ "$output" == *"call"* ]]-}--@test "sam mesh get agents --help returns success" {- run "$SAM_BINARY" mesh get agents --help+@test "sam-node --help returns success" {+ run "$SAM_NODE_BINARY" --help[[ "$status" -eq 0 ]]+ [[ "$output" == *"Sovereign Agent Mesh Node"* ]]}-@test "sam inspect biscuit parses and explains a token" {- token="alice;allow_skill=risk-audit,weather-bot"- run "$SAM_BINARY" inspect biscuit "$token"+@test "sam-node login --help returns success" {+ run "$SAM_NODE_BINARY" login --help[[ "$status" -eq 0 ]]- [[ "$output" == *"alice"* ]]- [[ "$output" == *"risk-audit"* ]]- [[ "$output" == *"weather-bot"* ]]+ [[ "$output" == *"Establish sovereign identity with the Hub"* ]]}-@test "sam inspect biscuit outputs JSON when token has multiple skills" {- token="bob;allow_skill=chat,email"- run "$SAM_BINARY" inspect biscuit "$token"+@test "sam-node run without identity prints guidance" {+ run "$SAM_NODE_BINARY" run[[ "$status" -eq 0 ]]- [[ "$output" == *"bob"* ]]- [[ "$output" == *"chat"* ]]- [[ "$output" == *"email"* ]]+ [[ "$output" == *"No identity found"* ]]}-@test "sam publish --dry-run=client outputs card structure" {- run "$SAM_BINARY" publish --skill weather-bot --mcp-port 9999 --dry-run=client+@test "sam-node login stores identity from stdin" {+ run bash -c "printf 'sample-token\n' | '$SAM_NODE_BINARY' login"[[ "$status" -eq 0 ]]- [[ "$output" == *'"peer_id"'* ]]- [[ "$output" == *'"weather-bot"'* ]]+ [[ "$output" == *"Success! Identity stored"* ]]}-@test "sam call --dry-run=client validates request without network" {- run "$SAM_BINARY" call test-peer --message "hello" --dry-run=client+@test "sam-hub --help returns success" {+ run "$SAM_HUB_BINARY" --help[[ "$status" -eq 0 ]]- [[ "$output" == *'"target"'* ]] || [[ "$output" == *'"capability"'* ]]-}--@test "sam inspect card decodes JSON agent card" {- card_json='{"peer_id":"test-peer","alg":"libp2p-ed25519","signature":"test","agent_card":{"name":"test"},"issued_at":"2026-01-01T00:00:00Z"}'- run "$SAM_BINARY" inspect card "$card_json"- [[ "$status" -eq 0 ]]- [[ "$output" == *"test-peer"* ]] || [[ "$output" == *"Peer ID"* ]]-}--@test "sam proxy --help returns success" {- run "$SAM_BINARY" proxy --help- [[ "$status" -eq 0 ]]- [[ "$output" == *"X-SAM-Target"* ]] || [[ "$output" == *"--port"* ]]-}--@test "sam proxy rejects requests without local identity login" {- proxy_port=18080- proxy_log="$TEST_TMPDIR/proxy.log"-- "$SAM_BINARY" proxy --port "$proxy_port" --listen /ip4/127.0.0.1/udp/4212/quic-v1 --run-for 10s >"$proxy_log" 2>&1 &- proxy_pid=$!-- status_code="000"- for _ in {1..40}; do- status_code="$(curl -s -o "$TEST_TMPDIR/proxy_body.txt" -w "%{http_code}" -H "X-SAM-Target: 12D3KooWJ5x6k6U4k6M8QfR5fE3iZ7W2V2QX2c9Lr4R8D8vH" "http://127.0.0.1:${proxy_port}/health" || true)"- if [[ "$status_code" != "000" ]]; then- break- fi- sleep 0.1- done-- kill "$proxy_pid" >/dev/null 2>&1 || true- wait "$proxy_pid" >/dev/null 2>&1 || true-- [[ "$status_code" == "401" ]]- run cat "$TEST_TMPDIR/proxy_body.txt"- [[ "$output" == *"unauthorized"* ]]-}--@test "sam proxy /.sam/search discovers writer skill" {- node_a_log="$TEST_TMPDIR/node-a.log"- node_b_log="$TEST_TMPDIR/node-b.log"- proxy_port=18081- node_a_listen="/ip4/127.0.0.1/udp/4313/quic-v1"- node_b_listen="/ip4/127.0.0.1/udp/4314/quic-v1"-- "$SAM_BINARY" proxy --port "$proxy_port" --listen "$node_b_listen" --dht-mode server --run-for 20s >"$node_b_log" 2>&1 &- node_b_pid=$!-- node_b_peer=""- for _ in {1..100}; do- node_b_peer="$(grep -o 'peer_id=[^ ]*' "$node_b_log" | head -n1 | cut -d= -f2)"- if [[ -n "$node_b_peer" ]]; then- break- fi- sleep 0.1- done- [[ -n "$node_b_peer" ]]-- node_a_peer=""- "$SAM_BINARY" publish --skill writer --mcp-port 19099 --listen "$node_a_listen" --bootstrap "/ip4/127.0.0.1/udp/4314/quic-v1/p2p/${node_b_peer}" --dht-mode server --run-for 20s >"$node_a_log" 2>&1 &- node_a_pid=$!-- for _ in {1..120}; do- node_a_peer="$(grep -o 'peer_id=[^ ]*' "$node_a_log" | head -n1 | cut -d= -f2)"- if [[ -n "$node_a_peer" ]]; then- break- fi- sleep 0.1- done- [[ -n "$node_a_peer" ]]-- search_status="000"- for _ in {1..120}; do- search_status="$(curl -s -o "$TEST_TMPDIR/search_body.json" -w "%{http_code}" "http://127.0.0.1:${proxy_port}/.sam/search?skill=writer" || true)"- if [[ "$search_status" == "200" ]] && grep -q "$node_a_peer" "$TEST_TMPDIR/search_body.json"; then- break- fi- sleep 0.2- done-- kill "$node_b_pid" >/dev/null 2>&1 || true- wait "$node_b_pid" >/dev/null 2>&1 || true- kill "$node_a_pid" >/dev/null 2>&1 || true- wait "$node_a_pid" >/dev/null 2>&1 || true-- [[ "$search_status" == "200" ]]- run cat "$TEST_TMPDIR/search_body.json"- [[ "$output" == *"$node_a_peer"* ]]- [[ "$output" == *'"signature"'* ]]+ [[ "$output" == *"Sovereign Agent Mesh - Multi-Transport Hub"* ]]}diff --git a/tests/e2e/watch.bats b/tests/e2e/watch.batsindex 99744e5d..7da8bf10 100644--- a/tests/e2e/watch.bats+++ b/tests/e2e/watch.bats@@ -1,9 +1,9 @@#!/usr/bin/env batssetup() {- export SAM_BINARY="${SAM_BINARY:-./bin/sam-agent}"- if [[ ! -x "$SAM_BINARY" ]]; then- skip "sam binary not found at $SAM_BINARY"+ export SAM_NODE_BINARY="${SAM_NODE_BINARY:-./bin/sam-node}"+ if [[ ! -x "$SAM_NODE_BINARY" ]]; then+ skip "sam-node binary not found at $SAM_NODE_BINARY"fiexport TEST_TMPDIR@@ -17,51 +17,45 @@ teardown() {rm -rf "$TEST_TMPDIR"}-@test "sam mesh get agents --watch updates when a new agent is published" {- watcher_log="$TEST_TMPDIR/mesh-watch.log"- publisher_log="$TEST_TMPDIR/mesh-publisher.log"- watcher_listen="/ip4/127.0.0.1/udp/4320/quic-v1"- publisher_listen="/ip4/127.0.0.1/udp/4321/quic-v1"+@test "sam-node run with token reaches online state" {+ log_file="$TEST_TMPDIR/run.log"+ "$SAM_NODE_BINARY" run --token test-token --listen /ip4/127.0.0.1/udp/0/quic-v1 --listen /ip4/127.0.0.1/tcp/0 >"$log_file" 2>&1 &+ pid=$!- "$SAM_BINARY" mesh get agents --watch -o json --listen "$watcher_listen" --dht-mode server --run-for 20s >"$watcher_log" 2>&1 &- watcher_pid=$!-- watcher_peer=""- for _ in {1..100}; do- watcher_peer="$(grep -o 'peer_id=[^ ]*' "$watcher_log" | head -n1 | cut -d= -f2)"- if [[ -n "$watcher_peer" ]]; then+ online=""+ for _ in {1..40}; do+ if grep -q "SAM Node Online" "$log_file"; then+ online="yes"breakfisleep 0.1done- [[ -n "$watcher_peer" ]]- "$SAM_BINARY" publish --skill writer --mcp-port 19100 --listen "$publisher_listen" --bootstrap "/ip4/127.0.0.1/udp/4320/quic-v1/p2p/${watcher_peer}" --dht-mode server --run-for 8s >"$publisher_log" 2>&1 &- publisher_pid=$!+ kill "$pid" >/dev/null 2>&1 || true+ wait "$pid" >/dev/null 2>&1 || true- publisher_peer=""- for _ in {1..100}; do- publisher_peer="$(grep -o 'peer_id=[^ ]*' "$publisher_log" | head -n1 | cut -d= -f2)"- if [[ -n "$publisher_peer" ]]; then- break- fi- sleep 0.1- done- [[ -n "$publisher_peer" ]]+ [[ "$online" == "yes" ]]+}++@test "sam-node login enables run without --token" {+ run bash -c "printf 'persisted-token\n' | '$SAM_NODE_BINARY' login"+ [[ "$status" -eq 0 ]]++ log_file="$TEST_TMPDIR/run-stored.log"+ "$SAM_NODE_BINARY" run --listen /ip4/127.0.0.1/udp/0/quic-v1 --listen /ip4/127.0.0.1/tcp/0 >"$log_file" 2>&1 &+ pid=$!- found=""- for _ in {1..120}; do- if grep -q "\"peer_id\":\"$publisher_peer\"" "$watcher_log" && grep -q 'writer' "$watcher_log"; then- found="yes"+ online=""+ for _ in {1..40}; do+ if grep -q "SAM Node Online" "$log_file"; then+ online="yes"breakfi- sleep 0.2+ sleep 0.1done- kill "$publisher_pid" >/dev/null 2>&1 || true- wait "$publisher_pid" >/dev/null 2>&1 || true- kill "$watcher_pid" >/dev/null 2>&1 || true- wait "$watcher_pid" >/dev/null 2>&1 || true+ kill "$pid" >/dev/null 2>&1 || true+ wait "$pid" >/dev/null 2>&1 || true- [[ "$found" == "yes" ]]-}\ No newline at end of file+ [[ "$online" == "yes" ]]+}diff --git a/tests/integration/call_test.go b/tests/integration/call_test.goindex c3ff13d7..1660d747 100644--- a/tests/integration/call_test.go+++ b/tests/integration/call_test.go@@ -15,527 +15,19 @@package integration_testimport (- "bytes"- "context"- "encoding/json"- "fmt"- "os"- "os/exec"- "path/filepath"- "strconv""strings"- "syscall""testing""time"-- "github.com/libp2p/go-libp2p/core/peer"- "github.com/modelcontextprotocol/go-sdk/jsonrpc"- "github.com/modelcontextprotocol/go-sdk/mcp"- "github.com/multiformats/go-multiaddr"- "go.etcd.io/bbolt"-- internaldb "sam/internal/db"- "sam/internal/testutils"- "sam/pkg/economy"- "sam/pkg/identity"- samnet "sam/pkg/net"- a2aprotocol "sam/pkg/protocol/a2a"- protocol "sam/pkg/protocol/discovery"- mcpprotocol "sam/pkg/protocol/mcp")-const (- callHelperEnv = "SAM_CALL_HELPER"- callRoleEnv = "SAM_CALL_ROLE"- callInfoEnv = "SAM_CALL_INFO_FILE"- callRepDBEnv = "SAM_CALL_REPUTATION_DB"- callProviderPIDEnv = "SAM_CALL_PROVIDER_PID"- callRoleProvider = "provider"- callRoleConsumer = "consumer"- callCapability = "weather-bot"- callRecordVersion = 1-)--type callPeerInfo struct {- PeerID string `json:"peer_id"`- Bootstrap string `json:"bootstrap"`-}--type callRoleProcess struct {- cmd *exec.Cmd- stdout bytes.Buffer- stderr bytes.Buffer-}--func TestA2ACallIntegration(t *testing.T) {- if os.Getenv(callHelperEnv) == "1" {- if err := runCallRole(); err != nil {- t.Fatalf("call helper failed: %v", err)- }- return- }-- testutils.Run(t, func(t *testing.T) {- runCallIntegration(t)- })-}--func runCallIntegration(t *testing.T) {- t.Helper()-- tmpDir := t.TempDir()- infoFile := filepath.Join(tmpDir, "provider.json")- repDB := filepath.Join(tmpDir, "reputation.db")-- provider := startCallRoleProcess(t, callRoleProvider, map[string]string{- callInfoEnv: infoFile,- })- t.Cleanup(func() {- if t.Failed() {- t.Logf("provider stdout:\n%s\nprovider stderr:\n%s", provider.stdout.String(), provider.stderr.String())- }- })- defer stopCallRoleProcess(provider)-- if err := waitForCallInfoFile(infoFile, 15*time.Second); err != nil {- t.Fatalf("provider did not write info file in time: %v\nprovider stdout:\n%s\nprovider stderr:\n%s",- err, provider.stdout.String(), provider.stderr.String())- }-- consumer := startCallRoleProcess(t, callRoleConsumer, map[string]string{- callInfoEnv: infoFile,- callRepDBEnv: repDB,- callProviderPIDEnv: strconv.Itoa(provider.cmd.Process.Pid),- })- t.Cleanup(func() {- if t.Failed() {- t.Logf("consumer stdout:\n%s\nconsumer stderr:\n%s", consumer.stdout.String(), consumer.stderr.String())- }- })- defer stopCallRoleProcess(consumer)-- waitCallRoleExit(t, consumer, 30*time.Second)- if consumer.cmd.ProcessState.ExitCode() != 0 {- t.Fatalf("consumer process failed\nstdout:\n%s\nstderr:\n%s",- consumer.stdout.String(), consumer.stderr.String())- }-- db, err := bbolt.Open(repDB, 0o600, &bbolt.Options{Timeout: 2 * time.Second})- if err != nil {- t.Fatalf("opening reputation DB: %v", err)- }- defer func() { _ = db.Close() }()-- type reputationRecord struct {- PeerID string `json:"peer_id"`- OK bool `json:"ok"`- LatencyMS int64 `json:"latency_ms,omitempty"`- ErrorType string `json:"error_type,omitempty"`- }-- codec := internaldb.JSONCodec{}- successes := 0- livenessFailures := 0- err = db.View(func(tx *bbolt.Tx) error {- bucket := tx.Bucket([]byte(internaldb.BucketReputation))- if bucket == nil {- return fmt.Errorf("missing reputation bucket")- }- return bucket.ForEach(func(_ []byte, value []byte) error {- var rec reputationRecord- if err := codec.Unmarshal(value, callRecordVersion, &rec, nil); err != nil {- return err- }- if rec.OK {- successes++- }- if !rec.OK && strings.EqualFold(rec.ErrorType, a2aprotocol.FailureTypeLiveness) {- livenessFailures++- }- return nil- })- })- if err != nil {- t.Fatalf("reading reputation records: %v", err)- }- if successes == 0 {- t.Fatalf("expected at least one success interaction")- }- if livenessFailures == 0 {- t.Fatalf("expected at least one liveness failure interaction")- }-}--func runCallRole() error {- switch os.Getenv(callRoleEnv) {- case callRoleProvider:- return runCallProviderRole()- case callRoleConsumer:- return runCallConsumerRole()- default:- return fmt.Errorf("unknown call role %q", os.Getenv(callRoleEnv))- }-}--func runCallProviderRole() error {- ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)- defer cancel()-- node, err := newCallNode(0, nil)- if err != nil {- return err- }- if err := node.Start(ctx); err != nil {- return fmt.Errorf("provider node start: %w", err)- }- providerPassport, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{- PeerID: node.PeerID().String(),- FederationID: "default",- Subject: "test-subject",- })- if err != nil {- return fmt.Errorf("issuing provider passport biscuit: %w", err)- }- if err := identity.SetLocalPassport(node.Host(), "default", providerPassport); err != nil {- return fmt.Errorf("setting provider local passport auth: %w", err)- }- // In a subprocess role, fire Stop asynchronously so the process can exit- // promptly; the OS will clean up resources when the process terminates.- defer func() {- go func() { _ = node.Stop(context.Background()) }()- }()-- // Register the A2A handler BEFORE writing the info file so the consumer- // cannot connect and attempt Execute before the protocol is ready.- a2aSvc, err := a2aprotocol.NewA2AService(node.Host(), delayedResponseConnector{delay: 1500 * time.Millisecond}, a2aprotocol.NopObserver{})- if err != nil {- return fmt.Errorf("provider A2A service setup: %w", err)- }- defer a2aSvc.Close()-- // Derive the bootstrap address from the actual listen addresses assigned- // by the OS (we bound to port 0 to avoid fixed-port conflicts).- // Filter to the first QUIC address to avoid picking up relay/circuit addrs.- var quicAddr multiaddr.Multiaddr- for _, a := range node.Host().Network().ListenAddresses() {- s := a.String()- if strings.Contains(s, "udp") && strings.Contains(s, "quic") {- quicAddr = a- break- }- }- if quicAddr == nil {- return fmt.Errorf("provider has no QUIC listen address after start; addrs: %v",- node.Host().Network().ListenAddresses())- }- bootstrapAddr := quicAddr.String() + "/p2p/" + node.PeerID().String()- if err := writeCallPeerInfo(os.Getenv(callInfoEnv), callPeerInfo{- PeerID: node.PeerID().String(),- Bootstrap: bootstrapAddr,- }); err != nil {- return err- }-- priv := node.Host().Peerstore().PrivKey(node.PeerID())- card, err := protocol.NewAgentCard(- node.PeerID(),- []string{callCapability},- []mcpprotocol.Resource{{Name: "weather", Kind: "tool", Endpoint: "mcp://weather"}},- priv,- )- if err != nil {- return fmt.Errorf("provider card creation: %w", err)- }-- pub, err := protocol.NewPublisher(node)- if err != nil {- return fmt.Errorf("provider publisher: %w", err)- }- if err := publishCallWithRetry(ctx, pub, card); err != nil {- return fmt.Errorf("provider publish: %w", err)- }-- discovery, err := protocol.NewDiscoveryService(node)- if err != nil {- return fmt.Errorf("provider discovery service: %w", err)- }- if err := discovery.RegisterLocalCard(card); err != nil {- return fmt.Errorf("provider register card: %w", err)- }-- <-ctx.Done()- return nil-}--func runCallConsumerRole() error {- ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)- defer cancel()-- providerPID, err := strconv.Atoi(os.Getenv(callProviderPIDEnv))- if err != nil || providerPID <= 0 {- return fmt.Errorf("invalid provider pid: %q", os.Getenv(callProviderPIDEnv))- }-- info, err := waitCallPeerInfo(ctx, os.Getenv(callInfoEnv))- if err != nil {- return err- }- bootstrap, err := multiaddr.NewMultiaddr(info.Bootstrap)- if err != nil {- return fmt.Errorf("parsing bootstrap addr: %w", err)- }- providerID, err := peer.Decode(info.PeerID)- if err != nil {- return fmt.Errorf("decoding provider peer ID: %w", err)- }- providerAddrInfo, err := peer.AddrInfoFromP2pAddr(bootstrap)- if err != nil {- return fmt.Errorf("building provider addr info: %w", err)- }-- node, err := newCallNode(0, []multiaddr.Multiaddr{bootstrap})- if err != nil {- return err- }- if err := node.Start(ctx); err != nil {- return fmt.Errorf("consumer node start: %w", err)- }- passport, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{- PeerID: node.PeerID().String(),- FederationID: "default",- Subject: "test-subject",- })- if err != nil {- return fmt.Errorf("issuing passport biscuit: %w", err)- }- if err := identity.SetLocalPassport(node.Host(), "default", passport); err != nil {- return fmt.Errorf("setting local passport auth: %w", err)- }- // In a subprocess role, fire Stop asynchronously so the process can exit- // promptly; the OS will clean up resources when the process terminates.- defer func() {- go func() { _ = node.Stop(context.Background()) }()- }()-- if err := connectCallWithRetry(ctx, node, *providerAddrInfo); err != nil {- return fmt.Errorf("connecting to provider bootstrap: %w", err)- }-- // For call execution reliability in isolated namespaces, use the provider peer- // directly after bootstrap connection instead of waiting for DHT convergence.- target := peer.AddrInfo{ID: providerID, Addrs: node.Host().Peerstore().Addrs(providerID)}-- observer, err := a2aprotocol.NewBoltObserver(os.Getenv(callRepDBEnv))- if err != nil {- return fmt.Errorf("creating bolt observer: %w", err)- }- defer func() { _ = observer.Close() }()-- req := a2aprotocol.ExecuteRequest{- Target: target,- Capability: callCapability,- Biscuit: "integration-biscuit",- Payment: economy.Micropayment{- Amount: 1,- Asset: "sam-credit",- Nonce: "nonce-success",- Capability: callCapability,- },- Request: []byte(`{"jsonrpc":"2.0","id":"sam-call","method":"message","params":{"message":"weather"}}`),- }-- if _, err := a2aprotocol.Execute(ctx, node.Host(), req, observer); err != nil {- return fmt.Errorf("expected initial call success, got: %w", err)- }-- go func() {- time.Sleep(200 * time.Millisecond)- _ = syscall.Kill(providerPID, syscall.SIGKILL)- }()-- req.Payment.Nonce = "nonce-failure"- failCtx, failCancel := context.WithTimeout(ctx, 5*time.Second)- defer failCancel()- if _, err := a2aprotocol.Execute(failCtx, node.Host(), req, observer); err == nil {- return fmt.Errorf("expected second call to fail after provider kill")- }-- return nil-}--func newCallNode(port int, bootstrap []multiaddr.Multiaddr) (samnet.Node, error) {- listen, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/127.0.0.1/udp/%d/quic-v1", port))- if err != nil {- return nil, fmt.Errorf("building listen address: %w", err)- }- key, err := samnet.GenerateKey()- if err != nil {- return nil, fmt.Errorf("generating node key: %w", err)- }- return samnet.New(- samnet.WithPrivateKey(key),- samnet.WithListenAddrs(listen),- samnet.WithBootstrapPeers(bootstrap...),- samnet.WithDHTMode(samnet.DHTModeServer),- )-}--func publishCallWithRetry(ctx context.Context, pub *protocol.Publisher, card *protocol.AgentCard) error {- ticker := time.NewTicker(250 * time.Millisecond)- defer ticker.Stop()- var last error- for {- if err := pub.Publish(ctx, card); err == nil {- return nil- } else {- last = err- }- select {- case <-ctx.Done():- return last- case <-ticker.C:- }- }-}--func connectCallWithRetry(ctx context.Context, node samnet.Node, pi peer.AddrInfo) error {- ticker := time.NewTicker(250 * time.Millisecond)- defer ticker.Stop()- var last error- for {- if err := node.Connect(ctx, pi); err == nil {- return nil- } else {- last = err- }- select {- case <-ctx.Done():- return last- case <-ticker.C:- }- }-}--func writeCallPeerInfo(path string, info callPeerInfo) error {- if path == "" {- return fmt.Errorf("%s is required", callInfoEnv)- }- if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {- return fmt.Errorf("creating info directory: %w", err)- }- data, err := json.Marshal(info)+func TestSamNodeLoginHelp(t *testing.T) {+ nodeBin := buildBinary(t, "./cmd/sam-node")+ stdout, stderr, err := runCommand(t, repoRoot(t), 10*time.Second, nil, "", nodeBin, "login", "--help")if err != nil {- return fmt.Errorf("encoding peer info: %w", err)- }- return os.WriteFile(path, data, 0o600)-}--func waitCallPeerInfo(ctx context.Context, path string) (callPeerInfo, error) {- ticker := time.NewTicker(200 * time.Millisecond)- defer ticker.Stop()- for {- data, err := os.ReadFile(path)- if err == nil {- var info callPeerInfo- if err := json.Unmarshal(data, &info); err == nil && info.PeerID != "" {- return info, nil- }- }- select {- case <-ctx.Done():- return callPeerInfo{}, fmt.Errorf("waiting for provider info file: %w", ctx.Err())- case <-ticker.C:- }- }-}--func waitForCallInfoFile(path string, timeout time.Duration) error {- ctx, cancel := context.WithTimeout(context.Background(), timeout)- defer cancel()- _, err := waitCallPeerInfo(ctx, path)- return err-}--func startCallRoleProcess(t *testing.T, role string, env map[string]string) *callRoleProcess {- t.Helper()- p := &callRoleProcess{}- cmd := exec.Command(os.Args[0], "-test.run=TestA2ACallIntegration$", "-test.v=true")- cmd.Env = append(os.Environ(), callHelperEnv+"=1", callRoleEnv+"="+role)- for k, v := range env {- cmd.Env = append(cmd.Env, k+"="+v)- }- cmd.Stdout = &p.stdout- cmd.Stderr = &p.stderr- if err := cmd.Start(); err != nil {- t.Fatalf("starting %s role process: %v", role, err)- }- p.cmd = cmd- return p-}--func waitCallRoleExit(t *testing.T, p *callRoleProcess, timeout time.Duration) {- t.Helper()- done := make(chan error, 1)- go func() {- done <- p.cmd.Wait()- }()- select {- case err := <-done:- if err != nil {- t.Fatalf("role process exited with error: %v", err)- }- case <-time.After(timeout):- t.Logf("stdout:\n%s\nstderr:\n%s", p.stdout.String(), p.stderr.String())- t.Fatalf("role process did not exit in %s", timeout)+ t.Fatalf("sam-node login --help failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout, stderr)}-}--func stopCallRoleProcess(p *callRoleProcess) {- if p == nil || p.cmd == nil || p.cmd.Process == nil {- return- }- _ = p.cmd.Process.Kill()- _, _ = p.cmd.Process.Wait()-}--type delayedResponseConnector struct {- delay time.Duration-}--func (c delayedResponseConnector) Open(context.Context) (mcp.Transport, error) {- return delayedResponseTransport(c), nil-}--type delayedResponseTransport struct {- delay time.Duration-}--func (t delayedResponseTransport) Connect(context.Context) (mcp.Connection, error) {- msg, err := jsonrpc.DecodeMessage([]byte(`{"jsonrpc":"2.0","id":"sam-call","result":{"content":"sunny"}}`))- if err != nil {- return nil, err+ out := stdout + stderr+ if !strings.Contains(out, "Establish sovereign identity with the Hub") {+ t.Fatalf("unexpected help output:\n%s", out)}- return &delayedResponseConn{delay: t.delay, response: msg}, nil-}--type delayedResponseConn struct {- delay time.Duration- response jsonrpc.Message-}--func (c *delayedResponseConn) Read(context.Context) (jsonrpc.Message, error) {- time.Sleep(c.delay)- return c.response, nil-}--func (c *delayedResponseConn) Write(context.Context, jsonrpc.Message) error {- return nil-}--func (c *delayedResponseConn) Close() error {- return nil-}--func (c *delayedResponseConn) SessionID() string {- return "integration-session"}diff --git a/tests/integration/cuj_test.go b/tests/integration/cuj_test.goindex 20a43675..3a83d20f 100644--- a/tests/integration/cuj_test.go+++ b/tests/integration/cuj_test.go@@ -15,276 +15,39 @@package integration_testimport (- "bufio""context"- "fmt"- "io"+ "os"+ "path/filepath""strings""testing""time"-- "github.com/libp2p/go-libp2p/core/network"- "github.com/libp2p/go-libp2p/core/peer"- coreprotocol "github.com/libp2p/go-libp2p/core/protocol"- "github.com/multiformats/go-multiaddr"-- "sam/internal/testutils"- "sam/pkg/identity"- samnet "sam/pkg/net")-// CUJ-1 Stealth Audit: peers in the same mesh namespace discover each other-// through DHT capability discovery.-func TestCUJ1StealthAuditMeshDiscovery(t *testing.T) {- if !testutils.IsSupported() {- t.Skip("user namespaces not available")- }- testutils.Run(t, runCUJ1StealthAuditMeshDiscovery)-}--func runCUJ1StealthAuditMeshDiscovery(t *testing.T) {- t.Helper()- ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)- defer cancel()-- seed := cujStartNode(t, cujNodeConfig{mode: samnet.DHTModeServer})-- publisher := cujStartNode(t, cujNodeConfig{bootstrap: cujBootstrapAddrs(t, seed), mode: samnet.DHTModeServer})- discovererA := cujStartNode(t, cujNodeConfig{bootstrap: cujBootstrapAddrs(t, seed), mode: samnet.DHTModeServer})- discovererB := cujStartNode(t, cujNodeConfig{bootstrap: cujBootstrapAddrs(t, seed), mode: samnet.DHTModeServer})-- const capability = "risk-audit"- if err := publisher.Announce(ctx, capability); err != nil {- t.Fatalf("publisher announce: %v", err)- }-- foundA := cujWaitDiscover(ctx, discovererA, capability, publisher.PeerID().String())- if !foundA {- t.Fatalf("mesh discovery failed: discovererA could not discover publisher capability")- }-- foundB := cujWaitDiscover(ctx, discovererB, capability, publisher.PeerID().String())- if !foundB {- t.Fatalf("mesh discovery failed: discovererB could not discover publisher capability")- }-}--// CUJ-2 Hole-Punch: verify relay-assisted connectivity path and attempt to-// observe a direct (non-circuit) connection after initial circuit dial.-//-// In restricted CI/network environments DCUtR may not complete; in that case-// the test validates relay path and skips direct-connection assertion.-func TestCUJ2HolePunchRelayAssisted(t *testing.T) {- if !testutils.IsSupported() {- t.Skip("user namespaces not available")- }- testutils.Run(t, runCUJ2HolePunchRelayAssisted)-}--func runCUJ2HolePunchRelayAssisted(t *testing.T) {- t.Helper()- ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)- defer cancel()-- relayNode := cujStartNode(t, cujNodeConfig{relayService: true, mode: samnet.DHTModeServer})- bootstrap := cujBootstrapAddrs(t, relayNode)-- caller := cujStartNode(t, cujNodeConfig{bootstrap: bootstrap, mode: samnet.DHTModeServer})- target := cujStartNode(t, cujNodeConfig{bootstrap: bootstrap, mode: samnet.DHTModeServer})-- const protoID coreprotocol.ID = "/sam/cuj/holepunch/1.0"- target.Host().SetStreamHandler(protoID, func(s network.Stream) {- defer func() { _ = s.Close() }()- r := bufio.NewReader(s)- line, _ := r.ReadString('\n')- _, _ = io.WriteString(s, line)- })-- circuitAddr, err := cujRelayCircuitAddr(relayNode, target)- if err != nil {- t.Fatalf("building circuit address: %v", err)- }- if err := caller.Connect(ctx, circuitAddr); err != nil {- t.Fatalf("relay-assisted connect failed: %v", err)- }-- stream, err := caller.Host().NewStream(ctx, target.PeerID(), protoID)- if err != nil {- t.Fatalf("opening stream over relay-assisted path failed: %v", err)- }- if _, err := io.WriteString(stream, "hello\n"); err != nil {- _ = stream.Close()- t.Fatalf("writing stream payload: %v", err)- }- resp, err := bufio.NewReader(stream).ReadString('\n')- _ = stream.Close()- if err != nil {- t.Fatalf("reading stream response: %v", err)- }- if strings.TrimSpace(resp) != "hello" {- t.Fatalf("unexpected stream response: %q", resp)- }-- directSeen := cujWaitForDirectConn(ctx, caller, target)- if !directSeen {- t.Skip("relay path verified; no direct non-circuit connection observed (DCUtR environment-dependent)")- }-}--type cujNodeConfig struct {- bootstrap []multiaddr.Multiaddr- relayService bool- mode samnet.DHTMode-}--func cujStartNode(t *testing.T, cfg cujNodeConfig) samnet.Node {- t.Helper()- listen, err := multiaddr.NewMultiaddr("/ip4/127.0.0.1/udp/0/quic-v1")- if err != nil {- t.Fatalf("creating listen addr: %v", err)- }- key, err := samnet.GenerateKey()- if err != nil {- t.Fatalf("generating key: %v", err)- }- opts := []samnet.Option{- samnet.WithPrivateKey(key),- samnet.WithListenAddrs(listen),- samnet.WithDHTMode(cfg.mode),- }- if len(cfg.bootstrap) > 0 {- opts = append(opts, samnet.WithBootstrapPeers(cfg.bootstrap...))- }- if cfg.relayService {- opts = append(opts, samnet.WithRelayService())- }- n, err := samnet.New(opts...)- if err != nil {- t.Fatalf("creating node: %v", err)- }-- if err := n.Start(context.Background()); err != nil {- t.Fatalf("starting node: %v", err)- }-- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)- defer cancel()- passport, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{- PeerID: n.PeerID().String(),- FederationID: "default",- Subject: n.PeerID().String(),- })- if err != nil {- t.Fatalf("issuing test passport: %v", err)- }- if err := identity.SetLocalPassport(n.Host(), "default", passport); err != nil {- t.Fatalf("setting test passport: %v", err)- }-- for _, bootstrapAddr := range cfg.bootstrap {- pi, err := peer.AddrInfoFromP2pAddr(bootstrapAddr)- if err != nil {- continue- }- _ = cujConnectWithRetry(ctx, n, *pi)- }-- t.Cleanup(func() {- go func() { _ = n.Stop(context.Background()) }()- })- return n-}--func cujBootstrapAddrs(t *testing.T, n samnet.Node) []multiaddr.Multiaddr {- t.Helper()- for _, a := range n.Addrs() {- if !strings.Contains(a.String(), "quic") {- continue- }- full, err := multiaddr.NewMultiaddr(fmt.Sprintf("%s/p2p/%s", a.String(), n.PeerID()))- if err == nil {- return []multiaddr.Multiaddr{full}- }- }- t.Fatalf("no bootstrap QUIC address found for %s", n.PeerID())- return nil-}--func cujConnectWithRetry(ctx context.Context, n samnet.Node, pi peer.AddrInfo) error {- ticker := time.NewTicker(250 * time.Millisecond)- defer ticker.Stop()- var last error- for {- if err := n.Connect(ctx, pi); err == nil {- return nil- } else {- last = err- }- select {- case <-ctx.Done():- if last != nil {- return last- }- return ctx.Err()- case <-ticker.C:- }- }-}--func cujWaitDiscover(ctx context.Context, n samnet.Node, capability, expectedPeerID string) bool {- ticker := time.NewTicker(300 * time.Millisecond)- defer ticker.Stop()-- for {- discoveryCtx, cancel := context.WithTimeout(ctx, 2*time.Second)- ch, err := n.Discover(discoveryCtx, capability)- if err == nil {- for ai := range ch {- if ai.ID.String() == expectedPeerID {- cancel()- return true- }- }- }- cancel()-- select {- case <-ctx.Done():- return false- case <-ticker.C:- }- }-}--func cujRelayCircuitAddr(relayNode, target samnet.Node) (peer.AddrInfo, error) {- for _, relayAddr := range relayNode.Addrs() {- if !strings.Contains(relayAddr.String(), "quic") {- continue- }- circuit := fmt.Sprintf("%s/p2p/%s/p2p-circuit/p2p/%s", relayAddr.String(), relayNode.PeerID(), target.PeerID())- ma, err := multiaddr.NewMultiaddr(circuit)- if err != nil {- continue- }- return peer.AddrInfo{ID: target.PeerID(), Addrs: []multiaddr.Multiaddr{ma}}, nil- }- return peer.AddrInfo{}, fmt.Errorf("no relay QUIC address available")-}--func cujWaitForDirectConn(ctx context.Context, a, b samnet.Node) bool {- ticker := time.NewTicker(400 * time.Millisecond)- defer ticker.Stop()- for {- conns := a.Host().Network().ConnsToPeer(b.PeerID())- for _, c := range conns {- if !strings.Contains(c.RemoteMultiaddr().String(), "p2p-circuit") {- return true- }- }- select {- case <-ctx.Done():- return false- case <-ticker.C:- }+func TestSamNodeRunWithManualTokenStarts(t *testing.T) {+ nodeBin := buildBinary(t, "./cmd/sam-node")+ tmpHome := t.TempDir()+ env := append(os.Environ(),+ "HOME="+tmpHome,+ "XDG_CONFIG_HOME="+filepath.Join(tmpHome, ".config"),+ )++ stdout, stderr, err := runCommand(+ t,+ repoRoot(t),+ 3*time.Second,+ env,+ "",+ nodeBin,+ "run",+ "--token", "test-token",+ "--listen", "/ip4/127.0.0.1/udp/0/quic-v1",+ "--listen", "/ip4/127.0.0.1/tcp/0",+ )+ if err != context.DeadlineExceeded {+ t.Fatalf("expected run command to keep running until timeout, got: %v\nstdout:\n%s\nstderr:\n%s", err, stdout, stderr)+ }+ out := stdout + stderr+ if !strings.Contains(out, "SAM Node Online") {+ t.Fatalf("node did not reach online state:\n%s", out)}}diff --git a/tests/integration/mesh_test.go b/tests/integration/mesh_test.goindex 8aa01d70..0fe329b4 100644--- a/tests/integration/mesh_test.go+++ b/tests/integration/mesh_test.go@@ -14,718 +14,20 @@package integration_test-// TestMeshDiscovery is an end-to-end integration test for the SAM mesh:-//-// Agent 1 ("publisher") starts a DHT server node, signs an AgentCard with-// the "agent.summarize" capability, publishes it to the DHT, and registers-// an MCP bridge backed by a loopback echo connector.-//-// Agent 2 ("subscriber") starts an independent DHT server node, connects to-// Agent 1 as its bootstrap peer, discovers the published card via DHT, opens-// a QUIC stream through the MCP bridge, and verifies the echo round-trip.-//-// Each agent runs in its own isolated network namespace (CLONE_NEWNET +-// CLONE_NEWUSER). The test parent creates a veth pair and configures it using-// the vishvananda/netlink library — no external tools required.-import (- "bufio"- "context"- "encoding/json"- "errors"- "fmt"- "io"- "net"- "os"- "os/exec"- "path/filepath"- "runtime"- "strconv"- "syscall"+ "strings""testing""time"-- "github.com/libp2p/go-libp2p/core/peer"- "github.com/modelcontextprotocol/go-sdk/mcp"- "github.com/multiformats/go-multiaddr"- "github.com/vishvananda/netlink"- "github.com/vishvananda/netns"-- "sam/internal/testutils"- "sam/pkg/economy"- "sam/pkg/identity"- samnet "sam/pkg/net"- protocol "sam/pkg/protocol/discovery"- mcpprotocol "sam/pkg/protocol/mcp")-// ----------------------------------------------------------------------------// Constants-// -----------------------------------------------------------------------------const (- meshHelperEnv = "SAM_MESH_HELPER"- meshRoleEnv = "SAM_MESH_ROLE"- meshInfoEnv = "SAM_MESH_INFO_FILE"- meshIPEnv = "SAM_MESH_IP"- meshPortEnv = "SAM_MESH_PORT"- meshPublisherRole = "publisher"- meshSubscriberRole = "subscriber"- meshPublisherIP = "10.200.0.1"- meshSubscriberIP = "10.200.0.2"- meshPublisherPort = 4201- meshSubscriberPort = 4202- meshCapability = "weather-bot"-)--type meshPeerInfo struct {- PeerID string `json:"peer_id"`- Bootstrap string `json:"bootstrap"`-}--// ----------------------------------------------------------------------------// Top-level test entry point-// -----------------------------------------------------------------------------// TestMeshDiscovery is the public test function. When re-invoked as a helper-// subprocess it dispatches to the appropriate agent role.-func TestMeshDiscovery(t *testing.T) {- if os.Getenv(meshHelperEnv) == "1" {- if err := runMeshHelperRole(); err != nil {- t.Fatalf("mesh helper failed: %v", err)- }- return- }-- testutils.Run(t, func(t *testing.T) {- runMeshDiscovery(t)- }, syscall.CLONE_NEWNET)-}--// ----------------------------------------------------------------------------// Orchestrator (runs in the outer user+net namespace)-// -----------------------------------------------------------------------------func runMeshDiscovery(t *testing.T) {- t.Helper()-- tmpDir := t.TempDir()- infoFile := filepath.Join(tmpDir, "publisher.json")-- publisher := startMeshRoleProcess(t, meshPublisherRole, infoFile, meshPublisherIP, meshPublisherPort)- defer stopMeshRoleProcess(publisher)-- subscriber := startMeshRoleProcess(t, meshSubscriberRole, infoFile, meshSubscriberIP, meshSubscriberPort)- defer stopMeshRoleProcess(subscriber)-- // Assign veth interfaces before unblocking either agent so that both have- // network connectivity from the moment they start QUIC listeners.- configureMeshVethPair(t, publisher.cmd.Process.Pid, subscriber.cmd.Process.Pid)-- if _, err := io.WriteString(publisher.stdin, "start\n"); err != nil {- t.Fatalf("unblocking publisher: %v", err)- }- if _, err := io.WriteString(subscriber.stdin, "start\n"); err != nil {- t.Fatalf("unblocking subscriber: %v", err)- }-- // Wait for publisher to be ready before checking subscriber exit.- if err := waitForMeshInfoFile(infoFile, 15*time.Second); err != nil {- t.Fatalf("publisher did not write info file in time: %v\npublisher stdout:\n%s\npublisher stderr:\n%s",- err, publisher.stdout.String(), publisher.stderr.String())- }-- waitMeshRoleExit(t, subscriber, 35*time.Second)- if subscriber.cmd.ProcessState.ExitCode() != 0 {- t.Fatalf("subscriber process failed\nstdout:\n%s\nstderr:\n%s",- subscriber.stdout.String(), subscriber.stderr.String())- }-}--// ----------------------------------------------------------------------------// Subprocess helper dispatcher-// -----------------------------------------------------------------------------func runMeshHelperRole() error {- // The orchestrator sends a single "start\n" line after configuring the- // network so that both agents have IP connectivity before they open ports.- reader := bufio.NewReader(os.Stdin)- if _, err := reader.ReadString('\n'); err != nil {- return fmt.Errorf("waiting for mesh start signal: %w", err)- }-- switch os.Getenv(meshRoleEnv) {- case meshPublisherRole:- return runMeshPublisher()- case meshSubscriberRole:- return runMeshSubscriber()- default:- return fmt.Errorf("unknown mesh role %q", os.Getenv(meshRoleEnv))- }-}--// ----------------------------------------------------------------------------// Agent 1 — Publisher-// -----------------------------------------------------------------------------func runMeshPublisher() error {- ctx, cancel := context.WithTimeout(context.Background(), 35*time.Second)- defer cancel()-- port, err := parseMeshPort()- if err != nil {- return err- }-- node, err := newMeshNode(port, samnet.DHTModeServer, nil)- if err != nil {- return err- }- if err := node.Start(ctx); err != nil {- return fmt.Errorf("publisher node start: %w", err)- }- if err := meshConfigureNodePassport(ctx, node, "publisher"); err != nil {- return fmt.Errorf("publisher passport setup: %w", err)- }- defer func() { _ = node.Stop(context.Background()) }()-- // Write the peer info before publishing so the subscriber can start- // connecting as soon as the DHT bootstrap is ready.- bootstrapAddr := fmt.Sprintf("/ip4/%s/udp/%d/quic-v1/p2p/%s",- os.Getenv(meshIPEnv), port, node.PeerID())- info := meshPeerInfo{PeerID: node.PeerID().String(), Bootstrap: bootstrapAddr}- if err := writeMeshPeerInfo(os.Getenv(meshInfoEnv), info); err != nil {- return err- }-- priv := node.Host().Peerstore().PrivKey(node.PeerID())- card, err := protocol.NewAgentCard(- node.PeerID(),- []string{meshCapability},- []mcpprotocol.Resource{{Name: "summarizer", Kind: "tool", Endpoint: "mcp://summarizer"}},- priv,- )- if err != nil {- return fmt.Errorf("publisher card creation: %w", err)- }-- pub, err := protocol.NewPublisher(node)+func TestSamHubHelp(t *testing.T) {+ hubBin := buildBinary(t, "./cmd/sam-hub")+ stdout, stderr, err := runCommand(t, repoRoot(t), 10*time.Second, nil, "", hubBin, "--help")if err != nil {- return fmt.Errorf("publisher: %w", err)+ t.Fatalf("sam-hub --help failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout, stderr)}- if err := meshPublishWithRetry(ctx, pub, card); err != nil {- return fmt.Errorf("publisher publish: %w", err)+ out := stdout + stderr+ if !strings.Contains(out, "Sovereign Agent Mesh - Multi-Transport Hub") {+ t.Fatalf("unexpected help output:\n%s", out)}-- discovery, err := protocol.NewDiscoveryService(node)- if err != nil {- return fmt.Errorf("publisher discovery service: %w", err)- }- if err := discovery.RegisterLocalCard(card); err != nil {- return fmt.Errorf("publisher register card: %w", err)- }-- // meshAllowVerifier accepts any token so the subscriber test needs no real Biscuit token.- if _, err := mcpprotocol.NewMCPBridge(node.Host(), meshAllowVerifier{}, meshEchoConnector{}); err != nil {- return fmt.Errorf("publisher bridge setup: %w", err)- }-- // Stay online until the context is cancelled (subscriber completed or timeout).- <-ctx.Done()- return nil-}--// ----------------------------------------------------------------------------// Agent 2 — Subscriber-// -----------------------------------------------------------------------------func runMeshSubscriber() error {- ctx, cancel := context.WithTimeout(context.Background(), 25*time.Second)- defer cancel()-- port, err := parseMeshPort()- if err != nil {- return err- }-- info, err := waitMeshPeerInfo(ctx, os.Getenv(meshInfoEnv))- if err != nil {- return err- }-- bootstrap, err := multiaddr.NewMultiaddr(info.Bootstrap)- if err != nil {- return fmt.Errorf("parsing bootstrap addr: %w", err)- }- publisherID, err := peer.Decode(info.PeerID)- if err != nil {- return fmt.Errorf("decoding publisher peer ID: %w", err)- }- publisherAddrInfo, err := peer.AddrInfoFromP2pAddr(bootstrap)- if err != nil {- return fmt.Errorf("building publisher addr info: %w", err)- }-- // Both peers must run as DHT servers in an isolated two-node mesh so that- // DHT records are visible to each other without external routing tables.- node, err := newMeshNode(port, samnet.DHTModeServer, []multiaddr.Multiaddr{bootstrap})- if err != nil {- return err- }- if err := node.Start(ctx); err != nil {- return fmt.Errorf("subscriber node start: %w", err)- }- if err := meshConfigureNodePassport(ctx, node, "subscriber"); err != nil {- return fmt.Errorf("subscriber passport setup: %w", err)- }- defer func() { _ = node.Stop(context.Background()) }()-- if err := meshConnectWithRetry(ctx, node, *publisherAddrInfo); err != nil {- return fmt.Errorf("connecting to publisher bootstrap: %w", err)- }-- discovery, err := protocol.NewDiscoveryService(node)- if err != nil {- return fmt.Errorf("subscriber discovery service: %w", err)- }-- // 1. Discover the published capability via DHT and connect.- peerIDs, err := meshDiscoverAndConnectWithRetry(ctx, discovery, meshCapability)- if err != nil {- return fmt.Errorf("subscriber DHT discovery failed: %w", err)- }- if len(peerIDs) == 0 {- return fmt.Errorf("expected at least one peer for capability %q, got none", meshCapability)- }-- // 2. Verify the discovered AgentCard contains the expected capability and a- // valid signature from the publisher's peer key.- cards, err := meshDiscoverCardsWithRetry(ctx, discovery, meshCapability)- if err != nil {- return fmt.Errorf("subscriber card discovery failed: %w", err)- }- if len(cards) == 0 {- return fmt.Errorf("expected at least one AgentCard for capability %q", meshCapability)- }- validated := false- for _, card := range cards {- if card.PeerID != publisherID.String() {- continue- }- if err := card.Verify(); err != nil {- return fmt.Errorf("publisher card signature verification failed: %w", err)- }- validated = true- break- }- if !validated {- return fmt.Errorf("publisher card not found in discovered results")- }-- // 3. Open a QUIC/MCP bridge stream to the publisher and do an echo round-trip.- bridge, err := mcpprotocol.NewMCPBridge(node.Host(), meshAllowVerifier{}, meshEchoConnector{})- if err != nil {- return fmt.Errorf("subscriber bridge setup: %w", err)- }- if err := meshEchoRoundTrip(ctx, bridge, publisherID); err != nil {- return fmt.Errorf("MCP echo round-trip failed: %w", err)- }-- return nil-}--// ----------------------------------------------------------------------------// Round-trip helper-// -----------------------------------------------------------------------------func meshEchoRoundTrip(ctx context.Context, bridge *mcpprotocol.MCPBridge, target peer.ID) error {- stream, err := bridge.Open(ctx, target, mcpprotocol.BridgeOpenRequest{- BiscuitToken: "mesh-token",- Amount: 1,- Asset: "sam-credit",- Nonce: "mesh-nonce",- Capability: meshCapability,- })- if err != nil {- return fmt.Errorf("opening bridge stream: %w", err)- }- defer func() { _ = stream.Close() }()-- payload := []byte("{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"ping\"}\n")- if _, err := stream.Write(payload); err != nil {- return fmt.Errorf("writing payload: %w", err)- }-- received := make([]byte, len(payload))- if _, err := io.ReadFull(stream, received); err != nil {- return fmt.Errorf("reading echo response: %w", err)- }- if string(received) != string(payload) {- return fmt.Errorf("echo mismatch: want %q, got %q", string(payload), string(received))- }- return nil-}--func meshConfigureNodePassport(ctx context.Context, node samnet.Node, subject string) error {- passport, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{- PeerID: node.PeerID().String(),- FederationID: "default",- Subject: subject,- })- if err != nil {- return err- }- return identity.SetLocalPassport(node.Host(), "default", passport)-}--// ----------------------------------------------------------------------------// Retry helpers (mesh-specific, same pattern as p2p_test.go)-// -----------------------------------------------------------------------------func meshPublishWithRetry(ctx context.Context, pub *protocol.Publisher, card *protocol.AgentCard) error {- ticker := time.NewTicker(250 * time.Millisecond)- defer ticker.Stop()- var last error- for {- if err := pub.Publish(ctx, card); err == nil {- return nil- } else {- last = err- }- select {- case <-ctx.Done():- if last != nil { //nolint:staticcheck // last is assigned only on error in the loop- return fmt.Errorf("publish did not converge: %w", last)- }- return ctx.Err()- case <-ticker.C:- }- }-}--func meshConnectWithRetry(ctx context.Context, node samnet.Node, pi peer.AddrInfo) error {- ticker := time.NewTicker(250 * time.Millisecond)- defer ticker.Stop()- var last error- for {- if err := node.Connect(ctx, pi); err == nil {- return nil- } else {- last = err- }- select {- case <-ctx.Done():- if last != nil { //nolint:staticcheck // last is assigned only on error in the loop- return last- }- return ctx.Err()- case <-ticker.C:- }- }-}--func meshDiscoverAndConnectWithRetry(ctx context.Context, svc *protocol.DiscoveryService, cap string) ([]peer.ID, error) {- ticker := time.NewTicker(300 * time.Millisecond)- defer ticker.Stop()- var last error- for {- ids, err := svc.DiscoverAndConnect(ctx, cap)- if len(ids) > 0 {- return ids, nil- }- if err != nil {- last = err- }- select {- case <-ctx.Done():- if last != nil {- return nil, fmt.Errorf("no peers for capability %q: %w", cap, last)- }- return nil, fmt.Errorf("no peers for capability %q: %w", cap, ctx.Err())- case <-ticker.C:- }- }-}--func meshDiscoverCardsWithRetry(ctx context.Context, svc *protocol.DiscoveryService, cap string) ([]*protocol.AgentCard, error) {- ticker := time.NewTicker(300 * time.Millisecond)- defer ticker.Stop()- var last error- for {- cards, err := svc.Discover(ctx, cap)- if err == nil && len(cards) > 0 {- return cards, nil- }- if err != nil {- last = err- }- select {- case <-ctx.Done():- if last != nil {- return nil, fmt.Errorf("card discovery for %q: %w", cap, last)- }- return nil, fmt.Errorf("no cards for capability %q: %w", cap, ctx.Err())- case <-ticker.C:- }- }-}--// ----------------------------------------------------------------------------// Node factory-// -----------------------------------------------------------------------------func newMeshNode(port int, mode samnet.DHTMode, bootstrap []multiaddr.Multiaddr) (samnet.Node, error) {- listen, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/0.0.0.0/udp/%d/quic-v1", port))- if err != nil {- return nil, fmt.Errorf("building listen address: %w", err)- }- key, err := samnet.GenerateKey()- if err != nil {- return nil, fmt.Errorf("generating node key: %w", err)- }- return samnet.New(- samnet.WithPrivateKey(key),- samnet.WithListenAddrs(listen),- samnet.WithBootstrapPeers(bootstrap...),- samnet.WithDHTMode(mode),- )-}--// ----------------------------------------------------------------------------// Process management-// (roleProcess is defined in p2p_test.go; reuse it here)-// -----------------------------------------------------------------------------func startMeshRoleProcess(t *testing.T, role, infoFile, ip string, port int) *roleProcess {- t.Helper()- proc := &roleProcess{}- cmd := exec.Command(os.Args[0], "-test.run=TestMeshDiscovery$", "-test.v=true")- cmd.Env = append(os.Environ(),- meshHelperEnv+"=1",- meshRoleEnv+"="+role,- meshInfoEnv+"="+infoFile,- meshIPEnv+"="+ip,- meshPortEnv+"="+strconv.Itoa(port),- )- cmd.SysProcAttr = &syscall.SysProcAttr{- Cloneflags: syscall.CLONE_NEWUSER | syscall.CLONE_NEWNET,- UidMappings: []syscall.SysProcIDMap{{ContainerID: 0, HostID: os.Getuid(), Size: 1}},- GidMappings: []syscall.SysProcIDMap{{ContainerID: 0, HostID: os.Getgid(), Size: 1}},- GidMappingsEnableSetgroups: false,- }- stdin, err := cmd.StdinPipe()- if err != nil {- t.Fatalf("creating %s stdin pipe: %v", role, err)- }- proc.stdin = stdin- cmd.Stdout = &proc.stdout- cmd.Stderr = &proc.stderr- if err := cmd.Start(); err != nil {- t.Fatalf("starting %s process: %v", role, err)- }- proc.cmd = cmd- return proc-}--func stopMeshRoleProcess(proc *roleProcess) {- if proc == nil || proc.cmd == nil || proc.cmd.Process == nil {- return- }- _ = proc.stdin.Close()- _ = proc.cmd.Process.Kill()- _, _ = proc.cmd.Process.Wait()-}--func waitMeshRoleExit(t *testing.T, proc *roleProcess, timeout time.Duration) {- t.Helper()- done := make(chan error, 1)- go func() { done <- proc.cmd.Wait() }()- select {- case err := <-done:- if err != nil {- t.Fatalf("role process wait failed: %v\nstdout:\n%s\nstderr:\n%s",- err, proc.stdout.String(), proc.stderr.String())- }- case <-time.After(timeout):- t.Fatalf("role process timed out\nstdout:\n%s\nstderr:\n%s",- proc.stdout.String(), proc.stderr.String())- }-}--// ----------------------------------------------------------------------------// Network namespace helpers-// -----------------------------------------------------------------------------func configureMeshVethPair(t *testing.T, publisherPID, subscriberPID int) {- t.Helper()- if err := netlink.LinkAdd(&netlink.Veth{- LinkAttrs: netlink.LinkAttrs{Name: "meshveth-p"},- PeerName: "meshveth-s",- }); err != nil {- t.Fatalf("creating mesh veth pair: %v", err)- }-- pubLink, err := netlink.LinkByName("meshveth-p")- if err != nil {- t.Fatalf("finding publisher veth: %v", err)- }- subLink, err := netlink.LinkByName("meshveth-s")- if err != nil {- t.Fatalf("finding subscriber veth: %v", err)- }-- if err := netlink.LinkSetNsPid(pubLink, publisherPID); err != nil {- t.Fatalf("moving publisher veth to pid %d: %v", publisherPID, err)- }- if err := netlink.LinkSetNsPid(subLink, subscriberPID); err != nil {- t.Fatalf("moving subscriber veth to pid %d: %v", subscriberPID, err)- }-- configureMeshLinkInNetNS(t, publisherPID, "meshveth-p", meshPublisherIP+"/24")- configureMeshLinkInNetNS(t, subscriberPID, "meshveth-s", meshSubscriberIP+"/24")-}--func configureMeshLinkInNetNS(t *testing.T, pid int, linkName, cidr string) {- t.Helper()- runtime.LockOSThread()- defer runtime.UnlockOSThread()-- originalNS, err := netns.Get()- if err != nil {- t.Fatalf("getting current netns: %v", err)- }- defer func() { _ = originalNS.Close() }()-- targetNS, err := netns.GetFromPid(pid)- if err != nil {- t.Fatalf("getting netns for pid %d: %v", pid, err)- }- defer func() { _ = targetNS.Close() }()-- if err := netns.Set(targetNS); err != nil {- t.Fatalf("entering netns for pid %d: %v", pid, err)- }- defer func() {- if err := netns.Set(originalNS); err != nil {- t.Fatalf("restoring original netns: %v", err)- }- }()-- lo, err := netlink.LinkByName("lo")- if err != nil {- t.Fatalf("getting loopback in netns pid %d: %v", pid, err)- }- if err := netlink.LinkSetUp(lo); err != nil {- t.Fatalf("bringing loopback up in netns pid %d: %v", pid, err)- }-- link, err := netlink.LinkByName(linkName)- if err != nil {- t.Fatalf("getting link %s in netns pid %d: %v", linkName, pid, err)- }- addr, err := netlink.ParseAddr(cidr)- if err != nil {- t.Fatalf("parsing cidr %s: %v", cidr, err)- }- if err := netlink.AddrAdd(link, addr); err != nil {- t.Fatalf("assigning addr %s to %s in pid %d: %v", cidr, linkName, pid, err)- }- if err := netlink.LinkSetUp(link); err != nil {- t.Fatalf("bringing link %s up in netns pid %d: %v", linkName, pid, err)- }-}--// ----------------------------------------------------------------------------// File I/O helpers-// -----------------------------------------------------------------------------func writeMeshPeerInfo(path string, info meshPeerInfo) error {- f, err := os.Create(path)- if err != nil {- return fmt.Errorf("creating mesh info file: %w", err)- }- defer func() { _ = f.Close() }()- return json.NewEncoder(f).Encode(info)-}--func waitMeshPeerInfo(ctx context.Context, path string) (meshPeerInfo, error) {- for {- data, err := os.ReadFile(path)- if err == nil {- var info meshPeerInfo- if unmarshalErr := json.Unmarshal(data, &info); unmarshalErr != nil {- return meshPeerInfo{}, fmt.Errorf("decoding mesh info: %w", unmarshalErr)- }- return info, nil- }- if !errors.Is(err, os.ErrNotExist) {- return meshPeerInfo{}, fmt.Errorf("reading mesh info: %w", err)- }- select {- case <-ctx.Done():- return meshPeerInfo{}, fmt.Errorf("waiting for mesh info file: %w", ctx.Err())- case <-time.After(100 * time.Millisecond):- }- }-}--func waitForMeshInfoFile(path string, timeout time.Duration) error {- deadline := time.Now().Add(timeout)- for {- if _, err := os.Stat(path); err == nil {- return nil- }- if time.Now().After(deadline) {- return fmt.Errorf("timed out waiting for %s", path)- }- time.Sleep(100 * time.Millisecond)- }-}--func parseMeshPort() (int, error) {- raw := os.Getenv(meshPortEnv)- if raw == "" {- return 0, fmt.Errorf("missing %s", meshPortEnv)- }- p, err := strconv.Atoi(raw)- if err != nil || p <= 0 {- return 0, fmt.Errorf("invalid mesh port %q", raw)- }- return p, nil-}--// ----------------------------------------------------------------------------// Stub verifier — accepts any micropayment token (mesh test has no real Biscuit)-// -----------------------------------------------------------------------------type meshAllowVerifier struct{}--func (meshAllowVerifier) Verify(_ context.Context, _ economy.VerifyRequest) (*economy.VerifyDecision, error) {- return &economy.VerifyDecision{Subject: "peer:mesh"}, nil-}--// ----------------------------------------------------------------------------// Stub MCP connector — loopback echo server-// -----------------------------------------------------------------------------type meshEchoConnector struct{}--func (meshEchoConnector) Open(context.Context) (mcp.Transport, error) {- a, b := net.Pipe()- go func() {- defer func() { _ = b.Close() }()- buf := make([]byte, 32*1024)- for {- n, err := b.Read(buf)- if n > 0 {- if _, werr := b.Write(buf[:n]); werr != nil {- return- }- }- if err != nil {- return- }- }- }()- return &mcp.IOTransport{Reader: a, Writer: a}, nil}diff --git a/tests/integration/minimal_helpers_test.go b/tests/integration/minimal_helpers_test.gonew file mode 100644index 00000000..ae2f8476--- /dev/null+++ b/tests/integration/minimal_helpers_test.go@@ -0,0 +1,82 @@+// 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 (+ "bytes"+ "context"+ "errors"+ "os/exec"+ "path/filepath"+ "runtime"+ "testing"+ "time"+)++func repoRoot(t *testing.T) string {+ t.Helper()+ _, thisFile, _, ok := runtime.Caller(0)+ if !ok {+ t.Fatal("unable to resolve test file path")+ }+ return filepath.Clean(filepath.Join(filepath.Dir(thisFile), "..", ".."))+}++func buildBinary(t *testing.T, pkgPath string) string {+ t.Helper()+ root := repoRoot(t)+ out := filepath.Join(t.TempDir(), filepath.Base(pkgPath))+ cmd := exec.Command("go", "build", "-o", out, pkgPath)+ cmd.Dir = root+ if output, err := cmd.CombinedOutput(); err != nil {+ t.Fatalf("building %s failed: %v\n%s", pkgPath, err, string(output))+ }+ return out+}++func runCommand(+ t *testing.T,+ cwd string,+ timeout time.Duration,+ env []string,+ stdin string,+ name string,+ args ...string,+) (string, string, error) {+ t.Helper()++ ctx, cancel := context.WithTimeout(context.Background(), timeout)+ defer cancel()++ cmd := exec.CommandContext(ctx, name, args...)+ cmd.Dir = cwd+ if len(env) > 0 {+ cmd.Env = append(cmd.Env, env...)+ }+ if stdin != "" {+ cmd.Stdin = bytes.NewBufferString(stdin)+ }++ var stdout bytes.Buffer+ var stderr bytes.Buffer+ cmd.Stdout = &stdout+ cmd.Stderr = &stderr++ err := cmd.Run()+ if errors.Is(ctx.Err(), context.DeadlineExceeded) {+ return stdout.String(), stderr.String(), context.DeadlineExceeded+ }+ return stdout.String(), stderr.String(), err+}diff --git a/tests/integration/p2p_test.go b/tests/integration/p2p_test.goindex 47184373..fd410873 100644--- a/tests/integration/p2p_test.go+++ b/tests/integration/p2p_test.go@@ -15,675 +15,26 @@package integration_testimport (- "bufio"- "bytes"- "context"- "encoding/json"- "errors"- "fmt"- "io"- "net""os"- "os/exec""path/filepath"- "runtime"- "strconv""strings"- "syscall""testing""time"-- "github.com/libp2p/go-libp2p/core/peer"- "github.com/modelcontextprotocol/go-sdk/mcp"- "github.com/multiformats/go-multiaddr"- "github.com/vishvananda/netlink"- "github.com/vishvananda/netns"-- "sam/internal/testutils"- "sam/pkg/economy"- "sam/pkg/identity"- samnet "sam/pkg/net"- protocol "sam/pkg/protocol/discovery"- mcpprotocol "sam/pkg/protocol/mcp"-)--const (- helperEnv = "SAM_INTEGRATION_HELPER"- helperRoleEnv = "SAM_INTEGRATION_ROLE"- helperInfoEnv = "SAM_INTEGRATION_INFO_FILE"- helperIPEnv = "SAM_INTEGRATION_IP"- helperPortEnv = "SAM_INTEGRATION_PORT"- providerRole = "provider"- consumerRole = "consumer"- providerIP = "10.199.0.1"- consumerIP = "10.199.0.2"- providerPort = 4101- consumerPort = 4102- validBiscuit = "valid-biscuit"- capabilityName = "agent.chat")-type providerInfo struct {- PeerID string `json:"peer_id"`- Bootstrap string `json:"bootstrap"`-}--type roleProcess struct {- cmd *exec.Cmd- stdin io.WriteCloser- stdout bytes.Buffer- stderr bytes.Buffer-}--func TestFirstContactP2P(t *testing.T) {- if os.Getenv(helperEnv) == "1" {- if err := runHelperRole(); err != nil {- t.Fatalf("integration helper failed: %v", err)- }- return- }-- testutils.Run(t, func(t *testing.T) {- runFirstContact(t)- }, syscall.CLONE_NEWNET)-}--func runFirstContact(t *testing.T) {- tmpDir := t.TempDir()- infoFile := filepath.Join(tmpDir, "provider.json")-- provider := startRoleProcess(t, providerRole, infoFile, providerIP, providerPort)- defer stopRoleProcess(provider)-- consumer := startRoleProcess(t, consumerRole, infoFile, consumerIP, consumerPort)- defer stopRoleProcess(consumer)-- configureVethPair(t, provider.cmd.Process.Pid, consumer.cmd.Process.Pid)-- if _, err := io.WriteString(provider.stdin, "start\n"); err != nil {- t.Fatalf("starting provider helper: %v", err)- }- if _, err := io.WriteString(consumer.stdin, "start\n"); err != nil {- t.Fatalf("starting consumer helper: %v", err)- }-- if err := waitForProviderInfoFile(infoFile, 10*time.Second); err != nil {- t.Fatalf("provider did not publish startup info: %v\nprovider stdout:\n%s\nprovider stderr:\n%s",- err, provider.stdout.String(), provider.stderr.String())- }-- waitRoleExit(t, consumer, 30*time.Second)-- if consumer.cmd.ProcessState.ExitCode() != 0 {- t.Fatalf("consumer process failed\nstdout:\n%s\nstderr:\n%s", consumer.stdout.String(), consumer.stderr.String())- }-}--func runHelperRole() error {- reader := bufio.NewReader(os.Stdin)- if _, err := reader.ReadString('\n'); err != nil {- return fmt.Errorf("waiting for helper start signal: %w", err)- }-- role := os.Getenv(helperRoleEnv)- switch role {- case providerRole:- return runProviderRole()- case consumerRole:- return runConsumerRole()- default:- return fmt.Errorf("unknown helper role %q", role)- }-}--func runProviderRole() error {- ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)- defer cancel()-- port, err := parseHelperPort()- if err != nil {- return err- }-- node, err := newNode(port, samnet.DHTModeServer, nil)- if err != nil {- return err- }- defer func() { _ = node.Stop(context.Background()) }()-- if err := node.Start(ctx); err != nil {- return fmt.Errorf("provider node start: %w", err)- }- if err := configureNodePassport(ctx, node, "provider"); err != nil {- return fmt.Errorf("provider passport setup: %w", err)- }-- priv := node.Host().Peerstore().PrivKey(node.PeerID())- card, err := protocol.NewAgentCard(- node.PeerID(),- []string{capabilityName},- []mcpprotocol.Resource{{Name: "echo", Kind: "tool", Endpoint: "mcp://echo"}},- priv,- )- if err != nil {- return fmt.Errorf("provider card creation: %w", err)- }-- discovery, err := protocol.NewDiscoveryService(node)- if err != nil {- return fmt.Errorf("provider discovery service: %w", err)- }- if err := discovery.RegisterLocalCard(card); err != nil {- return fmt.Errorf("provider register local card: %w", err)- }-- if _, err := mcpprotocol.NewMCPBridge(node.Host(), tokenVerifier{token: validBiscuit}, echoConnector{}); err != nil {- return fmt.Errorf("provider bridge setup: %w", err)- }-- providerAddr := fmt.Sprintf("/ip4/%s/udp/%d/quic-v1/p2p/%s", os.Getenv(helperIPEnv), port, node.PeerID())- info := providerInfo{PeerID: node.PeerID().String(), Bootstrap: providerAddr}- if err := writeProviderInfo(os.Getenv(helperInfoEnv), info); err != nil {- return err- }-- publisher, err := protocol.NewPublisher(node)- if err != nil {- return fmt.Errorf("provider publisher: %w", err)- }- if err := publisher.Publish(ctx, card); err != nil {- if err := publishWithRetry(ctx, publisher, card); err != nil {- return fmt.Errorf("provider publish: %w", err)- }- }-- // Keep the provider online while the consumer performs discovery and bridge calls.- <-ctx.Done()- return nil-}--func publishWithRetry(ctx context.Context, publisher *protocol.Publisher, card *protocol.AgentCard) error {- ticker := time.NewTicker(250 * time.Millisecond)- defer ticker.Stop()-- var lastErr error- for {- if err := publisher.Publish(ctx, card); err == nil {- return nil- } else {- lastErr = err- }-- select {- case <-ctx.Done():- if lastErr != nil { //nolint:staticcheck // lastErr is assigned only on error in the loop- return fmt.Errorf("context ended before publish converged: %w", lastErr)- }- return ctx.Err()- case <-ticker.C:- }- }-}--func runConsumerRole() error {- ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)- defer cancel()-- port, err := parseHelperPort()- if err != nil {- return err- }-- info, err := waitProviderInfo(ctx, os.Getenv(helperInfoEnv))- if err != nil {- return err- }- bootstrap, err := multiaddr.NewMultiaddr(info.Bootstrap)- if err != nil {- return fmt.Errorf("parsing bootstrap address: %w", err)- }- providerID, err := peer.Decode(info.PeerID)- if err != nil {- return fmt.Errorf("decoding provider peer ID: %w", err)- }- providerAddrInfo, err := peer.AddrInfoFromP2pAddr(bootstrap)- if err != nil {- return fmt.Errorf("building provider addr info from bootstrap: %w", err)- }-- // In a two-node isolated mesh, both peers need DHT server participation so- // provider records can be stored and later discovered.- node, err := newNode(port, samnet.DHTModeServer, []multiaddr.Multiaddr{bootstrap})- if err != nil {- return err- }- defer func() { _ = node.Stop(context.Background()) }()-- if err := node.Start(ctx); err != nil {- return fmt.Errorf("consumer node start: %w", err)- }- if err := configureNodePassport(ctx, node, "consumer"); err != nil {- return fmt.Errorf("consumer passport setup: %w", err)- }- if err := connectWithRetry(ctx, node, *providerAddrInfo); err != nil {- return fmt.Errorf("connecting to bootstrap provider: %w", err)- }-- discovery, err := protocol.NewDiscoveryService(node)- if err != nil {- return fmt.Errorf("consumer discovery service: %w", err)- }-- peerIDs, err := discoverAndConnectWithRetry(ctx, discovery, capabilityName)- if err != nil {- return err- }-- _, discoverErr := discoverCardsWithRetry(ctx, discovery, capabilityName)- if discoverErr != nil {- return discoverErr- }- _ = peerIDs-- bridge, err := mcpprotocol.NewMCPBridge(node.Host(), allowVerifier{}, echoConnector{})- if err != nil {- return fmt.Errorf("consumer bridge setup: %w", err)- }-- if err := expectDeniedBridge(ctx, bridge, providerID); err != nil {- return err- }- if err := expectAllowedBridge(ctx, bridge, providerID); err != nil {- return err- }-- return nil-}--func discoverAndConnectWithRetry(ctx context.Context, svc *protocol.DiscoveryService, capability string) ([]peer.ID, error) {- ticker := time.NewTicker(300 * time.Millisecond)- defer ticker.Stop()-- var lastErr error- for {- ids, err := svc.DiscoverAndConnect(ctx, capability)- if len(ids) > 0 {- return ids, nil- }- if err != nil {- lastErr = err- }-- select {- case <-ctx.Done():- if lastErr != nil {- return nil, fmt.Errorf("no peers connected for capability %q: %w", capability, lastErr)- }- return nil, fmt.Errorf("no peers connected for capability %q: %w", capability, ctx.Err())- case <-ticker.C:- }- }-}--func connectWithRetry(ctx context.Context, node samnet.Node, pi peer.AddrInfo) error {- ticker := time.NewTicker(250 * time.Millisecond)- defer ticker.Stop()-- var lastErr error- for {- if err := node.Connect(ctx, pi); err == nil {- return nil- } else {- lastErr = err- }-- select {- case <-ctx.Done():- if lastErr != nil {- return lastErr- }- return ctx.Err()- case <-ticker.C:- }- }-}--func discoverCardsWithRetry(ctx context.Context, svc *protocol.DiscoveryService, capability string) ([]*protocol.AgentCard, error) {- ticker := time.NewTicker(300 * time.Millisecond)- defer ticker.Stop()-- var lastErr error- for {- cards, err := svc.Discover(ctx, capability)- if err == nil && len(cards) > 0 {- return cards, nil- }- if err != nil {- lastErr = err- }-- select {- case <-ctx.Done():- if lastErr != nil {- return nil, fmt.Errorf("discovering cards for capability %q: %w", capability, lastErr)- }- return nil, fmt.Errorf("expected at least one discovered card for capability %q", capability)- case <-ticker.C:- }- }-}--func expectDeniedBridge(ctx context.Context, bridge *mcpprotocol.MCPBridge, providerID peer.ID) error {- stream, err := bridge.Open(ctx, providerID, mcpprotocol.BridgeOpenRequest{- BiscuitToken: "invalid-biscuit",- Amount: 1,- Asset: "sam-credit",- Nonce: "nonce-denied",- Capability: capabilityName,- })- if err != nil {- return fmt.Errorf("opening denied bridge stream: %w", err)- }- defer func() { _ = stream.Close() }()-- buf := make([]byte, 1024)- n, readErr := stream.Read(buf)- if readErr != nil && !errors.Is(readErr, io.EOF) {- return fmt.Errorf("reading denied bridge response: %w", readErr)- }- if !strings.Contains(string(buf[:n]), economy.ErrVerifierDeniedRequest.Error()) {- return fmt.Errorf("expected denied verifier response, got %q", string(buf[:n]))- }- return nil-}--func expectAllowedBridge(ctx context.Context, bridge *mcpprotocol.MCPBridge, providerID peer.ID) error {- stream, err := bridge.Open(ctx, providerID, mcpprotocol.BridgeOpenRequest{- BiscuitToken: validBiscuit,- Amount: 2,- Asset: "sam-credit",- Nonce: "nonce-allowed",- Capability: capabilityName,- })- if err != nil {- return fmt.Errorf("opening allowed bridge stream: %w", err)- }- defer func() { _ = stream.Close() }()-- payload := []byte("{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"handshake\"}\n")- if _, err := stream.Write(payload); err != nil {- return fmt.Errorf("writing allowed bridge payload: %w", err)- }-- received := make([]byte, len(payload))- if _, err := io.ReadFull(stream, received); err != nil {- return fmt.Errorf("reading allowed bridge response: %w", err)- }- if string(received) != string(payload) {- return fmt.Errorf("expected echo payload %q, got %q", string(payload), string(received))- }- return nil-}--func newNode(port int, mode samnet.DHTMode, bootstrap []multiaddr.Multiaddr) (samnet.Node, error) {- listen, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/0.0.0.0/udp/%d/quic-v1", port))- if err != nil {- return nil, fmt.Errorf("building listen address: %w", err)+func TestSamNodeRunWithoutIdentity(t *testing.T) {+ nodeBin := buildBinary(t, "./cmd/sam-node")+ tmpHome := t.TempDir()+ env := []string{+ "HOME=" + tmpHome,+ "XDG_CONFIG_HOME=" + filepath.Join(tmpHome, ".config"),}- key, err := samnet.GenerateKey()+ stdout, stderr, err := runCommand(t, repoRoot(t), 10*time.Second, append(os.Environ(), env...), "", nodeBin, "run")if err != nil {- return nil, fmt.Errorf("generating node key: %w", err)- }- return samnet.New(- samnet.WithPrivateKey(key),- samnet.WithListenAddrs(listen),- samnet.WithBootstrapPeers(bootstrap...),- samnet.WithDHTMode(mode),- )-}--func configureNodePassport(ctx context.Context, node samnet.Node, subject string) error {- passport, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{- PeerID: node.PeerID().String(),- FederationID: "default",- Subject: subject,- })- if err != nil {- return err- }- return identity.SetLocalPassport(node.Host(), "default", passport)-}--func writeProviderInfo(path string, info providerInfo) error {- f, err := os.Create(path)- if err != nil {- return fmt.Errorf("creating provider info file: %w", err)- }- defer func() { _ = f.Close() }()- if err := json.NewEncoder(f).Encode(info); err != nil {- return fmt.Errorf("encoding provider info: %w", err)- }- return nil-}--func waitProviderInfo(ctx context.Context, path string) (providerInfo, error) {- for {- data, err := os.ReadFile(path)- if err == nil {- var info providerInfo- if unmarshalErr := json.Unmarshal(data, &info); unmarshalErr != nil {- return providerInfo{}, fmt.Errorf("decoding provider info: %w", unmarshalErr)- }- return info, nil- }- if !errors.Is(err, os.ErrNotExist) {- return providerInfo{}, fmt.Errorf("reading provider info: %w", err)- }- select {- case <-ctx.Done():- return providerInfo{}, fmt.Errorf("waiting for provider info: %w", ctx.Err())- case <-time.After(100 * time.Millisecond):- }+ t.Fatalf("sam-node run without identity failed unexpectedly: %v\nstdout:\n%s\nstderr:\n%s", err, stdout, stderr)}-}--func waitForProviderInfoFile(path string, timeout time.Duration) error {- deadline := time.Now().Add(timeout)- for {- if _, err := os.Stat(path); err == nil {- return nil- }- if time.Now().After(deadline) {- return fmt.Errorf("timed out waiting for %s", path)- }- time.Sleep(100 * time.Millisecond)+ out := stdout + stderr+ if !strings.Contains(out, "No identity found") {+ t.Fatalf("expected missing identity message, got:\n%s", out)}}--func parseHelperPort() (int, error) {- portRaw := strings.TrimSpace(os.Getenv(helperPortEnv))- if portRaw == "" {- return 0, fmt.Errorf("missing %s", helperPortEnv)- }- port, err := strconv.Atoi(portRaw)- if err != nil || port <= 0 {- return 0, fmt.Errorf("invalid helper port %q", portRaw)- }- return port, nil-}--func startRoleProcess(t *testing.T, role, infoFile, ip string, port int) *roleProcess {- t.Helper()-- proc := &roleProcess{}- cmd := exec.Command(os.Args[0], "-test.run=TestFirstContactP2P$", "-test.v=true")- cmd.Env = append(os.Environ(),- helperEnv+"=1",- helperRoleEnv+"="+role,- helperInfoEnv+"="+infoFile,- helperIPEnv+"="+ip,- helperPortEnv+"="+strconv.Itoa(port),- )- cmd.SysProcAttr = &syscall.SysProcAttr{- Cloneflags: syscall.CLONE_NEWUSER | syscall.CLONE_NEWNET,- UidMappings: []syscall.SysProcIDMap{{ContainerID: 0, HostID: os.Getuid(), Size: 1}},- GidMappings: []syscall.SysProcIDMap{{ContainerID: 0, HostID: os.Getgid(), Size: 1}},- GidMappingsEnableSetgroups: false,- }- stdin, err := cmd.StdinPipe()- if err != nil {- t.Fatalf("creating %s stdin pipe: %v", role, err)- }- proc.stdin = stdin- cmd.Stdout = &proc.stdout- cmd.Stderr = &proc.stderr-- if err := cmd.Start(); err != nil {- t.Fatalf("starting %s process: %v", role, err)- }- proc.cmd = cmd- return proc-}--func stopRoleProcess(proc *roleProcess) {- if proc == nil || proc.cmd == nil || proc.cmd.Process == nil {- return- }- _ = proc.stdin.Close()- _ = proc.cmd.Process.Kill()- _, _ = proc.cmd.Process.Wait()-}--func waitRoleExit(t *testing.T, proc *roleProcess, timeout time.Duration) {- t.Helper()- done := make(chan error, 1)- go func() {- done <- proc.cmd.Wait()- }()- select {- case err := <-done:- if err != nil {- t.Fatalf("role process wait failed: %v\nstdout:\n%s\nstderr:\n%s", err, proc.stdout.String(), proc.stderr.String())- }- case <-time.After(timeout):- t.Fatalf("role process timed out\nstdout:\n%s\nstderr:\n%s", proc.stdout.String(), proc.stderr.String())- }-}--func configureVethPair(t *testing.T, providerPID, consumerPID int) {- t.Helper()- if err := netlink.LinkAdd(&netlink.Veth{- LinkAttrs: netlink.LinkAttrs{Name: "samveth-p"},- PeerName: "samveth-c",- }); err != nil {- t.Fatalf("creating veth pair: %v", err)- }-- providerLink, err := netlink.LinkByName("samveth-p")- if err != nil {- t.Fatalf("finding provider veth: %v", err)- }- consumerLink, err := netlink.LinkByName("samveth-c")- if err != nil {- t.Fatalf("finding consumer veth: %v", err)- }-- if err := netlink.LinkSetNsPid(providerLink, providerPID); err != nil {- t.Fatalf("moving provider veth to netns pid %d: %v", providerPID, err)- }- if err := netlink.LinkSetNsPid(consumerLink, consumerPID); err != nil {- t.Fatalf("moving consumer veth to netns pid %d: %v", consumerPID, err)- }-- configureLinkInNetNS(t, providerPID, "samveth-p", providerIP+"/24")- configureLinkInNetNS(t, consumerPID, "samveth-c", consumerIP+"/24")-}--func configureLinkInNetNS(t *testing.T, pid int, linkName, cidr string) {- t.Helper()- runtime.LockOSThread()- defer runtime.UnlockOSThread()-- originalNS, err := netns.Get()- if err != nil {- t.Fatalf("getting current netns: %v", err)- }- defer func() { _ = originalNS.Close() }()-- targetNS, err := netns.GetFromPid(pid)- if err != nil {- t.Fatalf("getting target netns for pid %d: %v", pid, err)- }- defer func() { _ = targetNS.Close() }()-- if err := netns.Set(targetNS); err != nil {- t.Fatalf("entering netns for pid %d: %v", pid, err)- }- defer func() {- if err := netns.Set(originalNS); err != nil {- t.Fatalf("restoring original netns: %v", err)- }- }()-- lo, err := netlink.LinkByName("lo")- if err != nil {- t.Fatalf("getting loopback in netns pid %d: %v", pid, err)- }- if err := netlink.LinkSetUp(lo); err != nil {- t.Fatalf("bringing loopback up in netns pid %d: %v", pid, err)- }-- link, err := netlink.LinkByName(linkName)- if err != nil {- t.Fatalf("getting link %s in netns pid %d: %v", linkName, pid, err)- }- addr, err := netlink.ParseAddr(cidr)- if err != nil {- t.Fatalf("parsing cidr %s: %v", cidr, err)- }- if err := netlink.AddrAdd(link, addr); err != nil {- t.Fatalf("assigning addr %s to %s in pid %d: %v", cidr, linkName, pid, err)- }- if err := netlink.LinkSetUp(link); err != nil {- t.Fatalf("bringing link %s up in netns pid %d: %v", linkName, pid, err)- }-}--type tokenVerifier struct {- token string-}--func (v tokenVerifier) Verify(_ context.Context, req economy.VerifyRequest) (*economy.VerifyDecision, error) {- if req.Token != v.token {- return nil, fmt.Errorf("invalid biscuit token")- }- return &economy.VerifyDecision{Subject: "peer:test"}, nil-}--type allowVerifier struct{}--func (allowVerifier) Verify(_ context.Context, _ economy.VerifyRequest) (*economy.VerifyDecision, error) {- return &economy.VerifyDecision{Subject: "peer:test"}, nil-}--type echoConnector struct{}--func (echoConnector) Open(context.Context) (mcp.Transport, error) {- a, b := net.Pipe()- go func() {- defer func() { _ = b.Close() }()- buf := make([]byte, 32*1024)- for {- n, err := b.Read(buf)- if n > 0 {- if _, werr := b.Write(buf[:n]); werr != nil {- return- }- }- if err != nil {- return- }- }- }()- return &mcp.IOTransport{Reader: a, Writer: a}, nil-}diff --git a/tests/integration/proxy_test.go b/tests/integration/proxy_test.goindex 86db4632..9a7db421 100644--- a/tests/integration/proxy_test.go+++ b/tests/integration/proxy_test.go@@ -15,427 +15,56 @@package integration_testimport (- "bytes""context"- "fmt"- "io"- "net/http"- "net/http/httptest""os""path/filepath""strings"- "sync/atomic""testing""time"-- "github.com/libp2p/go-libp2p/core/peer"- "github.com/multiformats/go-multiaddr"- "go.etcd.io/bbolt"-- internaldb "sam/internal/db"- "sam/internal/testutils"- "sam/pkg/economy"- "sam/pkg/identity"- samnet "sam/pkg/net"- a2aprotocol "sam/pkg/protocol/a2a"- httpprotocol "sam/pkg/protocol/http")-const proxyRecordVersion = 1--func TestProxyTunnelLegacyFlowIntegration(t *testing.T) {- testutils.Run(t, func(t *testing.T) {- runProxyTunnelLegacyFlowIntegration(t)- })-}--func TestProxyTunnelUnauthorizedBeforeDial(t *testing.T) {- testutils.Run(t, func(t *testing.T) {- runProxyTunnelUnauthorizedBeforeDial(t)- })-}--func runProxyTunnelLegacyFlowIntegration(t *testing.T) {- t.Helper()-- ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)- defer cancel()-+func TestSamNodeLoginThenRunWithStoredIdentity(t *testing.T) {+ nodeBin := buildBinary(t, "./cmd/sam-node")tmpHome := t.TempDir()- t.Setenv("HOME", tmpHome)- t.Setenv("XDG_CONFIG_HOME", filepath.Join(tmpHome, ".config"))-- federation := "proxy-legacy"- observer, err := a2aprotocol.NewBoltObserverForFederation(federation)- if err != nil {- t.Fatalf("creating observer: %v", err)- }- defer func() { _ = observer.Close() }()-- requestSeen := make(chan *http.Request, 1)- bodySeen := make(chan []byte, 1)- backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {- body, _ := io.ReadAll(r.Body)- requestSeen <- r.Clone(r.Context())- bodySeen <- append([]byte(nil), body...)- w.Header().Set("Content-Type", "application/json")- w.Header().Set("X-Backend", "sam-provider")- w.WriteHeader(http.StatusCreated)- _, _ = w.Write([]byte(`{"status":"ok"}`))- }))- defer backend.Close()-- providerNode, err := newProxyNode(0, nil)- if err != nil {- t.Fatalf("creating provider node: %v", err)- }- if err := providerNode.Start(ctx); err != nil {- t.Fatalf("starting provider node: %v", err)- }- providerPassport, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{- PeerID: providerNode.PeerID().String(),- FederationID: "default",- Subject: "test-subject",- Claims: map[string]string{"email": "[email protected]"},- })- if err != nil {- t.Fatalf("issuing provider passport biscuit: %v", err)- }- if err := identity.SetLocalPassport(providerNode.Host(), "default", providerPassport); err != nil {- t.Fatalf("setting provider local passport auth: %v", err)- }- defer func() { _ = providerNode.Stop(context.Background()) }()-- tunnelSvc, err := httpprotocol.NewHTTPTunnelService(- providerNode.Host(),- backend.URL,- httpprotocol.WithHTTPTunnelSkillGate(economy.NewBiscuitSkillGate(nil)),+ env := append(os.Environ(),+ "HOME="+tmpHome,+ "XDG_CONFIG_HOME="+filepath.Join(tmpHome, ".config"),)- if err != nil {- t.Fatalf("creating tunnel service: %v", err)- }- defer tunnelSvc.Close()-- consumerNode, err := newProxyNode(0, providerBootstrap(providerNode))- if err != nil {- t.Fatalf("creating consumer node: %v", err)- }- if err := consumerNode.Start(ctx); err != nil {- t.Fatalf("starting consumer node: %v", err)- }- passport, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{- PeerID: consumerNode.PeerID().String(),- FederationID: "default",- Subject: "test-subject",- Claims: map[string]string{"email": "[email protected]"},- })- if err != nil {- t.Fatalf("issuing passport biscuit: %v", err)- }- if err := identity.SetLocalPassport(consumerNode.Host(), "default", passport); err != nil {- t.Fatalf("setting local passport auth: %v", err)- }- defer func() { _ = consumerNode.Stop(context.Background()) }()-- providerInfo := peer.AddrInfo{ID: providerNode.PeerID(), Addrs: providerNode.Host().Addrs()}- if err := connectProxyWithRetry(ctx, consumerNode, providerInfo); err != nil {- t.Fatalf("connecting consumer->provider: %v", err)- }-- proxySrv := httptest.NewServer(proxyTunnelHandler(consumerNode, observer, "X-SAM-Target", "alice;allow_skill=risk-audit", passport))- defer proxySrv.Close()-- payload := []byte(`{"request":"through-proxy"}`)- req, err := http.NewRequestWithContext(ctx, http.MethodPost, proxySrv.URL+"/data.json?via=proxy", bytes.NewReader(payload))- if err != nil {- t.Fatalf("creating request: %v", err)- }- req.Header.Set("X-SAM-Target", providerNode.PeerID().String())- req.Header.Set("Authorization", "Bearer test-token")- req.Header.Set("User-Agent", "curl/8.5.0")- req.Header.Set("Content-Type", "application/json")- req.Header.Set("X-Trace-ID", "trace-123")-- resp, err := http.DefaultClient.Do(req)- if err != nil {- t.Fatalf("sending proxy request: %v", err)- }- defer func() { _ = resp.Body.Close() }()- respBody, err := io.ReadAll(resp.Body)- if err != nil {- t.Fatalf("reading proxy response: %v", err)- }- if resp.StatusCode != http.StatusCreated {- t.Fatalf("unexpected status code: got=%d body=%s", resp.StatusCode, string(respBody))- }- if got := resp.Header.Get("X-Backend"); got != "sam-provider" {- t.Fatalf("expected X-Backend header to be preserved, got=%q", got)- }- if !strings.Contains(string(respBody), `"status":"ok"`) {- t.Fatalf("unexpected response body: %s", string(respBody))- }-- select {- case backendReq := <-requestSeen:- if backendReq.Method != http.MethodPost {- t.Fatalf("backend method mismatch: got=%s", backendReq.Method)- }- if backendReq.URL.RequestURI() != "/data.json?via=proxy" {- t.Fatalf("backend path mismatch: got=%s", backendReq.URL.RequestURI())- }- if got := backendReq.Header.Get("Authorization"); got != "Bearer test-token" {- t.Fatalf("Authorization header not preserved: got=%q", got)- }- if got := backendReq.Header.Get("User-Agent"); got != "curl/8.5.0" {- t.Fatalf("User-Agent header not preserved: got=%q", got)- }- if got := backendReq.Header.Get("X-Trace-ID"); got != "trace-123" {- t.Fatalf("X-Trace-ID header not preserved: got=%q", got)- }- case <-time.After(2 * time.Second):- t.Fatalf("backend did not receive request")- }-- select {- case gotBody := <-bodySeen:- if string(gotBody) != string(payload) {- t.Fatalf("backend payload mismatch: got=%s", string(gotBody))- }- case <-time.After(2 * time.Second):- t.Fatalf("backend body not captured")- }-- repDBPath := filepath.Join(tmpHome, ".config", "sam", "federations", federation+".db")- if err := observer.Close(); err != nil {- t.Fatalf("closing observer: %v", err)- }- successes, failures, err := readProxyReputationCounts(repDBPath)- if err != nil {- t.Fatalf("reading reputation db: %v", err)- }- if successes == 0 {- t.Fatalf("expected at least one success reputation record")- }- if failures != 0 {- t.Fatalf("unexpected failure reputation records: %d", failures)- }-}--func runProxyTunnelUnauthorizedBeforeDial(t *testing.T) {- t.Helper()-- ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)- defer cancel()-- var backendHits atomic.Int64- backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {- backendHits.Add(1)- w.WriteHeader(http.StatusOK)- _, _ = w.Write([]byte("unexpected"))- }))- defer backend.Close()-- providerNode, err := newProxyNode(0, nil)- if err != nil {- t.Fatalf("creating provider node: %v", err)- }- if err := providerNode.Start(ctx); err != nil {- t.Fatalf("starting provider node: %v", err)- }- defer func() { _ = providerNode.Stop(context.Background()) }()-- tunnelSvc, err := httpprotocol.NewHTTPTunnelService(providerNode.Host(), backend.URL)- if err != nil {- t.Fatalf("creating tunnel service: %v", err)- }- defer tunnelSvc.Close()-- consumerNode, err := newProxyNode(0, providerBootstrap(providerNode))- if err != nil {- t.Fatalf("creating consumer node: %v", err)- }- if err := consumerNode.Start(ctx); err != nil {- t.Fatalf("starting consumer node: %v", err)- }- defer func() { _ = consumerNode.Stop(context.Background()) }()-- proxySrv := httptest.NewServer(proxyTunnelHandler(consumerNode, a2aprotocol.NopObserver{}, "X-SAM-Target", "", ""))- defer proxySrv.Close()-- req, err := http.NewRequestWithContext(ctx, http.MethodGet, proxySrv.URL+"/blocked", nil)- if err != nil {- t.Fatalf("creating request: %v", err)- }- req.Header.Set("X-SAM-Target", providerNode.PeerID().String())-- resp, err := http.DefaultClient.Do(req)+ loginOut, loginErrOut, err := runCommand(+ t,+ repoRoot(t),+ 10*time.Second,+ env,+ "test-biscuit-token\n",+ nodeBin,+ "login",+ )if err != nil {- t.Fatalf("sending request: %v", err)+ t.Fatalf("sam-node login failed: %v\nstdout:\n%s\nstderr:\n%s", err, loginOut, loginErrOut)}- defer func() { _ = resp.Body.Close() }()-- if resp.StatusCode != http.StatusUnauthorized {- body, _ := io.ReadAll(resp.Body)- t.Fatalf("expected unauthorized, got=%d body=%s", resp.StatusCode, string(body))- }- if backendHits.Load() != 0 {- t.Fatalf("expected no backend hits before authorization, got=%d", backendHits.Load())+ if !strings.Contains(loginOut+loginErrOut, "Success! Identity stored") {+ t.Fatalf("unexpected login output:\n%s\n%s", loginOut, loginErrOut)}-}-func proxyTunnelHandler(node samnet.Node, observer a2aprotocol.Observer, targetHeader, biscuit string, passport string) http.Handler {- return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {- if strings.TrimSpace(passport) == "" {- http.Error(w, "unauthorized: local identity login required", http.StatusUnauthorized)- return- }-- targetArg := strings.TrimSpace(r.Header.Get(targetHeader))- if targetArg == "" {- http.Error(w, "missing target header", http.StatusBadRequest)- return- }- targetID, err := peer.Decode(targetArg)- if err != nil {- http.Error(w, fmt.Sprintf("invalid target: %v", err), http.StatusBadRequest)- return- }-- body, err := io.ReadAll(r.Body)- if err != nil {- http.Error(w, fmt.Sprintf("reading body: %v", err), http.StatusBadRequest)- return- }-- headers := r.Header.Clone()- headers.Del(targetHeader)-- start := time.Now()- resp, err := httpprotocol.TunnelHTTP(r.Context(), node.Host(), targetID, httpprotocol.HTTPTunnelOpenRequest{- Biscuit: biscuit,- Capability: "risk-audit",- Request: httpprotocol.HTTPTunnelRequest{- Method: r.Method,- Path: r.URL.RequestURI(),- Headers: headers,- Body: body,- },- })- if err != nil {- observer.OnFailure(targetID.String(), a2aprotocol.FailureTypeLiveness)- http.Error(w, fmt.Sprintf("tunnel request failed: %v", err), http.StatusBadGateway)- return- }- if resp.Error != "" {- observer.OnFailure(targetID.String(), a2aprotocol.FailureTypeRemote)- status := resp.StatusCode- if status == 0 {- status = http.StatusBadGateway- }- http.Error(w, resp.Error, status)- return- }-- for key, vals := range resp.Headers {- for _, val := range vals {- w.Header().Add(key, val)- }- }- status := resp.StatusCode- if status == 0 {- status = http.StatusOK- }- w.WriteHeader(status)- _, _ = w.Write(resp.Body)-- observer.OnSuccess(targetID.String(), time.Since(start))- })-}--func providerBootstrap(node samnet.Node) []multiaddr.Multiaddr {- addrs := node.Host().Addrs()- if len(addrs) == 0 {- return nil- }- return []multiaddr.Multiaddr{addrs[0].Encapsulate(multiaddr.StringCast("/p2p/" + node.PeerID().String()))}-}--func newProxyNode(port int, bootstrap []multiaddr.Multiaddr) (samnet.Node, error) {- listen, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/127.0.0.1/udp/%d/quic-v1", port))- if err != nil {- return nil, fmt.Errorf("building listen address: %w", err)- }- key, err := samnet.GenerateKey()- if err != nil {- return nil, fmt.Errorf("generating node key: %w", err)- }- return samnet.New(- samnet.WithPrivateKey(key),- samnet.WithListenAddrs(listen),- samnet.WithBootstrapPeers(bootstrap...),- samnet.WithDHTMode(samnet.DHTModeServer),+ runOut, runErrOut, err := runCommand(+ t,+ repoRoot(t),+ 3*time.Second,+ env,+ "",+ nodeBin,+ "run",+ "--listen", "/ip4/127.0.0.1/udp/0/quic-v1",+ "--listen", "/ip4/127.0.0.1/tcp/0",)-}--func connectProxyWithRetry(ctx context.Context, node samnet.Node, pi peer.AddrInfo) error {- ticker := time.NewTicker(250 * time.Millisecond)- defer ticker.Stop()- var last error- for {- if err := node.Connect(ctx, pi); err == nil {- return nil- } else {- last = err- }- select {- case <-ctx.Done():- return last- case <-ticker.C:- }- }-}--func readProxyReputationCounts(path string) (int, int, error) {- if _, err := os.Stat(path); err != nil {- return 0, 0, err- }- db, err := bbolt.Open(path, 0o600, &bbolt.Options{Timeout: 2 * time.Second})- if err != nil {- return 0, 0, err+ if err != context.DeadlineExceeded {+ t.Fatalf("expected run command to keep running until timeout, got: %v\nstdout:\n%s\nstderr:\n%s", err, runOut, runErrOut)}- defer func() { _ = db.Close() }()-- type reputationRecord struct {- PeerID string `json:"peer_id"`- OK bool `json:"ok"`- LatencyMS int64 `json:"latency_ms,omitempty"`- ErrorType string `json:"error_type,omitempty"`+ if strings.Contains(runOut+runErrOut, "No identity found") {+ t.Fatalf("run command did not use stored identity:\n%s\n%s", runOut, runErrOut)}-- codec := internaldb.JSONCodec{}- successes := 0- failures := 0- err = db.View(func(tx *bbolt.Tx) error {- bucket := tx.Bucket([]byte(internaldb.BucketReputation))- if bucket == nil {- return fmt.Errorf("missing reputation bucket")- }- return bucket.ForEach(func(_ []byte, value []byte) error {- var rec reputationRecord- if err := codec.Unmarshal(value, proxyRecordVersion, &rec, nil); err != nil {- return err- }- if rec.OK {- successes++- } else {- failures++- }- return nil- })- })- if err != nil {- return 0, 0, err+ if !strings.Contains(runOut+runErrOut, "SAM Node Online") {+ t.Fatalf("node did not reach online state:\n%s\n%s", runOut, runErrOut)}- return successes, failures, nil}