Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
implement RFC 8252 dynamic loopback
Antonio Ojeaf20fb93e124e
diff --git a/.github/k8s/dex-config.yaml b/.github/k8s/dex-config.yamlindex cbf6bb6c..cc6cba22 100644--- a/.github/k8s/dex-config.yaml+++ b/.github/k8s/dex-config.yaml@@ -18,11 +18,9 @@ data:http: 0.0.0.0:5556oauth2:- # Explicitly enable the Device Flow for headless CLI usagegrantTypes:- "authorization_code"- "refresh_token"- - "urn:ietf:params:oauth:grant-type:device_code"skipApprovalScreen: trueconnectors:@@ -48,7 +46,5 @@ data:name: 'SAM Mesh CLI'public: true # Allows PKCE flow for CLIs without exposing the secretredirectURIs:- - 'http://127.0.0.1:8080/callback'- - 'http://localhost:8080/callback'- - 'https://auth.sam-mesh.dev/device/callback'- - '/device/callback'+ - 'http://127.0.0.1/callback'+ - 'http://localhost/callback'diff --git a/Makefile b/Makefileindex dd104189..6f5639af 100644--- a/Makefile+++ b/Makefile@@ -64,16 +64,16 @@ update:go mod tidydocker-build-hub:- docker build -t sam-hub:local -f Dockerfile.sam-hub .+ docker build --load -t sam-hub:local -f Dockerfile.sam-hub .docker-build-node:- docker build --no-cache -t sam-node:local -f Dockerfile.sam-node .+ docker build --load --no-cache -t sam-node:local -f Dockerfile.sam-node .docker-build-mock-oidc:- docker build -t sam-mock-oidc:local -f tests/e2e/docker/Dockerfile.mock-oidc .+ docker build --load -t sam-mock-oidc:local -f tests/e2e/docker/Dockerfile.mock-oidc .docker-build-e2e-runtime:- docker build -t sam-e2e-runtime:local -f tests/e2e/docker/Dockerfile.sam-runtime .+ docker build --load -t sam-e2e-runtime:local -f tests/e2e/docker/Dockerfile.sam-runtime .docker-build: docker-build-hub docker-build-node docker-build-mock-oidc docker-build-e2e-runtimediff --git a/cmd/sam-node/main.go b/cmd/sam-node/main.goindex acc68983..8e98fe17 100644--- a/cmd/sam-node/main.go+++ b/cmd/sam-node/main.go@@ -338,12 +338,12 @@ func main() {fmt.Printf("Client ID discovered: %s\n", hubInfo.ClientId)logger.Info("Discovering OIDC endpoints...")- tokenURL, deviceAuthURL, err := dummyNode.DiscoverEndpoints(ctx, hubInfo.OidcIssuer)+ tokenURL, authURL, err := dummyNode.DiscoverEndpoints(ctx, hubInfo.OidcIssuer)if err != nil {logger.Fatalf("Failed to discover OIDC endpoints: %v", err)}- jwtStr, err := dummyNode.InteractiveLogin(ctx, deviceAuthURL, tokenURL, hubInfo.ClientId, hubInfo.Audience)+ jwtStr, err := dummyNode.InteractiveLogin(ctx, authURL, tokenURL, hubInfo.ClientId, hubInfo.Audience)if err != nil {logger.Fatalf("Failed to get token: %v", err)}diff --git a/cmd/sam-node/mcp.go b/cmd/sam-node/mcp.goindex dece95a7..45bdd891 100644--- a/cmd/sam-node/mcp.go+++ b/cmd/sam-node/mcp.go@@ -154,10 +154,12 @@ func (n *SamNode) CallMCPTool(ctx context.Context, targetPeer peer.ID, toolNamefunc (n *SamNode) callMCPToolOnce(ctx context.Context, targetPeer peer.ID, toolName string, params any) (*mcp.CallToolResult, error) {// Open stream+ logger.Debugf("Dialing %s for MCP...\n", targetPeer)s, err := n.Host.NewStream(ctx, targetPeer, api.MCPProtocolID)if err != nil {return nil, fmt.Errorf("failed to open stream to %s: %w", targetPeer, err)}+ logger.Debugf("Opened stream to %s for MCP\n", targetPeer)defer func() {if err := s.Close(); err != nil {logger.Debugf("[MCP] Failed to close stream: %v", err)@@ -177,12 +179,14 @@ func (n *SamNode) callMCPToolOnce(ctx context.Context, targetPeer peer.ID, toolNauthBytes, _ := proto.Marshal(&authFrame)// Write AuthFrame+ logger.Debugf("Writing auth frame to %s...\n", targetPeer)writer := msgio.NewVarintWriter(s)if err := writer.WriteMsg(authBytes); err != nil {return nil, fmt.Errorf("failed to write auth frame to %s: %w", targetPeer, err)}// Read ACK+ logger.Debugf("Reading auth response from %s...\n", targetPeer)reader := msgio.NewVarintReaderSize(s, 1024*64)msg, err := reader.ReadMsg()if err != nil {@@ -226,7 +230,7 @@ func (n *SamNode) callMCPToolOnce(ctx context.Context, targetPeer peer.ID, toolN// fetchRemoteServiceCatalog calls the remote peer's list_local_services// MCP tool with the type filter and returns the parsed catalog.func (n *SamNode) fetchRemoteServiceCatalog(ctx context.Context, peerID peer.ID, typeStr string) ([]*api.ServiceInfo, error) {- res, err := n.callMCPToolOnce(ctx, peerID, "list_local_services", map[string]string{"type": typeStr})+ res, err := n.CallMCPTool(ctx, peerID, "list_local_services", map[string]string{"type": typeStr})if err != nil {return nil, err}diff --git a/cmd/sam-node/mcp_handlers.go b/cmd/sam-node/mcp_handlers.goindex 98377e7d..4bd418dd 100644--- a/cmd/sam-node/mcp_handlers.go+++ b/cmd/sam-node/mcp_handlers.go@@ -49,6 +49,7 @@ func (n *SamNode) handleListLocalServices(ctx context.Context, req *mcp.CallTooltypeFilter = parsed}services := n.ListLocalServices(typeFilter)+ logger.Infof("[ListLocalServices] Filter: %v, Returning %d services", typeFilter, len(services))respData, err := json.Marshal(services)if err != nil {return nil, nil, errdiff --git a/cmd/sam-node/node.go b/cmd/sam-node/node.goindex 41f00b47..4268b8b3 100644--- a/cmd/sam-node/node.go+++ b/cmd/sam-node/node.go@@ -416,6 +416,7 @@ dhtLoop:if len(errs) > 0 {return fmt.Errorf("failed to register static services: %w", errors.Join(errs...))}+ logger.Infof("[ServiceRegistry] Successfully registered %d static services", len(services))return nil}diff --git a/cmd/sam-node/oidc.go b/cmd/sam-node/oidc.goindex 800e2f1e..e6e5bbb1 100644--- a/cmd/sam-node/oidc.go+++ b/cmd/sam-node/oidc.go@@ -16,9 +16,13 @@ package mainimport ("context"+ "crypto/rand"+ "crypto/sha256"+ "encoding/base64""encoding/json""fmt""io"+ "net""net/http""net/url""os/exec"@@ -32,6 +36,18 @@ import ("google.golang.org/protobuf/proto")+// generatePKCE generates a PKCE code verifier and challenge.+func generatePKCE() (string, string, error) {+ b := make([]byte, 32)+ if _, err := rand.Read(b); err != nil {+ return "", "", err+ }+ verifier := base64.RawURLEncoding.EncodeToString(b)+ hash := sha256.Sum256([]byte(verifier))+ challenge := base64.RawURLEncoding.EncodeToString(hash[:])+ return verifier, challenge, nil+}+// FetchJWT fetches a JWT token using the Client Credentials flow.func (n *SamNode) FetchJWT(ctx context.Context, tokenURL, clientID, clientSecret string) (string, error) {config := &clientcredentials.Config{@@ -47,153 +63,172 @@ func (n *SamNode) FetchJWT(ctx context.Context, tokenURL, clientID, clientSecret}// InteractiveLogin prompts the user to go to a URL and enter a code.-func (n *SamNode) InteractiveLogin(ctx context.Context, deviceAuthURL, tokenURL, clientID, audience string) (string, error) {- if deviceAuthURL == "" {- return "", fmt.Errorf("device authorization URL is required")+func (n *SamNode) InteractiveLogin(ctx context.Context, authURL, tokenURL, clientID, audience string) (string, error) {+ if authURL == "" {+ return "", fmt.Errorf("authorization URL is required")}if tokenURL == "" {return "", fmt.Errorf("token URL is required")}if clientID == "" {- return "", fmt.Errorf("client ID is required for device flow")+ return "", fmt.Errorf("client ID is required")}- data := url.Values{}- data.Set("client_id", clientID)- data.Set("scope", "openid email profile")- if audience != "" {- data.Set("audience", audience)+ stateBytes := make([]byte, 16)+ if _, err := rand.Read(stateBytes); err != nil {+ return "", fmt.Errorf("failed to generate state: %w", err)}+ state := base64.RawURLEncoding.EncodeToString(stateBytes)- req, err := http.NewRequestWithContext(ctx, "POST", deviceAuthURL, strings.NewReader(data.Encode()))+ verifier, challenge, err := generatePKCE()if err != nil {- return "", err+ return "", fmt.Errorf("failed to generate PKCE: %w", err)}- req.Header.Set("Content-Type", "application/x-www-form-urlencoded")- client := &http.Client{}- resp, err := client.Do(req)+ listener, err := net.Listen("tcp", "127.0.0.1:0")if err != nil {- return "", err- }- defer func() {- if err := resp.Body.Close(); err != nil {- logger.Errorf("Failed to close response body: %v", err)- }- }()-- if resp.StatusCode != http.StatusOK {- body, _ := io.ReadAll(io.LimitReader(resp.Body, 1024*1024))- return "", fmt.Errorf("device auth request failed: %s - %s", resp.Status, string(body))+ return "", fmt.Errorf("failed to start local server: %w", err)}+ defer func() { _ = listener.Close() }()- var authResp struct {- DeviceCode string `json:"device_code"`- UserCode string `json:"user_code"`- VerificationURI string `json:"verification_uri"`- VerificationURIComplete string `json:"verification_uri_complete"`- ExpiresIn int `json:"expires_in"`- Interval int `json:"interval"`- }+ port := listener.Addr().(*net.TCPAddr).Port+ redirectURI := fmt.Sprintf("http://127.0.0.1:%d/callback", port)- if err := json.NewDecoder(resp.Body).Decode(&authResp); err != nil {- return "", err+ authReq, err := http.NewRequest("GET", authURL, nil)+ if err != nil {+ return "", fmt.Errorf("failed to create auth request: %w", err)+ }+ q := authReq.URL.Query()+ q.Add("response_type", "code")+ q.Add("client_id", clientID)+ q.Add("redirect_uri", redirectURI)+ q.Add("scope", "openid email profile")+ q.Add("state", state)+ q.Add("code_challenge", challenge)+ q.Add("code_challenge_method", "S256")+ if audience != "" {+ q.Add("audience", audience)}+ authReq.URL.RawQuery = q.Encode()+ targetURL := authReq.URL.String()fmt.Println("------------------------------------------------------------")- fmt.Println("Device Authorization Flow")+ fmt.Println("OAuth Authorization Flow")fmt.Println("------------------------------------------------------------")fmt.Printf("To authenticate, please go to the following URL in your browser:\n\n")- targetURL := authResp.VerificationURIComplete- if targetURL == "" {- targetURL = authResp.VerificationURI- }fmt.Printf(" %s\n\n", targetURL)- if authResp.VerificationURIComplete == "" {- fmt.Printf("And enter the following code:\n\n")- fmt.Printf(" %s\n\n", authResp.UserCode)- } else {- fmt.Println("The login code has been pre-filled for your convenience.")- }fmt.Println("Waiting for authorization...")fmt.Println("------------------------------------------------------------")// Try to open browser automatically- openBrowser(targetURL)+ openBrowserFunc(targetURL)- interval := authResp.Interval- if interval <= 0 {- interval = 5- }+ codeChan := make(chan string)+ errChan := make(chan error)++ mux := http.NewServeMux()+ mux.HandleFunc("/callback", func(w http.ResponseWriter, r *http.Request) {+ query := r.URL.Query()+ if query.Get("state") != state {+ http.Error(w, "Invalid state parameter", http.StatusBadRequest)+ select {+ case errChan <- fmt.Errorf("invalid state parameter received"):+ case <-ctx.Done():+ }+ return+ }+ if errStr := query.Get("error"); errStr != "" {+ desc := query.Get("error_description")+ http.Error(w, "Authorization failed: "+errStr, http.StatusBadRequest)+ select {+ case errChan <- fmt.Errorf("authorization failed: %s - %s", errStr, desc):+ case <-ctx.Done():+ }+ return+ }+ code := query.Get("code")+ if code == "" {+ http.Error(w, "No code in request", http.StatusBadRequest)+ select {+ case errChan <- fmt.Errorf("no code received"):+ case <-ctx.Done():+ }+ return+ }- ticker := time.NewTicker(time.Duration(interval) * time.Second)- defer ticker.Stop()+ w.Header().Set("Content-Type", "text/html")+ _, _ = w.Write([]byte("<html><body><h1>Authorization successful!</h1><p>You can close this window and return to the CLI.</p></body></html>"))- for {select {+ case codeChan <- code:case <-ctx.Done():- return "", ctx.Err()- case <-ticker.C:- pollData := url.Values{}- pollData.Set("grant_type", "urn:ietf:params:oauth:grant-type:device_code")- pollData.Set("device_code", authResp.DeviceCode)- pollData.Set("client_id", clientID)-- req, err := http.NewRequestWithContext(ctx, "POST", tokenURL, strings.NewReader(pollData.Encode()))- if err != nil {- return "", err- }- req.Header.Set("Content-Type", "application/x-www-form-urlencoded")+ }+ })- resp, err := client.Do(req)- if err != nil {- return "", err- }+ srv := &http.Server{Handler: mux}+ go func() {+ if err := srv.Serve(listener); err != nil && err != http.ErrServerClosed {+ errChan <- fmt.Errorf("local server error: %w", err)+ }+ }()- if resp.StatusCode == http.StatusOK {- var tokenResp struct {- AccessToken string `json:"access_token"`- IdToken string `json:"id_token"`- }- err := json.NewDecoder(resp.Body).Decode(&tokenResp)- if closeErr := resp.Body.Close(); closeErr != nil {- logger.Errorf("Failed to close response body: %v", closeErr)- }- if err != nil {- return "", err- }- if tokenResp.IdToken != "" {- return tokenResp.IdToken, nil- }- return tokenResp.AccessToken, nil- }+ var code string+ select {+ case <-ctx.Done():+ _ = srv.Close()+ return "", ctx.Err()+ case err := <-errChan:+ _ = srv.Close()+ return "", err+ case code = <-codeChan:+ _ = srv.Close()+ }- var errResp struct {- Error string `json:"error"`- }- err = json.NewDecoder(resp.Body).Decode(&errResp)- if closeErr := resp.Body.Close(); closeErr != nil {- logger.Errorf("Failed to close response body: %v", closeErr)- }- if err != nil {- return "", fmt.Errorf("token request failed with status %s", resp.Status)- }+ tokenData := url.Values{}+ tokenData.Set("grant_type", "authorization_code")+ tokenData.Set("client_id", clientID)+ tokenData.Set("code", code)+ tokenData.Set("redirect_uri", redirectURI)+ tokenData.Set("code_verifier", verifier)- switch errResp.Error {- case "authorization_pending":- continue- case "slow_down":- ticker.Reset(time.Duration(interval+5) * time.Second)- continue- case "expired_token":- return "", fmt.Errorf("device code expired")- case "access_denied":- return "", fmt.Errorf("access denied by user")- default:- return "", fmt.Errorf("token request failed: %s", errResp.Error)- }+ req, err := http.NewRequestWithContext(ctx, "POST", tokenURL, strings.NewReader(tokenData.Encode()))+ if err != nil {+ return "", err+ }+ req.Header.Set("Content-Type", "application/x-www-form-urlencoded")++ client := &http.Client{Timeout: 10 * time.Second}+ resp, err := client.Do(req)+ if err != nil {+ return "", err+ }+ defer func() {+ if err := resp.Body.Close(); err != nil {+ logger.Errorf("Failed to close response body: %v", err)+ }+ }()++ if resp.StatusCode != http.StatusOK {+ var errResp struct {+ Error string `json:"error"`+ ErrorDescription string `json:"error_description"`}+ _ = json.NewDecoder(resp.Body).Decode(&errResp)+ return "", fmt.Errorf("token request failed: %s - %s", errResp.Error, errResp.ErrorDescription)}++ var tokenResp struct {+ AccessToken string `json:"access_token"`+ IdToken string `json:"id_token"`+ }+ if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {+ return "", err+ }++ if tokenResp.IdToken != "" {+ return tokenResp.IdToken, nil+ }+ return tokenResp.AccessToken, nil}// DiscoverTokenURL discovers the token URL from the OIDC issuer.@@ -214,20 +249,20 @@ func (n *SamNode) DiscoverTokenURL(ctx context.Context, issuerURL string) (strinreturn claims.TokenURL, nil}-// DiscoverEndpoints discovers both token and device auth endpoints.-func (n *SamNode) DiscoverEndpoints(ctx context.Context, issuerURL string) (tokenURL, deviceURL string, err error) {+// DiscoverEndpoints discovers both token and authorization endpoints.+func (n *SamNode) DiscoverEndpoints(ctx context.Context, issuerURL string) (tokenURL, authURL string, err error) {provider, err := oidc.NewProvider(ctx, issuerURL)if err != nil {return "", "", fmt.Errorf("failed to create OIDC provider: %w", err)}var claims struct {- TokenURL string `json:"token_endpoint"`- DeviceURL string `json:"device_authorization_endpoint"`+ TokenURL string `json:"token_endpoint"`+ AuthURL string `json:"authorization_endpoint"`}if err := provider.Claims(&claims); err != nil {return "", "", fmt.Errorf("failed to extract claims: %w", err)}- return claims.TokenURL, claims.DeviceURL, nil+ return claims.TokenURL, claims.AuthURL, nil}// DiscoverHubInfo queries the hub's /info endpoint to fetch OIDC configurations.@@ -274,6 +309,8 @@ func (n *SamNode) DiscoverHubInfo(ctx context.Context, hubURL string) (*api.HubIreturn &hubInfo, nil}+var openBrowserFunc = openBrowser+func openBrowser(targetURL string) {parsedURL, err := url.Parse(targetURL)if err != nil || (parsedURL.Scheme != "http" && parsedURL.Scheme != "https") {diff --git a/cmd/sam-node/oidc_test.go b/cmd/sam-node/oidc_test.goindex 89f79b59..a063aaae 100644--- a/cmd/sam-node/oidc_test.go+++ b/cmd/sam-node/oidc_test.go@@ -5,52 +5,34 @@ import ("encoding/json""net/http""net/http/httptest"- "sync/atomic"+ "net/url""testing""time")func TestInteractiveLogin(t *testing.T) {- // Mock OIDC servermux := http.NewServeMux()-- // State for polling- var authorized atomic.Bool-- mux.HandleFunc("/device/code", func(w http.ResponseWriter, r *http.Request) {++ mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {if r.Method != "POST" {http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)return}- w.Header().Set("Content-Type", "application/json")- if err := json.NewEncoder(w).Encode(map[string]interface{}{- "device_code": "dev_code_123",- "user_code": "ABCD-1234",- "verification_uri": "http://example.com/verify",- "expires_in": 60,- "interval": 1, // Fast polling for test- }); err != nil {- t.Errorf("Failed to encode response: %v", err)+ _ = r.ParseForm()+ if r.FormValue("grant_type") != "authorization_code" {+ http.Error(w, "Invalid grant_type", http.StatusBadRequest)+ return}- })-- mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {- if r.Method != "POST" {- http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)+ if r.FormValue("code") != "dev_code_123" {+ http.Error(w, "Invalid code", http.StatusBadRequest)return}- w.Header().Set("Content-Type", "application/json")-- if !authorized.Load() {- w.WriteHeader(http.StatusBadRequest)- if err := json.NewEncoder(w).Encode(map[string]string{- "error": "authorization_pending",- }); err != nil {- t.Errorf("Failed to encode response: %v", err)- }+ if r.FormValue("code_verifier") == "" {+ http.Error(w, "Missing code_verifier", http.StatusBadRequest)return}-++ w.Header().Set("Content-Type", "application/json")if err := json.NewEncoder(w).Encode(map[string]string{"access_token": "access_token_xyz","id_token": "id_token_abc",@@ -63,33 +45,31 @@ func TestInteractiveLogin(t *testing.T) {defer server.Close()node := &SamNode{}-+ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)defer cancel()- // Run InteractiveLogin in a goroutine because it blocks- type result struct {- token string- err error- }- resChan := make(chan result, 1)-- go func() {- token, err := node.InteractiveLogin(ctx, server.URL+"/device/code", server.URL+"/token", "client_id_test", "sam-e2e")- resChan <- result{token, err}- }()+ // Mock openBrowser to simulate the user authorizing in the browser+ originalOpenBrowser := openBrowserFunc+ openBrowserFunc = func(urlStr string) {+ u, _ := url.Parse(urlStr)+ redirectURI := u.Query().Get("redirect_uri")+ state := u.Query().Get("state")- // Wait a bit and then authorize the user- time.Sleep(1500 * time.Millisecond)- authorized.Store(true)+ go func() {+ time.Sleep(100 * time.Millisecond)+ _, _ = http.Get(redirectURI + "?code=dev_code_123&state=" + state)+ }()+ }+ defer func() { openBrowserFunc = originalOpenBrowser }()- res := <-resChan- if res.err != nil {- t.Fatalf("InteractiveLogin failed: %v", res.err)+ token, err := node.InteractiveLogin(ctx, "http://auth.example.com/auth", server.URL+"/token", "client_id_test", "sam-e2e")+ if err != nil {+ t.Fatalf("InteractiveLogin failed: %v", err)}- if res.token != "id_token_abc" {- t.Errorf("Expected token 'id_token_abc', got '%s'", res.token)+ if token != "id_token_abc" {+ t.Errorf("Expected token 'id_token_abc', got '%s'", token)}}@@ -98,9 +78,9 @@ func TestDiscoverEndpoints(t *testing.T) {mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {w.Header().Set("Content-Type", "application/json")if err := json.NewEncoder(w).Encode(map[string]interface{}{- "issuer": "http://" + r.Host,- "token_endpoint": "http://" + r.Host + "/token",- "device_authorization_endpoint": "http://" + r.Host + "/device/code",+ "issuer": "http://" + r.Host,+ "token_endpoint": "http://" + r.Host + "/token",+ "authorization_endpoint": "http://" + r.Host + "/auth",}); err != nil {t.Errorf("Failed to encode response: %v", err)}@@ -112,7 +92,7 @@ func TestDiscoverEndpoints(t *testing.T) {node := &SamNode{}ctx := context.Background()- tokenURL, deviceURL, err := node.DiscoverEndpoints(ctx, server.URL)+ tokenURL, authURL, err := node.DiscoverEndpoints(ctx, server.URL)if err != nil {t.Fatalf("DiscoverEndpoints failed: %v", err)}@@ -120,7 +100,7 @@ func TestDiscoverEndpoints(t *testing.T) {if tokenURL != server.URL+"/token" {t.Errorf("Expected tokenURL %s, got %s", server.URL+"/token", tokenURL)}- if deviceURL != server.URL+"/device/code" {- t.Errorf("Expected deviceURL %s, got %s", server.URL+"/device/code", deviceURL)+ if authURL != server.URL+"/auth" {+ t.Errorf("Expected authURL %s, got %s", server.URL+"/auth", authURL)}}diff --git a/docs/kubernetes-deployment.md b/docs/kubernetes-deployment.mdindex 3f776878..d8c42ed9 100644--- a/docs/kubernetes-deployment.md+++ b/docs/kubernetes-deployment.md@@ -26,8 +26,7 @@ The manifests for the SAM Hub are available in [sam-hub.yaml](manifests/sam-hub.To use Google as the OIDC provider instead of the mock provider:-1. **Create OAuth Client ID:** Create a OAuth 2.0 Client ID in the Google Cloud Console.-2. **Set Redirect URI:** Set the authorized redirect URI to `http://<your-hub-public-ip>:8080/callback` (replace `<your-hub-public-ip>` with your actual public IP or domain).+2. **No Redirect URI required:** Because `sam-node` implements RFC 8252 (dynamic loopback port selection for native apps), you don't need to configure a specific Redirect URI when setting up a Desktop app. The authorization server will automatically allow loopback redirects.3. **Update Secret:** Update the `sam-hub-secret` in `sam-hub.yaml` with your Google credentials:```yamlSAM_OIDC_ISSUER: "https://accounts.google.com"@@ -175,10 +174,10 @@ sam-node run \--client-secret "$SAM_OIDC_SECRET"```-#### 2. Device Authorization Flow (Human Intervention)-* **Description:** For input-constrained devices or CLI tools used by humans. The device asks the user to go to a link on their computer or smartphone to authorize the device, avoiding the need to enter complex passwords in the CLI.-* **Use Case:** When a human operator is enrolling a node manually.-* **How to use:** The user obtains a token via the OIDC provider's device flow (or browser flow) and passes it directly via the `--jwt` flag.+#### 2. Native App Authorization Code Flow (Human Intervention)+* **Description:** For devices operated by humans, this uses the standard Authorization Code Flow with PKCE for native apps (RFC 8252). `sam-node` spins up a temporary local HTTP server, opens your browser, and receives the authentication token locally via an ephemeral loopback address.+* **Use Case:** When a human operator is enrolling a node manually via their local terminal.+* **How to use:** When you omit the `--jwt` or `--token-url` flags (or pass the OIDC issuer flag interactively), the node opens the browser and completes the flow without needing to enter complex passwords in the CLI. Alternatively, you can obtain a token yourself and pass it via the `--jwt` flag.* **Example:**```bashsam-node run \diff --git a/tests/e2e/auth_flows.bats b/tests/e2e/auth_flows.batsindex b41bcdf4..50a4e8bd 100644--- a/tests/e2e/auth_flows.bats+++ b/tests/e2e/auth_flows.bats@@ -54,11 +54,45 @@ teardown() {local data_vol="${MESH_PREFIX}-data"docker volume create "${data_vol}"- docker run --rm \+ docker run --name "${node_name}-join" \--network "${MESH_NETWORK}" \-v "${data_vol}:/root/.config/sam-mesh" \"sam-node:local" \- join "http://sam-hub:9090"+ join "http://sam-hub:9090" > "/tmp/${node_name}-join.out" 2>&1 &+ local join_pid=$!++ # Wait for redirect_uri and state in the output+ local redirect_uri=""+ local state=""+ local port=""+ for i in {1..20}; do+ if grep -q "redirect_uri=" "/tmp/${node_name}-join.out"; then+ # Output format: http://mock-oidc...redirect_uri=http%3A%2F%2F127.0.0.1%3A<PORT>%2Fcallback&...&state=<STATE>+ local line+ line=$(grep "redirect_uri=" "/tmp/${node_name}-join.out" | head -n 1)+ redirect_uri=$(echo "$line" | grep -o 'redirect_uri=[^&]*' | cut -d= -f2 | tr -d '\r\n')+ state=$(echo "$line" | grep -o 'state=[^&]*' | cut -d= -f2 | tr -d '\r\n')++ # URL decode redirect_uri+ # e.g. http%3A%2F%2F127.0.0.1%3A41353%2Fcallback -> http://127.0.0.1:41353/callback+ redirect_uri=$(echo "$redirect_uri" | sed -e 's/%3A/:/g' -e 's/%2F/\//g')++ port=$(echo "$redirect_uri" | grep -o ':[0-9]*' | tr -d ':\r\n')+ if [[ -n "$port" && -n "$state" ]]; then+ break+ fi+ fi+ sleep 1+ done++ [[ -n "$port" ]] && [[ -n "$state" ]]++ # Trigger the callback in the sam-node container's network namespace+ docker run --rm --network "container:${node_name}-join" python:3.12 python3 -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:${port}/callback?code=dev_code_123&state=${state}')"++ # Wait for the join process to finish+ wait $join_pid+ docker rm -f "${node_name}-join" >/dev/null 2>&1 || true# Now run the node with the stored identitydocker run -d \diff --git a/tests/e2e/policy.bats b/tests/e2e/policy.batsindex e79ad309..e95bd339 100644--- a/tests/e2e/policy.bats+++ b/tests/e2e/policy.bats@@ -232,7 +232,7 @@ EOF"mesh_wait_for_log "${MESH_PREFIX}-node-2" "SAM Node Online" 20local node2_id- node2_id=$(docker logs "${MESH_PREFIX}-node-2" 2>&1 | grep -A 1 "SAM Node Online" | grep -oE '12D3Koo[a-zA-Z0-9]+' | head -n 1)+ node2_id=$(docker logs "${MESH_PREFIX}-node-2" 2>&1 | grep "PeerID:" | grep -oE '12D3Koo[a-zA-Z0-9]+' | head -n 1)# Wait for discovery (Node 2 should see Node 1)local idiff --git a/tests/integration/fallback_test.go b/tests/integration/fallback_test.goindex ffd5f02b..39b8bf85 100644--- a/tests/integration/fallback_test.go+++ b/tests/integration/fallback_test.go@@ -392,7 +392,7 @@ func TestSelfHealingHTTPFallback(t *testing.T) {_ = json.NewEncoder(w).Encode(map[string]interface{}{"issuer": "http://" + r.Host,"token_endpoint": "http://" + r.Host + "/token",- "device_authorization_endpoint": "http://" + r.Host + "/device/code",+ "authorization_endpoint": "http://" + r.Host + "/auth",})})mux.HandleFunc("/device/code", func(w http.ResponseWriter, r *http.Request) {@@ -453,7 +453,7 @@ func TestSelfHealingHTTPFallback(t *testing.T) {)// Step 1: Enroll via Join (using mock OIDC)- joinStdout, joinStderr, err := runCommand(+ joinStdout, joinStderr, err := runCommandWithCallback(t,repoRoot(t),5*time.Second,diff --git a/tests/integration/login_test.go b/tests/integration/login_test.goindex 1c943d1c..1a6ba395 100644--- a/tests/integration/login_test.go+++ b/tests/integration/login_test.go@@ -41,7 +41,7 @@ func TestSamNodeJoin(t *testing.T) {if err := json.NewEncoder(w).Encode(map[string]interface{}{"issuer": "http://" + r.Host,"token_endpoint": "http://" + r.Host + "/token",- "device_authorization_endpoint": "http://" + r.Host + "/device/code",+ "authorization_endpoint": "http://" + r.Host + "/auth",}); err != nil {t.Errorf("Failed to encode response: %v", err)}@@ -74,7 +74,7 @@ func TestSamNodeJoin(t *testing.T) {// Start mock libp2p hub that knows about our mock OIDC server_, hubAddr := startMockLibp2pHubWithOIDC(t, oidcServer.URL)- stdout, stderr, err := runCommand(+ stdout, stderr, err := runCommandWithCallback(t,repoRoot(t),5*time.Second,diff --git a/tests/integration/minimal_helpers_test.go b/tests/integration/minimal_helpers_test.goindex 94da1773..b879e5d4 100644--- a/tests/integration/minimal_helpers_test.go+++ b/tests/integration/minimal_helpers_test.go@@ -21,17 +21,20 @@ import ("os/exec""path/filepath""runtime"+ "strings""testing""time""io""net/http""net/http/httptest"+ "net/url"+"github.com/google/sam/api""github.com/libp2p/go-libp2p"dht "github.com/libp2p/go-libp2p-kad-dht"- "github.com/libp2p/go-libp2p/core/peer""github.com/libp2p/go-libp2p/core/network"+ "github.com/libp2p/go-libp2p/core/peer""github.com/libp2p/go-msgio""google.golang.org/protobuf/proto")@@ -92,6 +95,82 @@ func runCommand(return stdout.String(), stderr.String(), err}+type interceptorWriter struct {+ w io.Writer+ buf *bytes.Buffer+ handled bool+}++func (iw *interceptorWriter) Write(p []byte) (n int, err error) {+ n, err = iw.w.Write(p)+ iw.buf.Write(p)+ if !iw.handled {+ s := iw.buf.String()+ if strings.Contains(s, "redirect_uri=") && strings.Contains(s, "state=") {+ iw.handled = true+ go func() {+ // Parse URL from the buffer to extract state and redirect_uri+ // The URL is printed like: " http://...redirect_uri=...&state=..."+ lines := strings.Split(s, "\n")+ for _, line := range lines {+ if strings.Contains(line, "redirect_uri=") {+ parts := strings.Split(strings.TrimSpace(line), " ")+ for _, p := range parts {+ if strings.HasPrefix(p, "http") {+ u, err := url.Parse(p)+ if err == nil {+ redirectURI := u.Query().Get("redirect_uri")+ state := u.Query().Get("state")+ if redirectURI != "" && state != "" {+ time.Sleep(100 * time.Millisecond)+ _, _ = http.Get(redirectURI + "?code=dev_code_123&state=" + state)+ }+ }+ }+ }+ }+ }+ }()+ }+ }+ return n, err+}++func runCommandWithCallback(+ 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 = &interceptorWriter{w: &stdout, buf: &bytes.Buffer{}}+ 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+}+func startMockLibp2pHub(t *testing.T) (peer.ID, string) {t.Helper()