Skip to content

Agent Mesh

add unit test for stdio

Antonio Ojea643963aea644
diff --git a/cmd/sam-node/node.go b/cmd/sam-node/node.go
index 6845665f..3f971cd4 100644
--- a/cmd/sam-node/node.go
+++ b/cmd/sam-node/node.go
@@ -710,6 +710,10 @@ func (b *StdioBridge) ServeHTTP(w http.ResponseWriter, r *http.Request) {
b.clients[ch] = true
b.mu.Unlock()
+ // Flush headers immediately to establish the stream
+ w.WriteHeader(http.StatusOK)
+ flusher.Flush()
+
defer func() {
b.mu.Lock()
delete(b.clients, ch)
diff --git a/cmd/sam-node/proxy_test.go b/cmd/sam-node/proxy_test.go
index aaa32761..feb1814b 100644
--- a/cmd/sam-node/proxy_test.go
+++ b/cmd/sam-node/proxy_test.go
@@ -1,6 +1,8 @@
package main
import (
+ "bufio"
+ "bytes"
"context"
"fmt"
"io"
@@ -8,6 +10,7 @@ import (
"net/http/httptest"
"net/http/httputil"
"net/url"
+ "strings"
"testing"
"time"
@@ -185,3 +188,146 @@ func TestDatapathIntegration(t *testing.T) {
t.Fatalf("Expected body %s, got %s", expectedBody, string(bodyBytes))
}
}
+
+func TestStdioDatapathIntegration(t *testing.T) {
+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+ defer cancel()
+
+ // 1. Setup: Create two in-memory nodes (Node A and Node B)
+ privA, _, _ := crypto.GenerateKeyPair(crypto.Ed25519, -1)
+ privB, _, _ := crypto.GenerateKeyPair(crypto.Ed25519, -1)
+
+ dirA := t.TempDir()
+ dirB := t.TempDir()
+
+ storeA, err := NewStore(dirA)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() { _ = storeA.Close() }()
+
+ storeB, err := NewStore(dirB)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() { _ = storeB.Close() }()
+
+ nodeA, err := NewSamNode(ctx, privA, nil, nil, storeA, "test-mesh", "1s", []string{"/ip4/127.0.0.1/tcp/0"}, false, &CompiledLocalPolicy{}, 24*time.Hour)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() { _ = nodeA.Host.Close() }()
+
+ nodeB, err := NewSamNode(ctx, privB, nil, nil, storeB, "test-mesh", "1s", []string{"/ip4/127.0.0.1/tcp/0"}, false, &CompiledLocalPolicy{}, 24*time.Hour)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() { _ = nodeB.Host.Close() }()
+
+ // Connect Node B to Node A directly
+ err = nodeB.Host.Connect(ctx, peer.AddrInfo{ID: nodeA.Host.ID(), Addrs: nodeA.Host.Addrs()})
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ // 2. Target Service: Register a stdio service on Node A using 'cat'
+ serviceName := "stdio-tool"
+ serviceInfo := &api.ServiceInfo{
+ Type: api.ServiceType_SERVICE_TYPE_MCP,
+ Name: serviceName,
+ }
+
+ req := &api.RegisterServiceRequest{
+ Service: serviceInfo,
+ Backend: &api.RegisterServiceRequest_Command{
+ Command: &api.CommandBackend{
+ Command: []string{"cat"},
+ },
+ },
+ }
+
+ // Manually add to services map to ensure it's registered for the test lookup
+ // and avoid double start by not calling RegisterService.
+ handler, cmd, err := nodeA.createStdioBridgeHandler(req.Backend.(*api.RegisterServiceRequest_Command).Command)
+ if err != nil {
+ t.Fatal(err)
+ }
+ nodeA.servicesMu.Lock()
+ nodeA.services[serviceName] = &ServiceManifest{
+ Info: serviceInfo,
+ Handler: handler,
+ Cmd: cmd,
+ }
+ nodeA.servicesMu.Unlock()
+
+ defer func() { _ = nodeA.UnregisterService(ctx, serviceName) }()
+
+ // Start the Sidecar server for Node B to get BoundHTTPAddr populated
+ nodeB.BoundHTTPAddr = "127.0.0.1:0" // Dummy
+
+ // 3. Execution: Node B makes requests via its local Egress Proxy
+ proxyHandler := createEgressProxy(nodeB)
+ proxyServer := httptest.NewServer(proxyHandler)
+ defer proxyServer.Close()
+
+ // Construct URLs
+ // http://localhost:<port>/sam/{peer_id}/{service_type}/{service_name}/{upstream_path}
+ sseURL := fmt.Sprintf("%s/sam/%s/mcp/%s/", proxyServer.URL, nodeA.Host.ID().String(), serviceName)
+ postURL := fmt.Sprintf("%s/sam/%s/mcp/%s/", proxyServer.URL, nodeA.Host.ID().String(), serviceName)
+
+ client := &http.Client{}
+
+ // Wait for DHT/routing to settle (retry mechanism)
+ var sseResp *http.Response
+ for i := 0; i < 3; i++ {
+ sseResp, err = client.Get(sseURL)
+ if err == nil && sseResp.StatusCode == http.StatusOK {
+ break
+ }
+ t.Logf("SSE Connect Attempt %d failed: %v, status: %v", i+1, err, sseResp)
+ time.Sleep(1 * time.Second)
+ }
+
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() { _ = sseResp.Body.Close() }()
+
+ if sseResp.StatusCode != http.StatusOK {
+ t.Fatalf("Expected SSE status OK, got %d", sseResp.StatusCode)
+ }
+
+ // Send a message via POST
+ testMessage := `{"jsonrpc":"2.0","method":"ping","id":1}`
+ postResp, err := client.Post(postURL, "application/json", bytes.NewBufferString(testMessage))
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() { _ = postResp.Body.Close() }()
+
+ if postResp.StatusCode != http.StatusOK {
+ t.Fatalf("Expected POST status OK, got %d", postResp.StatusCode)
+ }
+
+ // Read from SSE stream
+ reader := bufio.NewReader(sseResp.Body)
+ line, err := reader.ReadString('\n')
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ expectedPrefix := "data: "
+ if !strings.HasPrefix(line, expectedPrefix) {
+ t.Fatalf("Expected line to start with %q, got %q", expectedPrefix, line)
+ }
+
+ receivedMessage := strings.TrimPrefix(line, expectedPrefix)
+ receivedMessage = strings.TrimSpace(receivedMessage)
+
+ if receivedMessage != testMessage {
+ t.Fatalf("Expected to receive %q, got %q", testMessage, receivedMessage)
+ }
+
+ // Cancel context to close the SSE stream and allow server to close gracefully
+ cancel()
+}